You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by xi...@apache.org on 2021/06/06 07:08:35 UTC
[iotdb] 04/04: Move physicalGenerator to each opeartor inside
This is an automated email from the ASF dual-hosted git repository.
xiangweiwei pushed a commit to branch removeTokenType
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit d3fddf38d7873ffb5988a3d68068f37b93846b2d
Author: Alima777 <wx...@gmail.com>
AuthorDate: Sun Jun 6 15:07:38 2021 +0800
Move physicalGenerator to each opeartor inside
---
.../cluster/query/ClusterPhysicalGenerator.java | 15 +-
.../org/apache/iotdb/db/qp/logical/Operator.java | 7 +-
.../qp/logical/crud/AggregationQueryOperator.java | 56 +-
.../db/qp/logical/crud/DeleteDataOperator.java | 2 +-
.../db/qp/logical/crud/FillQueryOperator.java | 30 +-
.../qp/logical/crud/GroupByFillQueryOperator.java | 26 +-
.../db/qp/logical/crud/GroupByQueryOperator.java | 46 +-
.../iotdb/db/qp/logical/crud/InsertOperator.java | 2 +-
.../db/qp/logical/crud/LastQueryOperator.java | 14 +
.../iotdb/db/qp/logical/crud/QueryOperator.java | 343 ++++++++++++
.../iotdb/db/qp/logical/crud/UDFQueryOperator.java | 21 +
.../db/qp/logical/sys/AlterTimeSeriesOperator.java | 2 +-
.../iotdb/db/qp/logical/sys/AuthorOperator.java | 2 +-
.../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 | 2 +-
.../db/qp/logical/sys/CreateSnapshotOperator.java | 10 +
.../qp/logical/sys/CreateTimeSeriesOperator.java | 2 +-
.../db/qp/logical/sys/CreateTriggerOperator.java | 10 +
.../iotdb/db/qp/logical/sys/DataAuthOperator.java | 2 +-
.../db/qp/logical/sys/DeletePartitionOperator.java | 10 +
.../qp/logical/sys/DeleteStorageGroupOperator.java | 2 +-
.../qp/logical/sys/DeleteTimeSeriesOperator.java | 2 +-
.../db/qp/logical/sys/DropFunctionOperator.java | 10 +
.../iotdb/db/qp/logical/sys/DropIndexOperator.java | 2 +-
.../db/qp/logical/sys/DropTriggerOperator.java | 10 +
.../iotdb/db/qp/logical/sys/FlushOperator.java | 2 +-
.../iotdb/db/qp/logical/sys/KillQueryOperator.java | 10 +
.../qp/logical/sys/LoadConfigurationOperator.java | 9 +
.../iotdb/db/qp/logical/sys/LoadDataOperator.java | 2 +-
.../iotdb/db/qp/logical/sys/LoadFilesOperator.java | 10 +
.../iotdb/db/qp/logical/sys/MergeOperator.java | 2 +-
.../iotdb/db/qp/logical/sys/MoveFileOperator.java | 10 +
.../db/qp/logical/sys/RemoveFileOperator.java | 10 +
.../db/qp/logical/sys/SetStorageGroupOperator.java | 2 +-
.../iotdb/db/qp/logical/sys/SetTTLOperator.java | 2 +-
.../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 | 2 +-
.../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 | 2 +-
.../iotdb/db/qp/logical/sys/UnSetTTLOperator.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 +-
.../iotdb/db/qp/strategy/PhysicalGenerator.java | 591 +--------------------
55 files changed, 811 insertions(+), 665 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/qp/logical/Operator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/Operator.java
index 9cb15a1..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,6 +18,7 @@
*/
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;
@@ -67,8 +68,10 @@ public abstract class Operator {
return SQLConstant.tokenNames.get(tokenIntType);
}
- public abstract PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
- throws QueryProcessException;
+ 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 {
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 e7070a2..e18e873 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
@@ -26,6 +26,8 @@ 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;
@@ -68,30 +70,17 @@ public class AggregationQueryOperator extends QueryOperator {
}
}
- if (isGroupByLevel()) {
- try {
- if (!verifyAllAggregationDataTypesEqual()) {
- throw new LogicalOperatorException("Aggregate among unmatched data types");
- }
- } catch (MetadataException e) {
- throw new LogicalOperatorException(e);
- }
+ if (isGroupByLevel() && isAlignByDevice()) {
+ throw new LogicalOperatorException("group by level does not support align by device now.");
}
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
- AggregationPlan queryPlan = new AggregationPlan();
-
- queryPlan.setPaths(selectComponent.getPaths());
- queryPlan.setAggregations(selectComponent.getAggregationFunctions());
-
- if (isGroupByLevel()) {
- queryPlan.setLevel(specialClauseComponent.getLevel());
- }
-
- return queryPlan;
+ return isAlignByDevice()
+ ? this.generateAggregationAlignByDevicePlan(generator)
+ : this.generateRawDataQueryPlan(generator, new AggregationPlan());
}
private boolean verifyAllAggregationDataTypesEqual() throws MetadataException {
@@ -113,4 +102,33 @@ public class AggregationQueryOperator extends QueryOperator {
return true;
}
}
+
+ protected QueryPlan generateRawDataQueryPlan(PhysicalGenerator generator, QueryPlan queryPlan)
+ throws QueryProcessException {
+ AggregationPlan aggregationPlan = (AggregationPlan) queryPlan;
+ aggregationPlan.setAggregations(selectComponent.getAggregationFunctions());
+ super.generateRawDataQueryPlan(generator, aggregationPlan);
+
+ 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;
+ }
+
+ protected AlignByDevicePlan generateAggregationAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setAggregationPlan(
+ (AggregationPlan) generateRawDataQueryPlan(generator, new AggregationPlan()));
+
+ return alignByDevicePlan;
+ }
}
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 3e9512d..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
@@ -67,7 +67,7 @@ public class DeleteDataOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ 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 6deb3ad..56e0bb1 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
@@ -23,7 +23,9 @@ 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.physical.crud.QueryPlan;
import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
public class FillQueryOperator extends QueryOperator {
@@ -49,13 +51,33 @@ public class FillQueryOperator extends QueryOperator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
- FillQueryPlan queryPlan = new FillQueryPlan();
+ return isAlignByDevice()
+ ? this.generateAlignByDevicePlan(generator)
+ : this.generateRawDataQueryPlan(generator, new FillQueryPlan());
+ }
+
+ @Override
+ protected QueryPlan generateRawDataQueryPlan(PhysicalGenerator generator, QueryPlan queryPlan)
+ throws QueryProcessException {
+ FillQueryPlan fillQueryPlan = (FillQueryPlan) queryPlan;
FilterOperator timeFilter = whereComponent.getFilterOperator();
long time = Long.parseLong(((BasicFunctionOperator) timeFilter).getValue());
- queryPlan.setQueryTime(time);
- queryPlan.setFillType(((FillClauseComponent) specialClauseComponent).getFillTypes());
+ fillQueryPlan.setQueryTime(time);
+ fillQueryPlan.setFillType(((FillClauseComponent) specialClauseComponent).getFillTypes());
+ queryPlan = super.generateRawDataQueryPlan(generator, fillQueryPlan);
+
return queryPlan;
}
+
+ @Override
+ protected AlignByDevicePlan generateAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setFillQueryPlan(
+ (FillQueryPlan) generateRawDataQueryPlan(generator, new FillQueryPlan()));
+
+ return alignByDevicePlan;
+ }
}
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 5829ff1..1cd1f53 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
@@ -23,7 +23,9 @@ 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 {
@@ -40,14 +42,32 @@ public class GroupByFillQueryOperator extends GroupByQueryOperator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
- GroupByTimeFillPlan queryPlan = new GroupByTimeFillPlan();
+ return isAlignByDevice()
+ ? this.generateAggregationAlignByDevicePlan(generator)
+ : this.generateRawDataQueryPlan(generator, new GroupByTimeFillPlan());
+ }
+ @Override
+ protected QueryPlan generateRawDataQueryPlan(PhysicalGenerator generator, QueryPlan queryPlan)
+ throws QueryProcessException {
+ queryPlan = super.generateRawDataQueryPlan(generator, queryPlan);
+ GroupByTimeFillPlan groupByTimeFillPlan = (GroupByTimeFillPlan) queryPlan;
GroupByFillClauseComponent groupByFillClauseComponent =
(GroupByFillClauseComponent) specialClauseComponent;
- queryPlan.setFillType(groupByFillClauseComponent.getFillTypes());
+ groupByTimeFillPlan.setFillType(groupByFillClauseComponent.getFillTypes());
return queryPlan;
}
+
+ @Override
+ protected AlignByDevicePlan generateAggregationAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setGroupByTimePlan(
+ (GroupByTimeFillPlan) generateRawDataQueryPlan(generator, new GroupByTimeFillPlan()));
+
+ return alignByDevicePlan;
+ }
}
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 0da70d0..8428f46 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
@@ -21,30 +21,52 @@ 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.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 transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
- GroupByTimePlan queryPlan = new GroupByTimePlan();
+ return isAlignByDevice()
+ ? this.generateAggregationAlignByDevicePlan(generator)
+ : this.generateRawDataQueryPlan(generator, new GroupByTimePlan());
+ }
+ @Override
+ protected QueryPlan generateRawDataQueryPlan(PhysicalGenerator generator, QueryPlan queryPlan)
+ throws QueryProcessException {
+ queryPlan = super.generateRawDataQueryPlan(generator, queryPlan);
+
+ GroupByTimePlan groupByTimePlan = (GroupByTimePlan) queryPlan;
GroupByClauseComponent groupByClauseComponent = (GroupByClauseComponent) specialClauseComponent;
- queryPlan.setInterval(groupByClauseComponent.getUnit());
- queryPlan.setIntervalByMonth(groupByClauseComponent.isIntervalByMonth());
- queryPlan.setSlidingStep(groupByClauseComponent.getSlidingStep());
- queryPlan.setSlidingStepByMonth(groupByClauseComponent.isSlidingStepByMonth());
- queryPlan.setLeftCRightO(groupByClauseComponent.isLeftCRightO());
+
+ groupByTimePlan.setInterval(groupByClauseComponent.getUnit());
+ groupByTimePlan.setIntervalByMonth(groupByClauseComponent.isIntervalByMonth());
+ groupByTimePlan.setSlidingStep(groupByClauseComponent.getSlidingStep());
+ groupByTimePlan.setSlidingStepByMonth(groupByClauseComponent.isSlidingStepByMonth());
+ groupByTimePlan.setLeftCRightO(groupByClauseComponent.isLeftCRightO());
if (!groupByClauseComponent.isLeftCRightO()) {
- queryPlan.setStartTime(groupByClauseComponent.getStartTime() + 1);
- queryPlan.setEndTime(groupByClauseComponent.getEndTime() + 1);
+ groupByTimePlan.setStartTime(groupByClauseComponent.getStartTime() + 1);
+ groupByTimePlan.setEndTime(groupByClauseComponent.getEndTime() + 1);
} else {
- queryPlan.setStartTime(groupByClauseComponent.getStartTime());
- queryPlan.setEndTime(groupByClauseComponent.getEndTime());
+ groupByTimePlan.setStartTime(groupByClauseComponent.getStartTime());
+ groupByTimePlan.setEndTime(groupByClauseComponent.getEndTime());
}
- return queryPlan;
+ return groupByTimePlan;
+ }
+
+ @Override
+ protected AlignByDevicePlan generateAggregationAlignByDevicePlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ AlignByDevicePlan alignByDevicePlan = super.generateAlignByDevicePlan(generator);
+ alignByDevicePlan.setGroupByTimePlan(
+ (GroupByTimePlan) generateRawDataQueryPlan(generator, new GroupByTimePlan()));
+
+ return alignByDevicePlan;
}
}
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 cabbd00..6d98b2e 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
@@ -76,7 +76,7 @@ public class InsertOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
int measurementsNum = 0;
for (String measurement : measurementList) {
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..ec5fef9 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,323 @@ 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());
+ }
+ }
+
+ try {
+ rawDataQueryPlan.setDataTypes(generator.getSeriesTypes(selectComponent.getPaths()));
+ queryPlan.deduplicate(generator);
+ } catch (MetadataException e) {
+ throw new QueryProcessException(e);
+ }
+
+ if (specialClauseComponent != null) {
+ rawDataQueryPlan.setWithoutAllNull(specialClauseComponent.isWithoutAllNull());
+ rawDataQueryPlan.setWithoutAnyNull(specialClauseComponent.isWithoutAnyNull());
+ rawDataQueryPlan.setRowLimit(specialClauseComponent.getRowLimit());
+ rawDataQueryPlan.setRowOffset(specialClauseComponent.getRowOffset());
+ rawDataQueryPlan.setAscending(specialClauseComponent.isAscending());
+ rawDataQueryPlan.setAlignByTime(specialClauseComponent.isAlignByTime());
+ }
+
+ if (queryPlan instanceof QueryIndexPlan) {
+ ((QueryIndexPlan) queryPlan).setIndexType(indexType);
+ ((QueryIndexPlan) queryPlan).setProps(props);
+ }
+ 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);
+ }
+
+ // 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 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..fb937ee 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,12 @@
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.QueryPlan;
+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 +34,19 @@ public class UDFQueryOperator extends QueryOperator {
public UDFQueryOperator(QueryOperator queryOperator) {
super(queryOperator);
}
+
+ @Override
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
+ throws QueryProcessException {
+ return this.generateRawDataQueryPlan(generator, new UDTFPlan(selectComponent.getZoneId()));
+ }
+
+ @Override
+ protected QueryPlan generateRawDataQueryPlan(PhysicalGenerator generator, QueryPlan queryPlan)
+ throws QueryProcessException {
+ queryPlan = super.generateRawDataQueryPlan(generator, queryPlan);
+ UDTFPlan udtfPlan = (UDTFPlan) queryPlan;
+ udtfPlan.constructUdfExecutors(selectComponent.getResultColumns());
+ return udtfPlan;
+ }
}
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 3cfcdda..c790654 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
@@ -100,7 +100,7 @@ public class AlterTimeSeriesOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
return new AlterTimeSeriesPlan(
getPath(), getAlterType(), getAlterMap(), getAlias(), getTagsMap(), getAttributesMap());
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 8629d4c..4064bf0 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
@@ -116,7 +116,7 @@ public class AuthorOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
try {
return new AuthorPlan(
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 14137ee..512ef80 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
@@ -77,7 +77,7 @@ public class CreateIndexOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
return new CreateIndexPlan(getPaths(), getProps(), getTime(), getIndexType());
}
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 5c78597..c2b2576 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
@@ -111,7 +111,7 @@ public class CreateTimeSeriesOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
if (getTags() != null
&& !getTags().isEmpty()
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 b12f943..916d638 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
@@ -45,7 +45,7 @@ public class DataAuthOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator) {
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
return new DataAuthPlan(getType(), getUsers());
}
}
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 cc67ea2..dafef9c 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
@@ -44,7 +44,7 @@ public class DeleteStorageGroupOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator) {
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
return new DeleteStorageGroupPlan(getDeletePathList());
}
}
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 49a13ee..66b79c9 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
@@ -45,7 +45,7 @@ public class DeleteTimeSeriesOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator) {
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
return new DeleteTimeSeriesPlan(getDeletePathList());
}
}
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 22793aa..a329d72 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
@@ -58,7 +58,7 @@ public class DropIndexOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
return new DropIndexPlan(getPaths(), getIndexType());
}
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 a52b4ce..7abdd43 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
@@ -55,7 +55,7 @@ public class FlushOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
return new FlushPlan(isSeq(), getStorageGroupList());
}
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 48845a3..a322b70 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
@@ -48,7 +48,7 @@ public class LoadDataOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator) {
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
return new LoadDataPlan(getInputFilePath(), getMeasureType());
}
}
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..f98e29d 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, isAutoCreateSchema(), 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 a66b45e..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
@@ -33,7 +33,7 @@ public class MergeOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
if (tokenIntType == SQLConstant.TOK_FULL_MERGE) {
return new MergePlan(OperatorType.FULL_MERGE);
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 dca8f99..d8e99e5 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
@@ -42,7 +42,7 @@ public class SetStorageGroupOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator) {
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator) {
return new SetStorageGroupPlan(getPath());
}
}
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 f81f503..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
@@ -54,7 +54,7 @@ public class SetTTLOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ 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 9e806b3..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
@@ -42,7 +42,7 @@ public class ShowTTLOperator extends ShowOperator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator) {
+ 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 e156350..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
@@ -39,7 +39,7 @@ public class TracingOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ 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/UnSetTTLOperator.java b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/UnSetTTLOperator.java
index 1c4641c..61c5adc 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/UnSetTTLOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/logical/sys/UnSetTTLOperator.java
@@ -45,7 +45,7 @@ public class UnSetTTLOperator extends Operator {
}
@Override
- public PhysicalPlan transform2PhysicalPlan(int fetchSize, PhysicalGenerator generator)
+ public PhysicalPlan generatePhysicalPlan(PhysicalGenerator generator)
throws QueryProcessException {
return new SetTTLPlan(storageGroup);
}
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 5e7284d..e194ddd 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/strategy/PhysicalGenerator.java b/server/src/main/java/org/apache/iotdb/db/qp/strategy/PhysicalGenerator.java
index 2c647a9..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
@@ -19,236 +19,32 @@
package org.apache.iotdb.db.qp.strategy;
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.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.FillQueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.FilterOperator;
-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.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.CountOperator;
-import org.apache.iotdb.db.qp.logical.sys.CreateFunctionOperator;
-import org.apache.iotdb.db.qp.logical.sys.CreateTriggerOperator;
-import org.apache.iotdb.db.qp.logical.sys.DeletePartitionOperator;
-import org.apache.iotdb.db.qp.logical.sys.DropFunctionOperator;
-import org.apache.iotdb.db.qp.logical.sys.DropTriggerOperator;
-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.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.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.ShowStorageGroupOperator;
-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.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.FillQueryPlan;
-import org.apache.iotdb.db.qp.physical.crud.GroupByTimePlan;
-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.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.CreateSnapshotPlan;
-import org.apache.iotdb.db.qp.physical.sys.CreateTriggerPlan;
-import org.apache.iotdb.db.qp.physical.sys.DropFunctionPlan;
-import org.apache.iotdb.db.qp.physical.sys.DropTriggerPlan;
-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.OperateFilePlan;
-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.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.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.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.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 = operator.transform2PhysicalPlan(fetchSize, this);
+ 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 QUERY:
- return transformQuery((QueryOperator) operator);
- 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_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:
@@ -267,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
@@ -286,389 +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 instanceof GroupByQueryOperator) {
- GroupByTimePlan groupByTimePlan = (GroupByTimePlan) queryPlan;
- }
- if (queryOperator instanceof GroupByFillQueryOperator) {
-
- } else if (queryOperator.isGroupByLevel()) {
-
- }
- 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));
- }
-
- 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);
- }
}