This is an automated email from the ASF dual-hosted git repository. starocean999 pushed a commit to branch dev_rec in repository https://gitbox.apache.org/repos/asf/doris.git
commit 15e2609bc98787f061b4e3bdb29ffae2c19c6126 Author: lichi <[email protected]> AuthorDate: Wed Oct 22 11:46:36 2025 +0800 update fe part --- .../org/apache/doris/nereids/StatementContext.java | 10 ------ .../doris/nereids/rules/analysis/AnalyzeCTE.java | 3 +- .../LogicalRecursiveCteToPhysicalRecursiveCte.java | 3 +- .../doris/nereids/rules/rewrite/CTEInline.java | 15 ++++----- .../trees/copier/LogicalPlanDeepCopier.java | 3 +- .../trees/plans/logical/LogicalRecursiveCte.java | 37 +++++++++++++--------- .../trees/plans/physical/PhysicalRecursiveCte.java | 34 ++++++++++---------- 7 files changed, 51 insertions(+), 54 deletions(-) diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/StatementContext.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/StatementContext.java index a9997d3dfdc..5829a0c9b56 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/StatementContext.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/StatementContext.java @@ -71,7 +71,6 @@ import com.google.common.base.Suppliers; import com.google.common.base.Throwables; import com.google.common.collect.HashMultimap; import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; @@ -158,7 +157,6 @@ public class StatementContext implements Closeable { private final Map<CTEId, List<Pair<Multimap<Slot, Slot>, Group>>> cteIdToConsumerGroup = new HashMap<>(); private final Map<CTEId, LogicalPlan> rewrittenCteProducer = new HashMap<>(); private final Map<CTEId, LogicalPlan> rewrittenCteConsumer = new HashMap<>(); - private final Set<CTEId> recursiveCteIds = new HashSet<>(); private final Set<String> viewDdlSqlSet = Sets.newHashSet(); private final SqlCacheContext sqlCacheContext; @@ -596,14 +594,6 @@ public class StatementContext implements Closeable { return cteIdToConsumerGroup; } - public void addRecursiveCteIds(CTEId cteId) { - recursiveCteIds.add(cteId); - } - - public Set<CTEId> getRecursiveCteIds() { - return ImmutableSet.copyOf(recursiveCteIds); - } - public Map<CTEId, LogicalPlan> getRewrittenCteProducer() { return rewrittenCteProducer; } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalyzeCTE.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalyzeCTE.java index 594dede9edf..bbf0c036cf4 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalyzeCTE.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalyzeCTE.java @@ -196,7 +196,7 @@ public class AnalyzeCTE extends OneAnalysisRuleFactory { // create LogicalRecursiveCte LogicalUnion logicalUnion = (LogicalUnion) parsedCtePlan; - LogicalRecursiveCte analyzedCtePlan = new LogicalRecursiveCte( + LogicalRecursiveCte analyzedCtePlan = new LogicalRecursiveCte(aliasQuery.getAlias(), logicalUnion.getQualifier() == SetOperation.Qualifier.ALL, ImmutableList.of(analyzedAnchorChild, analyzedRecursiveChild)); List<List<NamedExpression>> childrenProjections = analyzedCtePlan.collectChildrenProjections(); @@ -222,7 +222,6 @@ public class AnalyzeCTE extends OneAnalysisRuleFactory { analyzedCtePlan = analyzedCtePlan.withNewOutputs(newOutputs); CTEId cteId = StatementScopeIdGenerator.newCTEId(); - cascadesContext.getStatementContext().addRecursiveCteIds(cteId); LogicalSubQueryAlias<Plan> logicalSubQueryAlias = aliasQuery.withChildren(ImmutableList.of(analyzedCtePlan)); outerCteCtx = new CTEContext(cteId, logicalSubQueryAlias, outerCteCtx); outerCteCtx.setAnalyzedPlan(logicalSubQueryAlias); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalRecursiveCteToPhysicalRecursiveCte.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalRecursiveCteToPhysicalRecursiveCte.java index 467092895a9..12ac89df19c 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalRecursiveCteToPhysicalRecursiveCte.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalRecursiveCteToPhysicalRecursiveCte.java @@ -28,7 +28,8 @@ public class LogicalRecursiveCteToPhysicalRecursiveCte extends OneImplementation @Override public Rule build() { return logicalRecursiveCte().then(recursiveCte -> - new PhysicalRecursiveCte(recursiveCte.isUnionAll(), + new PhysicalRecursiveCte(recursiveCte.getCteName(), + recursiveCte.isUnionAll(), recursiveCte.getOutputs(), recursiveCte.getRegularChildrenOutputs(), recursiveCte.getLogicalProperties(), diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/CTEInline.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/CTEInline.java index 9c6500238c8..75f228ff7fd 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/CTEInline.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/CTEInline.java @@ -21,7 +21,6 @@ import org.apache.doris.nereids.jobs.JobContext; import org.apache.doris.nereids.trees.copier.DeepCopierContext; import org.apache.doris.nereids.trees.copier.LogicalPlanDeepCopier; import org.apache.doris.nereids.trees.expressions.Alias; -import org.apache.doris.nereids.trees.expressions.CTEId; import org.apache.doris.nereids.trees.expressions.ExprId; import org.apache.doris.nereids.trees.expressions.Expression; import org.apache.doris.nereids.trees.expressions.NamedExpression; @@ -32,7 +31,7 @@ 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.LogicalPlan; import org.apache.doris.nereids.trees.plans.logical.LogicalProject; -import org.apache.doris.nereids.trees.plans.logical.LogicalRecursiveCte; +import org.apache.doris.nereids.trees.plans.logical.LogicalRecursiveCteRecursiveChild; import org.apache.doris.nereids.trees.plans.visitor.CustomRewriter; import org.apache.doris.nereids.trees.plans.visitor.DefaultPlanRewriter; import org.apache.doris.qe.ConnectContext; @@ -54,14 +53,13 @@ import java.util.Set; */ public class CTEInline extends DefaultPlanRewriter<LogicalCTEProducer<?>> implements CustomRewriter { private Set<LogicalCTEConsumer> mustInlineCteConsumers = new HashSet<>(); - private Set<CTEId> recursiveCteIds; @Override public Plan rewriteRoot(Plan plan, JobContext jobContext) { - recursiveCteIds = jobContext.getCascadesContext().getStatementContext().getRecursiveCteIds(); - List<LogicalRecursiveCte> recursiveCteList = plan.collectToList(LogicalRecursiveCte.class::isInstance); - for (LogicalRecursiveCte recursiveCte : recursiveCteList) { - mustInlineCteConsumers.addAll(recursiveCte.collect(LogicalCTEConsumer.class::isInstance)); + List<LogicalRecursiveCteRecursiveChild> recursiveCteRecursiveChildList = + plan.collectToList(LogicalRecursiveCteRecursiveChild.class::isInstance); + for (LogicalRecursiveCteRecursiveChild recursiveChild : recursiveCteRecursiveChildList) { + mustInlineCteConsumers.addAll(recursiveChild.collect(LogicalCTEConsumer.class::isInstance)); } Plan root = plan.accept(this, null); @@ -91,8 +89,7 @@ public class CTEInline extends DefaultPlanRewriter<LogicalCTEProducer<?>> implem } return false; }); - if (recursiveCteIds.contains(cteAnchor.getCteId()) - || !Sets.intersection(mustInlineCteConsumers, Sets.newHashSet(consumers)).isEmpty()) { + if (!Sets.intersection(mustInlineCteConsumers, Sets.newHashSet(consumers)).isEmpty()) { // should inline Plan root = cteAnchor.right().accept(this, (LogicalCTEProducer<?>) cteAnchor.left()); // process child 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 98c3ec2ef41..e900ba6b2b4 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 @@ -369,7 +369,8 @@ public class LogicalPlanDeepCopier extends DefaultPlanRewriter<DeepCopierContext .map(o -> (SlotReference) ExpressionDeepCopier.INSTANCE.deepCopy(o, context)) .collect(ImmutableList.toImmutableList())) .collect(ImmutableList.toImmutableList()); - return new LogicalRecursiveCte(recursiveCte.isUnionAll(), outputs, childrenOutputs, children); + return new LogicalRecursiveCte(recursiveCte.getCteName(), recursiveCte.isUnionAll(), outputs, + childrenOutputs, children); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveCte.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveCte.java index 4a727476d35..bef00db5f72 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveCte.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveCte.java @@ -48,29 +48,31 @@ import java.util.Optional; * LogicalRecursiveCte is basically like LogicalUnion */ public class LogicalRecursiveCte extends AbstractLogicalPlan implements RecursiveCte, OutputPrunable { - protected final List<NamedExpression> outputs; - protected final List<List<SlotReference>> regularChildrenOutputs; + private final String cteName; + private final List<NamedExpression> outputs; + private final List<List<SlotReference>> regularChildrenOutputs; private final boolean isUnionAll; /** LogicalRecursiveCte */ - public LogicalRecursiveCte(boolean isUnionAll, List<Plan> children) { - this(isUnionAll, ImmutableList.of(), ImmutableList.of(), children); + public LogicalRecursiveCte(String cteName, boolean isUnionAll, List<Plan> children) { + this(cteName, isUnionAll, ImmutableList.of(), ImmutableList.of(), children); } /** LogicalRecursiveCte */ - public LogicalRecursiveCte(boolean isUnionAll, List<NamedExpression> outputs, + public LogicalRecursiveCte(String cteName, boolean isUnionAll, List<NamedExpression> outputs, List<List<SlotReference>> childrenOutputs, List<Plan> children) { - this(isUnionAll, outputs, childrenOutputs, Optional.empty(), + this(cteName, isUnionAll, outputs, childrenOutputs, Optional.empty(), Optional.empty(), children); } /** LogicalRecursiveCte */ - public LogicalRecursiveCte(boolean isUnionAll, List<NamedExpression> outputs, + public LogicalRecursiveCte(String cteName, boolean isUnionAll, List<NamedExpression> outputs, List<List<SlotReference>> childrenOutputs, Optional<GroupExpression> groupExpression, Optional<LogicalProperties> logicalProperties, List<Plan> children) { super(PlanType.LOGICAL_RECURSIVE_CTE, groupExpression, logicalProperties, children); + this.cteName = cteName; this.isUnionAll = isUnionAll; this.outputs = ImmutableList.copyOf(outputs); this.regularChildrenOutputs = ImmutableList.copyOf(childrenOutputs); @@ -81,6 +83,10 @@ public class LogicalRecursiveCte extends AbstractLogicalPlan implements Recursiv return isUnionAll; } + public String getCteName() { + return cteName; + } + @Override public List<SlotReference> getRegularChildOutput(int i) { return regularChildrenOutputs.get(i); @@ -164,6 +170,7 @@ public class LogicalRecursiveCte extends AbstractLogicalPlan implements Recursiv @Override public String toString() { return Utils.toSqlStringSkipNull("LogicalRecursiveCte", + "cteName", cteName, "isUnionAll", isUnionAll, "outputs", outputs, "regularChildrenOutputs", regularChildrenOutputs, @@ -179,13 +186,13 @@ public class LogicalRecursiveCte extends AbstractLogicalPlan implements Recursiv return false; } LogicalRecursiveCte that = (LogicalRecursiveCte) o; - return isUnionAll == that.isUnionAll && Objects.equals(outputs, that.outputs) + return cteName.equals(that.cteName) && isUnionAll == that.isUnionAll && Objects.equals(outputs, that.outputs) && Objects.equals(regularChildrenOutputs, that.regularChildrenOutputs); } @Override public int hashCode() { - return Objects.hash(isUnionAll, outputs, regularChildrenOutputs); + return Objects.hash(cteName, isUnionAll, outputs, regularChildrenOutputs); } @Override @@ -207,7 +214,7 @@ public class LogicalRecursiveCte extends AbstractLogicalPlan implements Recursiv @Override public LogicalRecursiveCte withChildren(List<Plan> children) { - return new LogicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, children); + return new LogicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, children); } public LogicalRecursiveCte withChildrenAndTheirOutputs(List<Plan> children, @@ -215,31 +222,31 @@ public class LogicalRecursiveCte extends AbstractLogicalPlan implements Recursiv Preconditions.checkArgument(children.size() == childrenOutputs.size(), "children size %s is not equals with children outputs size %s", children.size(), childrenOutputs.size()); - return new LogicalRecursiveCte(isUnionAll, outputs, childrenOutputs, children); + return new LogicalRecursiveCte(cteName, isUnionAll, outputs, childrenOutputs, children); } @Override public LogicalRecursiveCte withGroupExpression(Optional<GroupExpression> groupExpression) { - return new LogicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, + return new LogicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, groupExpression, Optional.of(getLogicalProperties()), children); } @Override public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression, Optional<LogicalProperties> logicalProperties, List<Plan> children) { - return new LogicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, + return new LogicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, groupExpression, logicalProperties, children); } public LogicalRecursiveCte withNewOutputs(List<NamedExpression> newOutputs) { - return new LogicalRecursiveCte(isUnionAll, newOutputs, regularChildrenOutputs, + return new LogicalRecursiveCte(cteName, isUnionAll, newOutputs, regularChildrenOutputs, Optional.empty(), Optional.empty(), children); } public LogicalRecursiveCte withNewOutputsAndChildren(List<NamedExpression> newOutputs, List<Plan> children, List<List<SlotReference>> childrenOutputs) { - return new LogicalRecursiveCte(isUnionAll, newOutputs, childrenOutputs, + return new LogicalRecursiveCte(cteName, isUnionAll, newOutputs, childrenOutputs, Optional.empty(), Optional.empty(), children); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveCte.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveCte.java index c0a7f0222d7..e5a74a8292a 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveCte.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveCte.java @@ -49,38 +49,39 @@ import java.util.Set; * PhysicalRecursiveCte is basically like PhysicalUnion */ public class PhysicalRecursiveCte extends AbstractPhysicalPlan implements RecursiveCte { - - protected final List<NamedExpression> outputs; - protected final List<List<SlotReference>> regularChildrenOutputs; + private final String cteName; + private final List<NamedExpression> outputs; + private final List<List<SlotReference>> regularChildrenOutputs; private final boolean isUnionAll; /** PhysicalRecursiveCte */ - public PhysicalRecursiveCte(boolean isUnionAll, + public PhysicalRecursiveCte(String cteName, boolean isUnionAll, List<NamedExpression> outputs, List<List<SlotReference>> childrenOutputs, LogicalProperties logicalProperties, List<Plan> children) { - this(isUnionAll, outputs, childrenOutputs, Optional.empty(), logicalProperties, children); + this(cteName, isUnionAll, outputs, childrenOutputs, Optional.empty(), logicalProperties, children); } /** PhysicalRecursiveCte */ - public PhysicalRecursiveCte(boolean isUnionAll, + public PhysicalRecursiveCte(String cteName, boolean isUnionAll, List<NamedExpression> outputs, List<List<SlotReference>> childrenOutputs, Optional<GroupExpression> groupExpression, LogicalProperties logicalProperties, List<Plan> children) { - this(isUnionAll, outputs, childrenOutputs, groupExpression, logicalProperties, + this(cteName, isUnionAll, outputs, childrenOutputs, groupExpression, logicalProperties, PhysicalProperties.ANY, null, children); } /** PhysicalRecursiveCte */ - public PhysicalRecursiveCte(boolean isUnionAll, List<NamedExpression> outputs, + public PhysicalRecursiveCte(String cteName, boolean isUnionAll, List<NamedExpression> outputs, List<List<SlotReference>> childrenOutputs, Optional<GroupExpression> groupExpression, LogicalProperties logicalProperties, PhysicalProperties physicalProperties, Statistics statistics, List<Plan> children) { super(PlanType.PHYSICAL_RECURSIVE_CTE, groupExpression, logicalProperties, physicalProperties, statistics, children.toArray(new Plan[0])); + this.cteName = cteName; this.isUnionAll = isUnionAll; this.outputs = ImmutableList.copyOf(outputs); this.regularChildrenOutputs = ImmutableList.copyOf(childrenOutputs); @@ -122,13 +123,13 @@ public class PhysicalRecursiveCte extends AbstractPhysicalPlan implements Recurs return false; } PhysicalRecursiveCte that = (PhysicalRecursiveCte) o; - return isUnionAll == that.isUnionAll && Objects.equals(outputs, that.outputs) && Objects.equals( - regularChildrenOutputs, that.regularChildrenOutputs); + return cteName.equals(that.cteName) && isUnionAll == that.isUnionAll && Objects.equals(outputs, that.outputs) + && Objects.equals(regularChildrenOutputs, that.regularChildrenOutputs); } @Override public int hashCode() { - return Objects.hash(isUnionAll, outputs, regularChildrenOutputs); + return Objects.hash(cteName, isUnionAll, outputs, regularChildrenOutputs); } @Override @@ -145,6 +146,7 @@ public class PhysicalRecursiveCte extends AbstractPhysicalPlan implements Recurs public String toString() { return Utils.toSqlString("PhysicalRecursiveCte" + "[" + id.asInt() + "]" + getGroupIdWithPrefix(), "stats", statistics, + "cteName", cteName, "isUnionAll", isUnionAll, "outputs", outputs, "regularChildrenOutputs", regularChildrenOutputs); @@ -166,33 +168,33 @@ public class PhysicalRecursiveCte extends AbstractPhysicalPlan implements Recurs @Override public PhysicalRecursiveCte withChildren(List<Plan> children) { - return new PhysicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, groupExpression, + return new PhysicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, groupExpression, getLogicalProperties(), children); } @Override public PhysicalRecursiveCte withGroupExpression(Optional<GroupExpression> groupExpression) { - return new PhysicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, + return new PhysicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, groupExpression, getLogicalProperties(), children); } @Override public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression, Optional<LogicalProperties> logicalProperties, List<Plan> children) { - return new PhysicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, + return new PhysicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, groupExpression, logicalProperties.get(), children); } @Override public PhysicalRecursiveCte withPhysicalPropertiesAndStats( PhysicalProperties physicalProperties, Statistics statistics) { - return new PhysicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, + return new PhysicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, groupExpression, getLogicalProperties(), physicalProperties, statistics, children); } @Override public PhysicalRecursiveCte resetLogicalProperties() { - return new PhysicalRecursiveCte(isUnionAll, outputs, regularChildrenOutputs, + return new PhysicalRecursiveCte(cteName, isUnionAll, outputs, regularChildrenOutputs, Optional.empty(), null, physicalProperties, statistics, children); } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
