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 <[email protected]> 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); - } }
