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 2021/06/08 09:15:46 UTC
[iotdb] branch master updated: [IOTDB-1426] Restructure
physicalGenerator (#3369)
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 06001d1 [IOTDB-1426] Restructure physicalGenerator (#3369)
06001d1 is described below
commit 06001d13c387e0e830ada109ca3b131279067758
Author: Xiangwei Wei <34...@users.noreply.github.com>
AuthorDate: Tue Jun 8 17:15:24 2021 +0800
[IOTDB-1426] Restructure physicalGenerator (#3369)
Restructure physicalGenerator
---
.../cluster/query/ClusterPhysicalGenerator.java | 15 +-
.../org/apache/iotdb/db/auth/AuthorityChecker.java | 4 +-
.../apache/iotdb/db/qp/executor/PlanExecutor.java | 2 +-
.../org/apache/iotdb/db/qp/logical/Operator.java | 100 ++-
.../qp/logical/crud/AggregationQueryOperator.java | 75 ++
.../db/qp/logical/crud/DeleteDataOperator.java | 10 +
.../db/qp/logical/crud/FillQueryOperator.java | 37 +
.../qp/logical/crud/GroupByFillQueryOperator.java | 52 +-
.../db/qp/logical/crud/GroupByQueryOperator.java | 48 +-
.../iotdb/db/qp/logical/crud/InsertOperator.java | 41 +
.../db/qp/logical/crud/LastQueryOperator.java | 14 +
.../iotdb/db/qp/logical/crud/QueryOperator.java | 349 +++++++++
.../iotdb/db/qp/logical/crud/UDFQueryOperator.java | 17 +
.../iotdb/db/qp/logical/crud/WhereComponent.java | 1 +
.../db/qp/logical/sys/AlterTimeSeriesOperator.java | 10 +
.../iotdb/db/qp/logical/sys/AuthorOperator.java | 16 +
.../db/qp/logical/sys/ClearCacheOperator.java | 10 +
.../iotdb/db/qp/logical/sys/CountOperator.java | 27 +
.../db/qp/logical/sys/CreateFunctionOperator.java | 10 +
.../db/qp/logical/sys/CreateIndexOperator.java | 10 +
.../db/qp/logical/sys/CreateSnapshotOperator.java | 10 +
.../qp/logical/sys/CreateTimeSeriesOperator.java | 19 +
.../db/qp/logical/sys/CreateTriggerOperator.java | 10 +
.../iotdb/db/qp/logical/sys/DataAuthOperator.java | 8 +
.../db/qp/logical/sys/DeletePartitionOperator.java | 10 +
.../qp/logical/sys/DeleteStorageGroupOperator.java | 8 +
.../qp/logical/sys/DeleteTimeSeriesOperator.java | 8 +
.../db/qp/logical/sys/DropFunctionOperator.java | 10 +
.../iotdb/db/qp/logical/sys/DropIndexOperator.java | 10 +
.../db/qp/logical/sys/DropTriggerOperator.java | 10 +
.../iotdb/db/qp/logical/sys/FlushOperator.java | 10 +
.../iotdb/db/qp/logical/sys/KillQueryOperator.java | 10 +
.../qp/logical/sys/LoadConfigurationOperator.java | 9 +
.../iotdb/db/qp/logical/sys/LoadDataOperator.java | 10 +-
.../iotdb/db/qp/logical/sys/LoadFilesOperator.java | 10 +
.../iotdb/db/qp/logical/sys/MergeOperator.java | 15 +
.../iotdb/db/qp/logical/sys/MoveFileOperator.java | 10 +
.../db/qp/logical/sys/RemoveFileOperator.java | 10 +
.../db/qp/logical/sys/SetStorageGroupOperator.java | 8 +
.../iotdb/db/qp/logical/sys/SetTTLOperator.java | 10 +
.../db/qp/logical/sys/ShowChildNodesOperator.java | 11 +
.../db/qp/logical/sys/ShowChildPathsOperator.java | 11 +
.../db/qp/logical/sys/ShowDevicesOperator.java | 10 +
.../db/qp/logical/sys/ShowFunctionsOperator.java | 11 +
.../db/qp/logical/sys/ShowMergeStatusOperator.java | 10 +
.../iotdb/db/qp/logical/sys/ShowOperator.java | 24 +
.../qp/logical/sys/ShowStorageGroupOperator.java | 11 +
.../iotdb/db/qp/logical/sys/ShowTTLOperator.java | 8 +
.../db/qp/logical/sys/ShowTimeSeriesOperator.java | 15 +
.../db/qp/logical/sys/ShowTriggersOperator.java | 11 +
.../db/qp/logical/sys/StartTriggerOperator.java | 10 +
.../db/qp/logical/sys/StopTriggerOperator.java | 10 +
.../iotdb/db/qp/logical/sys/TracingOperator.java | 10 +
.../{SetTTLOperator.java => UnSetTTLOperator.java} | 19 +-
.../db/qp/physical/crud/AlignByDevicePlan.java | 2 +-
.../iotdb/db/qp/physical/crud/GroupByTimePlan.java | 2 +-
.../db/qp/physical/crud/InsertTabletPlan.java | 10 +-
.../iotdb/db/qp/physical/sys/LoadDataPlan.java | 2 +-
.../iotdb/db/qp/physical/sys/ShowDevicesPlan.java | 4 +-
.../apache/iotdb/db/qp/physical/sys/ShowPlan.java | 3 +-
.../db/qp/physical/sys/ShowTimeSeriesPlan.java | 4 +-
.../apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 10 +-
.../iotdb/db/qp/strategy/PhysicalGenerator.java | 861 +--------------------
.../db/query/dataset/AlignByDeviceDataSet.java | 2 +-
.../org/apache/iotdb/db/service/TSServiceImpl.java | 2 +-
.../db/integration/IoTDBUDTFHybridQueryIT.java | 2 +-
.../java/org/apache/iotdb/db/qp/PlannerTest.java | 2 +-
67 files changed, 1183 insertions(+), 947 deletions(-)
diff --git a/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java b/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
index 9e5e740..3141d18 100644
--- a/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
+++ b/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
@@ -47,7 +47,6 @@ import java.net.URL;
import java.util.List;
import java.util.Map;
import java.util.Properties;
-import java.util.Set;
public class ClusterPhysicalGenerator extends PhysicalGenerator {
@@ -58,7 +57,7 @@ public class ClusterPhysicalGenerator extends PhysicalGenerator {
}
@Override
- protected Pair<List<TSDataType>, List<TSDataType>> getSeriesTypes(
+ public Pair<List<TSDataType>, List<TSDataType>> getSeriesTypes(
List<PartialPath> paths, String aggregation) throws MetadataException {
return getCMManager().getSeriesTypesByPaths(paths, aggregation);
}
@@ -75,16 +74,6 @@ public class ClusterPhysicalGenerator extends PhysicalGenerator {
}
@Override
- protected List<PartialPath> getMatchedTimeseries(PartialPath path) throws MetadataException {
- return getCMManager().getMatchedPaths(path);
- }
-
- @Override
- protected Set<PartialPath> getMatchedDevices(PartialPath path) throws MetadataException {
- return getCMManager().getMatchedDevices(path);
- }
-
- @Override
public PhysicalPlan transformToPhysicalPlan(Operator operator, int fetchSize)
throws QueryProcessException {
// update storage groups before parsing query plans
@@ -99,7 +88,7 @@ public class ClusterPhysicalGenerator extends PhysicalGenerator {
}
@Override
- protected PhysicalPlan generateLoadConfigurationPlan(LoadConfigurationOperatorType type)
+ public PhysicalPlan generateLoadConfigurationPlan(LoadConfigurationOperatorType type)
throws QueryProcessException {
if (type == LoadConfigurationOperatorType.GLOBAL) {
Properties[] properties = new Properties[2];
diff --git a/server/src/main/java/org/apache/iotdb/db/auth/AuthorityChecker.java b/server/src/main/java/org/apache/iotdb/db/auth/AuthorityChecker.java
index 136ca1a..1b1bdc7 100644
--- a/server/src/main/java/org/apache/iotdb/db/auth/AuthorityChecker.java
+++ b/server/src/main/java/org/apache/iotdb/db/auth/AuthorityChecker.java
@@ -124,7 +124,7 @@ public class AuthorityChecker {
case DROP_INDEX:
return PrivilegeType.DELETE_TIMESERIES.ordinal();
case QUERY:
- case GROUPBYTIME:
+ case GROUP_BY_TIME:
case QUERY_INDEX:
case AGGREGATION:
case UDAF:
@@ -134,7 +134,7 @@ public class AuthorityChecker {
case GROUP_BY_FILL:
return PrivilegeType.READ_TIMESERIES.ordinal();
case INSERT:
- case LOADDATA:
+ case LOAD_DATA:
case CREATE_INDEX:
return PrivilegeType.INSERT_TIMESERIES.ordinal();
case LIST_ROLE:
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java b/server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java
index 4ebe4e9..8abf295 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/executor/PlanExecutor.java
@@ -244,7 +244,7 @@ public class PlanExecutor implements IPlanExecutor {
case BATCH_INSERT_ROWS:
insert((InsertRowsPlan) plan);
return true;
- case BATCHINSERT:
+ case BATCH_INSERT:
insertTablet((InsertTabletPlan) plan);
return true;
case MULTI_BATCH_INSERT:
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/Operator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/Operator.java
index cc10c82..dc5272a 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/Operator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/Operator.java
@@ -18,7 +18,11 @@
*/
package org.apache.iotdb.db.qp.logical;
+import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.constant.SQLConstant;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
/** This class is a superclass of all operator. */
public abstract class Operator {
@@ -64,22 +68,17 @@ public abstract class Operator {
return SQLConstant.tokenNames.get(tokenIntType);
}
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ throw new LogicalOperatorException(operatorType.toString(), "");
+ }
+
/** If you want to add new OperatorType, you must add it in the last. */
public enum OperatorType {
- GROUPBYTIME,
NULL,
- INSERT,
- BATCHINSERT,
- DELETE,
- QUERY,
- AGGREGATION,
+
AUTHOR,
- LOADDATA,
- METADATA,
- FILL,
- SET_STORAGE_GROUP,
- CREATE_TIMESERIES,
- DELETE_TIMESERIES,
+ LOAD_DATA,
CREATE_USER,
DELETE_USER,
MODIFY_PASSWORD,
@@ -99,49 +98,72 @@ public abstract class Operator {
LIST_ROLE_USERS,
GRANT_WATERMARK_EMBEDDING,
REVOKE_WATERMARK_EMBEDDING,
- TTL,
+
+ SET_STORAGE_GROUP,
DELETE_STORAGE_GROUP,
- LOAD_CONFIGURATION,
- SHOW,
- LOAD_FILES,
- REMOVE_FILE,
- MOVE_FILE,
+ CREATE_TIMESERIES,
+ CREATE_ALIGNED_TIMESERIES,
+ CREATE_MULTI_TIMESERIES,
+ DELETE_TIMESERIES,
+ ALTER_TIMESERIES,
+ CHANGE_ALIAS,
+ CHANGE_TAG_OFFSET,
+
+ INSERT,
+ BATCH_INSERT,
+ BATCH_INSERT_ROWS,
+ BATCH_INSERT_ONE_DEVICE,
+ MULTI_BATCH_INSERT,
+
+ DELETE,
+
+ QUERY,
LAST,
+ GROUP_BY_TIME,
GROUP_BY_FILL,
- ALTER_TIMESERIES,
- FLUSH,
- MERGE,
- FULL_MERGE,
- CLEAR_CACHE,
- SHOW_MERGE_STATUS,
- CREATE_SCHEMA_SNAPSHOT,
- TRACING,
- DELETE_PARTITION,
+ AGGREGATION,
+ FILL,
UDAF,
UDTF,
+
CREATE_FUNCTION,
DROP_FUNCTION,
- CREATE_ALIGNED_TIMESERIES,
- CREATE_MULTI_TIMESERIES,
- AUTO_CREATE_DEVICE_MNODE,
+
+ SHOW,
+ SHOW_MERGE_STATUS,
+
CREATE_INDEX,
DROP_INDEX,
QUERY_INDEX,
- KILL,
- CHANGE_TAG_OFFSET,
- CHANGE_ALIAS,
- MNODE,
- MEASUREMENT_MNODE,
- STORAGE_GROUP_MNODE,
- BATCH_INSERT_ONE_DEVICE,
- MULTI_BATCH_INSERT,
- BATCH_INSERT_ROWS,
+
+ LOAD_FILES,
+ REMOVE_FILE,
+ MOVE_FILE,
+
CREATE_TRIGGER,
DROP_TRIGGER,
START_TRIGGER,
STOP_TRIGGER,
+
CREATE_TEMPLATE,
SET_DEVICE_TEMPLATE,
SET_USING_DEVICE_TEMPLATE,
+
+ MERGE,
+ FULL_MERGE,
+
+ MNODE,
+ MEASUREMENT_MNODE,
+ STORAGE_GROUP_MNODE,
+ AUTO_CREATE_DEVICE_MNODE,
+
+ TTL,
+ KILL,
+ FLUSH,
+ TRACING,
+ CLEAR_CACHE,
+ DELETE_PARTITION,
+ LOAD_CONFIGURATION,
+ CREATE_SCHEMA_SNAPSHOT,
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/AggregationQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/AggregationQueryOperator.java
index bc7efb5..f21c5a8 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/AggregationQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/AggregationQueryOperator.java
@@ -19,10 +19,23 @@
package org.apache.iotdb.db.qp.logical.crud;
+import org.apache.iotdb.db.exception.metadata.MetadataException;
import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.constant.SQLConstant;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.AggregationPlan;
+import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan;
+import org.apache.iotdb.db.qp.physical.crud.QueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.db.query.expression.ResultColumn;
import org.apache.iotdb.db.query.expression.unary.TimeSeriesOperand;
+import org.apache.iotdb.db.utils.SchemaUtils;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+
+import java.util.List;
public class AggregationQueryOperator extends QueryOperator {
@@ -45,11 +58,73 @@ public class AggregationQueryOperator extends QueryOperator {
throw new LogicalOperatorException("AGGREGATION doesn't support disable align clause.");
}
+ if (hasTimeSeriesGeneratingFunction()) {
+ throw new LogicalOperatorException(
+ "User-defined and built-in hybrid aggregation is not supported together.");
+ }
+
for (ResultColumn resultColumn : selectComponent.getResultColumns()) {
Expression expression = resultColumn.getExpression();
if (expression instanceof TimeSeriesOperand) {
throw new LogicalOperatorException(ERROR_MESSAGE1);
}
}
+
+ if (isGroupByLevel() && isAlignByDevice()) {
+ throw new LogicalOperatorException("group by level does not support align by device now.");
+ }
+ }
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return isAlignByDevice()
+ ? this.generateAlignByDevicePlan(generator)
+ : super.generateRawDataQueryPlan(generator, initAggregationPlan(new AggregationPlan()));
+ }
+
+ private boolean verifyAllAggregationDataTypesEqual() throws MetadataException {
+ List<String> aggregations = selectComponent.getAggregationFunctions();
+ if (aggregations.isEmpty()) {
+ return true;
+ }
+
+ List<PartialPath> paths = selectComponent.getPaths();
+ List<TSDataType> dataTypes = SchemaUtils.getSeriesTypesByPaths(paths);
+ String aggType = aggregations.get(0);
+ switch (aggType) {
+ case SQLConstant.MIN_VALUE:
+ case SQLConstant.MAX_VALUE:
+ case SQLConstant.AVG:
+ case SQLConstant.SUM:
+ return dataTypes.stream().allMatch(dataTypes.get(0)::equals);
+ default:
+ return true;
+ }
+ }
+
+ @Override
+ protected AlignByDevicePlan generateAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setAggregationPlan(initAggregationPlan(new AggregationPlan()));
+
+ return alignByDevicePlan;
+ }
+
+ protected AggregationPlan initAggregationPlan(QueryPlan queryPlan) throws QueryProcessException {
+ AggregationPlan aggregationPlan = (AggregationPlan) queryPlan;
+ aggregationPlan.setAggregations(selectComponent.getAggregationFunctions());
+ if (isGroupByLevel()) {
+ aggregationPlan.setLevel(specialClauseComponent.getLevel());
+ try {
+ if (!verifyAllAggregationDataTypesEqual()) {
+ throw new LogicalOperatorException("Aggregate among unmatched data types");
+ }
+ } catch (MetadataException e) {
+ throw new LogicalOperatorException(e);
+ }
+ }
+ return aggregationPlan;
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/DeleteDataOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/DeleteDataOperator.java
index e7a0619..122e5f4 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/DeleteDataOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/DeleteDataOperator.java
@@ -18,8 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.crud;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.DeletePlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.ArrayList;
import java.util.List;
@@ -61,4 +65,10 @@ public class DeleteDataOperator extends Operator {
public void setEndTime(long time) {
this.endTime = time;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new DeletePlan(getStartTime(), getEndTime(), getPaths());
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/FillQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/FillQueryOperator.java
index 2a707f4..579016c 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/FillQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/FillQueryOperator.java
@@ -20,7 +20,12 @@
package org.apache.iotdb.db.qp.logical.crud;
import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.constant.FilterConstant.FilterType;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan;
+import org.apache.iotdb.db.qp.physical.crud.FillQueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class FillQueryOperator extends QueryOperator {
@@ -32,9 +37,41 @@ public class FillQueryOperator extends QueryOperator {
throw new LogicalOperatorException("FILL doesn't support disable align clause.");
}
+ if (hasTimeSeriesGeneratingFunction()) {
+ throw new LogicalOperatorException("Fill functions are not supported in UDF queries.");
+ }
+
FilterOperator filterOperator = whereComponent.getFilterOperator();
if (!filterOperator.isLeaf() || filterOperator.getFilterType() != FilterType.EQUAL) {
throw new LogicalOperatorException("Only \"=\" can be used in fill function");
+ } else if (!filterOperator.isSingle()) {
+ throw new LogicalOperatorException("Slice query must select a single time point");
}
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return isAlignByDevice()
+ ? this.generateAlignByDevicePlan(generator)
+ : super.generateRawDataQueryPlan(generator, initFillQueryPlan());
+ }
+
+ @Override
+ protected AlignByDevicePlan generateAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setFillQueryPlan(initFillQueryPlan());
+
+ return alignByDevicePlan;
+ }
+
+ private FillQueryPlan initFillQueryPlan() {
+ FillQueryPlan fillQueryPlan = new FillQueryPlan();
+ FilterOperator timeFilter = whereComponent.getFilterOperator();
+ long time = Long.parseLong(((BasicFunctionOperator) timeFilter).getValue());
+ fillQueryPlan.setQueryTime(time);
+ fillQueryPlan.setFillType(((FillClauseComponent) specialClauseComponent).getFillTypes());
+ return fillQueryPlan;
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByFillQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByFillQueryOperator.java
index b28b031..ac621cf 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByFillQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByFillQueryOperator.java
@@ -19,4 +19,54 @@
package org.apache.iotdb.db.qp.logical.crud;
-public class GroupByFillQueryOperator extends GroupByQueryOperator {}
+import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.constant.SQLConstant;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan;
+import org.apache.iotdb.db.qp.physical.crud.GroupByTimeFillPlan;
+import org.apache.iotdb.db.qp.physical.crud.QueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+
+public class GroupByFillQueryOperator extends GroupByQueryOperator {
+
+ @Override
+ public void check() throws LogicalOperatorException {
+ super.check();
+
+ for (String aggregation : selectComponent.getAggregationFunctions()) {
+ if (!SQLConstant.LAST_VALUE.equals(aggregation)) {
+ throw new LogicalOperatorException("Group By Fill only support last_value function");
+ }
+ }
+ }
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return isAlignByDevice()
+ ? this.generateAlignByDevicePlan(generator)
+ : super.generateRawDataQueryPlan(
+ generator, initGroupByTimeFillPlan(new GroupByTimeFillPlan()));
+ }
+
+ @Override
+ protected AlignByDevicePlan generateAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setGroupByTimePlan(initGroupByTimeFillPlan(new GroupByTimeFillPlan()));
+
+ return alignByDevicePlan;
+ }
+
+ protected GroupByTimeFillPlan initGroupByTimeFillPlan(QueryPlan queryPlan)
+ throws QueryProcessException {
+ GroupByTimeFillPlan groupByTimeFillPlan =
+ (GroupByTimeFillPlan) super.initGroupByTimePlan(queryPlan);
+ GroupByFillClauseComponent groupByFillClauseComponent =
+ (GroupByFillClauseComponent) specialClauseComponent;
+ groupByTimeFillPlan.setFillType(groupByFillClauseComponent.getFillTypes());
+
+ return groupByTimeFillPlan;
+ }
+}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByQueryOperator.java
index 363eb90..3ed87ec 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/GroupByQueryOperator.java
@@ -19,4 +19,50 @@
package org.apache.iotdb.db.qp.logical.crud;
-public class GroupByQueryOperator extends AggregationQueryOperator {}
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan;
+import org.apache.iotdb.db.qp.physical.crud.GroupByTimePlan;
+import org.apache.iotdb.db.qp.physical.crud.QueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+
+public class GroupByQueryOperator extends AggregationQueryOperator {
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return isAlignByDevice()
+ ? this.generateAlignByDevicePlan(generator)
+ : super.generateRawDataQueryPlan(generator, initGroupByTimePlan(new GroupByTimePlan()));
+ }
+
+ @Override
+ protected AlignByDevicePlan generateAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setGroupByTimePlan(initGroupByTimePlan(new GroupByTimePlan()));
+
+ return alignByDevicePlan;
+ }
+
+ protected GroupByTimePlan initGroupByTimePlan(QueryPlan queryPlan) throws QueryProcessException {
+ GroupByTimePlan groupByTimePlan = (GroupByTimePlan) initAggregationPlan(queryPlan);
+ GroupByClauseComponent groupByClauseComponent = (GroupByClauseComponent) specialClauseComponent;
+
+ groupByTimePlan.setInterval(groupByClauseComponent.getUnit());
+ groupByTimePlan.setIntervalByMonth(groupByClauseComponent.isIntervalByMonth());
+ groupByTimePlan.setSlidingStep(groupByClauseComponent.getSlidingStep());
+ groupByTimePlan.setSlidingStepByMonth(groupByClauseComponent.isSlidingStepByMonth());
+ groupByTimePlan.setLeftCRightO(groupByClauseComponent.isLeftCRightO());
+
+ if (!groupByClauseComponent.isLeftCRightO()) {
+ groupByTimePlan.setStartTime(groupByClauseComponent.getStartTime() + 1);
+ groupByTimePlan.setEndTime(groupByClauseComponent.getEndTime() + 1);
+ } else {
+ groupByTimePlan.setStartTime(groupByClauseComponent.getStartTime());
+ groupByTimePlan.setEndTime(groupByClauseComponent.getEndTime());
+ }
+
+ return groupByTimePlan;
+ }
+}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/InsertOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/InsertOperator.java
index e8c3f42..b48995e 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/InsertOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/InsertOperator.java
@@ -18,8 +18,16 @@
*/
package org.apache.iotdb.db.qp.logical.crud;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.exception.runtime.SQLParserException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
+import org.apache.iotdb.db.qp.physical.crud.InsertRowsPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+
+import java.util.Arrays;
/** this class extends {@code RootOperator} and process insert statement. */
public class InsertOperator extends Operator {
@@ -66,4 +74,37 @@ public class InsertOperator extends Operator {
public void setTimes(long[] times) {
this.times = times;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ int measurementsNum = 0;
+ for (String measurement : measurementList) {
+ if (measurement.startsWith("(") && measurement.endsWith(")")) {
+ measurementsNum += measurement.replace("(", "").replace(")", "").split(",").length;
+ } else {
+ measurementsNum++;
+ }
+ }
+ if (measurementsNum == 0 || (valueList.length % measurementsNum != 0)) {
+ throw new SQLParserException(
+ String.format(
+ "the measurementList's size %d is not consistent with the valueList's size %d",
+ measurementsNum, valueList.length));
+ }
+ if (measurementsNum == valueList.length) {
+ return new InsertRowPlan(device, times[0], measurementList, valueList);
+ }
+ InsertRowsPlan insertRowsPlan = new InsertRowsPlan();
+ for (int i = 0; i < times.length; i++) {
+ insertRowsPlan.addOneInsertRowPlan(
+ new InsertRowPlan(
+ device,
+ times[i],
+ measurementList,
+ Arrays.copyOfRange(valueList, i * measurementsNum, (i + 1) * measurementsNum)),
+ i);
+ }
+ return insertRowsPlan;
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/LastQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/LastQueryOperator.java
index 2200394..e78c75a 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/LastQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/LastQueryOperator.java
@@ -20,6 +20,10 @@
package org.apache.iotdb.db.qp.logical.crud;
import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.LastQueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.db.query.expression.ResultColumn;
import org.apache.iotdb.db.query.expression.unary.TimeSeriesOperand;
@@ -40,6 +44,10 @@ public class LastQueryOperator extends QueryOperator {
throw new LogicalOperatorException("Last query doesn't support align by device.");
}
+ if (!isAlignByTime()) {
+ throw new LogicalOperatorException("Disable align cannot be applied to LAST query.");
+ }
+
for (ResultColumn resultColumn : selectComponent.getResultColumns()) {
Expression expression = resultColumn.getExpression();
if (!(expression instanceof TimeSeriesOperand)) {
@@ -47,4 +55,10 @@ public class LastQueryOperator extends QueryOperator {
}
}
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return super.generateRawDataQueryPlan(generator, new LastQueryPlan());
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
index 2e3ec8e..f2668d3 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
@@ -18,13 +18,37 @@
*/
package org.apache.iotdb.db.qp.logical.crud;
+import org.apache.iotdb.db.exception.metadata.MetadataException;
import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.index.common.IndexType;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan;
+import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan.MeasurementType;
+import org.apache.iotdb.db.qp.physical.crud.QueryIndexPlan;
+import org.apache.iotdb.db.qp.physical.crud.QueryPlan;
+import org.apache.iotdb.db.qp.physical.crud.RawDataQueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+import org.apache.iotdb.db.query.expression.Expression;
+import org.apache.iotdb.db.query.expression.ResultColumn;
+import org.apache.iotdb.db.query.expression.unary.FunctionExpression;
+import org.apache.iotdb.db.query.expression.unary.TimeSeriesOperand;
+import org.apache.iotdb.db.service.IoTDB;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+import org.apache.iotdb.tsfile.read.expression.IExpression;
+import org.apache.iotdb.tsfile.utils.Pair;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
import java.util.Map;
+import java.util.Set;
public class QueryOperator extends Operator {
@@ -137,4 +161,329 @@ public class QueryOperator extends Operator {
}
}
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ QueryPlan queryPlan = indexType == null ? new RawDataQueryPlan() : new QueryIndexPlan();
+ return isAlignByDevice()
+ ? this.generateAlignByDevicePlan(generator)
+ : this.generateRawDataQueryPlan(generator, queryPlan);
+ }
+
+ protected QueryPlan generateRawDataQueryPlan(PhysicalGenerator generator, QueryPlan queryPlan)
+ throws QueryProcessException {
+ RawDataQueryPlan rawDataQueryPlan = (RawDataQueryPlan) queryPlan;
+ rawDataQueryPlan.setPaths(selectComponent.getPaths());
+ rawDataQueryPlan.setResultColumns(selectComponent.getResultColumns());
+
+ // transform filter operator to expression
+ if (whereComponent != null) {
+ FilterOperator filterOperator = whereComponent.getFilterOperator();
+ List<PartialPath> filterPaths = new ArrayList<>(filterOperator.getPathSet());
+ try {
+ List<TSDataType> seriesTypes = generator.getSeriesTypes(filterPaths);
+ HashMap<PartialPath, TSDataType> pathTSDataTypeHashMap = new HashMap<>();
+ for (int i = 0; i < filterPaths.size(); i++) {
+ rawDataQueryPlan.addFilterPathInDeviceToMeasurements(filterPaths.get(i));
+ pathTSDataTypeHashMap.put(filterPaths.get(i), seriesTypes.get(i));
+ }
+ IExpression expression = filterOperator.transformToExpression(pathTSDataTypeHashMap);
+ rawDataQueryPlan.setExpression(expression);
+ } catch (MetadataException e) {
+ throw new LogicalOptimizeException(e.getMessage());
+ }
+ }
+
+ if (queryPlan instanceof QueryIndexPlan) {
+ ((QueryIndexPlan) queryPlan).setIndexType(indexType);
+ ((QueryIndexPlan) queryPlan).setProps(props);
+ return queryPlan;
+ }
+
+ try {
+ rawDataQueryPlan.setDataTypes(generator.getSeriesTypes(selectComponent.getPaths()));
+ queryPlan.deduplicate(generator);
+ } catch (MetadataException e) {
+ throw new QueryProcessException(e);
+ }
+
+ convertSpecialClauseValues(rawDataQueryPlan);
+
+ return rawDataQueryPlan;
+ }
+
+ protected AlignByDevicePlan generateAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = new AlignByDevicePlan();
+
+ List<PartialPath> prefixPaths = fromComponent.getPrefixPaths();
+ // remove stars in fromPaths and get deviceId with deduplication
+ List<PartialPath> devices = removeStarsInDeviceWithUnique(prefixPaths);
+ List<ResultColumn> resultColumns = selectComponent.getResultColumns();
+ List<String> originAggregations = selectComponent.getAggregationFunctions();
+
+ // to record result measurement columns
+ List<String> measurements = new ArrayList<>();
+ Map<String, String> measurementAliasMap = new HashMap<>();
+ // to check the same measurement of different devices having the same datatype
+ // record the data type of each column of result set
+ Map<String, TSDataType> columnDataTypeMap = new HashMap<>();
+ Map<String, MeasurementType> measurementTypeMap = new HashMap<>();
+
+ // to record the real type of the corresponding measurement
+ Map<String, TSDataType> measurementDataTypeMap = new HashMap<>();
+ List<PartialPath> paths = new ArrayList<>();
+
+ for (int i = 0; i < resultColumns.size(); i++) { // per suffix in SELECT
+ ResultColumn resultColumn = resultColumns.get(i);
+ Expression suffixExpression = resultColumn.getExpression();
+ PartialPath suffixPath =
+ suffixExpression instanceof TimeSeriesOperand
+ ? ((TimeSeriesOperand) suffixExpression).getPath()
+ : (((FunctionExpression) suffixExpression).getPaths().get(0));
+
+ // to record measurements in the loop of a suffix path
+ Set<String> measurementSetOfGivenSuffix = new LinkedHashSet<>();
+
+ // if const measurement
+ if (suffixPath.getMeasurement().startsWith("'")) {
+ measurements.add(suffixPath.getMeasurement());
+ measurementTypeMap.put(suffixPath.getMeasurement(), MeasurementType.Constant);
+ continue;
+ }
+
+ for (PartialPath device : devices) { // per device in FROM after deduplication
+ PartialPath fullPath = device.concatPath(suffixPath);
+ try {
+ // remove stars in SELECT to get actual paths
+ List<PartialPath> actualPaths = getMatchedTimeseries(fullPath);
+ if (resultColumn.hasAlias()) {
+ if (actualPaths.size() == 1) {
+ String columnName = actualPaths.get(0).getMeasurement();
+ if (originAggregations != null && !originAggregations.isEmpty()) {
+ measurementAliasMap.put(
+ originAggregations.get(i) + "(" + columnName + ")", resultColumn.getAlias());
+ } else {
+ measurementAliasMap.put(columnName, resultColumn.getAlias());
+ }
+ } else if (actualPaths.size() >= 2) {
+ throw new QueryProcessException(
+ "alias '"
+ + resultColumn.getAlias()
+ + "' can only be matched with one time series");
+ }
+ }
+
+ // for actual non exist path
+ if (originAggregations != null && actualPaths.isEmpty() && originAggregations.isEmpty()) {
+ String nonExistMeasurement = fullPath.getMeasurement();
+ if (measurementSetOfGivenSuffix.add(nonExistMeasurement)
+ && measurementTypeMap.get(nonExistMeasurement) != MeasurementType.Exist) {
+ measurementTypeMap.put(fullPath.getMeasurement(), MeasurementType.NonExist);
+ }
+ }
+
+ // Get data types with and without aggregate functions (actual time series) respectively
+ // Data type with aggregation function `columnDataTypes` is used for:
+ // 1. Data type consistency check 2. Header calculation, output result set
+ // The actual data type of the time series `measurementDataTypes` is used for
+ // the actual query in the AlignByDeviceDataSet
+ String aggregation =
+ originAggregations != null && !originAggregations.isEmpty()
+ ? originAggregations.get(i)
+ : null;
+
+ Pair<List<TSDataType>, List<TSDataType>> pair =
+ generator.getSeriesTypes(actualPaths, aggregation);
+ List<TSDataType> columnDataTypes = pair.left;
+ List<TSDataType> measurementDataTypes = pair.right;
+ for (int pathIdx = 0; pathIdx < actualPaths.size(); pathIdx++) {
+ PartialPath path = new PartialPath(actualPaths.get(pathIdx).getNodes());
+
+ // check datatype consistency
+ // a example of inconsistency: select s0 from root.sg1.d1, root.sg1.d2 align by
+ // device,
+ // while root.sg1.d1.s0 is INT32 and root.sg1.d2.s0 is FLOAT.
+ String measurementChecked;
+ if (originAggregations != null && !originAggregations.isEmpty()) {
+ measurementChecked = originAggregations.get(i) + "(" + path.getMeasurement() + ")";
+ } else {
+ measurementChecked = path.getMeasurement();
+ }
+ TSDataType columnDataType = columnDataTypes.get(pathIdx);
+ if (columnDataTypeMap.containsKey(measurementChecked)) {
+ if (!columnDataType.equals(columnDataTypeMap.get(measurementChecked))) {
+ throw new QueryProcessException(
+ "The data types of the same measurement column should be the same across "
+ + "devices in ALIGN_BY_DEVICE sql. For more details please refer to the "
+ + "SQL document.");
+ }
+ } else {
+ columnDataTypeMap.put(measurementChecked, columnDataType);
+ measurementDataTypeMap.put(measurementChecked, measurementDataTypes.get(pathIdx));
+ }
+
+ // This step indicates that the measurement exists under the device and is correct,
+ // First, update measurementSetOfGivenSuffix which is distinct
+ // Then if this measurement is recognized as NonExist before，update it to Exist
+ if (measurementSetOfGivenSuffix.add(measurementChecked)
+ || measurementTypeMap.get(measurementChecked) != MeasurementType.Exist) {
+ measurementTypeMap.put(measurementChecked, MeasurementType.Exist);
+ }
+
+ // update paths
+ paths.add(path);
+ }
+
+ } catch (MetadataException | QueryProcessException e) {
+ throw new LogicalOptimizeException(
+ String.format(
+ "Error when getting all paths of a full path: %s", fullPath.getFullPath())
+ + e.getMessage());
+ }
+ }
+
+ // update measurements
+ // Note that in the loop of a suffix path, set is used.
+ // And across the loops of suffix paths, list is used.
+ // e.g. select *,s1 from root.sg.d0, root.sg.d1
+ // for suffix *, measurementSetOfGivenSuffix = {s1,s2,s3}
+ // for suffix s1, measurementSetOfGivenSuffix = {s1}
+ // therefore the final measurements is [s1,s2,s3,s1].
+ measurements.addAll(measurementSetOfGivenSuffix);
+ }
+
+ convertSpecialClauseValues(alignByDevicePlan);
+ // slimit trim on the measurementColumnList
+ if (specialClauseComponent.hasSlimit()) {
+ int seriesSlimit = specialClauseComponent.getSeriesLimit();
+ int seriesOffset = specialClauseComponent.getSeriesOffset();
+ measurements = slimitTrimColumn(measurements, seriesSlimit, seriesOffset);
+ }
+
+ // assigns to alignByDevicePlan
+ alignByDevicePlan.setMeasurements(measurements);
+ alignByDevicePlan.setMeasurementAliasMap(measurementAliasMap);
+ alignByDevicePlan.setDevices(devices);
+ alignByDevicePlan.setColumnDataTypeMap(columnDataTypeMap);
+ alignByDevicePlan.setMeasurementTypeMap(measurementTypeMap);
+ alignByDevicePlan.setMeasurementDataTypeMap(measurementDataTypeMap);
+ alignByDevicePlan.setPaths(paths);
+
+ // get deviceToFilterMap
+ if (whereComponent != null) {
+ alignByDevicePlan.setDeviceToFilterMap(
+ concatFilterByDevice(generator, devices, whereComponent.getFilterOperator()));
+ }
+
+ return alignByDevicePlan;
+ }
+
+ private void convertSpecialClauseValues(QueryPlan queryPlan) {
+ if (specialClauseComponent != null) {
+ queryPlan.setWithoutAllNull(specialClauseComponent.isWithoutAllNull());
+ queryPlan.setWithoutAnyNull(specialClauseComponent.isWithoutAnyNull());
+ queryPlan.setRowLimit(specialClauseComponent.getRowLimit());
+ queryPlan.setRowOffset(specialClauseComponent.getRowOffset());
+ queryPlan.setAscending(specialClauseComponent.isAscending());
+ queryPlan.setAlignByTime(specialClauseComponent.isAlignByTime());
+ }
+ }
+
+ private List<PartialPath> removeStarsInDeviceWithUnique(List<PartialPath> paths)
+ throws LogicalOptimizeException {
+ List<PartialPath> retDevices;
+ Set<PartialPath> deviceSet = new LinkedHashSet<>();
+ try {
+ for (PartialPath path : paths) {
+ Set<PartialPath> tempDS = getMatchedDevices(path);
+ deviceSet.addAll(tempDS);
+ }
+ retDevices = new ArrayList<>(deviceSet);
+ } catch (MetadataException e) {
+ throw new LogicalOptimizeException("error when remove star: " + e.getMessage());
+ }
+ return retDevices;
+ }
+
+ private List<String> slimitTrimColumn(List<String> columnList, int seriesLimit, int seriesOffset)
+ throws QueryProcessException {
+ int size = columnList.size();
+
+ // check parameter range
+ if (seriesOffset >= size) {
+ String errorMessage =
+ "The value of SOFFSET (%d) is equal to or exceeds the number of sequences (%d) that can actually be returned.";
+ throw new QueryProcessException(String.format(errorMessage, seriesOffset, size));
+ }
+ int endPosition = seriesOffset + seriesLimit;
+ if (endPosition > size) {
+ endPosition = size;
+ }
+
+ // trim seriesPath list
+ return new ArrayList<>(columnList.subList(seriesOffset, endPosition));
+ }
+
+ // e.g. translate "select * from root.ln.d1, root.ln.d2 where s1 < 20 AND s2 > 10" to
+ // [root.ln.d1 -> root.ln.d1.s1 < 20 AND root.ln.d1.s2 > 10,
+ // root.ln.d2 -> root.ln.d2.s1 < 20 AND root.ln.d2.s2 > 10)]
+ private Map<String, IExpression> concatFilterByDevice(
+ PhysicalGenerator generator, List<PartialPath> devices, FilterOperator operator)
+ throws QueryProcessException {
+ Map<String, IExpression> deviceToFilterMap = new HashMap<>();
+ Set<PartialPath> filterPaths = new HashSet<>();
+ for (PartialPath device : devices) {
+ FilterOperator newOperator = operator.copy();
+ concatFilterPath(device, newOperator, filterPaths);
+ // transform to a list so it can be indexed
+ List<PartialPath> filterPathList = new ArrayList<>(filterPaths);
+ try {
+ List<TSDataType> seriesTypes = generator.getSeriesTypes(filterPathList);
+ Map<PartialPath, TSDataType> pathTSDataTypeHashMap = new HashMap<>();
+ for (int i = 0; i < filterPathList.size(); i++) {
+ pathTSDataTypeHashMap.put(filterPathList.get(i), seriesTypes.get(i));
+ }
+ deviceToFilterMap.put(
+ device.getFullPath(), newOperator.transformToExpression(pathTSDataTypeHashMap));
+ filterPaths.clear();
+ } catch (MetadataException e) {
+ throw new QueryProcessException(e);
+ }
+ }
+
+ return deviceToFilterMap;
+ }
+
+ private void concatFilterPath(
+ PartialPath prefix, FilterOperator operator, Set<PartialPath> filterPaths) {
+ if (!operator.isLeaf()) {
+ for (FilterOperator child : operator.getChildren()) {
+ concatFilterPath(prefix, child, filterPaths);
+ }
+ return;
+ }
+ BasicFunctionOperator basicOperator = (BasicFunctionOperator) operator;
+ PartialPath filterPath = basicOperator.getSinglePath();
+
+ // do nothing in the cases of "where time > 5" or "where root.d1.s1 > 5"
+ if (SQLConstant.isReservedPath(filterPath)
+ || filterPath.getFirstNode().startsWith(SQLConstant.ROOT)) {
+ filterPaths.add(filterPath);
+ return;
+ }
+
+ PartialPath concatPath = prefix.concatPath(filterPath);
+ filterPaths.add(concatPath);
+ basicOperator.setSinglePath(concatPath);
+ }
+
+ protected Set<PartialPath> getMatchedDevices(PartialPath path) throws MetadataException {
+ return IoTDB.metaManager.getDevices(path);
+ }
+
+ protected List<PartialPath> getMatchedTimeseries(PartialPath path) throws MetadataException {
+ return IoTDB.metaManager.getAllTimeseriesPath(path);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/UDFQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/UDFQueryOperator.java
index 9b36f7c..4b6fdfe 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/UDFQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/UDFQueryOperator.java
@@ -19,6 +19,11 @@
package org.apache.iotdb.db.qp.logical.crud;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.UDTFPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+
public class UDFQueryOperator extends QueryOperator {
public UDFQueryOperator() {
@@ -28,4 +33,16 @@ public class UDFQueryOperator extends QueryOperator {
public UDFQueryOperator(QueryOperator queryOperator) {
super(queryOperator);
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return super.generateRawDataQueryPlan(generator, initUDTFPlan());
+ }
+
+ private UDTFPlan initUDTFPlan() {
+ UDTFPlan udtfPlan = new UDTFPlan(selectComponent.getZoneId());
+ udtfPlan.constructUdfExecutors(selectComponent.getResultColumns());
+ return udtfPlan;
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/WhereComponent.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/WhereComponent.java
index 881a4b1..3191d00 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/WhereComponent.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/WhereComponent.java
@@ -15,6 +15,7 @@
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
+ *
*/
package org.apache.iotdb.db.qp.logical.crud;
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AlterTimeSeriesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AlterTimeSeriesOperator.java
index 173ec20..fa663d6 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AlterTimeSeriesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AlterTimeSeriesOperator.java
@@ -19,8 +19,12 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.AlterTimeSeriesPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.Map;
@@ -95,6 +99,12 @@ public class AlterTimeSeriesOperator extends Operator {
this.alias = alias;
}
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new AlterTimeSeriesPlan(path, alterType, alterMap, alias, tagsMap, attributesMap);
+ }
+
public enum AlterType {
RENAME,
SET,
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AuthorOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AuthorOperator.java
index a82ac00..d3cb282 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AuthorOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/AuthorOperator.java
@@ -18,8 +18,13 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.auth.AuthException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.AuthorPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
/**
* this class maintains information in Author statement, including CREATE, DROP, GRANT and REVOKE.
@@ -110,6 +115,17 @@ public class AuthorOperator extends Operator {
this.nodeName = nodePath;
}
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ try {
+ return new AuthorPlan(
+ authorType, userName, roleName, password, newPassword, privilegeList, nodeName);
+ } catch (AuthException e) {
+ throw new QueryProcessException(e.getMessage());
+ }
+ }
+
public enum AuthorType {
CREATE_USER,
CREATE_ROLE,
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ClearCacheOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ClearCacheOperator.java
index a1e935b..6e0546a 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ClearCacheOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ClearCacheOperator.java
@@ -18,7 +18,11 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ClearCachePlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ClearCacheOperator extends Operator {
@@ -26,4 +30,10 @@ public class ClearCacheOperator extends Operator {
super(tokenIntType);
operatorType = OperatorType.CLEAR_CACHE;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ClearCachePlan();
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CountOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CountOperator.java
index 02b4dbe..6424116 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CountOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CountOperator.java
@@ -18,7 +18,14 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.constant.SQLConstant;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.CountPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
/** CountOperator is used to count time-series and count nodes. */
public class CountOperator extends ShowOperator {
@@ -43,4 +50,24 @@ public class CountOperator extends ShowOperator {
public int getLevel() {
return this.level;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ switch (tokenIntType) {
+ case SQLConstant.TOK_COUNT_DEVICES:
+ return new CountPlan(ShowContentType.COUNT_DEVICES, path);
+ case SQLConstant.TOK_COUNT_STORAGE_GROUP:
+ return new CountPlan(ShowContentType.COUNT_STORAGE_GROUP, path);
+ case SQLConstant.TOK_COUNT_NODE_TIMESERIES:
+ return new CountPlan(ShowContentType.COUNT_NODE_TIMESERIES, path, level);
+ case SQLConstant.TOK_COUNT_NODES:
+ return new CountPlan(ShowContentType.COUNT_NODES, path, level);
+ case SQLConstant.TOK_COUNT_TIMESERIES:
+ return new CountPlan(ShowContentType.COUNT_TIMESERIES, path);
+ default:
+ throw new LogicalOperatorException(
+ String.format("not supported operator type %s in show operation.", operatorType));
+ }
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateFunctionOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateFunctionOperator.java
index 3214ded..da6852a 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateFunctionOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateFunctionOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.CreateFunctionPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class CreateFunctionOperator extends Operator {
@@ -55,4 +59,10 @@ public class CreateFunctionOperator extends Operator {
public String getClassName() {
return className;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new CreateFunctionPlan(isTemporary, udfName, className);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateIndexOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateIndexOperator.java
index 8934bee..f0e7671 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateIndexOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateIndexOperator.java
@@ -18,9 +18,13 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.index.common.IndexType;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.CreateIndexPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.ArrayList;
import java.util.List;
@@ -71,4 +75,10 @@ public class CreateIndexOperator extends Operator {
public void setIndexType(IndexType indexType) {
this.indexType = indexType;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new CreateIndexPlan(paths, props, time, indexType);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateSnapshotOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateSnapshotOperator.java
index 866f1c9..dc9e9d1 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateSnapshotOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateSnapshotOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.CreateSnapshotPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class CreateSnapshotOperator extends Operator {
@@ -27,4 +31,10 @@ public class CreateSnapshotOperator extends Operator {
super(tokenIntType);
operatorType = OperatorType.CREATE_SCHEMA_SNAPSHOT;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new CreateSnapshotPlan();
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTimeSeriesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTimeSeriesOperator.java
index 95d173f..58bf710 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTimeSeriesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTimeSeriesOperator.java
@@ -18,8 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.CreateTimeSeriesPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import org.apache.iotdb.tsfile.file.metadata.enums.CompressionType;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
@@ -105,4 +109,19 @@ public class CreateTimeSeriesOperator extends Operator {
public void setTags(Map<String, String> tags) {
this.tags = tags;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ if (tags != null && !tags.isEmpty() && attributes != null && !attributes.isEmpty()) {
+ for (String tagKey : tags.keySet()) {
+ if (attributes.containsKey(tagKey)) {
+ throw new QueryProcessException(
+ String.format("Tag and attribute shouldn't have the same property key [%s]", tagKey));
+ }
+ }
+ }
+ return new CreateTimeSeriesPlan(
+ path, dataType, encoding, compressor, props, tags, attributes, alias);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTriggerOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTriggerOperator.java
index 38940bd..55910c8 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTriggerOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/CreateTriggerOperator.java
@@ -20,8 +20,12 @@
package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.engine.trigger.executor.TriggerEvent;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.CreateTriggerPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.HashMap;
import java.util.Map;
@@ -79,4 +83,10 @@ public class CreateTriggerOperator extends Operator {
public Map<String, String> getAttributes() {
return attributes;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new CreateTriggerPlan(triggerName, event, fullPath, className, attributes);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DataAuthOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DataAuthOperator.java
index 635e85d..d973e3a 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DataAuthOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DataAuthOperator.java
@@ -20,6 +20,9 @@ package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.DataAuthPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.List;
@@ -40,4 +43,9 @@ public class DataAuthOperator extends Operator {
public List<String> getUsers() {
return users;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
+ return new DataAuthPlan(getType(), users);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeletePartitionOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeletePartitionOperator.java
index 5a533fa..9c12a59 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeletePartitionOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeletePartitionOperator.java
@@ -19,8 +19,12 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.crud.DeletePartitionPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.Set;
@@ -49,4 +53,10 @@ public class DeletePartitionOperator extends Operator {
public Set<Long> getPartitionId() {
return partitionIds;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new DeletePartitionPlan(storageGroupName, partitionIds);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteStorageGroupOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteStorageGroupOperator.java
index 2540899..79288a2 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteStorageGroupOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteStorageGroupOperator.java
@@ -20,6 +20,9 @@ package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.DeleteStorageGroupPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.List;
@@ -39,4 +42,9 @@ public class DeleteStorageGroupOperator extends Operator {
public void setDeletePathList(List<PartialPath> deletePathList) {
this.deletePathList = deletePathList;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
+ return new DeleteStorageGroupPlan(deletePathList);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteTimeSeriesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteTimeSeriesOperator.java
index c3d2fe9..d83213c 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteTimeSeriesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DeleteTimeSeriesOperator.java
@@ -20,6 +20,9 @@ package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.DeleteTimeSeriesPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.List;
@@ -40,4 +43,9 @@ public class DeleteTimeSeriesOperator extends Operator {
public void setDeletePathList(List<PartialPath> deletePathList) {
this.deletePathList = deletePathList;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
+ return new DeleteTimeSeriesPlan(deletePathList);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropFunctionOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropFunctionOperator.java
index c35fc18..50f0908 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropFunctionOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropFunctionOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.DropFunctionPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class DropFunctionOperator extends Operator {
@@ -37,4 +41,10 @@ public class DropFunctionOperator extends Operator {
public String getUdfName() {
return udfName;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new DropFunctionPlan(udfName);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropIndexOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropIndexOperator.java
index e538311..2ade2ac 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropIndexOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropIndexOperator.java
@@ -18,9 +18,13 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.index.common.IndexType;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.DropIndexPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.ArrayList;
import java.util.List;
@@ -52,4 +56,10 @@ public class DropIndexOperator extends Operator {
public void setIndexType(IndexType indexType) {
this.indexType = indexType;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new DropIndexPlan(paths, indexType);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropTriggerOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropTriggerOperator.java
index 0980652..b6dbdda 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropTriggerOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/DropTriggerOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.DropTriggerPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class DropTriggerOperator extends Operator {
@@ -37,4 +41,10 @@ public class DropTriggerOperator extends Operator {
public String getTriggerName() {
return triggerName;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new DropTriggerPlan(triggerName);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/FlushOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/FlushOperator.java
index 2cbed7a..d47fb87 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/FlushOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/FlushOperator.java
@@ -18,8 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.FlushPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.List;
@@ -49,4 +53,10 @@ public class FlushOperator extends Operator {
super(tokenIntType);
operatorType = OperatorType.FLUSH;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new FlushPlan(isSeq, storageGroupList);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/KillQueryOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/KillQueryOperator.java
index 6b1e842..cd7b81d 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/KillQueryOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/KillQueryOperator.java
@@ -18,7 +18,11 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.KillQueryPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class KillQueryOperator extends Operator {
long queryId = -1;
@@ -39,4 +43,10 @@ public class KillQueryOperator extends Operator {
public long getQueryId() {
return queryId;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new KillQueryPlan(queryId);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadConfigurationOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadConfigurationOperator.java
index 330312a..93d35cd 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadConfigurationOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadConfigurationOperator.java
@@ -19,8 +19,11 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class LoadConfigurationOperator extends Operator {
@@ -40,4 +43,10 @@ public class LoadConfigurationOperator extends Operator {
LOCAL,
GLOBAL
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return generator.generateLoadConfigurationPlan(loadConfigurationOperatorType);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadDataOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadDataOperator.java
index 74d4cd6..5f61520 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadDataOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadDataOperator.java
@@ -19,6 +19,9 @@
package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.LoadDataPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
/**
* this class maintains information in Author statement, including CREATE, DROP, GRANT and REVOKE.
@@ -31,7 +34,7 @@ public class LoadDataOperator extends Operator {
/** Constructor of LoadDataOperator. */
public LoadDataOperator(int tokenIntType, String inputFilePath, String measureType) {
super(tokenIntType);
- operatorType = OperatorType.LOADDATA;
+ operatorType = OperatorType.LOAD_DATA;
this.inputFilePath = inputFilePath;
this.measureType = measureType;
}
@@ -43,4 +46,9 @@ public class LoadDataOperator extends Operator {
public String getMeasureType() {
return measureType;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
+ return new LoadDataPlan(inputFilePath, measureType);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadFilesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadFilesOperator.java
index 6dbd923..d74e118 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadFilesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/LoadFilesOperator.java
@@ -18,8 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.OperateFilePlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.io.File;
@@ -48,4 +52,10 @@ public class LoadFilesOperator extends Operator {
public int getSgLevel() {
return sgLevel;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new OperateFilePlan(file, OperatorType.LOAD_FILES, autoCreateSchema, sgLevel);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MergeOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MergeOperator.java
index 3660db8..416daa1 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MergeOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MergeOperator.java
@@ -18,7 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.MergePlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class MergeOperator extends Operator {
@@ -26,4 +31,14 @@ public class MergeOperator extends Operator {
super(tokenIntType);
operatorType = OperatorType.MERGE;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ if (tokenIntType == SQLConstant.TOK_FULL_MERGE) {
+ return new MergePlan(OperatorType.FULL_MERGE);
+ } else {
+ return new MergePlan();
+ }
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MoveFileOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MoveFileOperator.java
index 565d4d1..b75d896 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MoveFileOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/MoveFileOperator.java
@@ -18,8 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.OperateFilePlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.io.File;
@@ -42,4 +46,10 @@ public class MoveFileOperator extends Operator {
public File getTargetDir() {
return targetDir;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new OperateFilePlan(file, targetDir, OperatorType.MOVE_FILE);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/RemoveFileOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/RemoveFileOperator.java
index 2ded0e4..dc2cfad 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/RemoveFileOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/RemoveFileOperator.java
@@ -18,8 +18,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.OperateFilePlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.io.File;
@@ -36,4 +40,10 @@ public class RemoveFileOperator extends Operator {
public File getFile() {
return file;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new OperateFilePlan(file, OperatorType.REMOVE_FILE);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetStorageGroupOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetStorageGroupOperator.java
index d14624f..ad39e36 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetStorageGroupOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetStorageGroupOperator.java
@@ -20,6 +20,9 @@ package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.SetStorageGroupPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class SetStorageGroupOperator extends Operator {
@@ -37,4 +40,9 @@ public class SetStorageGroupOperator extends Operator {
public void setPath(PartialPath path) {
this.path = path;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
+ return new SetStorageGroupPlan(path);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java
index 1fdcde2..a572fd8 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java
@@ -20,8 +20,12 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.SetTTLPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class SetTTLOperator extends Operator {
@@ -48,4 +52,10 @@ public class SetTTLOperator extends Operator {
public void setDataTTL(long dataTTL) {
this.dataTTL = dataTTL;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new SetTTLPlan(storageGroup, dataTTL);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildNodesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildNodesOperator.java
index 15b882b..d132754 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildNodesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildNodesOperator.java
@@ -19,7 +19,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowChildNodesPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowChildNodesOperator extends ShowOperator {
@@ -33,4 +38,10 @@ public class ShowChildNodesOperator extends ShowOperator {
public PartialPath getPath() {
return path;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowChildNodesPlan(ShowContentType.CHILD_NODE, path);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildPathsOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildPathsOperator.java
index 5f10b09..f6bb0ae 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildPathsOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowChildPathsOperator.java
@@ -19,7 +19,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowChildPathsPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowChildPathsOperator extends ShowOperator {
@@ -33,4 +38,10 @@ public class ShowChildPathsOperator extends ShowOperator {
public PartialPath getPath() {
return path;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowChildPathsPlan(ShowContentType.CHILD_PATH, path);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowDevicesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowDevicesOperator.java
index 809187c..01a8df0 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowDevicesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowDevicesOperator.java
@@ -19,7 +19,11 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowDevicesPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowDevicesOperator extends ShowOperator {
@@ -60,4 +64,10 @@ public class ShowDevicesOperator extends ShowOperator {
public boolean hasSgCol() {
return hasSgCol;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowDevicesPlan(path, limit, offset, hasSgCol);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowFunctionsOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowFunctionsOperator.java
index 18f126b..822d725 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowFunctionsOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowFunctionsOperator.java
@@ -19,6 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowFunctionsPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+
public class ShowFunctionsOperator extends ShowOperator {
private boolean showTemporary;
@@ -34,4 +39,10 @@ public class ShowFunctionsOperator extends ShowOperator {
public boolean showTemporary() {
return showTemporary;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowFunctionsPlan(showTemporary);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowMergeStatusOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowMergeStatusOperator.java
index a52a3b0..315d05f 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowMergeStatusOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowMergeStatusOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowMergeStatusPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowMergeStatusOperator extends Operator {
@@ -27,4 +31,10 @@ public class ShowMergeStatusOperator extends Operator {
super(tokenIntType);
setOperatorType(OperatorType.SHOW_MERGE_STATUS);
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowMergeStatusPlan();
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowOperator.java
index 2d12d6a..f90ffd0 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowOperator.java
@@ -19,7 +19,15 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.LogicalOperatorException;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType;
+import org.apache.iotdb.db.qp.physical.sys.ShowQueryProcesslistPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowOperator extends Operator {
@@ -31,4 +39,20 @@ public class ShowOperator extends Operator {
super(tokenIntType);
this.operatorType = operatorType;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ switch (tokenIntType) {
+ case SQLConstant.TOK_FLUSH_TASK_INFO:
+ return new ShowPlan(ShowContentType.FLUSH_TASK_INFO);
+ case SQLConstant.TOK_VERSION:
+ return new ShowPlan(ShowContentType.VERSION);
+ case SQLConstant.TOK_QUERY_PROCESSLIST:
+ return new ShowQueryProcesslistPlan(ShowContentType.QUERY_PROCESSLIST);
+ default:
+ throw new LogicalOperatorException(
+ String.format("not supported operator type %s in show operation.", operatorType));
+ }
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowStorageGroupOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowStorageGroupOperator.java
index 5fb3c04..9dce408 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowStorageGroupOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowStorageGroupOperator.java
@@ -19,7 +19,12 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType;
+import org.apache.iotdb.db.qp.physical.sys.ShowStorageGroupPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowStorageGroupOperator extends ShowOperator {
@@ -33,4 +38,10 @@ public class ShowStorageGroupOperator extends ShowOperator {
public PartialPath getPath() {
return path;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowStorageGroupPlan(ShowContentType.STORAGE_GROUP, path);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTTLOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTTLOperator.java
index 063b4cd..99a62e2 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTTLOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTTLOperator.java
@@ -22,6 +22,9 @@ package org.apache.iotdb.db.qp.logical.sys;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.constant.SQLConstant;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowTTLPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import java.util.List;
@@ -37,4 +40,9 @@ public class ShowTTLOperator extends ShowOperator {
public List<PartialPath> getStorageGroups() {
return storageGroups;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
+ return new ShowTTLPlan(storageGroups);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTimeSeriesOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTimeSeriesOperator.java
index 9ee9294..d546688 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTimeSeriesOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTimeSeriesOperator.java
@@ -19,7 +19,11 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowTimeSeriesPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class ShowTimeSeriesOperator extends ShowOperator {
@@ -85,4 +89,15 @@ public class ShowTimeSeriesOperator extends ShowOperator {
public boolean isOrderByHeat() {
return orderByHeat;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ ShowTimeSeriesPlan showTimeSeriesPlan = new ShowTimeSeriesPlan(path, limit, offset);
+ showTimeSeriesPlan.setIsContains(isContains);
+ showTimeSeriesPlan.setKey(key);
+ showTimeSeriesPlan.setValue(value);
+ showTimeSeriesPlan.setOrderByHeat(orderByHeat);
+ return showTimeSeriesPlan;
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTriggersOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTriggersOperator.java
index d54f4e7..60b5f6a 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTriggersOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/ShowTriggersOperator.java
@@ -19,9 +19,20 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.ShowTriggersPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
+
public class ShowTriggersOperator extends ShowOperator {
public ShowTriggersOperator(int tokenIntType) {
super(tokenIntType);
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new ShowTriggersPlan();
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StartTriggerOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StartTriggerOperator.java
index 1377748..4d18023 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StartTriggerOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StartTriggerOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.StartTriggerPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class StartTriggerOperator extends Operator {
@@ -37,4 +41,10 @@ public class StartTriggerOperator extends Operator {
public String getTriggerName() {
return triggerName;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new StartTriggerPlan(triggerName);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StopTriggerOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StopTriggerOperator.java
index 83b1298..73a9fe3 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StopTriggerOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/StopTriggerOperator.java
@@ -19,7 +19,11 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.StopTriggerPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class StopTriggerOperator extends Operator {
@@ -37,4 +41,10 @@ public class StopTriggerOperator extends Operator {
public String getTriggerName() {
return triggerName;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new StopTriggerPlan(triggerName);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/TracingOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/TracingOperator.java
index 359ff9a..fcc3f0f 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/TracingOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/TracingOperator.java
@@ -18,7 +18,11 @@
*/
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.TracingPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class TracingOperator extends Operator {
@@ -33,4 +37,10 @@ public class TracingOperator extends Operator {
public boolean isTracingOn() {
return isTracingOn;
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new TracingPlan(isTracingOn);
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/UnSetTTLOperator.java
similarity index 71%
copy from server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java
copy to server/src/main/java/org/apache/iotdb/db/qp/logical/sys/UnSetTTLOperator.java
index 1fdcde2..61c5adc 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/SetTTLOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/UnSetTTLOperator.java
@@ -20,15 +20,18 @@
package org.apache.iotdb.db.qp.logical.sys;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.physical.PhysicalPlan;
+import org.apache.iotdb.db.qp.physical.sys.SetTTLPlan;
+import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
-public class SetTTLOperator extends Operator {
+public class UnSetTTLOperator extends Operator {
private PartialPath storageGroup;
- private long dataTTL;
- public SetTTLOperator(int tokenIntType) {
+ public UnSetTTLOperator(int tokenIntType) {
super(tokenIntType);
this.operatorType = OperatorType.TTL;
}
@@ -41,11 +44,9 @@ public class SetTTLOperator extends Operator {
this.storageGroup = storageGroup;
}
- public long getDataTTL() {
- return dataTTL;
- }
-
- public void setDataTTL(long dataTTL) {
- this.dataTTL = dataTTL;
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return new SetTTLPlan(storageGroup);
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/AlignByDevicePlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/AlignByDevicePlan.java
index 3f79a19..55a75eb 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/AlignByDevicePlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/AlignByDevicePlan.java
@@ -121,7 +121,7 @@ public class AlignByDevicePlan extends QueryPlan {
public void setGroupByTimePlan(GroupByTimePlan groupByTimePlan) {
this.groupByTimePlan = groupByTimePlan;
- this.setOperatorType(OperatorType.GROUPBYTIME);
+ this.setOperatorType(OperatorType.GROUP_BY_TIME);
}
public FillQueryPlan getFillQueryPlan() {
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/GroupByTimePlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/GroupByTimePlan.java
index 6c906bf..d3a54a3 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/GroupByTimePlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/GroupByTimePlan.java
@@ -38,7 +38,7 @@ public class GroupByTimePlan extends AggregationPlan {
public GroupByTimePlan() {
super();
- setOperatorType(Operator.OperatorType.GROUPBYTIME);
+ setOperatorType(Operator.OperatorType.GROUP_BY_TIME);
}
public long getStartTime() {
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/InsertTabletPlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/InsertTabletPlan.java
index 276569d..83c5dfd 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/InsertTabletPlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/crud/InsertTabletPlan.java
@@ -77,25 +77,25 @@ public class InsertTabletPlan extends InsertPlan {
private List<Object> failedColumns;
public InsertTabletPlan() {
- super(OperatorType.BATCHINSERT);
+ super(OperatorType.BATCH_INSERT);
}
public InsertTabletPlan(PartialPath prefixPath, List<String> measurements) {
- super(OperatorType.BATCHINSERT);
+ super(OperatorType.BATCH_INSERT);
this.prefixPath = prefixPath;
this.measurements = measurements.toArray(new String[0]);
this.canBeSplit = true;
}
public InsertTabletPlan(PartialPath prefixPath, String[] measurements) {
- super(OperatorType.BATCHINSERT);
+ super(OperatorType.BATCH_INSERT);
this.prefixPath = prefixPath;
this.measurements = measurements;
this.canBeSplit = true;
}
public InsertTabletPlan(PartialPath prefixPath, String[] measurements, List<Integer> dataTypes) {
- super(OperatorType.BATCHINSERT);
+ super(OperatorType.BATCH_INSERT);
this.prefixPath = prefixPath;
this.measurements = measurements;
setDataTypes(dataTypes);
@@ -104,7 +104,7 @@ public class InsertTabletPlan extends InsertPlan {
public InsertTabletPlan(
PartialPath prefixPath, String[] measurements, List<Integer> dataTypes, boolean isAligned) {
- super(OperatorType.BATCHINSERT);
+ super(OperatorType.BATCH_INSERT);
this.prefixPath = prefixPath;
this.measurements = measurements;
setDataTypes(dataTypes);
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/LoadDataPlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/LoadDataPlan.java
index 0c94e20..569843e 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/LoadDataPlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/LoadDataPlan.java
@@ -33,7 +33,7 @@ public class LoadDataPlan extends PhysicalPlan {
/** Constructor of LoadDataPlan. */
public LoadDataPlan(String inputFilePath, String measureType) {
- super(false, Operator.OperatorType.LOADDATA);
+ super(false, Operator.OperatorType.LOAD_DATA);
this.inputFilePath = inputFilePath;
this.measureType = measureType;
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowDevicesPlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowDevicesPlan.java
index c641e32..d194482 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowDevicesPlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowDevicesPlan.java
@@ -37,8 +37,8 @@ public class ShowDevicesPlan extends ShowPlan {
super(ShowContentType.DEVICES, path);
}
- public ShowDevicesPlan(PartialPath path, int limit, int offset, int fetchSize, boolean hasSgCol) {
- super(ShowContentType.DEVICES, path, limit, offset, fetchSize);
+ public ShowDevicesPlan(PartialPath path, int limit, int offset, boolean hasSgCol) {
+ super(ShowContentType.DEVICES, path, limit, offset);
this.hasSgCol = hasSgCol;
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowPlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowPlan.java
index 9342e10..60c1537 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowPlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowPlan.java
@@ -45,8 +45,7 @@ public class ShowPlan extends PhysicalPlan {
this.path = path;
}
- public ShowPlan(
- ShowContentType showContentType, PartialPath path, int limit, int offset, int fetchSize) {
+ public ShowPlan(ShowContentType showContentType, PartialPath path, int limit, int offset) {
this(showContentType, path);
this.limit = limit;
this.offset = offset;
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowTimeSeriesPlan.java b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowTimeSeriesPlan.java
index 5d5e382..2399658 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowTimeSeriesPlan.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/physical/sys/ShowTimeSeriesPlan.java
@@ -56,8 +56,8 @@ public class ShowTimeSeriesPlan extends ShowPlan {
this.orderByHeat = orderByHeat;
}
- public ShowTimeSeriesPlan(PartialPath path, int limit, int offset, int fetchSize) {
- super(ShowContentType.TIMESERIES, path, limit, offset, fetchSize);
+ public ShowTimeSeriesPlan(PartialPath path, int limit, int offset) {
+ super(ShowContentType.TIMESERIES, path, limit, offset);
}
public ShowTimeSeriesPlan() {
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 7b56de7..515b9a5 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -91,6 +91,7 @@ import org.apache.iotdb.db.qp.logical.sys.ShowTriggersOperator;
import org.apache.iotdb.db.qp.logical.sys.StartTriggerOperator;
import org.apache.iotdb.db.qp.logical.sys.StopTriggerOperator;
import org.apache.iotdb.db.qp.logical.sys.TracingOperator;
+import org.apache.iotdb.db.qp.logical.sys.UnSetTTLOperator;
import org.apache.iotdb.db.qp.sql.SqlBaseParser.AliasClauseContext;
import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlignByDeviceClauseOrDisableAlignContext;
import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlignByDeviceClauseOrDisableAlignStatementContext;
@@ -759,7 +760,7 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
@Override
public Operator visitUnsetTTLStatement(UnsetTTLStatementContext ctx) {
- SetTTLOperator operator = new SetTTLOperator(SQLConstant.TOK_UNSET);
+ UnSetTTLOperator operator = new UnSetTTLOperator(SQLConstant.TOK_UNSET);
operator.setStorageGroup(parsePrefixPath(ctx.prefixPath()));
return operator;
}
@@ -1047,13 +1048,12 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
for (ResultColumnContext resultColumnContext : ctx.resultColumn()) {
selectComponent.addResultColumn(parseResultColumn(resultColumnContext));
// judge query type according to the first select element
- if (!hasDecidedQueryType() && isFirstElement) {
+ if (!hasDecidedQueryType()) {
if (selectComponent.hasAggregationFunction()) {
queryOp = new AggregationQueryOperator(queryOp);
} else if (selectComponent.hasTimeSeriesGeneratingFunction()) {
queryOp = new UDFQueryOperator(queryOp);
}
- isFirstElement = false;
}
}
@@ -1063,7 +1063,9 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
private boolean hasDecidedQueryType() {
return queryOp instanceof GroupByQueryOperator
|| queryOp instanceof FillQueryOperator
- || queryOp instanceof LastQueryOperator;
+ || queryOp instanceof LastQueryOperator
+ || queryOp instanceof AggregationQueryOperator
+ || queryOp instanceof UDFQueryOperator;
}
@Override
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java b/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java
index aa46ec0..e2be172 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java
@@ -18,422 +18,33 @@
*/
package org.apache.iotdb.db.qp.strategy;
-import org.apache.iotdb.db.auth.AuthException;
import org.apache.iotdb.db.exception.metadata.MetadataException;
-import org.apache.iotdb.db.exception.query.LogicalOperatorException;
-import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.exception.query.QueryProcessException;
-import org.apache.iotdb.db.exception.runtime.SQLParserException;
import org.apache.iotdb.db.metadata.PartialPath;
-import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.logical.Operator;
-import org.apache.iotdb.db.qp.logical.Operator.OperatorType;
-import org.apache.iotdb.db.qp.logical.crud.BasicFunctionOperator;
-import org.apache.iotdb.db.qp.logical.crud.DeleteDataOperator;
-import org.apache.iotdb.db.qp.logical.crud.FillClauseComponent;
-import org.apache.iotdb.db.qp.logical.crud.FillQueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.FilterOperator;
-import org.apache.iotdb.db.qp.logical.crud.GroupByClauseComponent;
-import org.apache.iotdb.db.qp.logical.crud.GroupByFillClauseComponent;
-import org.apache.iotdb.db.qp.logical.crud.GroupByFillQueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.GroupByQueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.InsertOperator;
-import org.apache.iotdb.db.qp.logical.crud.LastQueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.SpecialClauseComponent;
-import org.apache.iotdb.db.qp.logical.crud.WhereComponent;
-import org.apache.iotdb.db.qp.logical.sys.AlterTimeSeriesOperator;
-import org.apache.iotdb.db.qp.logical.sys.AuthorOperator;
-import org.apache.iotdb.db.qp.logical.sys.CountOperator;
-import org.apache.iotdb.db.qp.logical.sys.CreateFunctionOperator;
-import org.apache.iotdb.db.qp.logical.sys.CreateIndexOperator;
-import org.apache.iotdb.db.qp.logical.sys.CreateTimeSeriesOperator;
-import org.apache.iotdb.db.qp.logical.sys.CreateTriggerOperator;
-import org.apache.iotdb.db.qp.logical.sys.DataAuthOperator;
-import org.apache.iotdb.db.qp.logical.sys.DeletePartitionOperator;
-import org.apache.iotdb.db.qp.logical.sys.DeleteStorageGroupOperator;
-import org.apache.iotdb.db.qp.logical.sys.DeleteTimeSeriesOperator;
-import org.apache.iotdb.db.qp.logical.sys.DropFunctionOperator;
-import org.apache.iotdb.db.qp.logical.sys.DropIndexOperator;
-import org.apache.iotdb.db.qp.logical.sys.DropTriggerOperator;
-import org.apache.iotdb.db.qp.logical.sys.FlushOperator;
-import org.apache.iotdb.db.qp.logical.sys.KillQueryOperator;
-import org.apache.iotdb.db.qp.logical.sys.LoadConfigurationOperator;
import org.apache.iotdb.db.qp.logical.sys.LoadConfigurationOperator.LoadConfigurationOperatorType;
-import org.apache.iotdb.db.qp.logical.sys.LoadDataOperator;
-import org.apache.iotdb.db.qp.logical.sys.LoadFilesOperator;
-import org.apache.iotdb.db.qp.logical.sys.MoveFileOperator;
-import org.apache.iotdb.db.qp.logical.sys.RemoveFileOperator;
-import org.apache.iotdb.db.qp.logical.sys.SetStorageGroupOperator;
-import org.apache.iotdb.db.qp.logical.sys.SetTTLOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowChildNodesOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowChildPathsOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowDevicesOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowFunctionsOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowLockInfoOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowStorageGroupOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowTTLOperator;
-import org.apache.iotdb.db.qp.logical.sys.ShowTimeSeriesOperator;
-import org.apache.iotdb.db.qp.logical.sys.StartTriggerOperator;
-import org.apache.iotdb.db.qp.logical.sys.StopTriggerOperator;
-import org.apache.iotdb.db.qp.logical.sys.TracingOperator;
import org.apache.iotdb.db.qp.physical.PhysicalPlan;
-import org.apache.iotdb.db.qp.physical.crud.AggregationPlan;
-import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan;
-import org.apache.iotdb.db.qp.physical.crud.AlignByDevicePlan.MeasurementType;
-import org.apache.iotdb.db.qp.physical.crud.DeletePartitionPlan;
-import org.apache.iotdb.db.qp.physical.crud.DeletePlan;
-import org.apache.iotdb.db.qp.physical.crud.FillQueryPlan;
-import org.apache.iotdb.db.qp.physical.crud.GroupByTimeFillPlan;
-import org.apache.iotdb.db.qp.physical.crud.GroupByTimePlan;
-import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
-import org.apache.iotdb.db.qp.physical.crud.InsertRowsPlan;
-import org.apache.iotdb.db.qp.physical.crud.LastQueryPlan;
-import org.apache.iotdb.db.qp.physical.crud.QueryIndexPlan;
-import org.apache.iotdb.db.qp.physical.crud.QueryPlan;
-import org.apache.iotdb.db.qp.physical.crud.RawDataQueryPlan;
-import org.apache.iotdb.db.qp.physical.crud.UDTFPlan;
-import org.apache.iotdb.db.qp.physical.sys.AlterTimeSeriesPlan;
-import org.apache.iotdb.db.qp.physical.sys.AuthorPlan;
-import org.apache.iotdb.db.qp.physical.sys.ClearCachePlan;
-import org.apache.iotdb.db.qp.physical.sys.CountPlan;
-import org.apache.iotdb.db.qp.physical.sys.CreateFunctionPlan;
-import org.apache.iotdb.db.qp.physical.sys.CreateIndexPlan;
-import org.apache.iotdb.db.qp.physical.sys.CreateSnapshotPlan;
-import org.apache.iotdb.db.qp.physical.sys.CreateTimeSeriesPlan;
-import org.apache.iotdb.db.qp.physical.sys.CreateTriggerPlan;
-import org.apache.iotdb.db.qp.physical.sys.DataAuthPlan;
-import org.apache.iotdb.db.qp.physical.sys.DeleteStorageGroupPlan;
-import org.apache.iotdb.db.qp.physical.sys.DeleteTimeSeriesPlan;
-import org.apache.iotdb.db.qp.physical.sys.DropFunctionPlan;
-import org.apache.iotdb.db.qp.physical.sys.DropIndexPlan;
-import org.apache.iotdb.db.qp.physical.sys.DropTriggerPlan;
-import org.apache.iotdb.db.qp.physical.sys.FlushPlan;
-import org.apache.iotdb.db.qp.physical.sys.KillQueryPlan;
import org.apache.iotdb.db.qp.physical.sys.LoadConfigurationPlan;
import org.apache.iotdb.db.qp.physical.sys.LoadConfigurationPlan.LoadConfigurationPlanType;
-import org.apache.iotdb.db.qp.physical.sys.LoadDataPlan;
-import org.apache.iotdb.db.qp.physical.sys.MergePlan;
-import org.apache.iotdb.db.qp.physical.sys.OperateFilePlan;
-import org.apache.iotdb.db.qp.physical.sys.SetStorageGroupPlan;
-import org.apache.iotdb.db.qp.physical.sys.SetTTLPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowChildNodesPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowChildPathsPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowDevicesPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowFunctionsPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowLockInfoPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowMergeStatusPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowPlan.ShowContentType;
-import org.apache.iotdb.db.qp.physical.sys.ShowQueryProcesslistPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowStorageGroupPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowTTLPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowTimeSeriesPlan;
-import org.apache.iotdb.db.qp.physical.sys.ShowTriggersPlan;
-import org.apache.iotdb.db.qp.physical.sys.StartTriggerPlan;
-import org.apache.iotdb.db.qp.physical.sys.StopTriggerPlan;
-import org.apache.iotdb.db.qp.physical.sys.TracingPlan;
-import org.apache.iotdb.db.query.expression.Expression;
-import org.apache.iotdb.db.query.expression.ResultColumn;
-import org.apache.iotdb.db.query.expression.unary.FunctionExpression;
-import org.apache.iotdb.db.query.expression.unary.TimeSeriesOperand;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.utils.SchemaUtils;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.read.expression.IExpression;
import org.apache.iotdb.tsfile.utils.Pair;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
-import java.util.Set;
/** Used to convert logical operator to physical plan */
public class PhysicalGenerator {
public PhysicalPlan transformToPhysicalPlan(Operator operator, int fetchSize)
throws QueryProcessException {
- PhysicalPlan physicalPlan = doTransformation(operator, fetchSize);
+ PhysicalPlan physicalPlan = operator.generatePhysicalPlan(this);
physicalPlan.setDebug(operator.isDebug());
return physicalPlan;
}
- @SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
- private PhysicalPlan doTransformation(Operator operator, int fetchSize)
- throws QueryProcessException {
- switch (operator.getType()) {
- case AUTHOR:
- AuthorOperator author = (AuthorOperator) operator;
- try {
- return new AuthorPlan(
- author.getAuthorType(),
- author.getUserName(),
- author.getRoleName(),
- author.getPassWord(),
- author.getNewPassword(),
- author.getPrivilegeList(),
- author.getNodeName());
- } catch (AuthException e) {
- throw new QueryProcessException(e.getMessage());
- }
- case GRANT_WATERMARK_EMBEDDING:
- case REVOKE_WATERMARK_EMBEDDING:
- DataAuthOperator dataAuthOperator = (DataAuthOperator) operator;
- return new DataAuthPlan(dataAuthOperator.getType(), dataAuthOperator.getUsers());
- case LOADDATA:
- LoadDataOperator loadData = (LoadDataOperator) operator;
- return new LoadDataPlan(loadData.getInputFilePath(), loadData.getMeasureType());
- case METADATA:
- case SET_STORAGE_GROUP:
- SetStorageGroupOperator setStorageGroup = (SetStorageGroupOperator) operator;
- return new SetStorageGroupPlan(setStorageGroup.getPath());
- case DELETE_STORAGE_GROUP:
- DeleteStorageGroupOperator deleteStorageGroup = (DeleteStorageGroupOperator) operator;
- return new DeleteStorageGroupPlan(deleteStorageGroup.getDeletePathList());
- case CREATE_TIMESERIES:
- CreateTimeSeriesOperator createOperator = (CreateTimeSeriesOperator) operator;
- if (createOperator.getTags() != null
- && !createOperator.getTags().isEmpty()
- && createOperator.getAttributes() != null
- && !createOperator.getAttributes().isEmpty()) {
- for (String tagKey : createOperator.getTags().keySet()) {
- if (createOperator.getAttributes().containsKey(tagKey)) {
- throw new QueryProcessException(
- String.format(
- "Tag and attribute shouldn't have the same property key [%s]", tagKey));
- }
- }
- }
- return new CreateTimeSeriesPlan(
- createOperator.getPath(),
- createOperator.getDataType(),
- createOperator.getEncoding(),
- createOperator.getCompressor(),
- createOperator.getProps(),
- createOperator.getTags(),
- createOperator.getAttributes(),
- createOperator.getAlias());
- case DELETE_TIMESERIES:
- DeleteTimeSeriesOperator deletePath = (DeleteTimeSeriesOperator) operator;
- return new DeleteTimeSeriesPlan(deletePath.getDeletePathList());
- case CREATE_INDEX:
- CreateIndexOperator createIndexOp = (CreateIndexOperator) operator;
- return new CreateIndexPlan(
- createIndexOp.getPaths(),
- createIndexOp.getProps(),
- createIndexOp.getTime(),
- createIndexOp.getIndexType());
- case DROP_INDEX:
- DropIndexOperator dropIndexOp = (DropIndexOperator) operator;
- return new DropIndexPlan(dropIndexOp.getPaths(), dropIndexOp.getIndexType());
- case ALTER_TIMESERIES:
- AlterTimeSeriesOperator alterTimeSeriesOperator = (AlterTimeSeriesOperator) operator;
- return new AlterTimeSeriesPlan(
- alterTimeSeriesOperator.getPath(),
- alterTimeSeriesOperator.getAlterType(),
- alterTimeSeriesOperator.getAlterMap(),
- alterTimeSeriesOperator.getAlias(),
- alterTimeSeriesOperator.getTagsMap(),
- alterTimeSeriesOperator.getAttributesMap());
- case DELETE:
- DeleteDataOperator delete = (DeleteDataOperator) operator;
- return new DeletePlan(delete.getStartTime(), delete.getEndTime(), delete.getPaths());
- case INSERT:
- InsertOperator insert = (InsertOperator) operator;
- int measurementsNum = 0;
- for (String measurement : insert.getMeasurementList()) {
- if (measurement.startsWith("(") && measurement.endsWith(")")) {
- measurementsNum += measurement.replace("(", "").replace(")", "").split(",").length;
- } else {
- measurementsNum++;
- }
- }
- if (measurementsNum == 0 || (insert.getValueList().length % measurementsNum != 0)) {
- throw new SQLParserException(
- String.format(
- "the measurementList's size %d is not consistent with the valueList's size %d",
- measurementsNum, insert.getValueList().length));
- }
- if (measurementsNum == insert.getValueList().length) {
- return new InsertRowPlan(
- insert.getDevice(),
- insert.getTimes()[0],
- insert.getMeasurementList(),
- insert.getValueList());
- }
- InsertRowsPlan insertRowsPlan = new InsertRowsPlan();
- for (int i = 0; i < insert.getTimes().length; i++) {
- insertRowsPlan.addOneInsertRowPlan(
- new InsertRowPlan(
- insert.getDevice(),
- insert.getTimes()[i],
- insert.getMeasurementList(),
- Arrays.copyOfRange(
- insert.getValueList(), i * measurementsNum, (i + 1) * measurementsNum)),
- i);
- }
- return insertRowsPlan;
- case MERGE:
- if (operator.getTokenIntType() == SQLConstant.TOK_FULL_MERGE) {
- return new MergePlan(OperatorType.FULL_MERGE);
- } else {
- return new MergePlan();
- }
- case FLUSH:
- FlushOperator flushOperator = (FlushOperator) operator;
- return new FlushPlan(flushOperator.isSeq(), flushOperator.getStorageGroupList());
- case TRACING:
- TracingOperator tracingOperator = (TracingOperator) operator;
- return new TracingPlan(tracingOperator.isTracingOn());
- case QUERY:
- return transformQuery((QueryOperator) operator);
- case TTL:
- switch (operator.getTokenIntType()) {
- case SQLConstant.TOK_SET:
- SetTTLOperator setTTLOperator = (SetTTLOperator) operator;
- return new SetTTLPlan(setTTLOperator.getStorageGroup(), setTTLOperator.getDataTTL());
- case SQLConstant.TOK_UNSET:
- SetTTLOperator unsetTTLOperator = (SetTTLOperator) operator;
- return new SetTTLPlan(unsetTTLOperator.getStorageGroup());
- case SQLConstant.TOK_SHOW:
- ShowTTLOperator showTTLOperator = (ShowTTLOperator) operator;
- return new ShowTTLPlan(showTTLOperator.getStorageGroups());
- default:
- throw new LogicalOperatorException(
- String.format(
- "not supported operator type %s in ttl operation.", operator.getType()));
- }
- case LOAD_CONFIGURATION:
- LoadConfigurationOperatorType type =
- ((LoadConfigurationOperator) operator).getLoadConfigurationOperatorType();
- return generateLoadConfigurationPlan(type);
- case SHOW:
- switch (operator.getTokenIntType()) {
- case SQLConstant.TOK_FLUSH_TASK_INFO:
- return new ShowPlan(ShowContentType.FLUSH_TASK_INFO);
- case SQLConstant.TOK_VERSION:
- return new ShowPlan(ShowContentType.VERSION);
- case SQLConstant.TOK_TIMESERIES:
- ShowTimeSeriesOperator showTimeSeriesOperator = (ShowTimeSeriesOperator) operator;
- ShowTimeSeriesPlan showTimeSeriesPlan =
- new ShowTimeSeriesPlan(
- showTimeSeriesOperator.getPath(),
- showTimeSeriesOperator.getLimit(),
- showTimeSeriesOperator.getOffset(),
- fetchSize);
- showTimeSeriesPlan.setIsContains(showTimeSeriesOperator.isContains());
- showTimeSeriesPlan.setKey(showTimeSeriesOperator.getKey());
- showTimeSeriesPlan.setValue(showTimeSeriesOperator.getValue());
- showTimeSeriesPlan.setOrderByHeat(showTimeSeriesOperator.isOrderByHeat());
- return showTimeSeriesPlan;
- case SQLConstant.TOK_STORAGE_GROUP:
- return new ShowStorageGroupPlan(
- ShowContentType.STORAGE_GROUP, ((ShowStorageGroupOperator) operator).getPath());
- case SQLConstant.TOK_LOCK_INFO:
- return new ShowLockInfoPlan(
- ShowContentType.LOCK_INFO, ((ShowLockInfoOperator) operator).getPath());
- case SQLConstant.TOK_DEVICES:
- ShowDevicesOperator showDevicesOperator = (ShowDevicesOperator) operator;
- return new ShowDevicesPlan(
- showDevicesOperator.getPath(),
- showDevicesOperator.getLimit(),
- showDevicesOperator.getOffset(),
- fetchSize,
- showDevicesOperator.hasSgCol());
- case SQLConstant.TOK_COUNT_DEVICES:
- return new CountPlan(
- ShowContentType.COUNT_DEVICES, ((CountOperator) operator).getPath());
- case SQLConstant.TOK_COUNT_STORAGE_GROUP:
- return new CountPlan(
- ShowContentType.COUNT_STORAGE_GROUP, ((CountOperator) operator).getPath());
- case SQLConstant.TOK_COUNT_NODE_TIMESERIES:
- return new CountPlan(
- ShowContentType.COUNT_NODE_TIMESERIES,
- ((CountOperator) operator).getPath(),
- ((CountOperator) operator).getLevel());
- case SQLConstant.TOK_COUNT_NODES:
- return new CountPlan(
- ShowContentType.COUNT_NODES,
- ((CountOperator) operator).getPath(),
- ((CountOperator) operator).getLevel());
- case SQLConstant.TOK_COUNT_TIMESERIES:
- return new CountPlan(
- ShowContentType.COUNT_TIMESERIES, ((CountOperator) operator).getPath());
- case SQLConstant.TOK_CHILD_PATHS:
- return new ShowChildPathsPlan(
- ShowContentType.CHILD_PATH, ((ShowChildPathsOperator) operator).getPath());
- case SQLConstant.TOK_CHILD_NODES:
- return new ShowChildNodesPlan(
- ShowContentType.CHILD_NODE, ((ShowChildNodesOperator) operator).getPath());
- case SQLConstant.TOK_QUERY_PROCESSLIST:
- return new ShowQueryProcesslistPlan(ShowContentType.QUERY_PROCESSLIST);
- case SQLConstant.TOK_SHOW_FUNCTIONS:
- return new ShowFunctionsPlan(((ShowFunctionsOperator) operator).showTemporary());
- case SQLConstant.TOK_SHOW_TRIGGERS:
- return new ShowTriggersPlan();
- default:
- throw new LogicalOperatorException(
- String.format(
- "not supported operator type %s in show operation.", operator.getType()));
- }
- case LOAD_FILES:
- return new OperateFilePlan(
- ((LoadFilesOperator) operator).getFile(),
- OperatorType.LOAD_FILES,
- ((LoadFilesOperator) operator).isAutoCreateSchema(),
- ((LoadFilesOperator) operator).getSgLevel());
- case REMOVE_FILE:
- return new OperateFilePlan(
- ((RemoveFileOperator) operator).getFile(), OperatorType.REMOVE_FILE);
- case MOVE_FILE:
- return new OperateFilePlan(
- ((MoveFileOperator) operator).getFile(),
- ((MoveFileOperator) operator).getTargetDir(),
- OperatorType.MOVE_FILE);
- case CLEAR_CACHE:
- return new ClearCachePlan();
- case SHOW_MERGE_STATUS:
- return new ShowMergeStatusPlan();
- case DELETE_PARTITION:
- DeletePartitionOperator op = (DeletePartitionOperator) operator;
- return new DeletePartitionPlan(op.getStorageGroupName(), op.getPartitionId());
- case CREATE_SCHEMA_SNAPSHOT:
- return new CreateSnapshotPlan();
- case KILL:
- return new KillQueryPlan(((KillQueryOperator) operator).getQueryId());
- case CREATE_FUNCTION:
- CreateFunctionOperator createFunctionOperator = (CreateFunctionOperator) operator;
- return new CreateFunctionPlan(
- createFunctionOperator.isTemporary(),
- createFunctionOperator.getUdfName(),
- createFunctionOperator.getClassName());
- case DROP_FUNCTION:
- DropFunctionOperator dropFunctionOperator = (DropFunctionOperator) operator;
- return new DropFunctionPlan(dropFunctionOperator.getUdfName());
- case CREATE_TRIGGER:
- CreateTriggerOperator createTriggerOperator = (CreateTriggerOperator) operator;
- return new CreateTriggerPlan(
- createTriggerOperator.getTriggerName(),
- createTriggerOperator.getEvent(),
- createTriggerOperator.getFullPath(),
- createTriggerOperator.getClassName(),
- createTriggerOperator.getAttributes());
- case DROP_TRIGGER:
- return new DropTriggerPlan(((DropTriggerOperator) operator).getTriggerName());
- case START_TRIGGER:
- return new StartTriggerPlan(((StartTriggerOperator) operator).getTriggerName());
- case STOP_TRIGGER:
- return new StopTriggerPlan(((StopTriggerOperator) operator).getTriggerName());
- default:
- throw new LogicalOperatorException(operator.getType().toString(), "");
- }
- }
-
- protected PhysicalPlan generateLoadConfigurationPlan(LoadConfigurationOperatorType type)
+ public PhysicalPlan generateLoadConfigurationPlan(LoadConfigurationOperatorType type)
throws QueryProcessException {
switch (type) {
case GLOBAL:
@@ -452,7 +63,7 @@ public class PhysicalGenerator {
* @return pair.left is the type of column in result set, pair.right is the real type of the
* measurement
*/
- protected Pair<List<TSDataType>, List<TSDataType>> getSeriesTypes(
+ public Pair<List<TSDataType>, List<TSDataType>> getSeriesTypes(
List<PartialPath> paths, String aggregation) throws MetadataException {
List<TSDataType> measurementDataTypes = SchemaUtils.getSeriesTypesByPaths(paths, (String) null);
// if the aggregation function is null, the type of column in result set
@@ -471,474 +82,8 @@ public class PhysicalGenerator {
return SchemaUtils.getSeriesTypesByPaths(paths);
}
- interface Transform {
- QueryPlan transform(QueryOperator queryOperator) throws QueryProcessException;
- }
-
- /** agg physical plan transform */
- public static class AggPhysicalPlanRule implements Transform {
-
- @Override
- public QueryPlan transform(QueryOperator queryOperator) throws QueryProcessException {
- AggregationPlan queryPlan;
- if (queryOperator.hasTimeSeriesGeneratingFunction()) {
- throw new QueryProcessException(
- "User-defined and built-in hybrid aggregation is not supported.");
- }
- if (queryOperator instanceof GroupByFillQueryOperator) {
- queryPlan = new GroupByTimeFillPlan();
- } else if (queryOperator instanceof GroupByQueryOperator) {
- queryPlan = new GroupByTimePlan();
- } else {
- queryPlan = new AggregationPlan();
- }
-
- queryPlan.setPaths(queryOperator.getSelectComponent().getPaths());
- queryPlan.setAggregations(queryOperator.getSelectComponent().getAggregationFunctions());
-
- if (queryOperator instanceof GroupByQueryOperator) {
- GroupByTimePlan groupByTimePlan = (GroupByTimePlan) queryPlan;
- GroupByClauseComponent groupByClauseComponent =
- (GroupByClauseComponent) queryOperator.getSpecialClauseComponent();
- groupByTimePlan.setInterval(groupByClauseComponent.getUnit());
- groupByTimePlan.setIntervalByMonth(groupByClauseComponent.isIntervalByMonth());
- groupByTimePlan.setSlidingStep(groupByClauseComponent.getSlidingStep());
- groupByTimePlan.setSlidingStepByMonth(groupByClauseComponent.isSlidingStepByMonth());
- groupByTimePlan.setLeftCRightO(groupByClauseComponent.isLeftCRightO());
- if (!groupByClauseComponent.isLeftCRightO()) {
- groupByTimePlan.setStartTime(groupByClauseComponent.getStartTime() + 1);
- groupByTimePlan.setEndTime(groupByClauseComponent.getEndTime() + 1);
- } else {
- groupByTimePlan.setStartTime(groupByClauseComponent.getStartTime());
- groupByTimePlan.setEndTime(groupByClauseComponent.getEndTime());
- }
- }
- if (queryOperator instanceof GroupByFillQueryOperator) {
- GroupByFillClauseComponent groupByFillClauseComponent =
- (GroupByFillClauseComponent) queryOperator.getSpecialClauseComponent();
- ((GroupByTimeFillPlan) queryPlan).setFillType(groupByFillClauseComponent.getFillTypes());
- for (String aggregation : queryPlan.getAggregations()) {
- if (!SQLConstant.LAST_VALUE.equals(aggregation)) {
- throw new QueryProcessException("Group By Fill only support last_value function");
- }
- }
- } else if (queryOperator.isGroupByLevel()) {
- queryPlan.setLevel(queryOperator.getSpecialClauseComponent().getLevel());
- try {
- if (!verifyAllAggregationDataTypesEqual(queryOperator)) {
- throw new QueryProcessException("Aggregate among unmatched data types");
- }
- } catch (MetadataException e) {
- throw new QueryProcessException(e);
- }
- }
- return queryPlan;
- }
- }
-
- /** fill physical plan transfrom */
- public static class FillPhysicalPlanRule implements Transform {
-
- @Override
- public QueryPlan transform(QueryOperator queryOperator) throws QueryProcessException {
- FillQueryOperator fillQueryOperator = (FillQueryOperator) queryOperator;
- if (queryOperator.hasTimeSeriesGeneratingFunction()) {
- throw new QueryProcessException("Fill functions are not supported in UDF queries.");
- }
- FillQueryPlan queryPlan = new FillQueryPlan();
- FilterOperator timeFilter = fillQueryOperator.getWhereComponent().getFilterOperator();
- if (!timeFilter.isSingle()) {
- throw new QueryProcessException("Slice query must select a single time point");
- }
- long time = Long.parseLong(((BasicFunctionOperator) timeFilter).getValue());
- queryPlan.setQueryTime(time);
- queryPlan.setFillType(
- ((FillClauseComponent) fillQueryOperator.getSpecialClauseComponent()).getFillTypes());
- return queryPlan;
- }
- }
-
- @SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
- private PhysicalPlan transformQuery(QueryOperator queryOperator) throws QueryProcessException {
- QueryPlan queryPlan;
-
- if (queryOperator.hasAggregationFunction()) {
- queryPlan = new AggPhysicalPlanRule().transform(queryOperator);
- } else if (queryOperator instanceof FillQueryOperator) {
- queryPlan = new FillPhysicalPlanRule().transform(queryOperator);
- } else if (queryOperator instanceof LastQueryOperator) {
- queryPlan = new LastQueryPlan();
- } else if (queryOperator.getIndexType() != null) {
- queryPlan = new QueryIndexPlan();
- } else if (queryOperator.hasTimeSeriesGeneratingFunction()) {
- queryPlan = new UDTFPlan(queryOperator.getSelectComponent().getZoneId());
- ((UDTFPlan) queryPlan)
- .constructUdfExecutors(queryOperator.getSelectComponent().getResultColumns());
- } else {
- queryPlan = new RawDataQueryPlan();
- }
-
- if (queryOperator.getSpecialClauseComponent() != null
- && queryOperator.getSpecialClauseComponent().isAlignByDevice()) {
- queryPlan = getAlignQueryPlan(queryOperator, queryPlan);
- } else {
- queryPlan.setPaths(queryOperator.getSelectComponent().getPaths());
- // Last query result set will not be affected by alignment
- if (queryPlan instanceof LastQueryPlan && !queryOperator.isAlignByTime()) {
- throw new QueryProcessException("Disable align cannot be applied to LAST query.");
- }
- queryPlan.setAlignByTime(queryOperator.isAlignByTime());
-
- // transform filter operator to expression
- WhereComponent whereComponent = queryOperator.getWhereComponent();
-
- if (whereComponent != null) {
- FilterOperator filterOperator = whereComponent.getFilterOperator();
- List<PartialPath> filterPaths = new ArrayList<>(filterOperator.getPathSet());
- try {
- List<TSDataType> seriesTypes = getSeriesTypes(filterPaths);
- HashMap<PartialPath, TSDataType> pathTSDataTypeHashMap = new HashMap<>();
- for (int i = 0; i < filterPaths.size(); i++) {
- ((RawDataQueryPlan) queryPlan).addFilterPathInDeviceToMeasurements(filterPaths.get(i));
- pathTSDataTypeHashMap.put(filterPaths.get(i), seriesTypes.get(i));
- }
- IExpression expression = filterOperator.transformToExpression(pathTSDataTypeHashMap);
- ((RawDataQueryPlan) queryPlan).setExpression(expression);
- } catch (MetadataException e) {
- throw new LogicalOptimizeException(e.getMessage());
- }
- }
- }
-
- if (queryOperator.getIndexType() != null) {
- if (queryPlan instanceof QueryIndexPlan) {
- ((QueryIndexPlan) queryPlan).setIndexType(queryOperator.getIndexType());
- ((QueryIndexPlan) queryPlan).setProps(queryOperator.getProps());
- }
- return queryPlan;
- }
-
- queryPlan.setResultColumns(queryOperator.getSelectComponent().getResultColumns());
-
- try {
- List<PartialPath> paths = queryPlan.getPaths();
- List<TSDataType> dataTypes = getSeriesTypes(paths);
- queryPlan.setDataTypes(dataTypes);
-
- queryPlan.deduplicate(this);
- } catch (MetadataException e) {
- throw new QueryProcessException(e);
- }
-
- if (queryOperator.getSpecialClauseComponent() != null) {
- SpecialClauseComponent specialClauseComponent = queryOperator.getSpecialClauseComponent();
- queryPlan.setWithoutAllNull(specialClauseComponent.isWithoutAllNull());
- queryPlan.setWithoutAnyNull(specialClauseComponent.isWithoutAnyNull());
- queryPlan.setRowLimit(specialClauseComponent.getRowLimit());
- queryPlan.setRowOffset(specialClauseComponent.getRowOffset());
- queryPlan.setAscending(specialClauseComponent.isAscending());
- }
-
- return queryPlan;
- }
-
- @SuppressWarnings("squid:S3777") // Suppress high Cognitive Complexity warning
- private QueryPlan getAlignQueryPlan(QueryOperator queryOperator, QueryPlan queryPlan)
- throws QueryProcessException {
- // below is the core realization of ALIGN_BY_DEVICE sql logic
- AlignByDevicePlan alignByDevicePlan = new AlignByDevicePlan();
- if (queryPlan instanceof GroupByTimePlan) {
- alignByDevicePlan.setGroupByTimePlan((GroupByTimePlan) queryPlan);
- } else if (queryPlan instanceof FillQueryPlan) {
- alignByDevicePlan.setFillQueryPlan((FillQueryPlan) queryPlan);
- } else if (queryPlan instanceof AggregationPlan) {
- if (((AggregationPlan) queryPlan).getLevel() >= 0) {
- throw new QueryProcessException("group by level does not support align by device now.");
- }
- alignByDevicePlan.setAggregationPlan((AggregationPlan) queryPlan);
- }
-
- List<PartialPath> prefixPaths = queryOperator.getFromComponent().getPrefixPaths();
- // remove stars in fromPaths and get deviceId with deduplication
- List<PartialPath> devices = this.removeStarsInDeviceWithUnique(prefixPaths);
- List<ResultColumn> resultColumns = queryOperator.getSelectComponent().getResultColumns();
- List<String> originAggregations = queryOperator.getSelectComponent().getAggregationFunctions();
-
- // to record result measurement columns
- List<String> measurements = new ArrayList<>();
- Map<String, String> measurementAliasMap = new HashMap<>();
- // to check the same measurement of different devices having the same datatype
- // record the data type of each column of result set
- Map<String, TSDataType> columnDataTypeMap = new HashMap<>();
- Map<String, MeasurementType> measurementTypeMap = new HashMap<>();
-
- // to record the real type of the corresponding measurement
- Map<String, TSDataType> measurementDataTypeMap = new HashMap<>();
- List<PartialPath> paths = new ArrayList<>();
-
- for (int i = 0; i < resultColumns.size(); i++) { // per suffix in SELECT
- ResultColumn resultColumn = resultColumns.get(i);
- Expression suffixExpression = resultColumn.getExpression();
- PartialPath suffixPath =
- suffixExpression instanceof TimeSeriesOperand
- ? ((TimeSeriesOperand) suffixExpression).getPath()
- : (((FunctionExpression) suffixExpression).getPaths().get(0));
-
- // to record measurements in the loop of a suffix path
- Set<String> measurementSetOfGivenSuffix = new LinkedHashSet<>();
-
- // if const measurement
- if (suffixPath.getMeasurement().startsWith("'")) {
- measurements.add(suffixPath.getMeasurement());
- measurementTypeMap.put(suffixPath.getMeasurement(), MeasurementType.Constant);
- continue;
- }
-
- for (PartialPath device : devices) { // per device in FROM after deduplication
- PartialPath fullPath = device.concatPath(suffixPath);
- try {
- // remove stars in SELECT to get actual paths
- List<PartialPath> actualPaths = getMatchedTimeseries(fullPath);
- if (resultColumn.hasAlias()) {
- if (actualPaths.size() == 1) {
- String columnName = actualPaths.get(0).getMeasurement();
- if (originAggregations != null && !originAggregations.isEmpty()) {
- measurementAliasMap.put(
- originAggregations.get(i) + "(" + columnName + ")", resultColumn.getAlias());
- } else {
- measurementAliasMap.put(columnName, resultColumn.getAlias());
- }
- } else if (actualPaths.size() >= 2) {
- throw new QueryProcessException(
- "alias '"
- + resultColumn.getAlias()
- + "' can only be matched with one time series");
- }
- }
-
- // for actual non exist path
- if (originAggregations != null && actualPaths.isEmpty() && originAggregations.isEmpty()) {
- String nonExistMeasurement = fullPath.getMeasurement();
- if (measurementSetOfGivenSuffix.add(nonExistMeasurement)
- && measurementTypeMap.get(nonExistMeasurement) != MeasurementType.Exist) {
- measurementTypeMap.put(fullPath.getMeasurement(), MeasurementType.NonExist);
- }
- }
-
- // Get data types with and without aggregate functions (actual time series) respectively
- // Data type with aggregation function `columnDataTypes` is used for:
- // 1. Data type consistency check 2. Header calculation, output result set
- // The actual data type of the time series `measurementDataTypes` is used for
- // the actual query in the AlignByDeviceDataSet
- String aggregation =
- originAggregations != null && !originAggregations.isEmpty()
- ? originAggregations.get(i)
- : null;
-
- Pair<List<TSDataType>, List<TSDataType>> pair = getSeriesTypes(actualPaths, aggregation);
- List<TSDataType> columnDataTypes = pair.left;
- List<TSDataType> measurementDataTypes = pair.right;
- for (int pathIdx = 0; pathIdx < actualPaths.size(); pathIdx++) {
- PartialPath path = new PartialPath(actualPaths.get(pathIdx).getNodes());
-
- // check datatype consistency
- // a example of inconsistency: select s0 from root.sg1.d1, root.sg1.d2 align by
- // device,
- // while root.sg1.d1.s0 is INT32 and root.sg1.d2.s0 is FLOAT.
- String measurementChecked;
- if (originAggregations != null && !originAggregations.isEmpty()) {
- measurementChecked = originAggregations.get(i) + "(" + path.getMeasurement() + ")";
- } else {
- measurementChecked = path.getMeasurement();
- }
- TSDataType columnDataType = columnDataTypes.get(pathIdx);
- if (columnDataTypeMap.containsKey(measurementChecked)) {
- if (!columnDataType.equals(columnDataTypeMap.get(measurementChecked))) {
- throw new QueryProcessException(
- "The data types of the same measurement column should be the same across "
- + "devices in ALIGN_BY_DEVICE sql. For more details please refer to the "
- + "SQL document.");
- }
- } else {
- columnDataTypeMap.put(measurementChecked, columnDataType);
- measurementDataTypeMap.put(measurementChecked, measurementDataTypes.get(pathIdx));
- }
-
- // This step indicates that the measurement exists under the device and is correct,
- // First, update measurementSetOfGivenSuffix which is distinct
- // Then if this measurement is recognized as NonExist before，update it to Exist
- if (measurementSetOfGivenSuffix.add(measurementChecked)
- || measurementTypeMap.get(measurementChecked) != MeasurementType.Exist) {
- measurementTypeMap.put(measurementChecked, MeasurementType.Exist);
- }
-
- // update paths
- paths.add(path);
- }
-
- } catch (MetadataException e) {
- throw new LogicalOptimizeException(
- String.format(
- "Error when getting all paths of a full path: %s", fullPath.getFullPath())
- + e.getMessage());
- }
- }
-
- // update measurements
- // Note that in the loop of a suffix path, set is used.
- // And across the loops of suffix paths, list is used.
- // e.g. select *,s1 from root.sg.d0, root.sg.d1
- // for suffix *, measurementSetOfGivenSuffix = {s1,s2,s3}
- // for suffix s1, measurementSetOfGivenSuffix = {s1}
- // therefore the final measurements is [s1,s2,s3,s1].
- measurements.addAll(measurementSetOfGivenSuffix);
- }
-
- // slimit trim on the measurementColumnList
- if (queryOperator.getSpecialClauseComponent().hasSlimit()) {
- int seriesSlimit = queryOperator.getSpecialClauseComponent().getSeriesLimit();
- int seriesOffset = queryOperator.getSpecialClauseComponent().getSeriesOffset();
- measurements = slimitTrimColumn(measurements, seriesSlimit, seriesOffset);
- }
-
- // assigns to alignByDevicePlan
- alignByDevicePlan.setMeasurements(measurements);
- alignByDevicePlan.setMeasurementAliasMap(measurementAliasMap);
- alignByDevicePlan.setDevices(devices);
- alignByDevicePlan.setColumnDataTypeMap(columnDataTypeMap);
- alignByDevicePlan.setMeasurementTypeMap(measurementTypeMap);
- alignByDevicePlan.setMeasurementDataTypeMap(measurementDataTypeMap);
- alignByDevicePlan.setPaths(paths);
-
- // get deviceToFilterMap
- WhereComponent whereComponent = queryOperator.getWhereComponent();
- if (whereComponent != null) {
- alignByDevicePlan.setDeviceToFilterMap(
- concatFilterByDevice(devices, whereComponent.getFilterOperator()));
- }
-
- queryPlan = alignByDevicePlan;
- return queryPlan;
- }
-
- // e.g. translate "select * from root.ln.d1, root.ln.d2 where s1 < 20 AND s2 > 10" to
- // [root.ln.d1 -> root.ln.d1.s1 < 20 AND root.ln.d1.s2 > 10,
- // root.ln.d2 -> root.ln.d2.s1 < 20 AND root.ln.d2.s2 > 10)]
- private Map<String, IExpression> concatFilterByDevice(
- List<PartialPath> devices, FilterOperator operator) throws QueryProcessException {
- Map<String, IExpression> deviceToFilterMap = new HashMap<>();
- Set<PartialPath> filterPaths = new HashSet<>();
- for (PartialPath device : devices) {
- FilterOperator newOperator = operator.copy();
- concatFilterPath(device, newOperator, filterPaths);
- // transform to a list so it can be indexed
- List<PartialPath> filterPathList = new ArrayList<>(filterPaths);
- try {
- List<TSDataType> seriesTypes = getSeriesTypes(filterPathList);
- Map<PartialPath, TSDataType> pathTSDataTypeHashMap = new HashMap<>();
- for (int i = 0; i < filterPathList.size(); i++) {
- pathTSDataTypeHashMap.put(filterPathList.get(i), seriesTypes.get(i));
- }
- deviceToFilterMap.put(
- device.getFullPath(), newOperator.transformToExpression(pathTSDataTypeHashMap));
- filterPaths.clear();
- } catch (MetadataException e) {
- throw new QueryProcessException(e);
- }
- }
-
- return deviceToFilterMap;
- }
-
- private List<PartialPath> removeStarsInDeviceWithUnique(List<PartialPath> paths)
- throws LogicalOptimizeException {
- List<PartialPath> retDevices;
- Set<PartialPath> deviceSet = new LinkedHashSet<>();
- try {
- for (PartialPath path : paths) {
- Set<PartialPath> tempDS = getMatchedDevices(path);
- deviceSet.addAll(tempDS);
- }
- retDevices = new ArrayList<>(deviceSet);
- } catch (MetadataException e) {
- throw new LogicalOptimizeException("error when remove star: " + e.getMessage());
- }
- return retDevices;
- }
-
- private void concatFilterPath(
- PartialPath prefix, FilterOperator operator, Set<PartialPath> filterPaths) {
- if (!operator.isLeaf()) {
- for (FilterOperator child : operator.getChildren()) {
- concatFilterPath(prefix, child, filterPaths);
- }
- return;
- }
- BasicFunctionOperator basicOperator = (BasicFunctionOperator) operator;
- PartialPath filterPath = basicOperator.getSinglePath();
-
- // do nothing in the cases of "where time > 5" or "where root.d1.s1 > 5"
- if (SQLConstant.isReservedPath(filterPath)
- || filterPath.getFirstNode().startsWith(SQLConstant.ROOT)) {
- filterPaths.add(filterPath);
- return;
- }
-
- PartialPath concatPath = prefix.concatPath(filterPath);
- filterPaths.add(concatPath);
- basicOperator.setSinglePath(concatPath);
- }
-
public Pair<List<PartialPath>, Map<String, Integer>> getSeriesSchema(List<PartialPath> paths)
throws MetadataException {
return IoTDB.metaManager.getSeriesSchemas(paths);
}
-
- private List<String> slimitTrimColumn(List<String> columnList, int seriesLimit, int seriesOffset)
- throws QueryProcessException {
- int size = columnList.size();
-
- // check parameter range
- if (seriesOffset >= size) {
- String errorMessage =
- "The value of SOFFSET (%d) is equal to or exceeds the number of sequences (%d) that can actually be returned.";
- throw new QueryProcessException(String.format(errorMessage, seriesOffset, size));
- }
- int endPosition = seriesOffset + seriesLimit;
- if (endPosition > size) {
- endPosition = size;
- }
-
- // trim seriesPath list
- return new ArrayList<>(columnList.subList(seriesOffset, endPosition));
- }
-
- private static boolean verifyAllAggregationDataTypesEqual(QueryOperator queryOperator)
- throws MetadataException {
- List<String> aggregations = queryOperator.getSelectComponent().getAggregationFunctions();
- if (aggregations.isEmpty()) {
- return true;
- }
-
- List<PartialPath> paths = queryOperator.getSelectComponent().getPaths();
- List<TSDataType> dataTypes = SchemaUtils.getSeriesTypesByPaths(paths);
- String aggType = aggregations.get(0);
- switch (aggType) {
- case SQLConstant.MIN_VALUE:
- case SQLConstant.MAX_VALUE:
- case SQLConstant.AVG:
- case SQLConstant.SUM:
- return dataTypes.stream().allMatch(dataTypes.get(0)::equals);
- default:
- return true;
- }
- }
-
- protected List<PartialPath> getMatchedTimeseries(PartialPath path) throws MetadataException {
- return IoTDB.metaManager.getAllTimeseriesPath(path);
- }
-
- protected Set<PartialPath> getMatchedDevices(PartialPath path) throws MetadataException {
- return IoTDB.metaManager.getDevices(path);
- }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/query/dataset/AlignByDeviceDataSet.java b/server/src/main/java/org/apache/iotdb/db/query/dataset/AlignByDeviceDataSet.java
index 2022067..829f3f1 100644
--- a/server/src/main/java/org/apache/iotdb/db/query/dataset/AlignByDeviceDataSet.java
+++ b/server/src/main/java/org/apache/iotdb/db/query/dataset/AlignByDeviceDataSet.java
@@ -92,7 +92,7 @@ public class AlignByDeviceDataSet extends QueryDataSet {
this.measurementTypeMap = alignByDevicePlan.getMeasurementTypeMap();
switch (alignByDevicePlan.getOperatorType()) {
- case GROUPBYTIME:
+ case GROUP_BY_TIME:
this.dataSetType = DataSetType.GROUPBYTIME;
this.groupByTimePlan = alignByDevicePlan.getGroupByTimePlan();
this.groupByTimePlan.setAscending(alignByDevicePlan.isAscending());
diff --git a/server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java b/server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java
index 8605d26..88e13ac 100644
--- a/server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/service/TSServiceImpl.java
@@ -1035,7 +1035,7 @@ public class TSServiceImpl implements TSIService.Iface {
}
break;
case AGGREGATION:
- case GROUPBYTIME:
+ case GROUP_BY_TIME:
case GROUP_BY_FILL:
List<String> aggregations = plan.getAggregations();
if (aggregations.size() != paths.size()) {
diff --git a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBUDTFHybridQueryIT.java b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBUDTFHybridQueryIT.java
index 0710b24..7b63e9e 100644
--- a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBUDTFHybridQueryIT.java
+++ b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBUDTFHybridQueryIT.java
@@ -120,7 +120,7 @@ public class IoTDBUDTFHybridQueryIT {
assertTrue(
throwable
.getMessage()
- .contains("User-defined and built-in hybrid aggregation is not supported."));
+ .contains("User-defined and built-in hybrid aggregation is not supported together."));
}
}
diff --git a/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java b/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java
index e1e5386..5b4c0fb 100644
--- a/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java
@@ -179,7 +179,7 @@ public class PlannerTest {
String groupbyStatement =
"select sum(*) from root.vehicle where root.vehicle.device1.sensor1 > 50 group by ([100,1100), 20ms)";
PhysicalPlan plan9 = processor.parseSQLToPhysicalPlan(groupbyStatement);
- assertEquals(OperatorType.GROUPBYTIME, plan9.getOperatorType());
+ assertEquals(OperatorType.GROUP_BY_TIME, plan9.getOperatorType());
String fillStatement =
"select sensor1 from root.vehicle.device1 where time = 50 Fill(int32[linear, 5m, 5m], boolean[previous, 5m])";