diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundOlapTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundOlapTableSink.java index 344cfb9b699441..e11e384b2f075f 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundOlapTableSink.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundOlapTableSink.java @@ -24,7 +24,8 @@ import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.PlanType; -import org.apache.doris.nereids.trees.plans.logical.LogicalUnary; +import org.apache.doris.nereids.trees.plans.algebra.Sink; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor; import org.apache.doris.nereids.util.Utils; @@ -37,7 +38,8 @@ /** * Represent an olap table sink plan node that has not been bound. */ -public class UnboundOlapTableSink extends LogicalUnary implements Unbound { +public class UnboundOlapTableSink extends LogicalSink implements Unbound, Sink { + private final List nameParts; private final List colNames; private final List hints; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/FragmentProcessor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/FragmentProcessor.java index e07b72b2f7d5c0..750ea8024f76ec 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/FragmentProcessor.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/FragmentProcessor.java @@ -45,7 +45,7 @@ public PhysicalHashJoin visitPhysicalHashJoin(PhysicalHashJoin project } @Override - public PhysicalRelation visitPhysicalScan(PhysicalRelation scan, CascadesContext context) { + public Plan visitPhysicalOneRowRelation(PhysicalOneRowRelation oneRowRelation, CascadesContext context) { + // TODO: OneRowRelation will be translated to union. Union node cannot apply runtime filter now + // so, just return itself now, until runtime filter could apply on any node. + return oneRowRelation; + } + + @Override + public PhysicalRelation visitPhysicalRelation(PhysicalRelation relation, CascadesContext context) { // add all the slots in map. RuntimeFilterContext ctx = context.getRuntimeFilterContext(); - scan.getOutput().forEach(slot -> ctx.getAliasTransferMap().put(slot, Pair.of(scan, slot))); - return scan; + relation.getOutput().forEach(slot -> ctx.getAliasTransferMap().put(slot, Pair.of(relation, slot))); + return relation; } private long getBuildSideNdv(PhysicalHashJoin join, EqualTo equalTo) { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/RuntimeFilterPruner.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/RuntimeFilterPruner.java index eb31e89eb94f73..aa1f10aa47849e 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/RuntimeFilterPruner.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/processor/post/RuntimeFilterPruner.java @@ -129,7 +129,7 @@ public PhysicalFilter visitPhysicalFilter(PhysicalFilter filter, } @Override - public PhysicalRelation visitPhysicalScan(PhysicalRelation scan, CascadesContext context) { + public PhysicalRelation visitPhysicalRelation(PhysicalRelation scan, CascadesContext context) { RuntimeFilterContext rfCtx = context.getRuntimeFilterContext(); List slots = rfCtx.getTargetOnOlapScanNodeMap().get(scan.getRelationId()); if (slots != null) { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/ChildOutputPropertyDeriver.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/ChildOutputPropertyDeriver.java index 6672ecfe08539e..2ebc3acc5fe946 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/ChildOutputPropertyDeriver.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/ChildOutputPropertyDeriver.java @@ -38,7 +38,6 @@ import org.apache.doris.nereids.trees.plans.physical.PhysicalEmptyRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalEsScan; import org.apache.doris.nereids.trees.plans.physical.PhysicalFileScan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalFileSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalFilter; import org.apache.doris.nereids.trees.plans.physical.PhysicalGenerate; import org.apache.doris.nereids.trees.plans.physical.PhysicalHashAggregate; @@ -47,12 +46,12 @@ import org.apache.doris.nereids.trees.plans.physical.PhysicalLimit; import org.apache.doris.nereids.trees.plans.physical.PhysicalNestedLoopJoin; import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapScan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapTableSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalOneRowRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalPartitionTopN; import org.apache.doris.nereids.trees.plans.physical.PhysicalProject; import org.apache.doris.nereids.trees.plans.physical.PhysicalRepeat; import org.apache.doris.nereids.trees.plans.physical.PhysicalSetOperation; +import org.apache.doris.nereids.trees.plans.physical.PhysicalSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalTVFRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalUnion; import org.apache.doris.nereids.trees.plans.physical.PhysicalWindow; @@ -92,26 +91,20 @@ public PhysicalProperties getOutputProperties(GroupExpression groupExpression) { return groupExpression.getPlan().accept(this, new PlanContext(groupExpression)); } + @Override + public PhysicalProperties visit(Plan plan, PlanContext context) { + return PhysicalProperties.ANY; + } + /* ******************************************************************************************** * sink Node, in lexicographical order * ******************************************************************************************** */ @Override - public PhysicalProperties visitPhysicalFileSink(PhysicalFileSink fileSink, PlanContext context) { + public PhysicalProperties visitPhysicalSink(PhysicalSink physicalSink, PlanContext context) { return PhysicalProperties.GATHER; } - @Override - public PhysicalProperties visitPhysicalOlapTableSink(PhysicalOlapTableSink olapTableSink, - PlanContext context) { - return PhysicalProperties.GATHER; - } - - @Override - public PhysicalProperties visit(Plan plan, PlanContext context) { - return PhysicalProperties.ANY; - } - /* ******************************************************************************************** * Leaf Plan Node, in lexicographical order * ******************************************************************************************** */ diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/AddDefaultLimit.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/AddDefaultLimit.java index 99904a70ce2bae..6853f1e9fb1e98 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/AddDefaultLimit.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/AddDefaultLimit.java @@ -22,9 +22,8 @@ import org.apache.doris.nereids.trees.plans.LimitPhase; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.logical.LogicalCTEAnchor; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; import org.apache.doris.nereids.trees.plans.logical.LogicalLimit; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.logical.LogicalSort; import org.apache.doris.nereids.trees.plans.visitor.CustomRewriter; import org.apache.doris.nereids.trees.plans.visitor.DefaultPlanRewriter; @@ -63,16 +62,9 @@ public Plan visitLogicalCTEAnchor(LogicalCTEAnchor olapTableSink, - StatementContext context) { - Plan child = olapTableSink.child().accept(this, context); - return olapTableSink.withChildren(child); - } - - @Override - public Plan visitLogicalFileSink(LogicalFileSink fileSink, StatementContext context) { - Plan child = fileSink.child().accept(this, context); - return fileSink.withChildren(child); + public Plan visitLogicalSink(LogicalSink logicalSink, StatementContext context) { + Plan child = logicalSink.child().accept(this, context); + return logicalSink.withChildren(child); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/ColumnPruning.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/ColumnPruning.java index 2fc17a717d06f8..85e0f84524caac 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/ColumnPruning.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/ColumnPruning.java @@ -28,11 +28,10 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalAggregate; import org.apache.doris.nereids.trees.plans.logical.LogicalCTEProducer; import org.apache.doris.nereids.trees.plans.logical.LogicalExcept; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; import org.apache.doris.nereids.trees.plans.logical.LogicalIntersect; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; import org.apache.doris.nereids.trees.plans.logical.LogicalProject; import org.apache.doris.nereids.trees.plans.logical.LogicalRepeat; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.logical.LogicalUnion; import org.apache.doris.nereids.trees.plans.logical.OutputPrunable; import org.apache.doris.nereids.trees.plans.visitor.CustomRewriter; @@ -162,13 +161,8 @@ public Plan visitLogicalIntersect(LogicalIntersect intersect, PruneContext conte } @Override - public Plan visitLogicalOlapTableSink(LogicalOlapTableSink olapTableSink, PruneContext context) { - return skipPruneThisAndFirstLevelChildren(olapTableSink); - } - - @Override - public Plan visitLogicalFileSink(LogicalFileSink fileSink, PruneContext context) { - return skipPruneThisAndFirstLevelChildren(fileSink); + public Plan visitLogicalSink(LogicalSink logicalSink, PruneContext context) { + return skipPruneThisAndFirstLevelChildren(logicalSink); } // the backend not support filter(project(agg)), so we can not prune the key set in the agg, diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/PullUpCteAnchor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/PullUpCteAnchor.java index 027a20b3db43ca..356333e4f69907 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/PullUpCteAnchor.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/PullUpCteAnchor.java @@ -21,8 +21,7 @@ import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.logical.LogicalCTEAnchor; import org.apache.doris.nereids.trees.plans.logical.LogicalCTEProducer; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.visitor.CustomRewriter; import org.apache.doris.nereids.trees.plans.visitor.DefaultPlanRewriter; @@ -77,14 +76,7 @@ public LogicalCTEProducer visitLogicalCTEProducer(LogicalCTEProducer olapTableSink, - List> producers) { - return olapTableSink.withChildren(rewriteRoot(olapTableSink.child(), producers)); - } - - @Override - public Plan visitLogicalFileSink(LogicalFileSink fileSink, - List> producers) { - return fileSink.withChildren(rewriteRoot(fileSink.child(), producers)); + public Plan visitLogicalSink(LogicalSink logicalSink, List> producers) { + return logicalSink.withChildren(rewriteRoot(logicalSink.child(), producers)); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/stats/StatsCalculator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/stats/StatsCalculator.java index 2dda0cfb0359f2..0ae4bbcc3f1ee1 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/stats/StatsCalculator.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/stats/StatsCalculator.java @@ -61,7 +61,6 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalEsScan; import org.apache.doris.nereids.trees.plans.logical.LogicalExcept; import org.apache.doris.nereids.trees.plans.logical.LogicalFileScan; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; import org.apache.doris.nereids.trees.plans.logical.LogicalFilter; import org.apache.doris.nereids.trees.plans.logical.LogicalGenerate; import org.apache.doris.nereids.trees.plans.logical.LogicalIntersect; @@ -69,12 +68,12 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalJoin; import org.apache.doris.nereids.trees.plans.logical.LogicalLimit; import org.apache.doris.nereids.trees.plans.logical.LogicalOlapScan; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; import org.apache.doris.nereids.trees.plans.logical.LogicalOneRowRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalPartitionTopN; import org.apache.doris.nereids.trees.plans.logical.LogicalProject; import org.apache.doris.nereids.trees.plans.logical.LogicalRepeat; import org.apache.doris.nereids.trees.plans.logical.LogicalSchemaScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.logical.LogicalSort; import org.apache.doris.nereids.trees.plans.logical.LogicalTVFRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalTopN; @@ -89,7 +88,6 @@ import org.apache.doris.nereids.trees.plans.physical.PhysicalEsScan; import org.apache.doris.nereids.trees.plans.physical.PhysicalExcept; import org.apache.doris.nereids.trees.plans.physical.PhysicalFileScan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalFileSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalFilter; import org.apache.doris.nereids.trees.plans.physical.PhysicalGenerate; import org.apache.doris.nereids.trees.plans.physical.PhysicalHashAggregate; @@ -99,13 +97,13 @@ import org.apache.doris.nereids.trees.plans.physical.PhysicalLimit; import org.apache.doris.nereids.trees.plans.physical.PhysicalNestedLoopJoin; import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapScan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapTableSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalOneRowRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalPartitionTopN; import org.apache.doris.nereids.trees.plans.physical.PhysicalProject; import org.apache.doris.nereids.trees.plans.physical.PhysicalQuickSort; import org.apache.doris.nereids.trees.plans.physical.PhysicalRepeat; import org.apache.doris.nereids.trees.plans.physical.PhysicalSchemaScan; +import org.apache.doris.nereids.trees.plans.physical.PhysicalSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalStorageLayerAggregate; import org.apache.doris.nereids.trees.plans.physical.PhysicalTVFRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalTopN; @@ -242,12 +240,7 @@ we record the lowest expression cost as group cost to avoid missing this group. } @Override - public Statistics visitLogicalOlapTableSink(LogicalOlapTableSink olapTableSink, Void context) { - return groupExpression.childStatistics(0); - } - - @Override - public Statistics visitLogicalFileSink(LogicalFileSink fileSink, Void context) { + public Statistics visitLogicalSink(LogicalSink logicalSink, Void context) { return groupExpression.childStatistics(0); } @@ -379,12 +372,7 @@ public Statistics visitLogicalWindow(LogicalWindow window, Void } @Override - public Statistics visitPhysicalOlapTableSink(PhysicalOlapTableSink olapTableSink, Void context) { - return groupExpression.childStatistics(0); - } - - @Override - public Statistics visitPhysicalFileSink(PhysicalFileSink fileSink, Void context) { + public Statistics visitPhysicalSink(PhysicalSink physicalSink, Void context) { return groupExpression.childStatistics(0); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java index 9da4690390ee5b..400d27e71aa9f2 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/copier/LogicalPlanDeepCopier.java @@ -39,7 +39,6 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalEsScan; import org.apache.doris.nereids.trees.plans.logical.LogicalExcept; import org.apache.doris.nereids.trees.plans.logical.LogicalFileScan; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; import org.apache.doris.nereids.trees.plans.logical.LogicalFilter; import org.apache.doris.nereids.trees.plans.logical.LogicalGenerate; import org.apache.doris.nereids.trees.plans.logical.LogicalHaving; @@ -48,13 +47,13 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalJoin; import org.apache.doris.nereids.trees.plans.logical.LogicalLimit; import org.apache.doris.nereids.trees.plans.logical.LogicalOlapScan; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; import org.apache.doris.nereids.trees.plans.logical.LogicalOneRowRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalPartitionTopN; import org.apache.doris.nereids.trees.plans.logical.LogicalPlan; import org.apache.doris.nereids.trees.plans.logical.LogicalProject; import org.apache.doris.nereids.trees.plans.logical.LogicalRepeat; import org.apache.doris.nereids.trees.plans.logical.LogicalSchemaScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.logical.LogicalSort; import org.apache.doris.nereids.trees.plans.logical.LogicalTVFRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalTopN; @@ -375,17 +374,9 @@ public Plan visitLogicalWindow(LogicalWindow window, DeepCopierC } @Override - public Plan visitLogicalOlapTableSink(LogicalOlapTableSink olapTableSink, - DeepCopierContext context) { - Plan child = olapTableSink.child().accept(this, context); - return new LogicalOlapTableSink<>(olapTableSink.getDatabase(), olapTableSink.getTargetTable(), - olapTableSink.getCols(), olapTableSink.getPartitionIds(), child); - } - - @Override - public Plan visitLogicalFileSink(LogicalFileSink fileSink, DeepCopierContext context) { - Plan child = fileSink.child().accept(this, context); - return fileSink.withChildren(child); + public Plan visitLogicalSink(LogicalSink logicalSink, DeepCopierContext context) { + Plan child = logicalSink.child().accept(this, context); + return logicalSink.withChildren(child); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/algebra/Sink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/algebra/Sink.java new file mode 100644 index 00000000000000..e662c5882888d6 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/algebra/Sink.java @@ -0,0 +1,24 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.doris.nereids.trees.plans.algebra; + +/** + * traits for all sink + */ +public interface Sink { +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileSink.java index 4523ee881bb2e5..89918d231744d1 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileSink.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileSink.java @@ -23,6 +23,7 @@ import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.PlanType; +import org.apache.doris.nereids.trees.plans.algebra.Sink; import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor; import com.google.common.base.Preconditions; @@ -37,7 +38,8 @@ /** * logicalFileSink for select into outfile */ -public class LogicalFileSink extends LogicalUnary { +public class LogicalFileSink extends LogicalSink implements Sink { + private final String filePath; private final String format; private final Map properties; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapTableSink.java index e1469397e003e0..fc683a86212a5e 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapTableSink.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapTableSink.java @@ -26,6 +26,7 @@ import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.PlanType; +import org.apache.doris.nereids.trees.plans.algebra.Sink; import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor; import org.apache.doris.nereids.util.Utils; @@ -39,12 +40,12 @@ /** * logical olap table sink for insert command */ -public class LogicalOlapTableSink extends LogicalUnary { +public class LogicalOlapTableSink extends LogicalSink implements Sink { // bound data sink - private Database database; - private OlapTable targetTable; - private List cols; - private List partitionIds; + private final Database database; + private final OlapTable targetTable; + private final List cols; + private final List partitionIds; public LogicalOlapTableSink(Database database, OlapTable targetTable, List cols, List partitionIds, CHILD_TYPE child) { @@ -65,8 +66,8 @@ public LogicalOlapTableSink(Database database, OlapTable targetTable, List children) { Preconditions.checkArgument(children.size() == 1, "LogicalOlapTableSink only accepts one child"); - return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, groupExpression, - Optional.of(getLogicalProperties()), children.get(0)); + return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, + Optional.empty(), Optional.empty(), children.get(0)); } public Database getDatabase() { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSink.java new file mode 100644 index 00000000000000..fd98c29a05ad6d --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSink.java @@ -0,0 +1,39 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.doris.nereids.trees.plans.logical; + +import org.apache.doris.nereids.memo.GroupExpression; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.trees.plans.Plan; +import org.apache.doris.nereids.trees.plans.PlanType; + +import java.util.Optional; + +/** abstract logical sink */ +public abstract class LogicalSink extends LogicalUnary { + + public LogicalSink(PlanType type, CHILD_TYPE child) { + super(type, child); + } + + public LogicalSink(PlanType type, + Optional groupExpression, + Optional logicalProperties, CHILD_TYPE child) { + super(type, groupExpression, logicalProperties, child); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSubQueryAlias.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSubQueryAlias.java index ef8588b1fe6117..5bef42f4f2c65b 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSubQueryAlias.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSubQueryAlias.java @@ -132,7 +132,7 @@ public LogicalSubQueryAlias withChildren(List children) { @Override public R accept(PlanVisitor visitor, C context) { - return visitor.visitSubQueryAlias(this, context); + return visitor.visitLogicalSubQueryAlias(this, context); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileSink.java index 142d07c69c3aaa..3482ac83489189 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileSink.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileSink.java @@ -23,6 +23,7 @@ import org.apache.doris.nereids.trees.expressions.Expression; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.PlanType; +import org.apache.doris.nereids.trees.plans.algebra.Sink; import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor; import org.apache.doris.statistics.Statistics; @@ -37,7 +38,8 @@ /** * physicalFileSink for select into outfile */ -public class PhysicalFileSink extends PhysicalUnary { +public class PhysicalFileSink extends PhysicalSink implements Sink { + private final String filePath; private final String format; private final Map properties; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapTableSink.java index 915c1eec705e2f..2dbc6b16f3dbb1 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapTableSink.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapTableSink.java @@ -29,6 +29,7 @@ import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.PlanType; +import org.apache.doris.nereids.trees.plans.algebra.Sink; import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor; import org.apache.doris.nereids.util.Utils; import org.apache.doris.statistics.Statistics; @@ -47,19 +48,14 @@ /** * physical olap table sink for insert command */ -public class PhysicalOlapTableSink extends PhysicalUnary { +public class PhysicalOlapTableSink extends PhysicalSink implements Sink { + private final Database database; private final OlapTable targetTable; private final List cols; private final List partitionIds; private final boolean singleReplicaLoad; - public PhysicalOlapTableSink(Database database, OlapTable targetTable, List partitionIds, - List cols, boolean singleReplicaLoad, LogicalProperties logicalProperties, - CHILD_TYPE child) { - this(database, targetTable, partitionIds, cols, singleReplicaLoad, Optional.empty(), logicalProperties, child); - } - /** * Constructor */ diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRelation.java index 49b42bb02a344d..cb1750d8c15602 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRelation.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRelation.java @@ -78,7 +78,7 @@ public int hashCode() { @Override public R accept(PlanVisitor visitor, C context) { - return visitor.visitPhysicalScan(this, context); + return visitor.visitPhysicalRelation(this, context); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSink.java new file mode 100644 index 00000000000000..be6837b0a5bce9 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSink.java @@ -0,0 +1,52 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.doris.nereids.trees.plans.physical; + +import org.apache.doris.nereids.memo.GroupExpression; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.properties.PhysicalProperties; +import org.apache.doris.nereids.trees.plans.Plan; +import org.apache.doris.nereids.trees.plans.PlanType; +import org.apache.doris.statistics.Statistics; + +import org.jetbrains.annotations.Nullable; + +import java.util.Optional; + +/** abstract physical sink */ +public abstract class PhysicalSink extends PhysicalUnary { + + public PhysicalSink(PlanType type, + LogicalProperties logicalProperties, CHILD_TYPE child) { + super(type, logicalProperties, child); + } + + public PhysicalSink(PlanType type, + Optional groupExpression, + LogicalProperties logicalProperties, CHILD_TYPE child) { + super(type, groupExpression, logicalProperties, child); + } + + public PhysicalSink(PlanType type, + Optional groupExpression, + LogicalProperties logicalProperties, + @Nullable PhysicalProperties physicalProperties, + Statistics statistics, CHILD_TYPE child) { + super(type, groupExpression, logicalProperties, physicalProperties, statistics, child); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/CommandVisitor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/CommandVisitor.java index 264598d9284d14..fbdf1085774ea8 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/CommandVisitor.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/CommandVisitor.java @@ -26,6 +26,7 @@ /** CommandVisitor. */ public interface CommandVisitor { + R visitCommand(Command command, C context); default R visitExplainCommand(ExplainCommand explain, C context) { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/PlanVisitor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/PlanVisitor.java index 1beff0f1230a52..c1077f7a7e7c12 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/PlanVisitor.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/PlanVisitor.java @@ -17,10 +17,6 @@ package org.apache.doris.nereids.trees.plans.visitor; -import org.apache.doris.nereids.analyzer.UnboundOlapTableSink; -import org.apache.doris.nereids.analyzer.UnboundOneRowRelation; -import org.apache.doris.nereids.analyzer.UnboundRelation; -import org.apache.doris.nereids.analyzer.UnboundTVFRelation; import org.apache.doris.nereids.trees.plans.GroupPlan; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.commands.Command; @@ -32,31 +28,22 @@ import org.apache.doris.nereids.trees.plans.logical.LogicalCTEConsumer; import org.apache.doris.nereids.trees.plans.logical.LogicalCTEProducer; import org.apache.doris.nereids.trees.plans.logical.LogicalCheckPolicy; -import org.apache.doris.nereids.trees.plans.logical.LogicalEmptyRelation; -import org.apache.doris.nereids.trees.plans.logical.LogicalEsScan; import org.apache.doris.nereids.trees.plans.logical.LogicalExcept; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileScan; -import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; import org.apache.doris.nereids.trees.plans.logical.LogicalFilter; import org.apache.doris.nereids.trees.plans.logical.LogicalGenerate; import org.apache.doris.nereids.trees.plans.logical.LogicalHaving; import org.apache.doris.nereids.trees.plans.logical.LogicalIntersect; -import org.apache.doris.nereids.trees.plans.logical.LogicalJdbcScan; import org.apache.doris.nereids.trees.plans.logical.LogicalJoin; import org.apache.doris.nereids.trees.plans.logical.LogicalLimit; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapScan; -import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; -import org.apache.doris.nereids.trees.plans.logical.LogicalOneRowRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalPartitionTopN; import org.apache.doris.nereids.trees.plans.logical.LogicalProject; import org.apache.doris.nereids.trees.plans.logical.LogicalRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalRepeat; -import org.apache.doris.nereids.trees.plans.logical.LogicalSchemaScan; import org.apache.doris.nereids.trees.plans.logical.LogicalSelectHint; import org.apache.doris.nereids.trees.plans.logical.LogicalSetOperation; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; import org.apache.doris.nereids.trees.plans.logical.LogicalSort; import org.apache.doris.nereids.trees.plans.logical.LogicalSubQueryAlias; -import org.apache.doris.nereids.trees.plans.logical.LogicalTVFRelation; import org.apache.doris.nereids.trees.plans.logical.LogicalTopN; import org.apache.doris.nereids.trees.plans.logical.LogicalUnion; import org.apache.doris.nereids.trees.plans.logical.LogicalWindow; @@ -67,31 +54,22 @@ import org.apache.doris.nereids.trees.plans.physical.PhysicalCTEConsumer; import org.apache.doris.nereids.trees.plans.physical.PhysicalCTEProducer; import org.apache.doris.nereids.trees.plans.physical.PhysicalDistribute; -import org.apache.doris.nereids.trees.plans.physical.PhysicalEmptyRelation; -import org.apache.doris.nereids.trees.plans.physical.PhysicalEsScan; import org.apache.doris.nereids.trees.plans.physical.PhysicalExcept; -import org.apache.doris.nereids.trees.plans.physical.PhysicalFileScan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalFileSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalFilter; import org.apache.doris.nereids.trees.plans.physical.PhysicalGenerate; import org.apache.doris.nereids.trees.plans.physical.PhysicalHashAggregate; import org.apache.doris.nereids.trees.plans.physical.PhysicalHashJoin; import org.apache.doris.nereids.trees.plans.physical.PhysicalIntersect; -import org.apache.doris.nereids.trees.plans.physical.PhysicalJdbcScan; import org.apache.doris.nereids.trees.plans.physical.PhysicalLimit; import org.apache.doris.nereids.trees.plans.physical.PhysicalNestedLoopJoin; -import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapScan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapTableSink; -import org.apache.doris.nereids.trees.plans.physical.PhysicalOneRowRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalPartitionTopN; import org.apache.doris.nereids.trees.plans.physical.PhysicalProject; import org.apache.doris.nereids.trees.plans.physical.PhysicalQuickSort; import org.apache.doris.nereids.trees.plans.physical.PhysicalRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalRepeat; -import org.apache.doris.nereids.trees.plans.physical.PhysicalSchemaScan; import org.apache.doris.nereids.trees.plans.physical.PhysicalSetOperation; +import org.apache.doris.nereids.trees.plans.physical.PhysicalSink; import org.apache.doris.nereids.trees.plans.physical.PhysicalStorageLayerAggregate; -import org.apache.doris.nereids.trees.plans.physical.PhysicalTVFRelation; import org.apache.doris.nereids.trees.plans.physical.PhysicalTopN; import org.apache.doris.nereids.trees.plans.physical.PhysicalUnion; import org.apache.doris.nereids.trees.plans.physical.PhysicalWindow; @@ -102,7 +80,7 @@ * @param Return type of each visit method. * @param Context type. */ -public abstract class PlanVisitor implements CommandVisitor { +public abstract class PlanVisitor implements CommandVisitor, RelationVisitor, SinkVisitor { public abstract R visit(Plan plan, C context); @@ -110,142 +88,119 @@ public abstract class PlanVisitor implements CommandVisitor { // commands // ******************************* + @Override public R visitCommand(Command command, C context) { return visit(command, context); } // ******************************* - // Logical plans + // relations // ******************************* - public R visitLogicalCTE(LogicalCTE cte, C context) { - return visit(cte, context); - } - - public R visitSubQueryAlias(LogicalSubQueryAlias alias, C context) { - return visit(alias, context); - } - - public R visitUnboundOneRowRelation(UnboundOneRowRelation oneRowRelation, C context) { - return visit(oneRowRelation, context); - } - - public R visitUnboundOlapTableSink(UnboundOlapTableSink unboundOlapTableSink, C context) { - return visit(unboundOlapTableSink, context); - } - - public R visitLogicalEmptyRelation(LogicalEmptyRelation emptyRelation, C context) { - return visit(emptyRelation, context); + @Override + public R visitLogicalRelation(LogicalRelation relation, C context) { + return visit(relation, context); } - public R visitLogicalOneRowRelation(LogicalOneRowRelation oneRowRelation, C context) { - return visit(oneRowRelation, context); + @Override + public R visitPhysicalRelation(PhysicalRelation physicalRelation, C context) { + return visit(physicalRelation, context); } - public R visitUnboundRelation(UnboundRelation relation, C context) { - return visit(relation, context); - } + // ******************************* + // sinks + // ******************************* - public R visitUnboundTVFRelation(UnboundTVFRelation unboundTVFRelation, C context) { - return visit(unboundTVFRelation, context); + @Override + public R visitLogicalSink(LogicalSink logicalSink, C context) { + return visit(logicalSink, context); } - public R visitLogicalRelation(LogicalRelation relation, C context) { - return visit(relation, context); + @Override + public R visitPhysicalSink(PhysicalSink physicalSink, C context) { + return visit(physicalSink, context); } - public R visitLogicalSelectHint(LogicalSelectHint hint, C context) { - return visit(hint, context); - } + // ******************************* + // Logical plans + // ******************************* public R visitLogicalAggregate(LogicalAggregate aggregate, C context) { return visit(aggregate, context); } - public R visitLogicalRepeat(LogicalRepeat repeat, C context) { - return visit(repeat, context); + public R visitLogicalApply(LogicalApply apply, C context) { + return visit(apply, context); } - public R visitLogicalFilter(LogicalFilter filter, C context) { - return visit(filter, context); + public R visitLogicalAssertNumRows(LogicalAssertNumRows assertNumRows, C context) { + return visit(assertNumRows, context); } public R visitLogicalCheckPolicy(LogicalCheckPolicy checkPolicy, C context) { return visit(checkPolicy, context); } - public R visitLogicalOlapScan(LogicalOlapScan olapScan, C context) { - return visitLogicalRelation(olapScan, context); - } - - public R visitLogicalSchemaScan(LogicalSchemaScan schemaScan, C context) { - return visitLogicalRelation(schemaScan, context); + public R visitLogicalCTE(LogicalCTE cte, C context) { + return visit(cte, context); } - public R visitLogicalFileScan(LogicalFileScan fileScan, C context) { - return visitLogicalRelation(fileScan, context); + public R visitLogicalCTEAnchor(LogicalCTEAnchor cteAnchor, C context) { + return visit(cteAnchor, context); } - public R visitLogicalTVFRelation(LogicalTVFRelation tvfRelation, C context) { - return visitLogicalRelation(tvfRelation, context); + public R visitLogicalCTEConsumer(LogicalCTEConsumer cteConsumer, C context) { + return visit(cteConsumer, context); } - public R visitLogicalJdbcScan(LogicalJdbcScan jdbcScan, C context) { - return visitLogicalRelation(jdbcScan, context); + public R visitLogicalCTEProducer(LogicalCTEProducer cteProducer, C context) { + return visit(cteProducer, context); } - public R visitLogicalEsScan(LogicalEsScan esScan, C context) { - return visitLogicalRelation(esScan, context); + public R visitLogicalFilter(LogicalFilter filter, C context) { + return visit(filter, context); } - public R visitLogicalProject(LogicalProject project, C context) { - return visit(project, context); + public R visitLogicalGenerate(LogicalGenerate generate, C context) { + return visit(generate, context); } - public R visitLogicalSort(LogicalSort sort, C context) { - return visit(sort, context); + public R visitGroupPlan(GroupPlan groupPlan, C context) { + return visit(groupPlan, context); } - public R visitLogicalTopN(LogicalTopN topN, C context) { - return visit(topN, context); + public R visitLogicalHaving(LogicalHaving having, C context) { + return visit(having, context); } - public R visitLogicalPartitionTopN(LogicalPartitionTopN partitionTopN, C context) { - return visit(partitionTopN, context); + public R visitLogicalJoin(LogicalJoin join, C context) { + return visit(join, context); } public R visitLogicalLimit(LogicalLimit limit, C context) { return visit(limit, context); } - public R visitLogicalJoin(LogicalJoin join, C context) { - return visit(join, context); - } - - public R visitGroupPlan(GroupPlan groupPlan, C context) { - return visit(groupPlan, context); + public R visitLogicalPartitionTopN(LogicalPartitionTopN partitionTopN, C context) { + return visit(partitionTopN, context); } - public R visitLogicalApply(LogicalApply apply, C context) { - return visit(apply, context); + public R visitLogicalProject(LogicalProject project, C context) { + return visit(project, context); } - public R visitLogicalAssertNumRows(LogicalAssertNumRows assertNumRows, C context) { - return visit(assertNumRows, context); + public R visitLogicalRepeat(LogicalRepeat repeat, C context) { + return visit(repeat, context); } - public R visitLogicalHaving(LogicalHaving having, C context) { - return visit(having, context); + public R visitLogicalSelectHint(LogicalSelectHint hint, C context) { + return visit(hint, context); } public R visitLogicalSetOperation(LogicalSetOperation setOperation, C context) { return visit(setOperation, context); } - public R visitLogicalUnion(LogicalUnion union, C context) { - return visitLogicalSetOperation(union, context); - } - public R visitLogicalExcept(LogicalExcept except, C context) { return visitLogicalSetOperation(except, context); } @@ -254,16 +209,24 @@ public R visitLogicalIntersect(LogicalIntersect intersect, C context) { return visitLogicalSetOperation(intersect, context); } - public R visitLogicalGenerate(LogicalGenerate generate, C context) { - return visit(generate, context); + public R visitLogicalUnion(LogicalUnion union, C context) { + return visitLogicalSetOperation(union, context); } - public R visitLogicalWindow(LogicalWindow window, C context) { - return visit(window, context); + public R visitLogicalSort(LogicalSort sort, C context) { + return visit(sort, context); } - public R visitLogicalOlapTableSink(LogicalOlapTableSink olapTableSink, C context) { - return visit(olapTableSink, context); + public R visitLogicalSubQueryAlias(LogicalSubQueryAlias alias, C context) { + return visit(alias, context); + } + + public R visitLogicalTopN(LogicalTopN topN, C context) { + return visit(topN, context); + } + + public R visitLogicalWindow(LogicalWindow window, C context) { + return visit(window, context); } // ******************************* @@ -274,85 +237,33 @@ public R visitPhysicalHashAggregate(PhysicalHashAggregate agg, C return visit(agg, context); } - public R visitPhysicalRepeat(PhysicalRepeat repeat, C context) { - return visit(repeat, context); - } - - public R visitPhysicalScan(PhysicalRelation scan, C context) { - return visit(scan, context); - } - - public R visitPhysicalEmptyRelation(PhysicalEmptyRelation emptyRelation, C context) { - return visit(emptyRelation, context); - } - - public R visitPhysicalOneRowRelation(PhysicalOneRowRelation oneRowRelation, C context) { - return visit(oneRowRelation, context); - } - - public R visitPhysicalOlapScan(PhysicalOlapScan olapScan, C context) { - return visitPhysicalScan(olapScan, context); - } - - public R visitPhysicalSchemaScan(PhysicalSchemaScan schemaScan, C context) { - return visitPhysicalScan(schemaScan, context); - } - - public R visitPhysicalFileScan(PhysicalFileScan fileScan, C context) { - return visitPhysicalScan(fileScan, context); - } - - public R visitPhysicalJdbcScan(PhysicalJdbcScan jdbcScan, C context) { - return visitPhysicalScan(jdbcScan, context); - } - - public R visitPhysicalEsScan(PhysicalEsScan esScan, C context) { - return visitPhysicalScan(esScan, context); - } - public R visitPhysicalStorageLayerAggregate(PhysicalStorageLayerAggregate storageLayerAggregate, C context) { return storageLayerAggregate.getRelation().accept(this, context); } - public R visitPhysicalTVFRelation(PhysicalTVFRelation tvfRelation, C context) { - return visitPhysicalScan(tvfRelation, context); - } - - public R visitAbstractPhysicalSort(AbstractPhysicalSort sort, C context) { - return visit(sort, context); - } - - public R visitPhysicalQuickSort(PhysicalQuickSort sort, C context) { - return visitAbstractPhysicalSort(sort, context); - } - - public R visitPhysicalWindow(PhysicalWindow window, C context) { - return visit(window, context); - } - - public R visitPhysicalTopN(PhysicalTopN topN, C context) { - return visitAbstractPhysicalSort(topN, context); + public R visitPhysicalAssertNumRows(PhysicalAssertNumRows assertNumRows, C context) { + return visit(assertNumRows, context); } - public R visitPhysicalPartitionTopN(PhysicalPartitionTopN partitionTopN, C context) { - return visit(partitionTopN, context); + public R visitPhysicalCTEAnchor( + PhysicalCTEAnchor cteAnchor, C context) { + return visit(cteAnchor, context); } - public R visitPhysicalLimit(PhysicalLimit limit, C context) { - return visit(limit, context); + public R visitPhysicalCTEConsumer(PhysicalCTEConsumer cteConsumer, C context) { + return visit(cteConsumer, context); } public R visitPhysicalCTEProducer(PhysicalCTEProducer cteProducer, C context) { return visit(cteProducer, context); } - public R visitPhysicalCTEConsumer(PhysicalCTEConsumer cteConsumer, C context) { - return visit(cteConsumer, context); + public R visitPhysicalFilter(PhysicalFilter filter, C context) { + return visit(filter, context); } - public R visitPhysicalCTEAnchor( - PhysicalCTEAnchor cteAnchor, C context) { - return visit(cteAnchor, context); + public R visitPhysicalGenerate(PhysicalGenerate generate, C context) { + return visit(generate, context); } public R visitAbstractPhysicalJoin(AbstractPhysicalJoin join, C context) { @@ -368,22 +279,26 @@ public R visitPhysicalNestedLoopJoin( return visitAbstractPhysicalJoin(nestedLoopJoin, context); } + public R visitPhysicalLimit(PhysicalLimit limit, C context) { + return visit(limit, context); + } + + public R visitPhysicalPartitionTopN(PhysicalPartitionTopN partitionTopN, C context) { + return visit(partitionTopN, context); + } + public R visitPhysicalProject(PhysicalProject project, C context) { return visit(project, context); } - public R visitPhysicalFilter(PhysicalFilter filter, C context) { - return visit(filter, context); + public R visitPhysicalRepeat(PhysicalRepeat repeat, C context) { + return visit(repeat, context); } public R visitPhysicalSetOperation(PhysicalSetOperation setOperation, C context) { return visit(setOperation, context); } - public R visitPhysicalUnion(PhysicalUnion union, C context) { - return visitPhysicalSetOperation(union, context); - } - public R visitPhysicalExcept(PhysicalExcept except, C context) { return visitPhysicalSetOperation(except, context); } @@ -392,43 +307,31 @@ public R visitPhysicalIntersect(PhysicalIntersect intersect, C context) { return visitPhysicalSetOperation(intersect, context); } - public R visitPhysicalGenerate(PhysicalGenerate generate, C context) { - return visit(generate, context); - } - - public R visitPhysicalOlapTableSink(PhysicalOlapTableSink olapTableSink, C context) { - return visit(olapTableSink, context); - } - - // ******************************* - // Physical enforcer - // ******************************* - - public R visitPhysicalDistribute(PhysicalDistribute distribute, C context) { - return visit(distribute, context); + public R visitPhysicalUnion(PhysicalUnion union, C context) { + return visitPhysicalSetOperation(union, context); } - public R visitPhysicalAssertNumRows(PhysicalAssertNumRows assertNumRows, C context) { - return visit(assertNumRows, context); + public R visitAbstractPhysicalSort(AbstractPhysicalSort sort, C context) { + return visit(sort, context); } - public R visitLogicalCTEProducer(LogicalCTEProducer cteProducer, C context) { - return visit(cteProducer, context); + public R visitPhysicalQuickSort(PhysicalQuickSort sort, C context) { + return visitAbstractPhysicalSort(sort, context); } - public R visitLogicalCTEConsumer(LogicalCTEConsumer cteConsumer, C context) { - return visit(cteConsumer, context); + public R visitPhysicalTopN(PhysicalTopN topN, C context) { + return visitAbstractPhysicalSort(topN, context); } - public R visitLogicalCTEAnchor(LogicalCTEAnchor cteAnchor, C context) { - return visit(cteAnchor, context); + public R visitPhysicalWindow(PhysicalWindow window, C context) { + return visit(window, context); } - public R visitLogicalFileSink(LogicalFileSink fileSink, C context) { - return visit(fileSink, context); - } + // ******************************* + // Physical enforcer + // ******************************* - public R visitPhysicalFileSink(PhysicalFileSink fileSink, C context) { - return visit(fileSink, context); + public R visitPhysicalDistribute(PhysicalDistribute distribute, C context) { + return visit(distribute, context); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/RelationVisitor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/RelationVisitor.java new file mode 100644 index 00000000000000..af65f43d9d4b53 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/RelationVisitor.java @@ -0,0 +1,142 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.doris.nereids.trees.plans.visitor; + +import org.apache.doris.nereids.analyzer.UnboundOneRowRelation; +import org.apache.doris.nereids.analyzer.UnboundRelation; +import org.apache.doris.nereids.analyzer.UnboundTVFRelation; +import org.apache.doris.nereids.trees.plans.logical.LogicalEmptyRelation; +import org.apache.doris.nereids.trees.plans.logical.LogicalEsScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalFileScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalJdbcScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalOlapScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalOneRowRelation; +import org.apache.doris.nereids.trees.plans.logical.LogicalRelation; +import org.apache.doris.nereids.trees.plans.logical.LogicalSchemaScan; +import org.apache.doris.nereids.trees.plans.logical.LogicalTVFRelation; +import org.apache.doris.nereids.trees.plans.physical.PhysicalEmptyRelation; +import org.apache.doris.nereids.trees.plans.physical.PhysicalEsScan; +import org.apache.doris.nereids.trees.plans.physical.PhysicalFileScan; +import org.apache.doris.nereids.trees.plans.physical.PhysicalJdbcScan; +import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapScan; +import org.apache.doris.nereids.trees.plans.physical.PhysicalOneRowRelation; +import org.apache.doris.nereids.trees.plans.physical.PhysicalRelation; +import org.apache.doris.nereids.trees.plans.physical.PhysicalSchemaScan; +import org.apache.doris.nereids.trees.plans.physical.PhysicalTVFRelation; + +/** + * relation visitor + */ +public interface RelationVisitor { + + // ******************************* + // interface + // ******************************* + + R visitLogicalRelation(LogicalRelation logicalRelation, C context); + + R visitPhysicalRelation(PhysicalRelation physicalRelation, C context); + + // ******************************* + // unbound relations + // ******************************* + + default R visitUnboundOneRowRelation(UnboundOneRowRelation oneRowRelation, C context) { + return visitLogicalRelation(oneRowRelation, context); + } + + default R visitUnboundRelation(UnboundRelation relation, C context) { + return visitLogicalRelation(relation, context); + } + + default R visitUnboundTVFRelation(UnboundTVFRelation unboundTVFRelation, C context) { + return visitLogicalRelation(unboundTVFRelation, context); + } + + // ******************************* + // logical relations + // ******************************* + + default R visitLogicalEmptyRelation(LogicalEmptyRelation emptyRelation, C context) { + return visitLogicalRelation(emptyRelation, context); + } + + default R visitLogicalEsScan(LogicalEsScan esScan, C context) { + return visitLogicalRelation(esScan, context); + } + + default R visitLogicalFileScan(LogicalFileScan fileScan, C context) { + return visitLogicalRelation(fileScan, context); + } + + default R visitLogicalJdbcScan(LogicalJdbcScan jdbcScan, C context) { + return visitLogicalRelation(jdbcScan, context); + } + + default R visitLogicalOlapScan(LogicalOlapScan olapScan, C context) { + return visitLogicalRelation(olapScan, context); + } + + default R visitLogicalOneRowRelation(LogicalOneRowRelation oneRowRelation, C context) { + return visitLogicalRelation(oneRowRelation, context); + } + + default R visitLogicalSchemaScan(LogicalSchemaScan schemaScan, C context) { + return visitLogicalRelation(schemaScan, context); + } + + default R visitLogicalTVFRelation(LogicalTVFRelation tvfRelation, C context) { + return visitLogicalRelation(tvfRelation, context); + } + + // ******************************* + // physical relations + // ******************************* + + default R visitPhysicalEmptyRelation(PhysicalEmptyRelation emptyRelation, C context) { + return visitPhysicalRelation(emptyRelation, context); + } + + default R visitPhysicalEsScan(PhysicalEsScan esScan, C context) { + return visitPhysicalRelation(esScan, context); + } + + default R visitPhysicalFileScan(PhysicalFileScan fileScan, C context) { + return visitPhysicalRelation(fileScan, context); + } + + default R visitPhysicalJdbcScan(PhysicalJdbcScan jdbcScan, C context) { + return visitPhysicalRelation(jdbcScan, context); + } + + default R visitPhysicalOlapScan(PhysicalOlapScan olapScan, C context) { + return visitPhysicalRelation(olapScan, context); + } + + default R visitPhysicalOneRowRelation(PhysicalOneRowRelation oneRowRelation, C context) { + return visitPhysicalRelation(oneRowRelation, context); + } + + default R visitPhysicalSchemaScan(PhysicalSchemaScan schemaScan, C context) { + return visitPhysicalRelation(schemaScan, context); + } + + default R visitPhysicalTVFRelation(PhysicalTVFRelation tvfRelation, C context) { + return visitPhysicalRelation(tvfRelation, context); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/SinkVisitor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/SinkVisitor.java new file mode 100644 index 00000000000000..629deaacf7d62b --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/visitor/SinkVisitor.java @@ -0,0 +1,73 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.doris.nereids.trees.plans.visitor; + +import org.apache.doris.nereids.analyzer.UnboundOlapTableSink; +import org.apache.doris.nereids.trees.plans.Plan; +import org.apache.doris.nereids.trees.plans.logical.LogicalFileSink; +import org.apache.doris.nereids.trees.plans.logical.LogicalOlapTableSink; +import org.apache.doris.nereids.trees.plans.logical.LogicalSink; +import org.apache.doris.nereids.trees.plans.physical.PhysicalFileSink; +import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapTableSink; +import org.apache.doris.nereids.trees.plans.physical.PhysicalSink; + +/** + * sink visitor + */ +public interface SinkVisitor { + + // ******************************* + // interface + // ******************************* + + R visitLogicalSink(LogicalSink logicalSink, C context); + + R visitPhysicalSink(PhysicalSink physicalSink, C context); + + // ******************************* + // unbound + // ******************************* + + default R visitUnboundOlapTableSink(UnboundOlapTableSink unboundOlapTableSink, C context) { + return visitLogicalSink(unboundOlapTableSink, context); + } + + // ******************************* + // logical + // ******************************* + + default R visitLogicalFileSink(LogicalFileSink fileSink, C context) { + return visitLogicalSink(fileSink, context); + } + + default R visitLogicalOlapTableSink(LogicalOlapTableSink olapTableSink, C context) { + return visitLogicalSink(olapTableSink, context); + } + + // ******************************* + // physical + // ******************************* + + default R visitPhysicalFileSink(PhysicalFileSink fileSink, C context) { + return visitPhysicalSink(fileSink, context); + } + + default R visitPhysicalOlapTableSink(PhysicalOlapTableSink olapTableSink, C context) { + return visitPhysicalSink(olapTableSink, context); + } +}