This is an automated email from the ASF dual-hosted git repository.
jackietien pushed a commit to branch ty/TableModelGrammar
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/ty/TableModelGrammar by this
push:
new 87fd54953c3 Unity the implementation of PlanOptimizers in query
87fd54953c3 is described below
commit 87fd54953c39ca15a09289ffbbcc95a0d8dcacd3
Author: Beyyes <[email protected]>
AuthorDate: Wed Jul 17 14:19:41 2024 +0800
Unity the implementation of PlanOptimizers in query
---
.../plan/relational/planner/LogicalPlanner.java | 116 +++++----------------
.../plan/relational/planner/PlannerContext.java | 4 +
.../distribute/TableDistributionPlanner.java | 34 ++++--
.../planner/optimizations/OptimizeFactory.java | 78 ++++++++++++++
.../planner/optimizations/PlanOptimizer.java | 44 ++++++--
...Down.java => PushLimitOffsetIntoTableScan.java} | 18 +---
.../optimizations/PushPredicateIntoTableScan.java | 18 ++--
.../planner/optimizations/SimplifyExpressions.java | 16 +--
.../planner/optimizations/TablePlanOptimizer.java | 30 ------
.../analyzer/LimitOffsetPushDownTest.java | 17 +--
.../plan/relational/analyzer/SortTest.java | 30 +++---
11 files changed, 198 insertions(+), 207 deletions(-)
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/distribute/TableDistributionPlanner.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributionPlanner.java
index b47eb51db94..e6911aceb7b 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributionPlanner.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableDistributionPlanner.java
@@ -26,9 +26,11 @@ import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.process.ExchangeNode;
import
org.apache.iotdb.db.queryengine.plan.planner.plan.node.sink.IdentitySinkNode;
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.planner.Symbol;
-import
org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.LimitOffsetPushDown;
-import
org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.TablePlanOptimizer;
+import org.apache.iotdb.db.queryengine.plan.relational.planner.SymbolAllocator;
+import
org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.PlanOptimizer;
+import
org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations.PushLimitOffsetIntoTableScan;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Query;
import java.util.Collections;
@@ -38,20 +40,21 @@ import java.util.Map;
import java.util.stream.Collectors;
import static com.google.common.base.Preconditions.checkArgument;
+import static
org.apache.iotdb.db.queryengine.execution.warnings.WarningCollector.NOOP;
import static
org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand.TIMESTAMP_EXPRESSION_STRING;
public class TableDistributionPlanner {
private final Analysis analysis;
private final LogicalQueryPlan logicalQueryPlan;
private final MPPQueryContext mppQueryContext;
- private final List<TablePlanOptimizer> optimizers;
+ private final List<PlanOptimizer> optimizers;
public TableDistributionPlanner(
Analysis analysis, LogicalQueryPlan logicalQueryPlan, MPPQueryContext
mppQueryContext) {
this.analysis = analysis;
this.logicalQueryPlan = logicalQueryPlan;
this.mppQueryContext = mppQueryContext;
- this.optimizers = Collections.singletonList(new LimitOffsetPushDown());
+ this.optimizers = Collections.singletonList(new
PushLimitOffsetIntoTableScan());
}
public DistributedQueryPlan plan() {
@@ -64,15 +67,26 @@ public class TableDistributionPlanner {
checkArgument(distributedPlanResult.size() == 1, "Root node must return
only one");
// distribute plan optimize rule
- this.optimizers.forEach(
- optimizer ->
- optimizer.optimize(
- distributedPlanResult.get(0), analysis, null, null,
mppQueryContext));
+ PlanNode distributedPlan = distributedPlanResult.get(0);
+ for (PlanOptimizer optimizer : optimizers) {
+ distributedPlan =
+ optimizer.optimize(
+ distributedPlan,
+ new PlanOptimizer.Context(
+ null,
+ analysis,
+ null,
+ mppQueryContext,
+ mppQueryContext.getTypeProvider(),
+ new SymbolAllocator(),
+ mppQueryContext.getQueryId(),
+ NOOP,
+
PlanOptimizersStatsCollector.createPlanOptimizersStatsCollector()));
+ }
// add exchange node for distributed plan
PlanNode outputNodeWithExchange =
- new AddExchangeNodes(mppQueryContext)
- .addExchangeNodes(distributedPlanResult.get(0), planContext);
+ new
AddExchangeNodes(mppQueryContext).addExchangeNodes(distributedPlan,
planContext);
if (analysis.getStatement() instanceof Query) {
analysis
.getRespDatasetHeader()
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..486721b46e9
--- /dev/null
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/OptimizeFactory.java
@@ -0,0 +1,78 @@
+/*
+ * 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 simplifyExpressionOptimizer = new SimplifyExpressions();
+ PlanOptimizer pushPredicateIntoTableScanOptimizer = new
PushPredicateIntoTableScan();
+
+ Set<Rule<?>> columnPruningRules =
+ ImmutableSet.of(
+ new PruneFilterColumns(),
+ new PruneLimitColumns(),
+ new PruneOffsetColumns(),
+ new PruneOutputSourceColumns(),
+ new PruneProjectColumns(),
+ new PruneSortColumns(),
+ new PruneTableScanColumns(plannerContext.getMetadata()));
+ IterativeOptimizer columnPruningOptimizer =
+ new IterativeOptimizer(plannerContext, new RuleStatsRecorder(),
columnPruningRules);
+
+ IterativeOptimizer inlineProjectionsOptimizer =
+ new IterativeOptimizer(
+ plannerContext,
+ new RuleStatsRecorder(),
+ ImmutableSet.of(
+ new InlineProjections(plannerContext), new
RemoveRedundantIdentityProjections()));
+
+ this.planOptimizers =
+ ImmutableList.of(
+ simplifyExpressionOptimizer,
+ columnPruningOptimizer,
+ inlineProjectionsOptimizer,
+ pushPredicateIntoTableScanOptimizer,
+ // redo columnPrune and inlineProjections after
pushPredicateIntoTableScan
+ columnPruningOptimizer,
+ inlineProjectionsOptimizer);
+ }
+
+ 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..003e7d12277 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,23 +31,32 @@ public interface PlanOptimizer {
class Context {
private final SessionInfo sessionInfo;
- private final TypeProvider types;
+ private final Analysis analysis;
+ private final Metadata metadata;
+ private final MPPQueryContext queryContext;
+ private final TypeProvider typeProvider;
private final SymbolAllocator symbolAllocator;
- private final QueryId idAllocator;
+ private final QueryId queryIdAllocator;
private final WarningCollector warningCollector;
private final PlanOptimizersStatsCollector planOptimizersStatsCollector;
public Context(
- SessionInfo session,
- TypeProvider types,
+ SessionInfo sessionInfo,
+ Analysis analysis,
+ Metadata metadata,
+ MPPQueryContext queryContext,
+ TypeProvider typeProvider,
SymbolAllocator symbolAllocator,
- QueryId idAllocator,
+ QueryId queryIdAllocator,
WarningCollector warningCollector,
PlanOptimizersStatsCollector planOptimizersStatsCollector) {
- this.sessionInfo = requireNonNull(session, "session is null");
- this.types = requireNonNull(types, "types is null");
+ this.sessionInfo = sessionInfo;
+ this.analysis = analysis;
+ this.metadata = metadata;
+ this.queryContext = queryContext;
+ this.typeProvider = requireNonNull(typeProvider, "types is null");
this.symbolAllocator = requireNonNull(symbolAllocator, "symbolAllocator
is null");
- this.idAllocator = requireNonNull(idAllocator, "idAllocator is null");
+ this.queryIdAllocator = requireNonNull(queryIdAllocator, "idAllocator is
null");
this.warningCollector = requireNonNull(warningCollector,
"warningCollector is null");
this.planOptimizersStatsCollector =
requireNonNull(planOptimizersStatsCollector,
"planOptimizersStatsCollector is null");
@@ -54,8 +66,20 @@ 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;
+ return typeProvider;
}
public SymbolAllocator symbolAllocator() {
@@ -63,7 +87,7 @@ public interface PlanOptimizer {
}
public QueryId idAllocator() {
- return idAllocator;
+ return queryIdAllocator;
}
public WarningCollector warningCollector() {
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/LimitOffsetPushDown.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushLimitOffsetIntoTableScan.java
similarity index 93%
rename from
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/LimitOffsetPushDown.java
rename to
iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushLimitOffsetIntoTableScan.java
index 4bf01ac1f72..081ea33983e 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/LimitOffsetPushDown.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/PushLimitOffsetIntoTableScan.java
@@ -15,13 +15,10 @@
package org.apache.iotdb.db.queryengine.plan.relational.planner.optimizations;
import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory;
-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.ColumnSchema;
-import org.apache.iotdb.db.queryengine.plan.relational.metadata.Metadata;
import org.apache.iotdb.db.queryengine.plan.relational.planner.OrderingScheme;
import org.apache.iotdb.db.queryengine.plan.relational.planner.Symbol;
import
org.apache.iotdb.db.queryengine.plan.relational.planner.node.CollectNode;
@@ -52,20 +49,15 @@ import static
org.apache.iotdb.db.utils.constant.TestConstant.TIMESTAMP_STR;
* <li>Order by all IDs, limit can be pushed down, set
pushDownToEachDevice==false
* <li>Order by some IDs or order by time, limit can be pushed down, set
pushDownToEachDevice==true
*/
-public class LimitOffsetPushDown implements TablePlanOptimizer {
+public class PushLimitOffsetIntoTableScan implements PlanOptimizer {
@Override
- public PlanNode optimize(
- PlanNode planNode,
- Analysis analysis,
- Metadata metadata,
- SessionInfo sessionInfo,
- MPPQueryContext context) {
- if (!(analysis.getStatement() instanceof Query)) {
- return planNode;
+ public PlanNode optimize(PlanNode plan, PlanOptimizer.Context context) {
+ if (!(context.getAnalysis().getStatement() instanceof Query)) {
+ return plan;
}
- return planNode.accept(new Rewriter(), new Context(analysis));
+ return plan.accept(new Rewriter(), new Context(context.getAnalysis()));
}
private static class Rewriter extends PlanVisitor<PlanNode, Context> {
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/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/TablePlanOptimizer.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/TablePlanOptimizer.java
deleted file mode 100644
index ce33f82adc3..00000000000
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/optimizations/TablePlanOptimizer.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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.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.relational.analyzer.Analysis;
-import org.apache.iotdb.db.queryengine.plan.relational.metadata.Metadata;
-
-public interface TablePlanOptimizer {
- PlanNode optimize(
- PlanNode planNode,
- Analysis analysis,
- Metadata metadata,
- SessionInfo sessionInfo,
- MPPQueryContext context);
-}
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();
