This is an automated email from the ASF dual-hosted git repository. caogaofei pushed a commit to branch beyyes/perfect_pushpredicatedown in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit fe3ab17bc7a1eb040f2607d828085c6146ca382d Author: Beyyes <[email protected]> AuthorDate: Wed Jul 17 10:58:32 2024 +0800 unify PlanOptimizer --- .../plan/planner/TableOperatorGenerator.java | 5 +- .../plan/relational/planner/LogicalPlanner.java | 116 +++++---------------- .../plan/relational/planner/PlannerContext.java | 4 + .../planner/optimizations/OptimizeFactory.java | 72 +++++++++++++ .../planner/optimizations/PlanOptimizer.java | 24 +++++ .../optimizations/PushPredicateIntoTableScan.java | 18 ++-- .../planner/optimizations/SimplifyExpressions.java | 16 +-- .../analyzer/LimitOffsetPushDownTest.java | 17 +-- .../plan/relational/analyzer/SortTest.java | 30 +++--- 9 files changed, 157 insertions(+), 145 deletions(-) diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java index b1ba6ded7f0..b9a03e01c06 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/TableOperatorGenerator.java @@ -242,9 +242,12 @@ public class TableOperatorGenerator extends PlanVisitor<Operator, LocalExecution } } - int[] newColumnsIndexArray = new int[outputColumnCount - 1]; + int[] newColumnsIndexArray; if (hasTimeColumn) { + newColumnsIndexArray = new int[outputColumnCount - 1]; System.arraycopy(columnsIndexArray, 0, newColumnsIndexArray, 0, outputColumnCount - 1); + } else { + newColumnsIndexArray = columnsIndexArray; } SeriesScanOptions.Builder scanOptionsBuilder = diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/LogicalPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/LogicalPlanner.java index 8d34326e066..ad8fc032791 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/LogicalPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/LogicalPlanner.java @@ -17,7 +17,6 @@ package org.apache.iotdb.db.queryengine.plan.relational.planner; import org.apache.iotdb.commons.partition.SchemaPartition; import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory; import org.apache.iotdb.commons.schema.table.column.TsTableColumnSchema; -import org.apache.iotdb.commons.utils.TestOnly; import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.common.SessionInfo; import org.apache.iotdb.db.queryengine.common.header.ColumnHeader; @@ -33,24 +32,10 @@ import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Field; import org.apache.iotdb.db.queryengine.plan.relational.analyzer.RelationType; import org.apache.iotdb.db.queryengine.plan.relational.execution.querystats.PlanOptimizersStatsCollector; import org.apache.iotdb.db.queryengine.plan.relational.metadata.Metadata; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.IterativeOptimizer; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.Rule; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.RuleStatsRecorder; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.InlineProjections; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneFilterColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneLimitColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneOffsetColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneOutputSourceColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneProjectColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneSortColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneTableScanColumns; -import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.RemoveRedundantIdentityProjections; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.CreateTableDeviceNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.OutputNode; +import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.OptimizeFactory; import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.PlanOptimizer; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.PushPredicateIntoTableScan; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.SimplifyExpressions; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.TablePlanOptimizer; import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.CreateDevice; import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Explain; import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.FetchDevice; @@ -63,14 +48,11 @@ import org.apache.iotdb.db.schemaengine.table.DataNodeTableCache; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import java.util.Set; import static java.util.Objects.requireNonNull; import static org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING; @@ -78,98 +60,46 @@ import static org.apache.iotdb.db.queryengine.plan.relational.type.InternalTypeM public class LogicalPlanner { private static final Logger LOG = LoggerFactory.getLogger(LogicalPlanner.class); - private final MPPQueryContext context; + private final MPPQueryContext queryContext; private final SessionInfo sessionInfo; private final SymbolAllocator symbolAllocator = new SymbolAllocator(); private final List<PlanOptimizer> planOptimizers; - // TODO Remove after all rules are modified - private final List<TablePlanOptimizer> tablePlanOptimizers; private final Metadata metadata; private final WarningCollector warningCollector; public LogicalPlanner( - MPPQueryContext context, + MPPQueryContext queryContext, Metadata metadata, SessionInfo sessionInfo, WarningCollector warningCollector) { - this.context = context; + this.queryContext = queryContext; this.metadata = metadata; this.sessionInfo = requireNonNull(sessionInfo, "session is null"); this.warningCollector = requireNonNull(warningCollector, "warningCollector is null"); PlannerContext plannerContext = new PlannerContext(metadata, new InternalTypeManager()); - this.tablePlanOptimizers = - Arrays.asList(new SimplifyExpressions(), new PushPredicateIntoTableScan()); - - Set<Rule<?>> pruneRules = - ImmutableSet.of( - new PruneFilterColumns(), - new PruneLimitColumns(), - new PruneOffsetColumns(), - new PruneOutputSourceColumns(), - new PruneProjectColumns(), - new PruneSortColumns(), - new PruneTableScanColumns(metadata)); - Set<Rule<?>> inlineProjections = - ImmutableSet.of( - new InlineProjections(plannerContext), new RemoveRedundantIdentityProjections()); - this.planOptimizers = - ImmutableList.of( - new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), pruneRules), - new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), inlineProjections)); - } - - @TestOnly - public LogicalPlanner( - MPPQueryContext context, - Metadata metadata, - SessionInfo sessionInfo, - List<TablePlanOptimizer> tablePlanOptimizers, - WarningCollector warningCollector) { - this.context = context; - this.metadata = metadata; - this.sessionInfo = requireNonNull(sessionInfo, "session is null"); - this.warningCollector = requireNonNull(warningCollector, "warningCollector is null"); - this.tablePlanOptimizers = tablePlanOptimizers; - PlannerContext plannerContext = new PlannerContext(metadata, new InternalTypeManager()); - Set<Rule<?>> pruneRules = - ImmutableSet.of( - new PruneFilterColumns(), - new PruneLimitColumns(), - new PruneOffsetColumns(), - new PruneOutputSourceColumns(), - new PruneProjectColumns(), - new PruneSortColumns(), - new PruneTableScanColumns(metadata)); - Set<Rule<?>> inlineProjections = - ImmutableSet.of( - new InlineProjections(plannerContext), new RemoveRedundantIdentityProjections()); - this.planOptimizers = - ImmutableList.of( - new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), pruneRules), - new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), inlineProjections)); + this.planOptimizers = new OptimizeFactory(plannerContext).getPlanOptimizers(); } public LogicalQueryPlan plan(Analysis analysis) { PlanNode planNode = planStatement(analysis, analysis.getStatement()); - // TODO remove after all optimizer rewritten as Trino-like - for (TablePlanOptimizer optimizer : tablePlanOptimizers) { - planNode = optimizer.optimize(planNode, analysis, metadata, sessionInfo, context); - } - for (PlanOptimizer optimizer : planOptimizers) { planNode = optimizer.optimize( planNode, new PlanOptimizer.Context( sessionInfo, - context.getTypeProvider(), + analysis, + metadata, + queryContext, + queryContext.getTypeProvider(), symbolAllocator, - context.getQueryId(), + queryContext.getQueryId(), warningCollector, PlanOptimizersStatsCollector.createPlanOptimizersStatsCollector())); } - return new LogicalQueryPlan(context, planNode); + + return new LogicalQueryPlan(queryContext, planNode); } private PlanNode planStatement(Analysis analysis, Statement statement) { @@ -221,7 +151,10 @@ public class LogicalPlanner { OutputNode outputNode = new OutputNode( - context.getQueryId().genPlanNodeId(), plan.getRoot(), names.build(), outputs.build()); + queryContext.getQueryId().genPlanNodeId(), + plan.getRoot(), + names.build(), + outputs.build()); DatasetHeader respDatasetHeader = new DatasetHeader(columnHeaders, false); analysis.setRespDatasetHeader(respDatasetHeader); @@ -238,15 +171,16 @@ public class LogicalPlanner { } private RelationPlanner getRelationPlanner(Analysis analysis) { - return new RelationPlanner(analysis, symbolAllocator, context, sessionInfo, ImmutableMap.of()); + return new RelationPlanner( + analysis, symbolAllocator, queryContext, sessionInfo, ImmutableMap.of()); } private PlanNode planCreateDevice(CreateDevice statement, Analysis analysis) { - context.setQueryType(QueryType.WRITE); + queryContext.setQueryType(QueryType.WRITE); CreateTableDeviceNode node = new CreateTableDeviceNode( - context.getQueryId().genPlanNodeId(), + queryContext.getQueryId().genPlanNodeId(), statement.getDatabase(), statement.getTable(), statement.getDeviceIdList(), @@ -258,14 +192,14 @@ public class LogicalPlanner { metadata.getOrCreateSchemaPartition( statement.getDatabase(), node.getPartitionKeyList(), - context.getSession().getUserName()); + queryContext.getSession().getUserName()); analysis.setSchemaPartitionInfo(partition); return node; } private PlanNode planFetchDevice(FetchDevice statement, Analysis analysis) { - context.setQueryType(QueryType.READ); + queryContext.setQueryType(QueryType.READ); List<ColumnHeader> columnHeaderList = getColumnHeaderList(statement.getDatabase(), statement.getTableName()); @@ -274,7 +208,7 @@ public class LogicalPlanner { TableDeviceFetchNode fetchNode = new TableDeviceFetchNode( - context.getQueryId().genPlanNodeId(), + queryContext.getQueryId().genPlanNodeId(), statement.getDatabase(), statement.getTableName(), statement.getDeviceIdList(), @@ -293,14 +227,14 @@ public class LogicalPlanner { } private PlanNode planShowDevice(ShowDevice statement, Analysis analysis) { - context.setQueryType(QueryType.READ); + queryContext.setQueryType(QueryType.READ); List<ColumnHeader> columnHeaderList = getColumnHeaderList(statement.getDatabase(), statement.getTableName()); TableDeviceQueryNode queryNode = new TableDeviceQueryNode( - context.getQueryId().genPlanNodeId(), + queryContext.getQueryId().genPlanNodeId(), statement.getDatabase(), statement.getTableName(), statement.getIdDeterminedPredicateList(), diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlannerContext.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlannerContext.java index b8090df85d4..7fb3a2cb59e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlannerContext.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlannerContext.java @@ -37,4 +37,8 @@ public class PlannerContext { this.metadata = metadata; this.typeManager = typeManager; } + + public Metadata getMetadata() { + return metadata; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/OptimizeFactory.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/OptimizeFactory.java new file mode 100644 index 00000000000..129f6a557e0 --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/OptimizeFactory.java @@ -0,0 +1,72 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations; + +import org.apache.iotdb.db.queryengine.plan.relational.planner.PlannerContext; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.IterativeOptimizer; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.Rule; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.RuleStatsRecorder; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.InlineProjections; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneFilterColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneLimitColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneOffsetColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneOutputSourceColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneProjectColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneSortColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.PruneTableScanColumns; +import org.apache.iotdb.db.queryengine.plan.relational.planner.iterative.rule.RemoveRedundantIdentityProjections; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; + +import java.util.List; +import java.util.Set; + +public class OptimizeFactory { + + private final List<PlanOptimizer> planOptimizers; + + public OptimizeFactory(PlannerContext plannerContext) { + + PlanOptimizer simplifyExpression = new SimplifyExpressions(); + PlanOptimizer pushPredicateIntoTableScan = new PushPredicateIntoTableScan(); + + Set<Rule<?>> columnPruningRules = + ImmutableSet.of( + new PruneFilterColumns(), + new PruneLimitColumns(), + new PruneOffsetColumns(), + new PruneOutputSourceColumns(), + new PruneProjectColumns(), + new PruneSortColumns(), + new PruneTableScanColumns(plannerContext.getMetadata())); + + Set<Rule<?>> inlineProjections = + ImmutableSet.of( + new InlineProjections(plannerContext), new RemoveRedundantIdentityProjections()); + + this.planOptimizers = + ImmutableList.of( + simplifyExpression, + new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), columnPruningRules), + new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), inlineProjections), + pushPredicateIntoTableScan, + new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), columnPruningRules), + new IterativeOptimizer(plannerContext, new RuleStatsRecorder(), inlineProjections)); + } + + public List<PlanOptimizer> getPlanOptimizers() { + return planOptimizers; + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PlanOptimizer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PlanOptimizer.java index a2a4de8ae95..ac8bd860704 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PlanOptimizer.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PlanOptimizer.java @@ -13,12 +13,15 @@ */ package org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations; +import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.common.QueryId; import org.apache.iotdb.db.queryengine.common.SessionInfo; import org.apache.iotdb.db.queryengine.execution.warnings.WarningCollector; import org.apache.iotdb.db.queryengine.plan.analyze.TypeProvider; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode; +import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Analysis; import org.apache.iotdb.db.queryengine.plan.relational.execution.querystats.PlanOptimizersStatsCollector; +import org.apache.iotdb.db.queryengine.plan.relational.metadata.Metadata; import org.apache.iotdb.db.queryengine.plan.relational.planner.SymbolAllocator; import static java.util.Objects.requireNonNull; @@ -28,6 +31,9 @@ public interface PlanOptimizer { class Context { private final SessionInfo sessionInfo; + private final Analysis analysis; + private final Metadata metadata; + private final MPPQueryContext queryContext; private final TypeProvider types; private final SymbolAllocator symbolAllocator; private final QueryId idAllocator; @@ -36,12 +42,18 @@ public interface PlanOptimizer { public Context( SessionInfo session, + Analysis analysis, + Metadata metadata, + MPPQueryContext queryContext, TypeProvider types, SymbolAllocator symbolAllocator, QueryId idAllocator, WarningCollector warningCollector, PlanOptimizersStatsCollector planOptimizersStatsCollector) { this.sessionInfo = requireNonNull(session, "session is null"); + this.analysis = analysis; + this.metadata = metadata; + this.queryContext = queryContext; this.types = requireNonNull(types, "types is null"); this.symbolAllocator = requireNonNull(symbolAllocator, "symbolAllocator is null"); this.idAllocator = requireNonNull(idAllocator, "idAllocator is null"); @@ -54,6 +66,18 @@ public interface PlanOptimizer { return sessionInfo; } + public Analysis getAnalysis() { + return analysis; + } + + public Metadata getMetadata() { + return metadata; + } + + public MPPQueryContext getQueryContext() { + return queryContext; + } + public TypeProvider types() { return types; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java index 63d55214779..74ff26c7dce 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushPredicateIntoTableScan.java @@ -20,7 +20,6 @@ import org.apache.iotdb.commons.partition.DataPartitionQueryParam; import org.apache.iotdb.db.conf.IoTDBConfig; import org.apache.iotdb.db.conf.IoTDBDescriptor; import org.apache.iotdb.db.queryengine.common.MPPQueryContext; -import org.apache.iotdb.db.queryengine.common.SessionInfo; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanVisitor; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.MultiChildProcessNode; @@ -45,6 +44,7 @@ import org.apache.tsfile.utils.Pair; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.Locale; import java.util.Set; import java.util.stream.Collectors; @@ -52,6 +52,7 @@ import static java.util.Objects.requireNonNull; import static org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory.ATTRIBUTE; import static org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory.MEASUREMENT; import static org.apache.iotdb.db.queryengine.plan.analyze.AnalyzeVisitor.getTimePartitionSlotList; +import static org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING; import static org.apache.iotdb.db.queryengine.plan.relational.planner.ir.GlobalTimePredicateExtractVisitor.extractGlobalTimeFilter; /** @@ -75,18 +76,15 @@ import static org.apache.iotdb.db.queryengine.plan.relational.planner.ir.GlobalT * <p>Notice that, when aggregation, multi-table, join are introduced, this optimization rule need * to be adapted. */ -public class PushPredicateIntoTableScan implements TablePlanOptimizer { +public class PushPredicateIntoTableScan implements PlanOptimizer { private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig(); @Override - public PlanNode optimize( - PlanNode planNode, - Analysis analysis, - Metadata metadata, - SessionInfo sessionInfo, - MPPQueryContext queryContext) { - return planNode.accept(new Rewriter(queryContext, analysis, metadata), null); + public PlanNode optimize(PlanNode plan, Context context) { + return plan.accept( + new Rewriter(context.getQueryContext(), context.getAnalysis(), context.getMetadata()), + null); } private static class Rewriter extends PlanVisitor<PlanNode, Void> { @@ -204,7 +202,7 @@ public class PushPredicateIntoTableScan implements TablePlanOptimizer { .filter(e -> MEASUREMENT.equals(e.getValue().getColumnCategory())) .map(e -> e.getKey().getName()) .collect(Collectors.toSet()); - measurementColumnNames.add("time"); + measurementColumnNames.add(TIMESTAMP_EXPRESSION_STRING.toLowerCase(Locale.ENGLISH)); List<Expression> metadataExpressions = new ArrayList<>(); List<Expression> expressionsCanPushDown = new ArrayList<>(); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/SimplifyExpressions.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/SimplifyExpressions.java index 2b0256ee2d3..1c0d5f55599 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/SimplifyExpressions.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/SimplifyExpressions.java @@ -14,12 +14,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations; -import org.apache.iotdb.db.queryengine.common.MPPQueryContext; -import org.apache.iotdb.db.queryengine.common.SessionInfo; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanVisitor; -import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Analysis; -import org.apache.iotdb.db.queryengine.plan.relational.metadata.Metadata; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.FilterNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.TableScanNode; import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Expression; @@ -28,17 +24,11 @@ import static org.apache.iotdb.db.queryengine.plan.relational.planner.ir.Extract import static org.apache.iotdb.db.queryengine.plan.relational.planner.ir.NormalizeOrExpressionRewriter.normalizeOrExpression; /** <b>Optimization phase:</b> Logical plan planning. */ -public class SimplifyExpressions implements TablePlanOptimizer { +public class SimplifyExpressions implements PlanOptimizer { @Override - public PlanNode optimize( - PlanNode planNode, - Analysis analysis, - Metadata metadata, - SessionInfo sessionInfo, - MPPQueryContext context) { - // TODO add query statement pruning - return planNode.accept(new Rewriter(), new RewriterContext()); + public PlanNode optimize(PlanNode plan, Context context) { + return plan.accept(new Rewriter(), new RewriterContext()); } private static class Rewriter extends PlanVisitor<PlanNode, RewriterContext> { diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/LimitOffsetPushDownTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/LimitOffsetPushDownTest.java index da2368a0ab3..ba8b20794a3 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/LimitOffsetPushDownTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/LimitOffsetPushDownTest.java @@ -30,15 +30,10 @@ import org.apache.iotdb.db.queryengine.plan.relational.planner.node.CollectNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.MergeSortNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.SortNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.TableScanNode; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.PushPredicateIntoTableScan; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.SimplifyExpressions; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.TablePlanOptimizer; import org.junit.Test; import java.time.ZoneId; -import java.util.Arrays; -import java.util.List; import static org.apache.iotdb.db.queryengine.plan.relational.analyzer.AnalyzerTest.analyzeSQL; import static org.apache.iotdb.db.queryengine.plan.statement.component.Ordering.ASC; @@ -67,8 +62,6 @@ public class LimitOffsetPushDownTest { TableDistributionPlanner distributionPlanner; DistributedQueryPlan distributedQueryPlan; TableScanNode tableScanNode; - List<TablePlanOptimizer> planOptimizerList = - Arrays.asList(new SimplifyExpressions(), new PushPredicateIntoTableScan()); // without sort operation, limit can be pushed into TableScan, pushLimitToEachDevice==false // Output - Project - Limit - Offset - Collect - TableScan @@ -78,7 +71,7 @@ public class LimitOffsetPushDownTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); assertTrue(getChildrenNode(rootNode, 4) instanceof TableScanNode); @@ -116,7 +109,7 @@ public class LimitOffsetPushDownTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); assertTrue(getChildrenNode(rootNode, 6) instanceof TableScanNode); @@ -154,7 +147,7 @@ public class LimitOffsetPushDownTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); assertTrue(getChildrenNode(rootNode, 6) instanceof TableScanNode); @@ -192,7 +185,7 @@ public class LimitOffsetPushDownTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); assertTrue(getChildrenNode(rootNode, 6) instanceof TableScanNode); @@ -230,7 +223,7 @@ public class LimitOffsetPushDownTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); assertTrue(getChildrenNode(rootNode, 6) instanceof TableScanNode); diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/SortTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/SortTest.java index c36e40d2bb8..1fcbc31ed98 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/SortTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/SortTest.java @@ -41,15 +41,11 @@ import org.apache.iotdb.db.queryengine.plan.relational.planner.node.OutputNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.ProjectNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.SortNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.TableScanNode; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.PushPredicateIntoTableScan; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.SimplifyExpressions; -import org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.TablePlanOptimizer; import org.junit.Test; import java.time.ZoneId; import java.util.Arrays; -import java.util.List; import java.util.stream.Collectors; import static org.apache.iotdb.db.queryengine.plan.relational.analyzer.AnalyzerTest.analyzeSQL; @@ -79,8 +75,6 @@ public class SortTest { TableDistributionPlanner distributionPlanner; DistributedQueryPlan distributedQueryPlan; TableScanNode tableScanNode; - List<TablePlanOptimizer> planOptimizerList = - Arrays.asList(new SimplifyExpressions(), new PushPredicateIntoTableScan()); /* * order by time, others, some_ids @@ -118,7 +112,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -259,7 +253,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -403,7 +397,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -542,7 +536,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -696,7 +690,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -839,7 +833,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -979,7 +973,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -1122,7 +1116,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -1262,7 +1256,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -1408,7 +1402,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -1565,7 +1559,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode(); @@ -1705,7 +1699,7 @@ public class SortTest { context = new MPPQueryContext(sql, queryId, sessionInfo, null, null); actualAnalysis = analyzeSQL(sql, metadata); logicalQueryPlan = - new LogicalPlanner(context, metadata, sessionInfo, planOptimizerList, WarningCollector.NOOP) + new LogicalPlanner(context, metadata, sessionInfo, WarningCollector.NOOP) .plan(actualAnalysis); rootNode = logicalQueryPlan.getRootNode();
