You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by en...@apache.org on 2026/03/17 03:47:18 UTC
(doris) branch master updated: [refactor](nereids) Preserve plan node id across withXxx() copy methods (#61343)
This is an automated email from the ASF dual-hosted git repository.
englefly pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new b68c77d257a [refactor](nereids) Preserve plan node id across withXxx() copy methods (#61343)
b68c77d257a is described below
commit b68c77d257ac4ce9652206ed23fd627ba871caa2
Author: minghong <zh...@selectdb.com>
AuthorDate: Tue Mar 17 11:47:12 2026 +0800
[refactor](nereids) Preserve plan node id across withXxx() copy methods (#61343)
## Problem
In the Nereids optimizer, every plan node (both logical and physical)
carries a unique ObjectId (`AbstractPlan.id`). Previously, every call to
a `withXxx()` method (e.g. `withChildren`, `withGroupExpression`,
`withGroupExprLogicalPropChildren`, `withPhysicalPropertiesAndStats`)
constructed a brand-new node that was allocated a fresh id via
`StatementScopeIdGenerator.newObjectId()`. This means a node and its
"copy" had different ids even though they represent the same operator,
which can confuse plan identification, caching, and debugging.
## Solution
Introduce a thread-local id-inheritance mechanism in `AbstractPlan`:
1. Add `private static final ThreadLocal<ObjectId> INHERIT_ID` to
`AbstractPlan`.
2. Add a static helper `AbstractPlan.copyWithSameId(source, factory)`:
it stores `source.id` in the ThreadLocal, calls the constructor through
the supplied lambda, and clears the ThreadLocal in a `finally` block.
3. Modify the constructor to read and clear `INHERIT_ID` when present;
otherwise allocate a fresh id as before.
4. Rewrite all `withXxx()` methods in every logical and physical plan
node (60 logical + 51 physical, ~490 call sites) to use
`AbstractPlan.copyWithSameId(this, () -> new ...)`.
This approach keeps `id` final-by-contract (only set once in the
constructor), is thread-safe without locking, and requires no changes to
callers outside the plan-node classes themselves.
---
.../doris/nereids/trees/plans/AbstractPlan.java | 45 ++++++-
.../trees/plans/logical/LogicalAggregate.java | 76 +++++++-----
.../nereids/trees/plans/logical/LogicalApply.java | 16 ++-
.../trees/plans/logical/LogicalAssertNumRows.java | 12 +-
.../trees/plans/logical/LogicalBlackholeSink.java | 13 +-
.../nereids/trees/plans/logical/LogicalCTE.java | 12 +-
.../trees/plans/logical/LogicalCTEAnchor.java | 10 +-
.../trees/plans/logical/LogicalCTEConsumer.java | 16 ++-
.../trees/plans/logical/LogicalCTEProducer.java | 10 +-
.../trees/plans/logical/LogicalCheckPolicy.java | 10 +-
.../logical/LogicalDeferMaterializeOlapScan.java | 16 ++-
.../logical/LogicalDeferMaterializeResultSink.java | 21 ++--
.../plans/logical/LogicalDeferMaterializeTopN.java | 16 ++-
.../trees/plans/logical/LogicalDictionarySink.java | 26 ++--
.../trees/plans/logical/LogicalEmptyRelation.java | 15 ++-
.../nereids/trees/plans/logical/LogicalEsScan.java | 26 ++--
.../nereids/trees/plans/logical/LogicalExcept.java | 22 ++--
.../trees/plans/logical/LogicalFileScan.java | 36 +++---
.../trees/plans/logical/LogicalFileSink.java | 17 ++-
.../nereids/trees/plans/logical/LogicalFilter.java | 20 +++-
.../trees/plans/logical/LogicalGenerate.java | 17 ++-
.../nereids/trees/plans/logical/LogicalHaving.java | 18 ++-
.../trees/plans/logical/LogicalHiveTableSink.java | 27 +++--
.../trees/plans/logical/LogicalHudiScan.java | 44 ++++---
.../plans/logical/LogicalIcebergTableSink.java | 27 +++--
.../trees/plans/logical/LogicalInlineTable.java | 9 +-
.../trees/plans/logical/LogicalIntersect.java | 22 ++--
.../trees/plans/logical/LogicalJdbcScan.java | 21 ++--
.../trees/plans/logical/LogicalJdbcTableSink.java | 27 +++--
.../nereids/trees/plans/logical/LogicalJoin.java | 76 +++++++-----
.../nereids/trees/plans/logical/LogicalLimit.java | 14 ++-
.../trees/plans/logical/LogicalLoadProject.java | 23 ++--
.../plans/logical/LogicalMaxComputeTableSink.java | 27 +++--
.../trees/plans/logical/LogicalOdbcScan.java | 17 ++-
.../trees/plans/logical/LogicalOlapScan.java | 70 ++++++-----
.../trees/plans/logical/LogicalOlapTableSink.java | 31 +++--
.../trees/plans/logical/LogicalOneRowRelation.java | 13 +-
.../trees/plans/logical/LogicalPartitionTopN.java | 21 ++--
.../trees/plans/logical/LogicalPostProject.java | 23 ++--
.../trees/plans/logical/LogicalPreAggOnHint.java | 10 +-
.../trees/plans/logical/LogicalPreFilter.java | 19 ++-
.../trees/plans/logical/LogicalProject.java | 23 ++--
.../trees/plans/logical/LogicalQualify.java | 13 +-
.../trees/plans/logical/LogicalRecursiveUnion.java | 27 +++--
.../plans/logical/LogicalRecursiveUnionAnchor.java | 12 +-
.../logical/LogicalRecursiveUnionProducer.java | 12 +-
.../nereids/trees/plans/logical/LogicalRepeat.java | 34 ++++--
.../trees/plans/logical/LogicalResultSink.java | 13 +-
.../trees/plans/logical/LogicalSchemaScan.java | 26 ++--
.../trees/plans/logical/LogicalSelectHint.java | 10 +-
.../nereids/trees/plans/logical/LogicalSort.java | 18 ++-
.../trees/plans/logical/LogicalSubQueryAlias.java | 14 ++-
.../trees/plans/logical/LogicalTVFRelation.java | 24 ++--
.../trees/plans/logical/LogicalTVFTableSink.java | 17 ++-
.../trees/plans/logical/LogicalTestScan.java | 14 ++-
.../nereids/trees/plans/logical/LogicalTopN.java | 23 ++--
.../nereids/trees/plans/logical/LogicalUnion.java | 45 ++++---
.../trees/plans/logical/LogicalUsingJoin.java | 16 ++-
.../nereids/trees/plans/logical/LogicalView.java | 10 +-
.../nereids/trees/plans/logical/LogicalWindow.java | 20 ++--
.../plans/logical/LogicalWorkTableReference.java | 15 ++-
.../plans/physical/PhysicalAssertNumRows.java | 21 ++--
.../plans/physical/PhysicalBlackholeSink.java | 17 +--
.../trees/plans/physical/PhysicalCTEAnchor.java | 16 +--
.../trees/plans/physical/PhysicalCTEConsumer.java | 13 +-
.../trees/plans/physical/PhysicalCTEProducer.java | 15 ++-
.../physical/PhysicalDeferMaterializeOlapScan.java | 16 ++-
.../PhysicalDeferMaterializeResultSink.java | 19 +--
.../physical/PhysicalDeferMaterializeTopN.java | 26 ++--
.../plans/physical/PhysicalDictionarySink.java | 21 ++--
.../trees/plans/physical/PhysicalDistribute.java | 17 +--
.../plans/physical/PhysicalEmptyRelation.java | 13 +-
.../trees/plans/physical/PhysicalEsScan.java | 14 ++-
.../trees/plans/physical/PhysicalExcept.java | 16 +--
.../trees/plans/physical/PhysicalFileScan.java | 20 ++--
.../trees/plans/physical/PhysicalFileSink.java | 17 +--
.../trees/plans/physical/PhysicalFilter.java | 19 +--
.../trees/plans/physical/PhysicalGenerate.java | 18 +--
.../plans/physical/PhysicalHashAggregate.java | 29 +++--
.../trees/plans/physical/PhysicalHashJoin.java | 25 ++--
.../plans/physical/PhysicalHiveTableSink.java | 17 +--
.../trees/plans/physical/PhysicalHudiScan.java | 20 ++--
.../plans/physical/PhysicalIcebergTableSink.java | 17 +--
.../trees/plans/physical/PhysicalIntersect.java | 17 +--
.../trees/plans/physical/PhysicalJdbcScan.java | 13 +-
.../plans/physical/PhysicalJdbcTableSink.java | 17 +--
.../plans/physical/PhysicalLazyMaterialize.java | 10 +-
.../physical/PhysicalLazyMaterializeOlapScan.java | 3 +-
.../physical/PhysicalLazyMaterializeTVFScan.java | 10 +-
.../trees/plans/physical/PhysicalLimit.java | 19 +--
.../physical/PhysicalMaxComputeTableSink.java | 17 +--
.../plans/physical/PhysicalNestedLoopJoin.java | 17 +--
.../trees/plans/physical/PhysicalOdbcScan.java | 13 +-
.../trees/plans/physical/PhysicalOlapScan.java | 29 ++---
.../plans/physical/PhysicalOlapTableSink.java | 33 +++---
.../plans/physical/PhysicalOneRowRelation.java | 13 +-
.../plans/physical/PhysicalPartitionTopN.java | 21 ++--
.../trees/plans/physical/PhysicalProject.java | 29 ++---
.../trees/plans/physical/PhysicalQuickSort.java | 15 ++-
.../plans/physical/PhysicalRecursiveUnion.java | 18 +--
.../physical/PhysicalRecursiveUnionAnchor.java | 15 ++-
.../physical/PhysicalRecursiveUnionProducer.java | 15 ++-
.../trees/plans/physical/PhysicalRepeat.java | 31 +++--
.../trees/plans/physical/PhysicalResultSink.java | 17 +--
.../trees/plans/physical/PhysicalSchemaScan.java | 13 +-
.../physical/PhysicalStorageLayerAggregate.java | 15 +--
.../trees/plans/physical/PhysicalTVFRelation.java | 13 +-
.../trees/plans/physical/PhysicalTVFTableSink.java | 19 +--
.../nereids/trees/plans/physical/PhysicalTopN.java | 17 +--
.../trees/plans/physical/PhysicalUnion.java | 21 ++--
.../trees/plans/physical/PhysicalWindow.java | 26 ++--
.../plans/physical/PhysicalWorkTableReference.java | 16 ++-
.../trees/plans/PlanNodeIdPreservationTest.java | 131 +++++++++++++++++++++
113 files changed, 1532 insertions(+), 894 deletions(-)
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/AbstractPlan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/AbstractPlan.java
index 271b008362c..7b2873dc2a7 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/AbstractPlan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/AbstractPlan.java
@@ -61,6 +61,15 @@ public abstract class AbstractPlan extends AbstractTreeNode<Plan> implements Pla
private static final ObjectId zeroId = new ObjectId(0);
+ /**
+ * When a {@code withXxx} method wants the newly created plan node to reuse the
+ * same {@link ObjectId} as the original node, it calls
+ * {@link #copyWithSameId(AbstractPlan, Supplier)}. That helper stores the id
+ * here before invoking the constructor, and the constructor reads and clears it.
+ * Using a ThreadLocal makes this thread-safe without any locking.
+ */
+ private static final ThreadLocal<ObjectId> INHERIT_ID = new ThreadLocal<>();
+
public final int depth;
protected final ObjectId id;
@@ -84,7 +93,14 @@ public abstract class AbstractPlan extends AbstractTreeNode<Plan> implements Pla
? optLogicalProperties::get
: LazyCompute.of(this::computeLogicalProperties);
this.statistics = statistics;
- this.id = StatementScopeIdGenerator.newObjectId();
+ // Inherit id from the original node when called via copyWithSameId(), otherwise allocate a fresh id.
+ ObjectId inherited = INHERIT_ID.get();
+ if (inherited != null) {
+ this.id = inherited;
+ INHERIT_ID.remove();
+ } else {
+ this.id = StatementScopeIdGenerator.newObjectId();
+ }
this.hasUnboundChild = buildHasUnboundChildCache();
switch (children.size()) {
@@ -137,6 +153,33 @@ public abstract class AbstractPlan extends AbstractTreeNode<Plan> implements Pla
}
}
+ /**
+ * Create a new plan node using {@code factory} and assign it the same {@link ObjectId}
+ * as {@code source}.
+ *
+ * <p>Usage in {@code withXxx} methods:
+ * <pre>{@code
+ * public LogicalProject<Plan> withChildren(List<Plan> children) {
+ * return AbstractPlan.copyWithSameId(this, () ->
+ * new LogicalProject<>(projects, isDistinct, children));
+ * }
+ * }</pre>
+ *
+ * @param source the original plan whose id should be inherited
+ * @param factory supplier that creates the new plan node (usually a constructor call)
+ * @param <T> the concrete plan type
+ * @return the new plan node with the same id as {@code source}
+ */
+ public static <T extends AbstractPlan> T copyWithSameId(AbstractPlan source, Supplier<T> factory) {
+ INHERIT_ID.set(source.id);
+ try {
+ return factory.get();
+ } finally {
+ // Guard against constructor throwing before it could clear the ThreadLocal.
+ INHERIT_ID.remove();
+ }
+ }
+
private int computeDepth() {
int depth = 0;
for (Plan child : children) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAggregate.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAggregate.java
index b7b4e4f756b..7dba523df42 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAggregate.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAggregate.java
@@ -32,6 +32,7 @@ import org.apache.doris.nereids.trees.expressions.functions.agg.AggregatePhase;
import org.apache.doris.nereids.trees.expressions.functions.agg.Count;
import org.apache.doris.nereids.trees.expressions.functions.agg.Ndv;
import org.apache.doris.nereids.trees.expressions.literal.Literal;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Aggregate;
@@ -288,9 +289,10 @@ public class LogicalAggregate<CHILD_TYPE extends Plan>
}
public LogicalAggregate<Plan> withPartitionExpressions(Optional<List<Expression>> newPartitionExpressions) {
- return new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), newPartitionExpressions,
- child());
+ child()));
}
public boolean isNormalized() {
@@ -330,69 +332,78 @@ public class LogicalAggregate<CHILD_TYPE extends Plan>
@Override
public LogicalAggregate<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- children.get(0));
+ children.get(0)));
}
@Override
public LogicalAggregate<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, groupExpression, Optional.of(getLogicalProperties()),
- partitionExpressions, children.get(0));
+ partitionExpressions, children.get(0)));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, groupExpression, Optional.of(getLogicalProperties()),
- partitionExpressions, children.get(0));
+ partitionExpressions, children.get(0)));
}
public LogicalAggregate<Plan> withGroupByAndOutput(List<Expression> groupByExprList,
List<NamedExpression> outputExpressionList) {
- return new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- child());
+ child()));
}
public LogicalAggregate<Plan> withGroupBy(List<Expression> groupByExprList) {
- return new LogicalAggregate<>(groupByExprList, outputExpressions, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExprList, outputExpressions, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- child());
+ child()));
}
public LogicalAggregate<Plan> withChildGroupByAndOutput(List<Expression> groupByExprList,
List<NamedExpression> outputExpressionList, Plan newChild) {
- return new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- newChild);
+ newChild));
}
public LogicalAggregate<Plan> withChildGroupByAndOutputAndPartitionExpr(List<Expression> groupByExprList,
List<NamedExpression> outputExpressionList, Optional<List<Expression>> partitionExpressions,
Plan newChild) {
- return new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(),
- partitionExpressions, newChild);
+ partitionExpressions, newChild));
}
public LogicalAggregate<Plan> withChildGroupByAndOutputAndSourceRepeatAndPartitionExpr(
List<Expression> groupByExprList,
List<NamedExpression> outputExpressionList, Optional<List<Expression>> partitionExpressions, Plan newChild,
Optional<LogicalRepeat<? extends Plan>> sourceRepeat) {
- return new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExprList, outputExpressionList, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(),
- partitionExpressions, newChild);
+ partitionExpressions, newChild));
}
public LogicalAggregate<Plan> withChildAndOutput(CHILD_TYPE child,
List<NamedExpression> outputExpressionList) {
- return new LogicalAggregate<>(groupByExpressions, outputExpressionList, normalized, ordinalIsResolved,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressionList, normalized, ordinalIsResolved,
generated, hasPushed, withInProjection, sourceRepeat, Optional.empty(),
- Optional.empty(), partitionExpressions, child);
+ Optional.empty(), partitionExpressions, child));
}
@Override
@@ -402,34 +413,39 @@ public class LogicalAggregate<CHILD_TYPE extends Plan>
@Override
public LogicalAggregate<CHILD_TYPE> withAggOutput(List<NamedExpression> newOutput) {
- return new LogicalAggregate<>(groupByExpressions, newOutput, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, newOutput, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- child());
+ child()));
}
public LogicalAggregate<Plan> withAggOutputChild(List<NamedExpression> newOutput, Plan newChild) {
- return new LogicalAggregate<>(groupByExpressions, newOutput, normalized, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, newOutput, normalized, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- newChild);
+ newChild));
}
public LogicalAggregate<Plan> withNormalized(List<Expression> normalizedGroupBy,
List<NamedExpression> normalizedOutput, Plan normalizedChild) {
- return new LogicalAggregate<>(normalizedGroupBy, normalizedOutput, true, ordinalIsResolved, generated,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(normalizedGroupBy, normalizedOutput, true, ordinalIsResolved, generated,
hasPushed, withInProjection, sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions,
- normalizedChild);
+ normalizedChild));
}
public LogicalAggregate<Plan> withInProjection(boolean withInProjection) {
- return new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved,
generated, hasPushed, withInProjection,
- sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions, child());
+ sourceRepeat, Optional.empty(), Optional.empty(), partitionExpressions, child()));
}
public LogicalAggregate<Plan> withSourceRepeat(LogicalRepeat<?> sourceRepeat) {
- return new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAggregate<>(groupByExpressions, outputExpressions, normalized, ordinalIsResolved,
generated, hasPushed, withInProjection, Optional.ofNullable(sourceRepeat),
- Optional.empty(), Optional.empty(), partitionExpressions, child());
+ Optional.empty(), Optional.empty(), partitionExpressions, child()));
}
private boolean isUniqueGroupByUnique(NamedExpression namedExpression) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalApply.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalApply.java
index 6c73f5ac977..22a3a354899 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalApply.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalApply.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.MarkJoinSlotReference;
import org.apache.doris.nereids.trees.expressions.ScalarSubquery;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -286,25 +287,28 @@ public class LogicalApply<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends
@Override
public LogicalApply<Plan, Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new LogicalApply<>(correlationSlot, subqueryType, isNot, compareExpr, typeCoercionExpr,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalApply<>(correlationSlot, subqueryType, isNot, compareExpr, typeCoercionExpr,
correlationFilter, markJoinSlotReference, needAddSubOutputToProjects, isMarkJoinSlotNotNull,
- children.get(0), children.get(1));
+ children.get(0), children.get(1)));
}
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalApply<>(groupExpression, Optional.of(getLogicalProperties()),
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalApply<>(groupExpression, Optional.of(getLogicalProperties()),
correlationSlot, subqueryType, isNot, compareExpr, typeCoercionExpr, correlationFilter,
- markJoinSlotReference, needAddSubOutputToProjects, isMarkJoinSlotNotNull, left(), right());
+ markJoinSlotReference, needAddSubOutputToProjects, isMarkJoinSlotNotNull, left(), right()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new LogicalApply<>(groupExpression, logicalProperties, correlationSlot, subqueryType, isNot,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalApply<>(groupExpression, logicalProperties, correlationSlot, subqueryType, isNot,
compareExpr, typeCoercionExpr, correlationFilter, markJoinSlotReference,
- needAddSubOutputToProjects, isMarkJoinSlotNotNull, children.get(0), children.get(1));
+ needAddSubOutputToProjects, isMarkJoinSlotNotNull, children.get(0), children.get(1)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAssertNumRows.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAssertNumRows.java
index f78b41d7bdd..c6f24f1e21c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAssertNumRows.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalAssertNumRows.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.AssertNumRowsElement;
import org.apache.doris.nereids.trees.expressions.AssertNumRowsElement.Assertion;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -101,20 +102,23 @@ public class LogicalAssertNumRows<CHILD_TYPE extends Plan> extends LogicalUnary<
@Override
public LogicalUnary<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalAssertNumRows<>(assertNumRowsElement, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAssertNumRows<>(assertNumRowsElement, children.get(0)));
}
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalAssertNumRows<>(assertNumRowsElement,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAssertNumRows<>(assertNumRowsElement,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalAssertNumRows<>(assertNumRowsElement, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalAssertNumRows<>(assertNumRowsElement, groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBlackholeSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBlackholeSink.java
index 97b6c220b86..64478c3ce0a 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBlackholeSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBlackholeSink.java
@@ -20,6 +20,7 @@ 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.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -55,7 +56,8 @@ public class LogicalBlackholeSink<CHILD_TYPE extends Plan> extends LogicalSink<C
public LogicalBlackholeSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalBlackholeSink's children size must be 1, but real is %s", children.size());
- return new LogicalBlackholeSink<>(outputExprs, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalBlackholeSink<>(outputExprs, children.get(0)));
}
@Override
@@ -65,19 +67,22 @@ public class LogicalBlackholeSink<CHILD_TYPE extends Plan> extends LogicalSink<C
@Override
public LogicalBlackholeSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalBlackholeSink<>(outputExprs, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalBlackholeSink<>(outputExprs, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalBlackholeSink<Plan> withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalBlackholeSink only accepts one child");
- return new LogicalBlackholeSink<>(outputExprs, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalBlackholeSink<>(outputExprs, groupExpression, logicalProperties, children.get(0)));
}
@Override
public LogicalBlackholeSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalBlackholeSink<>(outputExprs, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalBlackholeSink<>(outputExprs, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTE.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTE.java
index 00229afa10d..68cf5d1b05e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTE.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTE.java
@@ -21,6 +21,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -124,7 +125,8 @@ public class LogicalCTE<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_TYPE
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(aliasQueries.size() > 0);
- return new LogicalCTE<>(isRecursive, aliasQueries, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTE<>(isRecursive, aliasQueries, children.get(0)));
}
@Override
@@ -139,14 +141,16 @@ public class LogicalCTE<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_TYPE
@Override
public LogicalCTE<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalCTE<>(isRecursive, aliasQueries, groupExpression,
- Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTE<>(isRecursive, aliasQueries, groupExpression,
+ Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(aliasQueries.size() > 0);
- return new LogicalCTE<>(isRecursive, aliasQueries, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTE<>(isRecursive, aliasQueries, groupExpression, logicalProperties, children.get(0)));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEAnchor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEAnchor.java
index 37989a6bc2a..23cd6181345 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEAnchor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEAnchor.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -55,7 +56,8 @@ public class LogicalCTEAnchor<LEFT_CHILD_TYPE extends Plan,
@Override
public Plan withChildren(List<Plan> children) {
- return new LogicalCTEAnchor<>(cteId, children.get(0), children.get(1));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEAnchor<>(cteId, children.get(0), children.get(1)));
}
@Override
@@ -70,13 +72,15 @@ public class LogicalCTEAnchor<LEFT_CHILD_TYPE extends Plan,
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalCTEAnchor<>(cteId, groupExpression, Optional.of(getLogicalProperties()), left(), right());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEAnchor<>(cteId, groupExpression, Optional.of(getLogicalProperties()), left(), right()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalCTEAnchor<>(cteId, groupExpression, logicalProperties, children.get(0), children.get(1));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEAnchor<>(cteId, groupExpression, logicalProperties, children.get(0), children.get(1)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEConsumer.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEConsumer.java
index be2c41d2605..df4ffb7581e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEConsumer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEConsumer.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.StatementScopeIdGenerator;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -129,23 +130,26 @@ public class LogicalCTEConsumer extends LogicalRelation implements BlockFuncDeps
public Plan withTwoMaps(Map<Slot, Slot> consumerToProducerOutputMap,
Multimap<Slot, Slot> producerToConsumerOutputMap) {
- return new LogicalCTEConsumer(relationId, cteId, name,
- consumerToProducerOutputMap, producerToConsumerOutputMap);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEConsumer(relationId, cteId, name,
+ consumerToProducerOutputMap, producerToConsumerOutputMap));
}
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalCTEConsumer(relationId, cteId, name,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEConsumer(relationId, cteId, name,
consumerToProducerOutputMap, producerToConsumerOutputMap,
- groupExpression, Optional.of(getLogicalProperties()));
+ groupExpression, Optional.of(getLogicalProperties())));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalCTEConsumer(relationId, cteId, name,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEConsumer(relationId, cteId, name,
consumerToProducerOutputMap, producerToConsumerOutputMap,
- groupExpression, logicalProperties);
+ groupExpression, logicalProperties));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEProducer.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEProducer.java
index 2c03e7e3d9e..5cb772fc610 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEProducer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCTEProducer.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -61,7 +62,8 @@ public class LogicalCTEProducer<CHILD_TYPE extends Plan> extends LogicalUnary<CH
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalCTEProducer<>(cteId, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEProducer<>(cteId, children.get(0)));
}
@Override
@@ -76,13 +78,15 @@ public class LogicalCTEProducer<CHILD_TYPE extends Plan> extends LogicalUnary<CH
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalCTEProducer<>(cteId, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEProducer<>(cteId, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalCTEProducer<>(cteId, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCTEProducer<>(cteId, groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCheckPolicy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCheckPolicy.java
index 98ef53b08a8..6d204304cb1 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCheckPolicy.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalCheckPolicy.java
@@ -38,6 +38,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.StatementScopeIdGenerator;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -116,20 +117,23 @@ public class LogicalCheckPolicy<CHILD_TYPE extends Plan> extends LogicalUnary<CH
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalCheckPolicy<>(groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCheckPolicy<>(groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalCheckPolicy<>(groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCheckPolicy<>(groupExpression, logicalProperties, children.get(0)));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalCheckPolicy<>(children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalCheckPolicy<>(children.get(0)));
}
/**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeOlapScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeOlapScan.java
index 8017e6795c8..bd2794a234e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeOlapScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeOlapScan.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.RelationId;
import org.apache.doris.nereids.trees.plans.algebra.OlapScan;
@@ -113,16 +114,18 @@ public class LogicalDeferMaterializeOlapScan extends LogicalCatalogRelation impl
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalDeferMaterializeOlapScan(logicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, Optional.of(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeOlapScan(logicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
+ groupExpression, Optional.of(getLogicalProperties())));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.isEmpty(), "LogicalDeferMaterializeOlapScan should have no child");
- return new LogicalDeferMaterializeOlapScan(logicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, logicalProperties);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeOlapScan(logicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
+ groupExpression, logicalProperties));
}
@Override
@@ -140,8 +143,9 @@ public class LogicalDeferMaterializeOlapScan extends LogicalCatalogRelation impl
public LogicalDeferMaterializeOlapScan withTableAlias(String tableAlias) {
// Update the wrapped LogicalOlapScan with the new alias
LogicalOlapScan newOlapScan = logicalOlapScan.withTableAlias(tableAlias);
- return new LogicalDeferMaterializeOlapScan(newOlapScan, deferMaterializeSlotIds, columnIdSlot,
- Optional.empty(), Optional.of(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeOlapScan(newOlapScan, deferMaterializeSlotIds, columnIdSlot,
+ Optional.empty(), Optional.of(getLogicalProperties())));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeResultSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeResultSink.java
index 4944b38d808..5ddeed059fc 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeResultSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeResultSink.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
import org.apache.doris.nereids.trees.plans.algebra.Sink;
@@ -78,15 +79,17 @@ public class LogicalDeferMaterializeResultSink<CHILD_TYPE extends Plan>
public LogicalDeferMaterializeResultSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalDeferMaterializeResultSink only accepts one child");
- return new LogicalDeferMaterializeResultSink<>(
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeResultSink<>(
logicalResultSink.withChildren(ImmutableList.of(children.get(0))),
- olapTable, selectedIndexId, Optional.empty(), Optional.empty(), children.get(0));
+ olapTable, selectedIndexId, Optional.empty(), Optional.empty(), children.get(0)));
}
@Override
public LogicalDeferMaterializeResultSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalDeferMaterializeResultSink<>(logicalResultSink, olapTable, selectedIndexId,
- Optional.empty(), Optional.empty(), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeResultSink<>(logicalResultSink, olapTable, selectedIndexId,
+ Optional.empty(), Optional.empty(), child()));
}
@Override
@@ -101,8 +104,9 @@ public class LogicalDeferMaterializeResultSink<CHILD_TYPE extends Plan>
@Override
public LogicalDeferMaterializeResultSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalDeferMaterializeResultSink<>(logicalResultSink, olapTable, selectedIndexId,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeResultSink<>(logicalResultSink, olapTable, selectedIndexId,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
@@ -112,9 +116,10 @@ public class LogicalDeferMaterializeResultSink<CHILD_TYPE extends Plan>
List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalDeferMaterializeResultSink only accepts one child");
- return new LogicalDeferMaterializeResultSink<>(
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeResultSink<>(
logicalResultSink.withChildren(ImmutableList.of(children.get(0))),
- olapTable, selectedIndexId, groupExpression, logicalProperties, children.get(0));
+ olapTable, selectedIndexId, groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeTopN.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeTopN.java
index 8e59c3f8afd..211fb41b787 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeTopN.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDeferMaterializeTopN.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.ObjectId;
import org.apache.doris.nereids.trees.plans.Plan;
@@ -122,8 +123,9 @@ public class LogicalDeferMaterializeTopN<CHILD_TYPE extends Plan> extends Logica
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalDeferMaterializeTopN<>(logicalTopN, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeTopN<>(logicalTopN, deferMaterializeSlotIds, columnIdSlot,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
@@ -131,16 +133,18 @@ public class LogicalDeferMaterializeTopN<CHILD_TYPE extends Plan> extends Logica
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalDeferMaterializeTopN should have 1 child, but input is %s", children.size());
- return new LogicalDeferMaterializeTopN<>(logicalTopN.withChildren(ImmutableList.of(children.get(0))),
- deferMaterializeSlotIds, columnIdSlot, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeTopN<>(logicalTopN.withChildren(ImmutableList.of(children.get(0))),
+ deferMaterializeSlotIds, columnIdSlot, groupExpression, logicalProperties, children.get(0)));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalDeferMaterializeTopN should have 1 child, but input is %s", children.size());
- return new LogicalDeferMaterializeTopN<>(logicalTopN.withChildren(ImmutableList.of(children.get(0))),
- deferMaterializeSlotIds, columnIdSlot, Optional.empty(), Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDeferMaterializeTopN<>(logicalTopN.withChildren(ImmutableList.of(children.get(0))),
+ deferMaterializeSlotIds, columnIdSlot, Optional.empty(), Optional.empty(), children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDictionarySink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDictionarySink.java
index 888ad8371be..f0b6f92c1a3 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDictionarySink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalDictionarySink.java
@@ -24,6 +24,7 @@ import org.apache.doris.dictionary.Dictionary;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -83,16 +84,18 @@ public class LogicalDictionarySink<CHILD_TYPE extends Plan> extends LogicalTable
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalDictionarySink only accepts one child");
- return new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, Optional.empty(),
- Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs,
+ Optional.empty(), Optional.empty(), children.get(0)));
}
// This function will really set outputExprs in base class
public Plan withChildAndUpdateOutput(Plan child) {
List<NamedExpression> output = child.getOutput().stream().map(NamedExpression.class::cast)
.collect(ImmutableList.toImmutableList());
- return new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, output, Optional.empty(),
- Optional.empty(), child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, output, Optional.empty(),
+ Optional.empty(), child));
}
@Override
@@ -102,15 +105,17 @@ public class LogicalDictionarySink<CHILD_TYPE extends Plan> extends LogicalTable
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
- Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
+ Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
- logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
+ logicalProperties, children.get(0)));
}
@Override
@@ -120,8 +125,9 @@ public class LogicalDictionarySink<CHILD_TYPE extends Plan> extends LogicalTable
@Override
public LogicalSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, Optional.empty(),
- Optional.empty(), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs,
+ Optional.empty(), Optional.empty(), child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEmptyRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEmptyRelation.java
index beb3968cf12..930d85763f3 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEmptyRelation.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEmptyRelation.java
@@ -21,6 +21,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -72,14 +73,16 @@ public class LogicalEmptyRelation extends LogicalRelation
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalEmptyRelation(relationId, projects,
- groupExpression, Optional.of(logicalPropertiesSupplier.get()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEmptyRelation(relationId, projects,
+ groupExpression, Optional.of(logicalPropertiesSupplier.get())));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalEmptyRelation(relationId, projects, groupExpression, logicalProperties);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEmptyRelation(relationId, projects, groupExpression, logicalProperties));
}
@Override
@@ -88,11 +91,13 @@ public class LogicalEmptyRelation extends LogicalRelation
}
public LogicalEmptyRelation withProjects(List<NamedExpression> projects) {
- return new LogicalEmptyRelation(relationId, projects);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEmptyRelation(relationId, projects));
}
public LogicalEmptyRelation withRelationIdAndProjects(RelationId relationId, List<NamedExpression> projects) {
- return new LogicalEmptyRelation(relationId, projects);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEmptyRelation(relationId, projects));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
index f3a38212faa..a696ee9a87d 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalEsScan.java
@@ -21,6 +21,7 @@ import org.apache.doris.catalog.TableIf;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -69,32 +70,37 @@ public class LogicalEsScan extends LogicalCatalogRelation {
@Override
public LogicalEsScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalEsScan(relationId, table, qualifier, virtualColumns,
- groupExpression, Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEsScan(relationId, table, qualifier, virtualColumns,
+ groupExpression, Optional.of(getLogicalProperties()), tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalEsScan(relationId, table, qualifier, virtualColumns, groupExpression, logicalProperties,
- tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEsScan(relationId, table, qualifier, virtualColumns, groupExpression, logicalProperties,
+ tableAlias));
}
@Override
public LogicalEsScan withRelationId(RelationId relationId) {
- return new LogicalEsScan(relationId, table, qualifier, virtualColumns, Optional.empty(), Optional.empty(),
- tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEsScan(relationId, table, qualifier, virtualColumns, Optional.empty(), Optional.empty(),
+ tableAlias));
}
@Override
public LogicalEsScan withVirtualColumns(List<NamedExpression> virtualColumns) {
- return new LogicalEsScan(relationId, table, qualifier, virtualColumns, Optional.empty(), Optional.empty(),
- tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEsScan(relationId, table, qualifier, virtualColumns, Optional.empty(), Optional.empty(),
+ tableAlias));
}
public LogicalEsScan withTableAlias(String tableAlias) {
- return new LogicalEsScan(relationId, table, qualifier, virtualColumns, Optional.empty(),
- Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalEsScan(relationId, table, qualifier, virtualColumns, Optional.empty(),
+ Optional.of(getLogicalProperties()), tableAlias));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalExcept.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalExcept.java
index 5fd0c6aa00a..55cd0f044c1 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalExcept.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalExcept.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Except;
@@ -84,7 +85,8 @@ public class LogicalExcept extends LogicalSetOperation implements Except {
@Override
public LogicalExcept withChildren(List<Plan> children) {
- return new LogicalExcept(qualifier, outputs, regularChildrenOutputs, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalExcept(qualifier, outputs, regularChildrenOutputs, children));
}
@Override
@@ -93,26 +95,30 @@ public class LogicalExcept extends LogicalSetOperation implements Except {
Preconditions.checkArgument(children.size() == childrenOutputs.size(),
"children size %s is not equals with children outputs size %s",
children.size(), childrenOutputs.size());
- return new LogicalExcept(qualifier, outputs, childrenOutputs, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalExcept(qualifier, outputs, childrenOutputs, children));
}
@Override
public LogicalExcept withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalExcept(qualifier, outputs, regularChildrenOutputs, groupExpression,
- Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalExcept(qualifier, outputs, regularChildrenOutputs, groupExpression,
+ Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalExcept(qualifier, outputs, regularChildrenOutputs,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalExcept(qualifier, outputs, regularChildrenOutputs,
+ groupExpression, logicalProperties, children));
}
@Override
public LogicalExcept withNewOutputs(List<NamedExpression> newOutputs) {
- return new LogicalExcept(qualifier, newOutputs, regularChildrenOutputs,
- Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalExcept(qualifier, newOutputs, regularChildrenOutputs,
+ Optional.empty(), Optional.empty(), children));
}
private Map<Slot, Slot> constructReplaceMapForChild(int index) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
index 409f9a2ee11..53bd8243309 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFileScan.java
@@ -29,6 +29,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.TableSample;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -136,39 +137,44 @@ public class LogicalFileScan extends LogicalCatalogRelation implements SupportPr
@Override
public LogicalFileScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
scanParams, groupExpression, Optional.of(getLogicalProperties()), tableAlias,
- cachedOutputs);
+ cachedOutputs));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
- scanParams, groupExpression, logicalProperties, tableAlias, cachedOutputs);
+ scanParams, groupExpression, logicalProperties, tableAlias, cachedOutputs));
}
public LogicalFileScan withSelectedPartitions(SelectedPartitions selectedPartitions) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
scanParams, Optional.empty(), Optional.of(getLogicalProperties()), tableAlias,
- cachedOutputs);
+ cachedOutputs));
}
@Override
public LogicalFileScan withRelationId(RelationId relationId) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
- scanParams, Optional.empty(), Optional.empty(), tableAlias, cachedOutputs);
+ scanParams, Optional.empty(), Optional.empty(), tableAlias, cachedOutputs));
}
public LogicalFileScan withTableAlias(String tableAlias) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
scanParams, Optional.empty(), Optional.of(getLogicalProperties()), tableAlias,
- cachedOutputs);
+ cachedOutputs));
}
@Override
@@ -279,15 +285,17 @@ public class LogicalFileScan extends LogicalCatalogRelation implements SupportPr
@Override
public LogicalFileScan withOperativeSlots(Collection<Slot> operativeSlots) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
- scanParams, groupExpression, Optional.of(getLogicalProperties()), tableAlias, cachedOutputs);
+ scanParams, groupExpression, Optional.of(getLogicalProperties()), tableAlias, cachedOutputs));
}
public LogicalFileScan withCachedOutput(List<Slot> cachedOutputs) {
- return new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, operativeSlots, virtualColumns, tableSample, tableSnapshot,
- scanParams, groupExpression, Optional.empty(), tableAlias, Optional.of(cachedOutputs));
+ scanParams, groupExpression, Optional.empty(), tableAlias, Optional.of(cachedOutputs)));
}
@Override
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 47a1ed6ff5b..27c216e298b 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
@@ -20,6 +20,7 @@ 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.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -61,13 +62,15 @@ public class LogicalFileSink<CHILD_TYPE extends Plan> extends LogicalSink<CHILD_
}
public LogicalFileSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalFileSink<>(filePath, format, properties, outputExprs, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileSink<>(filePath, format, properties, outputExprs, child()));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalFileSink<>(filePath, format, properties, outputExprs, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileSink<>(filePath, format, properties, outputExprs, children.get(0)));
}
@Override
@@ -98,16 +101,18 @@ public class LogicalFileSink<CHILD_TYPE extends Plan> extends LogicalSink<CHILD_
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalFileSink<>(filePath, format, properties, outputExprs,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileSink<>(filePath, format, properties, outputExprs,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalFileSink<>(filePath, format, properties, outputExprs,
- groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFileSink<>(filePath, format, properties, outputExprs,
+ groupExpression, logicalProperties, children.get(0)));
}
public String getFilePath() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFilter.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFilter.java
index b7d72b3476b..2af224c2617 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFilter.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFilter.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SubqueryExpr;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -161,35 +162,42 @@ public class LogicalFilter<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_T
}
public LogicalFilter<Plan> withConjuncts(Set<Expression> conjuncts) {
- return new LogicalFilter<>(conjuncts, null, Optional.empty(), Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFilter<>(conjuncts, null, Optional.empty(), Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalFilter<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalFilter<>(conjuncts, predicate, Optional.empty(), Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFilter<>(conjuncts, predicate, Optional.empty(), Optional.empty(), children.get(0)));
}
@Override
public LogicalFilter<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalFilter<>(conjuncts, predicate, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFilter<>(conjuncts, predicate, groupExpression,
+ Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalFilter<>(conjuncts, predicate, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFilter<>(conjuncts, predicate, groupExpression, logicalProperties, children.get(0)));
}
public LogicalFilter<Plan> withConjunctsAndChild(Set<Expression> conjuncts, Plan child) {
- return new LogicalFilter<>(conjuncts, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFilter<>(conjuncts, child));
}
public LogicalFilter<Plan> withConjunctsAndProps(Set<Expression> conjuncts,
Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, Plan child) {
- return new LogicalFilter<>(conjuncts, null, groupExpression, logicalProperties, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalFilter<>(conjuncts, null, groupExpression, logicalProperties, child));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalGenerate.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalGenerate.java
index d5adde59537..a8d83b1d641 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalGenerate.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalGenerate.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.functions.Function;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -103,7 +104,8 @@ public class LogicalGenerate<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD
@Override
public LogicalGenerate<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalGenerate<>(generators, generatorOutput, expandColumnAlias, conjuncts, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalGenerate<>(generators, generatorOutput, expandColumnAlias, conjuncts, children.get(0)));
}
@Override
@@ -136,21 +138,24 @@ public class LogicalGenerate<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD
for (int i = 0; i < generators.size(); i++) {
newGeneratorOutput.add(generatorOutput.get(i).withNullable(generators.get(i).nullable()));
}
- return new LogicalGenerate<>(generators, newGeneratorOutput, expandColumnAlias, conjuncts, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalGenerate<>(generators, newGeneratorOutput, expandColumnAlias, conjuncts, child()));
}
@Override
public LogicalGenerate<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalGenerate<>(generators, generatorOutput, expandColumnAlias, conjuncts,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalGenerate<>(generators, generatorOutput, expandColumnAlias, conjuncts,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalGenerate<>(generators, generatorOutput, expandColumnAlias, conjuncts,
- groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalGenerate<>(generators, generatorOutput, expandColumnAlias, conjuncts,
+ groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHaving.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHaving.java
index 339a2bb046e..b28abc0c86d 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHaving.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHaving.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.DataTrait.Builder;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Filter;
@@ -72,7 +73,8 @@ public class LogicalHaving<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_T
@Override
public LogicalHaving<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalHaving<>(conjuncts, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHaving<>(conjuncts, children.get(0)));
}
@Override
@@ -82,23 +84,27 @@ public class LogicalHaving<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_T
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalHaving<>(conjuncts, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHaving<>(conjuncts, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalHaving<>(conjuncts, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHaving<>(conjuncts, groupExpression, logicalProperties, children.get(0)));
}
public LogicalHaving<Plan> withConjuncts(Set<Expression> conjuncts) {
- return new LogicalHaving<>(conjuncts, Optional.empty(),
- Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHaving<>(conjuncts, Optional.empty(),
+ Optional.of(getLogicalProperties()), child()));
}
public LogicalHaving<Plan> withConjunctsAndChild(Set<Expression> conjuncts, Plan child) {
- return new LogicalHaving<>(conjuncts, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHaving<>(conjuncts, child));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHiveTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHiveTableSink.java
index 147f14e5e69..507549e7c2a 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHiveTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHiveTableSink.java
@@ -23,6 +23,7 @@ import org.apache.doris.datasource.hive.HMSExternalTable;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -65,24 +66,28 @@ public class LogicalHiveTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
this.dmlCommandType = dmlCommandType;
}
+ /** Update output expressions based on child output and replace child. */
public Plan withChildAndUpdateOutput(Plan child) {
List<NamedExpression> output = child.getOutput().stream()
.map(NamedExpression.class::cast)
.collect(ImmutableList.toImmutableList());
- return new LogicalHiveTableSink<>(database, targetTable, cols, output,
- dmlCommandType, Optional.empty(), Optional.empty(), child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHiveTableSink<>(database, targetTable, cols, output,
+ dmlCommandType, Optional.empty(), Optional.empty(), child));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalHiveTableSink only accepts one child");
- return new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), children.get(0)));
}
public LogicalHiveTableSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), child()));
}
public HMSExternalDatabase getDatabase() {
@@ -137,14 +142,16 @@ public class LogicalHiveTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHiveTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, logicalProperties, children.get(0)));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
index ca380dbdddd..5ff0f937444 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalHudiScan.java
@@ -38,6 +38,7 @@ import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.literal.StringLiteral;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.RelationId;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -157,34 +158,38 @@ public class LogicalHudiScan extends LogicalFileScan {
@Override
public LogicalHudiScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, groupExpression, Optional.of(getLogicalProperties()),
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, groupExpression, logicalProperties,
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
public LogicalHudiScan withSelectedPartitions(SelectedPartitions selectedPartitions) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, groupExpression, Optional.of(getLogicalProperties()),
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
@Override
public LogicalHudiScan withRelationId(RelationId relationId) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, groupExpression, Optional.empty(),
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
@Override
@@ -194,26 +199,29 @@ public class LogicalHudiScan extends LogicalFileScan {
@Override
public LogicalHudiScan withOperativeSlots(Collection<Slot> operativeSlots) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, groupExpression, Optional.of(getLogicalProperties()),
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
@Override
public LogicalHudiScan withTableAlias(String tableAlias) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, Optional.empty(), Optional.of(getLogicalProperties()),
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
@Override
public LogicalHudiScan withCachedOutput(List<Slot> cachedOutputs) {
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation,
operativeSlots, virtualColumns, groupExpression, Optional.empty(),
- tableAlias, Optional.of(cachedOutputs));
+ tableAlias, Optional.of(cachedOutputs)));
}
/**
@@ -264,9 +272,11 @@ public class LogicalHudiScan extends LogicalFileScan {
"Failed to create incremental relation for table: " + table.getFullQualifiers(), e);
}
}
- return new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
- selectedPartitions, tableSample, tableSnapshot, scanParams, newIncrementalRelation,
+ Optional<IncrementalRelation> finalIncrementalRelation = newIncrementalRelation;
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalHudiScan(relationId, (ExternalTable) table, qualifier,
+ selectedPartitions, tableSample, tableSnapshot, scanParams, finalIncrementalRelation,
operativeSlots, virtualColumns, groupExpression, Optional.of(getLogicalProperties()),
- tableAlias, cachedOutputs);
+ tableAlias, cachedOutputs));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIcebergTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIcebergTableSink.java
index 91398ddc5ac..b229f4c4cb3 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIcebergTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIcebergTableSink.java
@@ -23,6 +23,7 @@ import org.apache.doris.datasource.iceberg.IcebergExternalTable;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -65,24 +66,28 @@ public class LogicalIcebergTableSink<CHILD_TYPE extends Plan> extends LogicalTab
this.dmlCommandType = dmlCommandType;
}
+ /** Update output expressions based on child output and replace child. */
public Plan withChildAndUpdateOutput(Plan child) {
List<NamedExpression> output = child.getOutput().stream()
.map(NamedExpression.class::cast)
.collect(ImmutableList.toImmutableList());
- return new LogicalIcebergTableSink<>(database, targetTable, cols, output,
- dmlCommandType, Optional.empty(), Optional.empty(), child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIcebergTableSink<>(database, targetTable, cols, output,
+ dmlCommandType, Optional.empty(), Optional.empty(), child));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalIcebergTableSink only accepts one child");
- return new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), children.get(0)));
}
public LogicalIcebergTableSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), child()));
}
public IcebergExternalDatabase getDatabase() {
@@ -137,14 +142,16 @@ public class LogicalIcebergTableSink<CHILD_TYPE extends Plan> extends LogicalTab
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIcebergTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, logicalProperties, children.get(0)));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalInlineTable.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalInlineTable.java
index 748bc8fdfa2..e38e5f226ea 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalInlineTable.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalInlineTable.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -84,9 +85,10 @@ public class LogicalInlineTable extends LogicalLeaf implements InlineTable, Bloc
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalInlineTable(
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalInlineTable(
constantExprsList, groupExpression, Optional.of(getLogicalProperties())
- );
+ ));
}
@Override
@@ -95,7 +97,8 @@ public class LogicalInlineTable extends LogicalLeaf implements InlineTable, Bloc
if (!children.isEmpty()) {
throw new AnalysisException("children should not be empty");
}
- return new LogicalInlineTable(constantExprsList, groupExpression, logicalProperties);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalInlineTable(constantExprsList, groupExpression, logicalProperties));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIntersect.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIntersect.java
index fdfc7123f55..8d08cdc2114 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIntersect.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalIntersect.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Intersect;
@@ -84,7 +85,8 @@ public class LogicalIntersect extends LogicalSetOperation implements Intersect {
@Override
public LogicalIntersect withChildren(List<Plan> children) {
- return new LogicalIntersect(qualifier, outputs, regularChildrenOutputs, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIntersect(qualifier, outputs, regularChildrenOutputs, children));
}
@Override
@@ -93,26 +95,30 @@ public class LogicalIntersect extends LogicalSetOperation implements Intersect {
Preconditions.checkArgument(children.size() == childrenOutputs.size(),
"children size %s is not equals with children outputs size %s",
children.size(), childrenOutputs.size());
- return new LogicalIntersect(qualifier, outputs, childrenOutputs, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIntersect(qualifier, outputs, childrenOutputs, children));
}
@Override
public LogicalIntersect withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalIntersect(qualifier, outputs, regularChildrenOutputs, groupExpression,
- Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIntersect(qualifier, outputs, regularChildrenOutputs, groupExpression,
+ Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalIntersect(qualifier, outputs, regularChildrenOutputs,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIntersect(qualifier, outputs, regularChildrenOutputs,
+ groupExpression, logicalProperties, children));
}
@Override
public LogicalIntersect withNewOutputs(List<NamedExpression> newOutputs) {
- return new LogicalIntersect(qualifier, newOutputs, regularChildrenOutputs,
- Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalIntersect(qualifier, newOutputs, regularChildrenOutputs,
+ Optional.empty(), Optional.empty(), children));
}
Map<Slot, Slot> constructReplaceMap() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
index ef55849ca63..7b88d5d408e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcScan.java
@@ -23,6 +23,7 @@ import org.apache.doris.datasource.ExternalTable;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -76,26 +77,30 @@ public class LogicalJdbcScan extends LogicalCatalogRelation {
@Override
public LogicalJdbcScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalJdbcScan(relationId, table, qualifier, virtualColumns,
- groupExpression, Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcScan(relationId, table, qualifier, virtualColumns,
+ groupExpression, Optional.of(getLogicalProperties()), tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalJdbcScan(relationId, table, qualifier, virtualColumns,
- groupExpression, logicalProperties, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcScan(relationId, table, qualifier, virtualColumns,
+ groupExpression, logicalProperties, tableAlias));
}
@Override
public LogicalJdbcScan withRelationId(RelationId relationId) {
- return new LogicalJdbcScan(relationId, table, qualifier, virtualColumns,
- Optional.empty(), Optional.empty(), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcScan(relationId, table, qualifier, virtualColumns,
+ Optional.empty(), Optional.empty(), tableAlias));
}
public LogicalJdbcScan withTableAlias(String tableAlias) {
- return new LogicalJdbcScan(relationId, table, qualifier, virtualColumns, Optional.empty(),
- Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcScan(relationId, table, qualifier, virtualColumns, Optional.empty(),
+ Optional.of(getLogicalProperties()), tableAlias));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcTableSink.java
index b4027383916..17206bb349e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJdbcTableSink.java
@@ -23,6 +23,7 @@ import org.apache.doris.datasource.jdbc.JdbcExternalTable;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -65,25 +66,29 @@ public class LogicalJdbcTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
this.dmlCommandType = dmlCommandType;
}
+ /** Update output expressions based on child output and replace child. */
public Plan withChildAndUpdateOutput(Plan child) {
List<NamedExpression> output = child.getOutput().stream()
.map(NamedExpression.class::cast)
.collect(ImmutableList.toImmutableList());
- return new LogicalJdbcTableSink<>(database, targetTable, cols, output,
- dmlCommandType, Optional.empty(), Optional.empty(), child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcTableSink<>(database, targetTable, cols, output,
+ dmlCommandType, Optional.empty(), Optional.empty(), child));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalJdbcTableSink only accepts one child");
- return new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), children.get(0)));
}
@Override
public LogicalSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), child()));
}
public JdbcExternalDatabase getDatabase() {
@@ -138,14 +143,16 @@ public class LogicalJdbcTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJdbcTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, logicalProperties, children.get(0)));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJoin.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJoin.java
index b1ccabc52db..f2867ea6d6c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJoin.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJoin.java
@@ -31,6 +31,7 @@ import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.MarkJoinSlotReference;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.DistributeType;
import org.apache.doris.nereids.trees.plans.JoinType;
@@ -423,32 +424,36 @@ public class LogicalJoin<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends
@Override
public LogicalJoin<Plan, Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), children, joinReorderContext);
+ Optional.empty(), Optional.empty(), children, joinReorderContext));
}
@Override
public LogicalJoin<Plan, Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- groupExpression, Optional.of(getLogicalProperties()), children, joinReorderContext);
+ groupExpression, Optional.of(getLogicalProperties()), children, joinReorderContext));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- groupExpression, logicalProperties, children, joinReorderContext);
+ groupExpression, logicalProperties, children, joinReorderContext));
}
public LogicalJoin<Plan, Plan> withChildrenNoContext(Plan left, Plan right,
JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext));
}
/**
@@ -456,17 +461,19 @@ public class LogicalJoin<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends
*/
public LogicalJoin<Plan, Plan> withJoinConjuncts(List<Expression> hashJoinConjuncts,
List<Expression> otherJoinConjuncts, JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), children, otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), children, otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withJoinConjuncts(List<Expression> hashJoinConjuncts,
List<Expression> otherJoinConjuncts, List<Expression> markJoinConjuncts,
JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.of(getLogicalProperties()), children, otherJoinReorderContext);
+ Optional.empty(), Optional.of(getLogicalProperties()), children, otherJoinReorderContext));
}
/**
@@ -485,65 +492,74 @@ public class LogicalJoin<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends
List<Expression> hashJoinConjuncts, List<Expression> markJoinConjuncts,
Plan left, Plan right, JoinReorderContext otherJoinReorderContext) {
Preconditions.checkArgument(children.size() == 2);
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withHashJoinConjuncts(List<Expression> hashJoinConjuncts) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
Optional.empty(), Optional.empty(),
- ImmutableList.of(left(), right()), joinReorderContext);
+ ImmutableList.of(left(), right()), joinReorderContext));
}
public LogicalJoin<Plan, Plan> withConjunctsChildren(List<Expression> hashJoinConjuncts,
List<Expression> otherJoinConjuncts, Plan left, Plan right, JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withConjunctsChildren(List<Expression> hashJoinConjuncts,
List<Expression> otherJoinConjuncts, List<Expression> markJoinConjuncts, Plan left, Plan right,
JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withJoinType(JoinType joinType) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- groupExpression, Optional.empty(), children, joinReorderContext);
+ groupExpression, Optional.empty(), children, joinReorderContext));
}
public LogicalJoin<Plan, Plan> withJoinTypeAndContext(JoinType joinType,
JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), children, otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), children, otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withTypeChildren(JoinType joinType, Plan left, Plan right,
JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withTypeChildrenAndOtherConjuncts(JoinType joinType, Plan left, Plan right,
List<Expression> otherJoinConjuncts,
JoinReorderContext otherJoinReorderContext) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), otherJoinReorderContext));
}
public LogicalJoin<Plan, Plan> withDistributeHintChildren(DistributeHint hint, Plan left, Plan right) {
- return new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts,
hint, markJoinSlotReference, exceptAsteriskOutputs,
- Optional.empty(), Optional.empty(), ImmutableList.of(left, right), joinReorderContext);
+ Optional.empty(), Optional.empty(), ImmutableList.of(left, right), joinReorderContext));
}
/**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLimit.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLimit.java
index e651fb75272..ca418e361cc 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLimit.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLimit.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.DataTrait;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.LimitPhase;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -133,25 +134,30 @@ public class LogicalLimit<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_TY
public LogicalLimit<Plan> withLimitChild(long limit, long offset, Plan child) {
Preconditions.checkArgument(children.size() == 1,
"LogicalTopN should have 1 child, but input is %s", children.size());
- return new LogicalLimit<>(limit, offset, phase, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLimit<>(limit, offset, phase, child));
}
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalLimit<>(limit, offset, phase, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLimit<>(limit, offset, phase, groupExpression,
+ Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalLimit<>(limit, offset, phase, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLimit<>(limit, offset, phase, groupExpression, logicalProperties, children.get(0)));
}
@Override
public LogicalLimit<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalLimit<>(limit, offset, phase, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLimit<>(limit, offset, phase, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLoadProject.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLoadProject.java
index c197fc60d2c..207d80495f0 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLoadProject.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLoadProject.java
@@ -30,6 +30,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.functions.NoneMovableFunction;
import org.apache.doris.nereids.trees.expressions.functions.scalar.Uuid;
import org.apache.doris.nereids.trees.expressions.literal.TinyIntLiteral;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Project;
@@ -154,33 +155,39 @@ public class LogicalLoadProject<CHILD_TYPE extends Plan> extends LogicalUnary<CH
@Override
public LogicalLoadProject<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalLoadProject<>(projects, isDistinct, Utils.fastToImmutableList(children));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLoadProject<>(projects, isDistinct, Utils.fastToImmutableList(children)));
}
@Override
public LogicalLoadProject<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalLoadProject<>(projects, isDistinct,
- groupExpression, Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLoadProject<>(projects, isDistinct,
+ groupExpression, Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalLoadProject<>(projects, isDistinct,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLoadProject<>(projects, isDistinct,
+ groupExpression, logicalProperties, children));
}
public LogicalLoadProject<Plan> withProjects(List<NamedExpression> projects) {
- return new LogicalLoadProject<>(projects, isDistinct, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLoadProject<>(projects, isDistinct, children));
}
public LogicalLoadProject<Plan> withProjectsAndChild(List<NamedExpression> projects, Plan child) {
- return new LogicalLoadProject<>(projects, isDistinct, ImmutableList.of(child));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLoadProject<>(projects, isDistinct, ImmutableList.of(child)));
}
public LogicalLoadProject<Plan> withDistinct(boolean isDistinct) {
- return new LogicalLoadProject<>(projects, isDistinct, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalLoadProject<>(projects, isDistinct, children));
}
public boolean isDistinct() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalMaxComputeTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalMaxComputeTableSink.java
index 7399b218d52..8514fcc885c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalMaxComputeTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalMaxComputeTableSink.java
@@ -23,6 +23,7 @@ import org.apache.doris.datasource.maxcompute.MaxComputeExternalTable;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -64,24 +65,28 @@ public class LogicalMaxComputeTableSink<CHILD_TYPE extends Plan> extends Logical
this.dmlCommandType = dmlCommandType;
}
+ /** Update output expressions based on child output and replace child. */
public Plan withChildAndUpdateOutput(Plan child) {
List<NamedExpression> output = child.getOutput().stream()
.map(NamedExpression.class::cast)
.collect(ImmutableList.toImmutableList());
- return new LogicalMaxComputeTableSink<>(database, targetTable, cols, output,
- dmlCommandType, Optional.empty(), Optional.empty(), child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalMaxComputeTableSink<>(database, targetTable, cols, output,
+ dmlCommandType, Optional.empty(), Optional.empty(), child));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalMaxComputeTableSink only accepts one child");
- return new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), children.get(0)));
}
public LogicalMaxComputeTableSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, Optional.empty(), Optional.empty(), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, Optional.empty(), Optional.empty(), child()));
}
public MaxComputeExternalDatabase getDatabase() {
@@ -136,14 +141,16 @@ public class LogicalMaxComputeTableSink<CHILD_TYPE extends Plan> extends Logical
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
- dmlCommandType, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalMaxComputeTableSink<>(database, targetTable, cols, outputExprs,
+ dmlCommandType, groupExpression, logicalProperties, children.get(0)));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
index b56c775feda..a4d66919283 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOdbcScan.java
@@ -21,6 +21,7 @@ import org.apache.doris.catalog.OdbcTable;
import org.apache.doris.catalog.TableIf;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -70,24 +71,28 @@ public class LogicalOdbcScan extends LogicalCatalogRelation {
@Override
public LogicalOdbcScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalOdbcScan(relationId, table, qualifier, groupExpression,
- Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOdbcScan(relationId, table, qualifier, groupExpression,
+ Optional.of(getLogicalProperties()), tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalOdbcScan(relationId, table, qualifier, groupExpression, logicalProperties, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOdbcScan(relationId, table, qualifier, groupExpression, logicalProperties, tableAlias));
}
@Override
public LogicalOdbcScan withRelationId(RelationId relationId) {
- return new LogicalOdbcScan(relationId, table, qualifier, Optional.empty(), Optional.empty(), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOdbcScan(relationId, table, qualifier, Optional.empty(), Optional.empty(), tableAlias));
}
public LogicalOdbcScan withTableAlias(String tableAlias) {
- return new LogicalOdbcScan(relationId, table, qualifier, Optional.empty(),
- Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOdbcScan(relationId, table, qualifier, Optional.empty(),
+ Optional.of(getLogicalProperties()), tableAlias));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
index 9a6f8262414..13d055d01be 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOlapScan.java
@@ -34,6 +34,7 @@ import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.StatementScopeIdGenerator;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PreAggStatus;
@@ -349,37 +350,40 @@ public class LogicalOlapScan extends LogicalCatalogRelation implements OlapScan,
@Override
public LogicalOlapScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
groupExpression, Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier, groupExpression, logicalProperties,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier, groupExpression, logicalProperties,
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
* withSelectedPartitionIds
*/
public LogicalOlapScan withSelectedPartitionIds(List<Long> selectedPartitionIds) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.of(getLogicalProperties()),
selectedPartitionIds, true, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
@@ -388,88 +392,95 @@ public class LogicalOlapScan extends LogicalCatalogRelation implements OlapScan,
* @return scan with materialized index id
*/
public LogicalOlapScan withMaterializedIndexSelected(long indexId) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
indexId, true, PreAggStatus.unset(), manuallySpecifiedPartitions, hints, cacheSlotWithSlotName,
cachedOutput, tableSample, directMvScan, colToSubPathsMap, manuallySpecifiedTabletIds,
operativeSlots, virtualColumns, scoreOrderKeys, scoreLimit, scoreRangeInfo,
- annOrderKeys, annLimit, tableAlias);
+ annOrderKeys, annLimit, tableAlias));
}
/**
* withSelectedTabletIds
*/
public LogicalOlapScan withSelectedTabletIds(List<Long> selectedTabletIds) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns, scoreOrderKeys,
- scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
* withPreAggStatus
*/
public LogicalOlapScan withPreAggStatus(PreAggStatus preAggStatus) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
* constructor
*/
public LogicalOlapScan withColToSubPathsMap(Map<String, Set<List<String>>> colToSubPathsMap) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.empty(),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
* constructor
*/
public LogicalOlapScan withManuallySpecifiedTabletIds(List<Long> manuallySpecifiedTabletIds) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
public LogicalOlapScan withRelationId(RelationId relationId) {
// we have to set partitionPruned to false, so that mtmv rewrite can prevent deadlock when rewriting union
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.empty(),
selectedPartitionIds, false, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, Maps.newHashMap(), Optional.empty(), tableSample, directMvScan,
colToSubPathsMap, selectedTabletIds, operativeSlots, virtualColumns, scoreOrderKeys,
- scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
public LogicalOlapScan withTableAlias(String tableAlias) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
Optional.empty(), Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan,
colToSubPathsMap, manuallySpecifiedTabletIds, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
@@ -482,14 +493,15 @@ public class LogicalOlapScan extends LogicalCatalogRelation implements OlapScan,
LogicalProperties logicalProperties = getLogicalProperties();
List<Slot> output = Lists.newArrayList(logicalProperties.getOutput());
output.addAll(virtualColumns.stream().map(NamedExpression::toSlot).collect(Collectors.toList()));
- logicalProperties = new LogicalProperties(() -> output, this::computeDataTrait);
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
- groupExpression, Optional.of(logicalProperties),
+ LogicalProperties finalLogicalProperties = new LogicalProperties(() -> output, this::computeDataTrait);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
+ groupExpression, Optional.of(finalLogicalProperties),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan, colToSubPathsMap,
manuallySpecifiedTabletIds, operativeSlots, virtualColumns, scoreOrderKeys, scoreLimit,
- scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
/**
@@ -881,13 +893,14 @@ public class LogicalOlapScan extends LogicalCatalogRelation implements OlapScan,
@Override
public CatalogRelation withOperativeSlots(Collection<Slot> operativeSlots) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
groupExpression, Optional.of(getLogicalProperties()),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, cachedOutput, tableSample, directMvScan, colToSubPathsMap,
manuallySpecifiedTabletIds, operativeSlots, virtualColumns, scoreOrderKeys, scoreLimit,
- scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
private Map<Slot, Slot> constructReplaceMap(MTMV mtmv) {
@@ -922,13 +935,14 @@ public class LogicalOlapScan extends LogicalCatalogRelation implements OlapScan,
/** withCachedOutput */
public LogicalOlapScan withCachedOutput(List<Slot> outputSlots) {
- return new LogicalOlapScan(relationId, (Table) table, qualifier,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapScan(relationId, (Table) table, qualifier,
groupExpression, Optional.empty(),
selectedPartitionIds, partitionPruned, selectedTabletIds,
selectedIndexId, indexSelected, preAggStatus, manuallySpecifiedPartitions,
hints, cacheSlotWithSlotName, Optional.of(outputSlots), tableSample, directMvScan, colToSubPathsMap,
manuallySpecifiedTabletIds, operativeSlots, virtualColumns, scoreOrderKeys, scoreLimit,
- scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
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 5690aa1fb72..4c527110d41 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
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -106,17 +107,19 @@ public class LogicalOlapTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
Map<Long, Expression> syncMvWhereClauses, List<Slot> targetTableSlots) {
List<NamedExpression> output = child.getOutput().stream().map(NamedExpression.class::cast)
.collect(ImmutableList.toImmutableList());
- return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, output,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, output,
isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList, syncMvWhereClauses,
- targetTableSlots, Optional.empty(), Optional.empty(), child);
+ targetTableSlots, Optional.empty(), Optional.empty(), child));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalOlapTableSink only accepts one child");
- return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList, syncMvWhereClauses,
- targetTableSlots, Optional.empty(), Optional.empty(), children.get(0));
+ targetTableSlots, Optional.empty(), Optional.empty(), children.get(0)));
}
public DatabaseIf getDatabase() {
@@ -156,9 +159,10 @@ public class LogicalOlapTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
}
public LogicalOlapTableSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList, syncMvWhereClauses,
- targetTableSlots, Optional.empty(), Optional.empty(), child());
+ targetTableSlots, Optional.empty(), Optional.empty(), child()));
}
@Override
@@ -207,23 +211,26 @@ public class LogicalOlapTableSink<CHILD_TYPE extends Plan> extends LogicalTableS
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList, syncMvWhereClauses,
- targetTableSlots, groupExpression, Optional.of(getLogicalProperties()), child());
+ targetTableSlots, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList, syncMvWhereClauses,
- targetTableSlots, groupExpression, logicalProperties, children.get(0));
+ targetTableSlots, groupExpression, logicalProperties, children.get(0)));
}
public Plan withPartitionExprAndMvWhereClause(List<Expression> partitionExprList,
Map<Long, Expression> syncMvWhereClauses) {
- return new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList, syncMvWhereClauses,
- targetTableSlots, Optional.empty(), Optional.empty(), child());
+ targetTableSlots, Optional.empty(), Optional.empty(), child()));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOneRowRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOneRowRelation.java
index 5f8446fb015..370fa71df4b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOneRowRelation.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalOneRowRelation.java
@@ -27,6 +27,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.WindowExpression;
import org.apache.doris.nereids.trees.expressions.functions.generator.TableGeneratingFunction;
import org.apache.doris.nereids.trees.expressions.functions.scalar.GroupingScalarFunction;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -96,13 +97,15 @@ public class LogicalOneRowRelation extends LogicalRelation implements OneRowRela
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalOneRowRelation(relationId, projects, groupExpression, Optional.of(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOneRowRelation(relationId, projects, groupExpression, Optional.of(getLogicalProperties())));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalOneRowRelation(relationId, projects, groupExpression, logicalProperties);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOneRowRelation(relationId, projects, groupExpression, logicalProperties));
}
@Override
@@ -111,7 +114,8 @@ public class LogicalOneRowRelation extends LogicalRelation implements OneRowRela
}
public LogicalOneRowRelation withRelationIdAndProjects(RelationId relationId, List<NamedExpression> projects) {
- return new LogicalOneRowRelation(relationId, projects);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOneRowRelation(relationId, projects));
}
@Override
@@ -149,7 +153,8 @@ public class LogicalOneRowRelation extends LogicalRelation implements OneRowRela
}
public LogicalOneRowRelation withProjects(List<NamedExpression> namedExpressions) {
- return new LogicalOneRowRelation(relationId, namedExpressions, Optional.empty(), Optional.empty());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalOneRowRelation(relationId, namedExpressions, Optional.empty(), Optional.empty()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPartitionTopN.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPartitionTopN.java
index b4b70005ea5..6cd3455adb2 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPartitionTopN.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPartitionTopN.java
@@ -26,6 +26,7 @@ import org.apache.doris.nereids.trees.expressions.WindowExpression;
import org.apache.doris.nereids.trees.expressions.functions.window.DenseRank;
import org.apache.doris.nereids.trees.expressions.functions.window.Rank;
import org.apache.doris.nereids.trees.expressions.functions.window.RowNumber;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -179,28 +180,32 @@ public class LogicalPartitionTopN<CHILD_TYPE extends Plan> extends LogicalUnary<
public LogicalPartitionTopN<Plan> withPartitionKeysAndOrderKeys(
List<Expression> partitionKeys, List<OrderExpression> orderKeys) {
- return new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
- Optional.empty(), Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
+ Optional.empty(), Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalPartitionTopN<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
- children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
+ children.get(0)));
}
@Override
public LogicalPartitionTopN<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
- groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit,
+ groupExpression, logicalProperties, children.get(0)));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPostProject.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPostProject.java
index e3d1ad85296..08207ee636e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPostProject.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPostProject.java
@@ -29,6 +29,7 @@ import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.functions.NoneMovableFunction;
import org.apache.doris.nereids.trees.expressions.literal.TinyIntLiteral;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Project;
@@ -150,33 +151,39 @@ public class LogicalPostProject<CHILD_TYPE extends Plan> extends LogicalUnary<CH
@Override
public LogicalPostProject<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPostProject<>(projects, isDistinct, Utils.fastToImmutableList(children));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPostProject<>(projects, isDistinct, Utils.fastToImmutableList(children)));
}
@Override
public LogicalPostProject<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalPostProject<>(projects, isDistinct,
- groupExpression, Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPostProject<>(projects, isDistinct,
+ groupExpression, Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPostProject<>(projects, isDistinct,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPostProject<>(projects, isDistinct,
+ groupExpression, logicalProperties, children));
}
public LogicalPostProject<Plan> withProjects(List<NamedExpression> projects) {
- return new LogicalPostProject<>(projects, isDistinct, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPostProject<>(projects, isDistinct, children));
}
public LogicalPostProject<Plan> withProjectsAndChild(List<NamedExpression> projects, Plan child) {
- return new LogicalPostProject<>(projects, isDistinct, ImmutableList.of(child));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPostProject<>(projects, isDistinct, ImmutableList.of(child)));
}
public LogicalPostProject<Plan> withDistinct(boolean isDistinct) {
- return new LogicalPostProject<>(projects, isDistinct, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPostProject<>(projects, isDistinct, children));
}
public boolean isDistinct() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreAggOnHint.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreAggOnHint.java
index 079f6daabe6..0b109a2ae92 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreAggOnHint.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreAggOnHint.java
@@ -21,6 +21,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
@@ -57,7 +58,8 @@ public class LogicalPreAggOnHint<CHILD_TYPE extends Plan> extends LogicalUnary<C
@Override
public LogicalPreAggOnHint<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPreAggOnHint<>(children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreAggOnHint<>(children.get(0)));
}
@Override
@@ -72,14 +74,16 @@ public class LogicalPreAggOnHint<CHILD_TYPE extends Plan> extends LogicalUnary<C
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalPreAggOnHint<>(groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreAggOnHint<>(groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPreAggOnHint<>(groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreAggOnHint<>(groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreFilter.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreFilter.java
index b6614cd6cef..614a929685c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreFilter.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPreFilter.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SubqueryExpr;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -122,35 +123,41 @@ public class LogicalPreFilter<CHILD_TYPE extends Plan> extends LogicalUnary<CHIL
}
public LogicalPreFilter<Plan> withConjuncts(Set<Expression> conjuncts) {
- return new LogicalPreFilter<>(conjuncts, Optional.empty(), Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreFilter<>(conjuncts, Optional.empty(), Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalPreFilter<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPreFilter<>(conjuncts, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreFilter<>(conjuncts, children.get(0)));
}
@Override
public LogicalPreFilter<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalPreFilter<>(conjuncts, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreFilter<>(conjuncts, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalPreFilter<>(conjuncts, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreFilter<>(conjuncts, groupExpression, logicalProperties, children.get(0)));
}
public LogicalPreFilter<Plan> withConjunctsAndChild(Set<Expression> conjuncts, Plan child) {
- return new LogicalPreFilter<>(conjuncts, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreFilter<>(conjuncts, child));
}
public LogicalPreFilter<Plan> withConjunctsAndProps(Set<Expression> conjuncts,
Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, Plan child) {
- return new LogicalPreFilter<>(conjuncts, groupExpression, logicalProperties, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalPreFilter<>(conjuncts, groupExpression, logicalProperties, child));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalProject.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalProject.java
index 35bce61733a..fe076a7f8fc 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalProject.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalProject.java
@@ -28,6 +28,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.functions.NoneMovableFunction;
import org.apache.doris.nereids.trees.expressions.functions.scalar.Uuid;
import org.apache.doris.nereids.trees.expressions.literal.TinyIntLiteral;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Project;
@@ -186,33 +187,39 @@ public class LogicalProject<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_
@Override
public LogicalProject<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalProject<>(projects, isDistinct, Utils.fastToImmutableList(children));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalProject<>(projects, isDistinct, Utils.fastToImmutableList(children)));
}
@Override
public LogicalProject<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalProject<>(projects, isDistinct,
- groupExpression, Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalProject<>(projects, isDistinct,
+ groupExpression, Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalProject<>(projects, isDistinct,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalProject<>(projects, isDistinct,
+ groupExpression, logicalProperties, children));
}
public LogicalProject<Plan> withProjects(List<NamedExpression> projects) {
- return new LogicalProject<>(projects, isDistinct, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalProject<>(projects, isDistinct, children));
}
public LogicalProject<Plan> withProjectsAndChild(List<NamedExpression> projects, Plan child) {
- return new LogicalProject<>(projects, isDistinct, ImmutableList.of(child));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalProject<>(projects, isDistinct, ImmutableList.of(child)));
}
public LogicalProject<Plan> withDistinct(boolean isDistinct) {
- return new LogicalProject<>(projects, isDistinct, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalProject<>(projects, isDistinct, children));
}
public boolean isDistinct() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalQualify.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalQualify.java
index 665990b3fdc..2c20c6e259c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalQualify.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalQualify.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.DataTrait.Builder;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Filter;
@@ -70,18 +71,21 @@ public class LogicalQualify<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalQualify<>(conjuncts, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalQualify<>(conjuncts, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalQualify<>(conjuncts, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalQualify<>(conjuncts, groupExpression, logicalProperties, children.get(0)));
}
public LogicalQualify<Plan> withConjuncts(Set<Expression> conjuncts) {
- return new LogicalQualify<>(conjuncts, Optional.empty(), Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalQualify<>(conjuncts, Optional.empty(), Optional.of(getLogicalProperties()), child()));
}
@Override
@@ -130,7 +134,8 @@ public class LogicalQualify<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_
@Override
public LogicalQualify<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalQualify<>(conjuncts, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalQualify<>(conjuncts, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnion.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnion.java
index 4c5ae7fd00c..a00de0d18b2 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnion.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnion.java
@@ -33,6 +33,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.StatementScopeIdGenerator;
import org.apache.doris.nereids.trees.expressions.literal.Literal;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.RecursiveCte;
@@ -241,7 +242,8 @@ public class LogicalRecursiveUnion<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYP
@Override
public LogicalRecursiveUnion<Plan, Plan> withChildren(List<Plan> children) {
- return new LogicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs, children));
}
public LogicalRecursiveUnion<Plan, Plan> withChildrenAndTheirOutputs(List<Plan> children,
@@ -249,32 +251,37 @@ public class LogicalRecursiveUnion<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYP
Preconditions.checkArgument(children.size() == childrenOutputs.size(),
"children size %s is not equals with children outputs size %s",
children.size(), childrenOutputs.size());
- return new LogicalRecursiveUnion<>(cteName, qualifier, outputs, childrenOutputs, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnion<>(cteName, qualifier, outputs, childrenOutputs, children));
}
@Override
public LogicalRecursiveUnion<Plan, Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
- groupExpression, Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
+ groupExpression, Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
+ groupExpression, logicalProperties, children));
}
public LogicalRecursiveUnion<Plan, Plan> withNewOutputs(List<NamedExpression> newOutputs) {
- return new LogicalRecursiveUnion<>(cteName, qualifier, newOutputs, regularChildrenOutputs,
- Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnion<>(cteName, qualifier, newOutputs, regularChildrenOutputs,
+ Optional.empty(), Optional.empty(), children));
}
public LogicalRecursiveUnion<Plan, Plan> withNewOutputsAndChildren(List<NamedExpression> newOutputs,
List<Plan> children,
List<List<SlotReference>> childrenOutputs) {
- return new LogicalRecursiveUnion<>(cteName, qualifier, newOutputs, childrenOutputs,
- Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnion<>(cteName, qualifier, newOutputs, childrenOutputs,
+ Optional.empty(), Optional.empty(), children));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionAnchor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionAnchor.java
index 96c3f812432..3d100738576 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionAnchor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionAnchor.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -61,7 +62,8 @@ public class LogicalRecursiveUnionAnchor<CHILD_TYPE extends Plan> extends Logica
@Override
public Plan withChildren(List<Plan> children) {
- return new LogicalRecursiveUnionAnchor<>(cteId, Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnionAnchor<>(cteId, Optional.empty(), Optional.empty(), children));
}
@Override
@@ -76,14 +78,16 @@ public class LogicalRecursiveUnionAnchor<CHILD_TYPE extends Plan> extends Logica
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalRecursiveUnionAnchor<>(cteId, groupExpression,
- Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnionAnchor<>(cteId, groupExpression,
+ Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalRecursiveUnionAnchor<>(cteId, groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnionAnchor<>(cteId, groupExpression, logicalProperties, children));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionProducer.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionProducer.java
index 68bc22e2ce7..4b572de10ca 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionProducer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRecursiveUnionProducer.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.DataTrait;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -60,7 +61,8 @@ public class LogicalRecursiveUnionProducer<CHILD_TYPE extends Plan> extends Logi
@Override
public Plan withChildren(List<Plan> children) {
- return new LogicalRecursiveUnionProducer<>(cteName, Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnionProducer<>(cteName, Optional.empty(), Optional.empty(), children));
}
@Override
@@ -75,14 +77,16 @@ public class LogicalRecursiveUnionProducer<CHILD_TYPE extends Plan> extends Logi
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalRecursiveUnionProducer<>(cteName, groupExpression,
- Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnionProducer<>(cteName, groupExpression,
+ Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalRecursiveUnionProducer<>(cteName, groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRecursiveUnionProducer<>(cteName, groupExpression, logicalProperties, children));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRepeat.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRepeat.java
index 7b10cd2ced4..544255a68a2 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRepeat.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRepeat.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.functions.scalar.GroupingScalarFunction;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Repeat;
@@ -226,49 +227,58 @@ public class LogicalRepeat<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_T
@Override
public LogicalRepeat<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalRepeat<>(groupingSets, outputExpressions, groupingId, type, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressions, groupingId, type, children.get(0)));
}
@Override
public LogicalRepeat<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalRepeat<>(groupingSets, outputExpressions, groupExpression,
- Optional.of(getLogicalProperties()), groupingId, withInProjection, type, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressions, groupExpression,
+ Optional.of(getLogicalProperties()), groupingId, withInProjection, type, child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalRepeat<>(groupingSets, outputExpressions, groupExpression, logicalProperties,
- groupingId, withInProjection, type, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressions, groupExpression, logicalProperties,
+ groupingId, withInProjection, type, children.get(0)));
}
public LogicalRepeat<CHILD_TYPE> withGroupSets(List<List<Expression>> groupingSets) {
- return new LogicalRepeat<>(groupingSets, outputExpressions, groupingId, type, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressions, groupingId, type, child()));
}
public LogicalRepeat<CHILD_TYPE> withGroupSetsAndOutput(List<List<Expression>> groupingSets,
List<NamedExpression> outputExpressionList) {
- return new LogicalRepeat<>(groupingSets, outputExpressionList, groupingId, type, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressionList, groupingId, type, child()));
}
@Override
public LogicalRepeat<CHILD_TYPE> withAggOutput(List<NamedExpression> newOutput) {
- return new LogicalRepeat<>(groupingSets, newOutput, groupingId, type, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, newOutput, groupingId, type, child()));
}
public LogicalRepeat<Plan> withNormalizedExpr(List<List<Expression>> groupingSets,
List<NamedExpression> outputExpressionList, SlotReference groupingId, Plan child) {
- return new LogicalRepeat<>(groupingSets, outputExpressionList, groupingId, type, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressionList, groupingId, type, child));
}
public LogicalRepeat<Plan> withAggOutputAndChild(List<NamedExpression> newOutput, Plan child) {
- return new LogicalRepeat<>(groupingSets, newOutput, groupingId, type, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, newOutput, groupingId, type, child));
}
public LogicalRepeat<CHILD_TYPE> withInProjection(boolean withInProjection) {
- return new LogicalRepeat<>(groupingSets, outputExpressions,
- Optional.empty(), Optional.empty(), groupingId, withInProjection, type, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalRepeat<>(groupingSets, outputExpressions,
+ Optional.empty(), Optional.empty(), groupingId, withInProjection, type, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalResultSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalResultSink.java
index 7f6847af209..364eece4302 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalResultSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalResultSink.java
@@ -21,6 +21,7 @@ import org.apache.doris.analysis.StmtType;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -53,7 +54,8 @@ public class LogicalResultSink<CHILD_TYPE extends Plan> extends LogicalSink<CHIL
public LogicalResultSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalResultSink's children size must be 1, but real is %s", children.size());
- return new LogicalResultSink<>(outputExprs, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalResultSink<>(outputExprs, children.get(0)));
}
@Override
@@ -63,19 +65,22 @@ public class LogicalResultSink<CHILD_TYPE extends Plan> extends LogicalSink<CHIL
@Override
public LogicalResultSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalResultSink<>(outputExprs, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalResultSink<>(outputExprs, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalResultSink<Plan> withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalResultSink only accepts one child");
- return new LogicalResultSink<>(outputExprs, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalResultSink<>(outputExprs, groupExpression, logicalProperties, children.get(0)));
}
@Override
public LogicalResultSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalResultSink<>(outputExprs, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalResultSink<>(outputExprs, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
index 7eddfbf7eb3..c441cfbb15b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSchemaScan.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -119,36 +120,41 @@ public class LogicalSchemaScan extends LogicalCatalogRelation {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalSchemaScan(relationId, table, qualifier, filterPushed,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSchemaScan(relationId, table, qualifier, filterPushed,
schemaCatalog, schemaDatabase, schemaTable, virtualColumns,
- frontendConjuncts, groupExpression, Optional.of(getLogicalProperties()), tableAlias);
+ frontendConjuncts, groupExpression, Optional.of(getLogicalProperties()), tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalSchemaScan(relationId, table, qualifier, filterPushed,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSchemaScan(relationId, table, qualifier, filterPushed,
schemaCatalog, schemaDatabase, schemaTable, virtualColumns, frontendConjuncts, groupExpression,
- logicalProperties, tableAlias);
+ logicalProperties, tableAlias));
}
@Override
public LogicalSchemaScan withRelationId(RelationId relationId) {
- return new LogicalSchemaScan(relationId, table, qualifier, filterPushed,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSchemaScan(relationId, table, qualifier, filterPushed,
schemaCatalog, schemaDatabase, schemaTable, virtualColumns, frontendConjuncts, Optional.empty(),
- Optional.empty(), tableAlias);
+ Optional.empty(), tableAlias));
}
public LogicalSchemaScan withFrontendConjuncts(Optional<String> schemaCatalog, Optional<String> schemaDatabase,
Optional<String> schemaTable, List<Expression> frontendConjuncts) {
- return new LogicalSchemaScan(relationId, table, qualifier, true, schemaCatalog, schemaDatabase, schemaTable,
- virtualColumns, frontendConjuncts, Optional.empty(), Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSchemaScan(relationId, table, qualifier, true, schemaCatalog, schemaDatabase, schemaTable,
+ virtualColumns, frontendConjuncts, Optional.empty(), Optional.of(getLogicalProperties()), tableAlias));
}
public LogicalSchemaScan withTableAlias(String tableAlias) {
- return new LogicalSchemaScan(relationId, table, qualifier, filterPushed, schemaCatalog, schemaDatabase,
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSchemaScan(relationId, table, qualifier, filterPushed, schemaCatalog, schemaDatabase,
schemaTable, virtualColumns, frontendConjuncts, Optional.empty(),
- Optional.of(getLogicalProperties()), tableAlias);
+ Optional.of(getLogicalProperties()), tableAlias));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSelectHint.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSelectHint.java
index 2257444cc1f..11d8e837a7e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSelectHint.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSelectHint.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.SelectHint;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
@@ -84,7 +85,8 @@ public class LogicalSelectHint<CHILD_TYPE extends Plan> extends LogicalUnary<CHI
@Override
public LogicalSelectHint<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalSelectHint<>(hints, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSelectHint<>(hints, children.get(0)));
}
@Override
@@ -99,14 +101,16 @@ public class LogicalSelectHint<CHILD_TYPE extends Plan> extends LogicalUnary<CHI
@Override
public LogicalSelectHint<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalSelectHint<>(hints, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSelectHint<>(hints, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalSelectHint<>(hints, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSelectHint<>(hints, groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSort.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSort.java
index 45e0e081a3c..eb2f4bcb657 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSort.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalSort.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -131,27 +132,32 @@ public class LogicalSort<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_TYP
@Override
public LogicalSort<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalSort<>(orderKeys, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSort<>(orderKeys, children.get(0)));
}
@Override
public LogicalSort<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalSort<>(orderKeys, groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSort<>(orderKeys, groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalSort<Plan> withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalSort<>(orderKeys, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSort<>(orderKeys, groupExpression, logicalProperties, children.get(0)));
}
public LogicalSort<Plan> withOrderKeys(List<OrderKey> orderKeys) {
- return new LogicalSort<>(orderKeys, Optional.empty(),
- Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSort<>(orderKeys, Optional.empty(),
+ Optional.of(getLogicalProperties()), child()));
}
public LogicalSort<Plan> withOrderKeysAndChild(List<OrderKey> orderKeys, Plan child) {
- return new LogicalSort<>(orderKeys, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSort<>(orderKeys, 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 a6f076733d3..3e98f911840 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
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.DataTrait;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.DiffOutputInAsterisk;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -224,7 +225,8 @@ public class LogicalSubQueryAlias<CHILD_TYPE extends Plan> extends LogicalUnary<
@Override
public LogicalSubQueryAlias<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalSubQueryAlias<>(qualifier, columnAliases, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSubQueryAlias<>(qualifier, columnAliases, children.get(0)));
}
@Override
@@ -239,16 +241,18 @@ public class LogicalSubQueryAlias<CHILD_TYPE extends Plan> extends LogicalUnary<
@Override
public LogicalSubQueryAlias<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalSubQueryAlias<>(qualifier, columnAliases, groupExpression,
- Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSubQueryAlias<>(qualifier, columnAliases, groupExpression,
+ Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalSubQueryAlias<>(qualifier, columnAliases, groupExpression, logicalProperties,
- children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalSubQueryAlias<>(qualifier, columnAliases, groupExpression, logicalProperties,
+ children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFRelation.java
index c6d0241f393..3a9781a681b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFRelation.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFRelation.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.StatementScopeIdGenerator;
import org.apache.doris.nereids.trees.expressions.functions.table.TableValuedFunction;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -76,25 +77,29 @@ public class LogicalTVFRelation extends LogicalRelation implements TVFRelation,
@Override
public LogicalTVFRelation withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalTVFRelation(relationId, function, operativeSlots,
- groupExpression, Optional.of(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFRelation(relationId, function, operativeSlots,
+ groupExpression, Optional.of(getLogicalProperties())));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalTVFRelation(relationId, function, operativeSlots, groupExpression, logicalProperties);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFRelation(relationId, function, operativeSlots, groupExpression, logicalProperties));
}
@Override
public LogicalTVFRelation withRelationId(RelationId relationId) {
- return new LogicalTVFRelation(relationId, function, operativeSlots, Optional.empty(),
- Optional.of(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFRelation(relationId, function, operativeSlots, Optional.empty(),
+ Optional.of(getLogicalProperties())));
}
public LogicalTVFRelation withOperativeSlots(Collection<Slot> operativeSlots) {
- return new LogicalTVFRelation(relationId, function, Utils.fastToImmutableList(operativeSlots),
- Optional.empty(), Optional.of(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFRelation(relationId, function, Utils.fastToImmutableList(operativeSlots),
+ Optional.empty(), Optional.of(getLogicalProperties())));
}
public List<Slot> getOperativeSlots() {
@@ -154,7 +159,8 @@ public class LogicalTVFRelation extends LogicalRelation implements TVFRelation,
}
public LogicalTVFRelation withCachedOutputs(List<Slot> replaceSlots) {
- return new LogicalTVFRelation(relationId, function, Utils.fastToImmutableList(operativeSlots),
- Optional.of(replaceSlots), Optional.empty(), Optional.empty());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFRelation(relationId, function, Utils.fastToImmutableList(operativeSlots),
+ Optional.of(replaceSlots), Optional.empty(), Optional.empty()));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFTableSink.java
index 00b7e754782..6e78a40d84e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTVFTableSink.java
@@ -21,6 +21,7 @@ import org.apache.doris.catalog.Column;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -79,7 +80,8 @@ public class LogicalTVFTableSink<CHILD_TYPE extends Plan> extends LogicalSink<CH
public LogicalTVFTableSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalTVFTableSink's children size must be 1, but real is %s", children.size());
- return new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs, children.get(0)));
}
@Override
@@ -89,21 +91,24 @@ public class LogicalTVFTableSink<CHILD_TYPE extends Plan> extends LogicalSink<CH
@Override
public LogicalTVFTableSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public LogicalTVFTableSink<Plan> withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "LogicalTVFTableSink only accepts one child");
- return new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
- groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
+ groupExpression, logicalProperties, children.get(0)));
}
@Override
public LogicalTVFTableSink<CHILD_TYPE> withOutputExprs(List<NamedExpression> outputExprs) {
- return new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTVFTableSink<>(tvfName, properties, cols, outputExprs, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTestScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTestScan.java
index 7ac51a3248b..e49df118b9c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTestScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTestScan.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.plans.logical;
import org.apache.doris.catalog.TableIf;
import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -66,19 +67,22 @@ public class LogicalTestScan extends LogicalCatalogRelation {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalTestScan(relationId, table, qualifier,
- groupExpression, Optional.ofNullable(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTestScan(relationId, table, qualifier,
+ groupExpression, Optional.ofNullable(getLogicalProperties()), tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalTestScan(relationId, table, qualifier, groupExpression, logicalProperties, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTestScan(relationId, table, qualifier, groupExpression, logicalProperties, tableAlias));
}
public LogicalTestScan withTableAlias(String tableAlias) {
- return new LogicalTestScan(relationId, table, qualifier, Optional.empty(),
- Optional.of(getLogicalProperties()), tableAlias);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTestScan(relationId, table, qualifier, Optional.empty(),
+ Optional.of(getLogicalProperties()), tableAlias));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTopN.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTopN.java
index 6d6aa2b8131..903f58dfbc4 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTopN.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalTopN.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.ObjectId;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -128,36 +129,42 @@ public class LogicalTopN<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_TYP
}
public LogicalTopN<Plan> withOrderKeys(List<OrderKey> orderKeys) {
- return new LogicalTopN<>(orderKeys, limit, offset,
- Optional.empty(), Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTopN<>(orderKeys, limit, offset,
+ Optional.empty(), Optional.of(getLogicalProperties()), child()));
}
public LogicalTopN<Plan> withLimitChild(long limit, long offset, Plan child) {
- return new LogicalTopN<>(orderKeys, limit, offset, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTopN<>(orderKeys, limit, offset, child));
}
public LogicalTopN<Plan> withLimitOrderKeyAndChild(long limit, long offset, List<OrderKey> orderKeys, Plan child) {
- return new LogicalTopN<>(orderKeys, limit, offset, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTopN<>(orderKeys, limit, offset, child));
}
@Override
public LogicalTopN<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"LogicalTopN should have 1 child, but input is %s", children.size());
- return new LogicalTopN<>(orderKeys, limit, offset, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTopN<>(orderKeys, limit, offset, children.get(0)));
}
@Override
public LogicalTopN<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalTopN<>(orderKeys, limit, offset, groupExpression, Optional.of(getLogicalProperties()),
- child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTopN<>(orderKeys, limit, offset, groupExpression, Optional.of(getLogicalProperties()),
+ child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalTopN<>(orderKeys, limit, offset, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalTopN<>(orderKeys, limit, offset, groupExpression, logicalProperties, children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnion.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnion.java
index 55ffc5a286a..5f2d912a8dd 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnion.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnion.java
@@ -29,6 +29,7 @@ import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.literal.Literal;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Union;
@@ -157,8 +158,9 @@ public class LogicalUnion extends LogicalSetOperation implements Union, OutputPr
@Override
public LogicalUnion withChildren(List<Plan> children) {
- return new LogicalUnion(qualifier, outputs, regularChildrenOutputs,
- constantExprsList, hasPushedFilter, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, outputs, regularChildrenOutputs,
+ constantExprsList, hasPushedFilter, children));
}
@Override
@@ -167,49 +169,57 @@ public class LogicalUnion extends LogicalSetOperation implements Union, OutputPr
Preconditions.checkArgument(children.size() == childrenOutputs.size(),
"children size %s is not equals with children outputs size %s",
children.size(), childrenOutputs.size());
- return new LogicalUnion(qualifier, outputs, childrenOutputs, constantExprsList, hasPushedFilter, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, outputs, childrenOutputs, constantExprsList, hasPushedFilter, children));
}
@Override
public LogicalUnion withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList, hasPushedFilter,
- groupExpression, Optional.of(getLogicalProperties()), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList, hasPushedFilter,
+ groupExpression, Optional.of(getLogicalProperties()), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList, hasPushedFilter,
- groupExpression, logicalProperties, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList, hasPushedFilter,
+ groupExpression, logicalProperties, children));
}
@Override
public LogicalUnion withNewOutputs(List<NamedExpression> newOutputs) {
- return new LogicalUnion(qualifier, newOutputs, regularChildrenOutputs, constantExprsList,
- hasPushedFilter, Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, newOutputs, regularChildrenOutputs, constantExprsList,
+ hasPushedFilter, Optional.empty(), Optional.empty(), children));
}
public LogicalUnion withNewOutputsAndConstExprsList(List<NamedExpression> newOutputs,
List<List<NamedExpression>> constantExprsList) {
- return new LogicalUnion(qualifier, newOutputs, regularChildrenOutputs, constantExprsList,
- hasPushedFilter, Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, newOutputs, regularChildrenOutputs, constantExprsList,
+ hasPushedFilter, Optional.empty(), Optional.empty(), children));
}
public LogicalUnion withChildrenAndConstExprsList(List<Plan> children,
List<List<SlotReference>> childrenOutputs, List<List<NamedExpression>> constantExprsList) {
- return new LogicalUnion(qualifier, outputs, childrenOutputs, constantExprsList, hasPushedFilter, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, outputs, childrenOutputs, constantExprsList, hasPushedFilter, children));
}
public LogicalUnion withNewOutputsChildrenAndConstExprsList(List<NamedExpression> newOutputs, List<Plan> children,
List<List<SlotReference>> childrenOutputs,
List<List<NamedExpression>> constantExprsList) {
- return new LogicalUnion(qualifier, newOutputs, childrenOutputs, constantExprsList,
- hasPushedFilter, Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, newOutputs, childrenOutputs, constantExprsList,
+ hasPushedFilter, Optional.empty(), Optional.empty(), children));
}
public LogicalUnion withAllQualifier() {
- return new LogicalUnion(Qualifier.ALL, outputs, regularChildrenOutputs, constantExprsList, hasPushedFilter,
- Optional.empty(), Optional.empty(), children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(Qualifier.ALL, outputs, regularChildrenOutputs, constantExprsList, hasPushedFilter,
+ Optional.empty(), Optional.empty(), children));
}
@Override
@@ -430,6 +440,7 @@ public class LogicalUnion extends LogicalSetOperation implements Union, OutputPr
Preconditions.checkArgument(children.size() == childrenOutputs.size(),
"children size %s is not equals with children outputs size %s",
children.size(), childrenOutputs.size());
- return new LogicalUnion(qualifier, newOuptuts, childrenOutputs, constantExprsList, hasPushedFilter, children);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUnion(qualifier, newOuptuts, childrenOutputs, constantExprsList, hasPushedFilter, children));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUsingJoin.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUsingJoin.java
index a6b685a782a..14f53c3c881 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUsingJoin.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUsingJoin.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.DistributeType;
import org.apache.doris.nereids.trees.plans.JoinType;
@@ -76,21 +77,24 @@ public class LogicalUsingJoin<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE ext
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalUsingJoin<>(joinType, child(0), child(1),
- usingSlots, matchCondition, groupExpression, Optional.of(getLogicalProperties()), hint);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUsingJoin<>(joinType, child(0), child(1),
+ usingSlots, matchCondition, groupExpression, Optional.of(getLogicalProperties()), hint));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalUsingJoin<>(joinType, children.get(0), children.get(1),
- usingSlots, matchCondition, groupExpression, logicalProperties, hint);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUsingJoin<>(joinType, children.get(0), children.get(1),
+ usingSlots, matchCondition, groupExpression, logicalProperties, hint));
}
@Override
public Plan withChildren(List<Plan> children) {
- return new LogicalUsingJoin<>(joinType, children.get(0), children.get(1),
- usingSlots, matchCondition, groupExpression, Optional.of(getLogicalProperties()), hint);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalUsingJoin<>(joinType, children.get(0), children.get(1),
+ usingSlots, matchCondition, groupExpression, Optional.of(getLogicalProperties()), hint));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalView.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalView.java
index 0384e003175..a7dd046cb36 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalView.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalView.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.properties.DataTrait.Builder;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -78,13 +79,15 @@ public class LogicalView<BODY extends Plan> extends LogicalUnary<BODY> {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalView<>(view, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalView<>(view, child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalView<>(view, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalView<>(view, child()));
}
@Override
@@ -136,7 +139,8 @@ public class LogicalView<BODY extends Plan> extends LogicalUnary<BODY> {
@Override
public Plan withChildren(List<Plan> children) {
- return new LogicalView<>(view, (LogicalPlan) children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalView<>(view, (LogicalPlan) children.get(0)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWindow.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWindow.java
index 72067d73ef8..d91c80cf05c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWindow.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWindow.java
@@ -39,6 +39,7 @@ import org.apache.doris.nereids.trees.expressions.functions.window.DenseRank;
import org.apache.doris.nereids.trees.expressions.functions.window.Rank;
import org.apache.doris.nereids.trees.expressions.functions.window.RowNumber;
import org.apache.doris.nereids.trees.expressions.literal.IntegerLikeLiteral;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Window;
@@ -107,18 +108,21 @@ public class LogicalWindow<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_T
}
public LogicalWindow<Plan> withExpressionsAndChild(List<NamedExpression> windowExpressions, Plan child) {
- return new LogicalWindow<>(windowExpressions, isChecked, child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWindow<>(windowExpressions, isChecked, child));
}
public LogicalWindow<Plan> withChecked(List<NamedExpression> windowExpressions, Plan child) {
- return new LogicalWindow<>(windowExpressions, true, Optional.empty(),
- Optional.of(getLogicalProperties()), child);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWindow<>(windowExpressions, true, Optional.empty(),
+ Optional.of(getLogicalProperties()), child));
}
@Override
public LogicalUnary<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalWindow<>(windowExpressions, isChecked, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWindow<>(windowExpressions, isChecked, children.get(0)));
}
@Override
@@ -128,15 +132,17 @@ public class LogicalWindow<CHILD_TYPE extends Plan> extends LogicalUnary<CHILD_T
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalWindow<>(windowExpressions, isChecked,
- groupExpression, Optional.of(getLogicalProperties()), child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWindow<>(windowExpressions, isChecked,
+ groupExpression, Optional.of(getLogicalProperties()), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new LogicalWindow<>(windowExpressions, isChecked, groupExpression, logicalProperties, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWindow<>(windowExpressions, isChecked, groupExpression, logicalProperties, children.get(0)));
}
/**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWorkTableReference.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWorkTableReference.java
index f52bb20774d..9b7ba913b94 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWorkTableReference.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalWorkTableReference.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -97,14 +98,17 @@ public class LogicalWorkTableReference extends LogicalRelation {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new LogicalWorkTableReference(relationId, cteId, outputs, nameParts,
- groupExpression, Optional.ofNullable(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWorkTableReference(relationId, cteId, outputs, nameParts,
+ groupExpression, Optional.ofNullable(getLogicalProperties())));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new LogicalWorkTableReference(relationId, cteId, outputs, nameParts, groupExpression, logicalProperties);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWorkTableReference(relationId, cteId, outputs, nameParts,
+ groupExpression, logicalProperties));
}
@Override
@@ -129,8 +133,9 @@ public class LogicalWorkTableReference extends LogicalRelation {
@Override
public LogicalWorkTableReference withRelationId(RelationId relationId) {
- return new LogicalWorkTableReference(relationId, cteId, outputs, nameParts,
- groupExpression, Optional.ofNullable(getLogicalProperties()));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new LogicalWorkTableReference(relationId, cteId, outputs, nameParts,
+ groupExpression, Optional.ofNullable(getLogicalProperties())));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalAssertNumRows.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalAssertNumRows.java
index 2636156111a..60fcabc8c7e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalAssertNumRows.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalAssertNumRows.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.AssertNumRowsElement;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -105,29 +106,33 @@ public class PhysicalAssertNumRows<CHILD_TYPE extends Plan> extends PhysicalUnar
@Override
public PhysicalAssertNumRows<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalAssertNumRows<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
- logicalProperties.get(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
+ logicalProperties.get(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalAssertNumRows<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalAssertNumRows<>(assertNumRowsElement, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBlackholeSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBlackholeSink.java
index 53666ccab14..ba264973077 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBlackholeSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBlackholeSink.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.ComputeResultSet;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -66,8 +67,8 @@ public class PhysicalBlackholeSink<CHILD_TYPE extends Plan> extends PhysicalSink
public PhysicalBlackholeSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalBlackholeSink's children size must be 1, but real is %s", children.size());
- return new PhysicalBlackholeSink<>(outputExprs, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalBlackholeSink<>(outputExprs, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -82,8 +83,8 @@ public class PhysicalBlackholeSink<CHILD_TYPE extends Plan> extends PhysicalSink
@Override
public PhysicalBlackholeSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalBlackholeSink<>(outputExprs, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalBlackholeSink<>(outputExprs, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
@@ -91,15 +92,15 @@ public class PhysicalBlackholeSink<CHILD_TYPE extends Plan> extends PhysicalSink
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalBlackholeSink's children size must be 1, but real is %s", children.size());
- return new PhysicalBlackholeSink<>(outputExprs, groupExpression, logicalProperties.get(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalBlackholeSink<>(outputExprs, groupExpression,
+ logicalProperties.get(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalBlackholeSink<Plan> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalBlackholeSink<>(outputExprs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalBlackholeSink<>(outputExprs, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEAnchor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEAnchor.java
index 21a77d66597..8e494bd66dc 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEAnchor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEAnchor.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -104,28 +105,29 @@ public class PhysicalCTEAnchor<
@Override
public PhysicalCTEAnchor<Plan, Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new PhysicalCTEAnchor<>(cteId, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, children.get(0), children.get(1));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEAnchor<>(cteId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0), children.get(1)));
}
@Override
public PhysicalCTEAnchor<Plan, Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalCTEAnchor<>(cteId, groupExpression, getLogicalProperties(), child(0), child(1));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEAnchor<>(cteId, groupExpression,
+ getLogicalProperties(), child(0), child(1)));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new PhysicalCTEAnchor<>(cteId, groupExpression, logicalProperties.get(), children.get(0),
- children.get(1));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEAnchor<>(cteId, groupExpression,
+ logicalProperties.get(), children.get(0), children.get(1)));
}
@Override
public PhysicalCTEAnchor<Plan, Plan> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalCTEAnchor<>(cteId, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child(0), child(1));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEAnchor<>(cteId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child(0), child(1)));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEConsumer.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEConsumer.java
index 720e1eee0b5..0c6fa61015d 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEConsumer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEConsumer.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -115,25 +116,25 @@ public class PhysicalCTEConsumer extends PhysicalRelation implements BlockFuncDe
@Override
public PhysicalCTEConsumer withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalCTEConsumer(relationId, cteId,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEConsumer(relationId, cteId,
consumerToProducerSlotMap, producerToConsumerSlotMap,
- groupExpression, getLogicalProperties());
+ groupExpression, getLogicalProperties()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalCTEConsumer(relationId, cteId,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEConsumer(relationId, cteId,
consumerToProducerSlotMap, producerToConsumerSlotMap,
- groupExpression, logicalProperties.get());
+ groupExpression, logicalProperties.get()));
}
@Override
public PhysicalCTEConsumer withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalCTEConsumer(relationId, cteId,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEConsumer(relationId, cteId,
consumerToProducerSlotMap, producerToConsumerSlotMap,
- groupExpression, getLogicalProperties(), physicalProperties, statistics);
+ groupExpression, getLogicalProperties(), physicalProperties, statistics));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEProducer.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEProducer.java
index d06ba006d05..09064011d1c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEProducer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalCTEProducer.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -103,26 +104,28 @@ public class PhysicalCTEProducer<CHILD_TYPE extends Plan> extends PhysicalUnary<
@Override
public PhysicalCTEProducer<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalCTEProducer<>(cteId, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEProducer<>(cteId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalCTEProducer<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalCTEProducer<>(cteId, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEProducer<>(cteId, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalCTEProducer<>(cteId, groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEProducer<>(cteId, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalCTEProducer<CHILD_TYPE> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalCTEProducer<>(cteId, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalCTEProducer<>(cteId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeOlapScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeOlapScan.java
index fdf88955fec..cc39b2686b6 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeOlapScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeOlapScan.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.algebra.OlapScan;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -110,21 +111,24 @@ public class PhysicalDeferMaterializeOlapScan extends PhysicalCatalogRelation im
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalDeferMaterializeOlapScan(physicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, getLogicalProperties(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeOlapScan(physicalOlapScan,
+ deferMaterializeSlotIds, columnIdSlot, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalDeferMaterializeOlapScan(physicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, logicalProperties.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeOlapScan(physicalOlapScan,
+ deferMaterializeSlotIds, columnIdSlot, groupExpression, logicalProperties.get(),
+ physicalProperties, statistics));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalDeferMaterializeOlapScan(physicalOlapScan, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, getLogicalProperties(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeOlapScan(physicalOlapScan,
+ deferMaterializeSlotIds, columnIdSlot, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeResultSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeResultSink.java
index 4bb7a579641..883beccc459 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeResultSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeResultSink.java
@@ -22,6 +22,7 @@ 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.expressions.Expression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.algebra.Sink;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -82,10 +83,10 @@ public class PhysicalDeferMaterializeResultSink<CHILD_TYPE extends Plan>
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalDeferMaterializeResultSink's children size must be 1, but real is %s", children.size());
- return new PhysicalDeferMaterializeResultSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeResultSink<>(
physicalResultSink.withChildren(ImmutableList.of(children.get(0))),
olapTable, selectedIndexId, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ physicalProperties, statistics, children.get(0)));
}
@Override
@@ -100,8 +101,9 @@ public class PhysicalDeferMaterializeResultSink<CHILD_TYPE extends Plan>
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalDeferMaterializeResultSink<>(physicalResultSink, olapTable, selectedIndexId,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeResultSink<>(physicalResultSink,
+ olapTable, selectedIndexId, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics, child()));
}
@Override
@@ -109,16 +111,17 @@ public class PhysicalDeferMaterializeResultSink<CHILD_TYPE extends Plan>
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalDeferMaterializeResultSink's children size must be 1, but real is %s", children.size());
- return new PhysicalDeferMaterializeResultSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeResultSink<>(
physicalResultSink.withChildren(ImmutableList.of(children.get(0))),
olapTable, selectedIndexId, groupExpression, logicalProperties.get(),
- physicalProperties, statistics, children.get(0));
+ physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalDeferMaterializeResultSink<>(physicalResultSink, olapTable, selectedIndexId,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeResultSink<>(physicalResultSink,
+ olapTable, selectedIndexId, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeTopN.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeTopN.java
index 14412f2cfc6..578f800d669 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeTopN.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDeferMaterializeTopN.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.ObjectId;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.algebra.TopN;
@@ -94,17 +95,19 @@ public class PhysicalDeferMaterializeTopN<CHILD_TYPE extends Plan>
}
public PhysicalDeferMaterializeTopN<? extends Plan> withPhysicalTopN(PhysicalTopN<? extends Plan> physicalTopN) {
- return new PhysicalDeferMaterializeTopN<>(physicalTopN, deferMaterializeSlotIds, columnIdSlot, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, physicalTopN.child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeTopN<>(physicalTopN,
+ deferMaterializeSlotIds, columnIdSlot, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, physicalTopN.child()));
}
@Override
public PhysicalDeferMaterializeTopN<? extends Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalDeferMaterializeTopN's children size must be 1, but real is %s", children.size());
- return new PhysicalDeferMaterializeTopN<>(physicalTopN.withChildren(ImmutableList.of(children.get(0))),
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeTopN<>(
+ physicalTopN.withChildren(ImmutableList.of(children.get(0))),
deferMaterializeSlotIds, columnIdSlot, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ physicalProperties, statistics, children.get(0)));
}
@Override
@@ -114,8 +117,9 @@ public class PhysicalDeferMaterializeTopN<CHILD_TYPE extends Plan>
@Override
public PhysicalDeferMaterializeTopN<? extends Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalDeferMaterializeTopN<>(physicalTopN, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeTopN<>(physicalTopN,
+ deferMaterializeSlotIds, columnIdSlot, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics, child()));
}
@Override
@@ -124,16 +128,18 @@ public class PhysicalDeferMaterializeTopN<CHILD_TYPE extends Plan>
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalDeferMaterializeTopN's children size must be 1, but real is %s", children.size());
- return new PhysicalDeferMaterializeTopN<>(physicalTopN.withChildren(ImmutableList.of(children.get(0))),
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeTopN<>(
+ physicalTopN.withChildren(ImmutableList.of(children.get(0))),
deferMaterializeSlotIds, columnIdSlot, groupExpression, logicalProperties.get(),
- physicalProperties, statistics, children.get(0));
+ physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalDeferMaterializeTopN<? extends Plan> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalDeferMaterializeTopN<>(physicalTopN, deferMaterializeSlotIds, columnIdSlot,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDeferMaterializeTopN<>(physicalTopN,
+ deferMaterializeSlotIds, columnIdSlot, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDictionarySink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDictionarySink.java
index 797127d176f..1537e6902e2 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDictionarySink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDictionarySink.java
@@ -27,6 +27,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
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;
@@ -101,27 +102,31 @@ public class PhysicalDictionarySink<CHILD_TYPE extends Plan> extends PhysicalTab
@Override
public Plan withChildren(List<Plan> children) {
- return new PhysicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
- getLogicalProperties(), statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDictionarySink<>(database, dictionary,
+ allowAdaptiveLoad, cols, outputExprs, groupExpression,
+ getLogicalProperties(), statistics, children.get(0)));
}
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
- getLogicalProperties(), statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDictionarySink<>(database, dictionary,
+ allowAdaptiveLoad, cols, outputExprs, groupExpression,
+ getLogicalProperties(), statistics, child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
- logicalProperties.get(), statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDictionarySink<>(database, dictionary,
+ allowAdaptiveLoad, cols, outputExprs, groupExpression,
+ logicalProperties.get(), statistics, children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalDictionarySink<>(database, dictionary, allowAdaptiveLoad, cols, outputExprs, groupExpression,
- getLogicalProperties(), statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDictionarySink<>(database, dictionary,
+ allowAdaptiveLoad, cols, outputExprs, groupExpression,
+ getLogicalProperties(), statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDistribute.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDistribute.java
index 3dfc30847ef..5352d03294e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDistribute.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalDistribute.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -98,29 +99,29 @@ public class PhysicalDistribute<CHILD_TYPE extends Plan> extends PhysicalUnary<C
@Override
public PhysicalDistribute<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalDistribute<>(distributionSpec, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
-
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDistribute<>(distributionSpec, Optional.empty(),
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalDistribute<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalDistribute<>(distributionSpec, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDistribute<>(distributionSpec, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalDistribute<>(distributionSpec, groupExpression,
- logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDistribute<>(distributionSpec, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalDistribute<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalDistribute<>(distributionSpec, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalDistribute<>(distributionSpec, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEmptyRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEmptyRelation.java
index b1b5ea2beee..acf8e9a464f 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEmptyRelation.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEmptyRelation.java
@@ -27,6 +27,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.ComputeResultSet;
import org.apache.doris.nereids.trees.plans.Plan;
@@ -79,15 +80,15 @@ public class PhysicalEmptyRelation extends PhysicalRelation
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalEmptyRelation(relationId, projects, groupExpression,
- logicalPropertiesSupplier.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalEmptyRelation(relationId, projects, groupExpression,
+ logicalPropertiesSupplier.get(), physicalProperties, statistics));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalEmptyRelation(relationId, projects, groupExpression,
- logicalProperties.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalEmptyRelation(relationId, projects, groupExpression,
+ logicalProperties.get(), physicalProperties, statistics));
}
@Override
@@ -112,8 +113,8 @@ public class PhysicalEmptyRelation extends PhysicalRelation
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalEmptyRelation(relationId, projects, Optional.empty(),
- logicalPropertiesSupplier.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalEmptyRelation(relationId, projects, Optional.empty(),
+ logicalPropertiesSupplier.get(), physicalProperties, statistics));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEsScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEsScan.java
index bc893be0221..947f1ac8fa5 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEsScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalEsScan.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.memo.GroupExpression;
import org.apache.doris.nereids.properties.DistributionSpec;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -89,21 +90,22 @@ public class PhysicalEsScan extends PhysicalCatalogRelation {
@Override
public PhysicalEsScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalEsScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, getLogicalProperties(), null, null, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalEsScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, getLogicalProperties(), null, null, tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalEsScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, logicalProperties.get(), null, null, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalEsScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, logicalProperties.get(), null, null, tableAlias));
}
@Override
public PhysicalEsScan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statsDeriveResult) {
- return new PhysicalEsScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, getLogicalProperties(), physicalProperties, statsDeriveResult, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalEsScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, getLogicalProperties(), physicalProperties, statsDeriveResult,
+ tableAlias));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalExcept.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalExcept.java
index b973d5545d4..99981ad7bde 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalExcept.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalExcept.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Except;
@@ -87,28 +88,29 @@ public class PhysicalExcept extends PhysicalSetOperation implements Except {
@Override
public PhysicalExcept withChildren(List<Plan> children) {
- return new PhysicalExcept(qualifier, outputs, regularChildrenOutputs, getLogicalProperties(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalExcept(qualifier, outputs,
+ regularChildrenOutputs, getLogicalProperties(), children));
}
@Override
public PhysicalExcept withGroupExpression(
Optional<GroupExpression> groupExpression) {
- return new PhysicalExcept(qualifier, outputs, regularChildrenOutputs,
- groupExpression, getLogicalProperties(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalExcept(qualifier, outputs, regularChildrenOutputs,
+ groupExpression, getLogicalProperties(), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalExcept(qualifier, outputs, regularChildrenOutputs,
- groupExpression, logicalProperties.get(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalExcept(qualifier, outputs, regularChildrenOutputs,
+ groupExpression, logicalProperties.get(), children));
}
@Override
public PhysicalExcept withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalExcept(qualifier, outputs, regularChildrenOutputs, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics, children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalExcept(qualifier, outputs, regularChildrenOutputs,
+ Optional.empty(), getLogicalProperties(), physicalProperties, statistics, children));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileScan.java
index e592051e18c..520f03f6748 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFileScan.java
@@ -26,6 +26,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.TableSample;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -152,17 +153,17 @@ public class PhysicalFileScan extends PhysicalCatalogRelation {
@Override
public PhysicalFileScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalFileScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, getLogicalProperties(), selectedPartitions, tableSample, tableSnapshot,
- operativeSlots, scanParams);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, getLogicalProperties(), selectedPartitions, tableSample,
+ tableSnapshot, operativeSlots, scanParams));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalFileScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, logicalProperties.get(), selectedPartitions, tableSample, tableSnapshot,
- operativeSlots, scanParams);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, logicalProperties.get(), selectedPartitions, tableSample,
+ tableSnapshot, operativeSlots, scanParams));
}
@Override
@@ -173,10 +174,9 @@ public class PhysicalFileScan extends PhysicalCatalogRelation {
@Override
public PhysicalFileScan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalFileScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, getLogicalProperties(), physicalProperties, statistics,
- selectedPartitions, tableSample, tableSnapshot,
- operativeSlots, scanParams);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, getLogicalProperties(), physicalProperties, statistics,
+ selectedPartitions, tableSample, tableSnapshot, operativeSlots, scanParams));
}
@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 291c3c07ae0..aed84e1b2ec 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
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
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;
@@ -95,8 +96,8 @@ public class PhysicalFileSink<CHILD_TYPE extends Plan> extends PhysicalSink<CHIL
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "PhysicalFileSink only accepts one child");
- return new PhysicalFileSink<>(outputExprs, filePath, format, properties,
- getLogicalProperties(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileSink<>(outputExprs, filePath, format,
+ properties, getLogicalProperties(), children.get(0)));
}
@Override
@@ -139,21 +140,21 @@ public class PhysicalFileSink<CHILD_TYPE extends Plan> extends PhysicalSink<CHIL
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalFileSink<>(outputExprs, filePath, format, properties,
- groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileSink<>(outputExprs, filePath, format,
+ properties, groupExpression, getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalFileSink<>(outputExprs, filePath, format, properties,
- groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileSink<>(outputExprs, filePath, format,
+ properties, groupExpression, logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalFileSink<>(outputExprs, filePath, format, properties, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFileSink<>(outputExprs, filePath, format,
+ properties, groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFilter.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFilter.java
index 74aaf1af23c..7839c259535 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFilter.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFilter.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Filter;
@@ -117,32 +118,34 @@ public class PhysicalFilter<CHILD_TYPE extends Plan> extends PhysicalUnary<CHILD
@Override
public PhysicalFilter<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalFilter<>(conjuncts, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFilter<>(conjuncts, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalFilter<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalFilter<>(conjuncts, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFilter<>(conjuncts, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalFilter<>(conjuncts, groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFilter<>(conjuncts, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalFilter<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalFilter<>(conjuncts, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFilter<>(conjuncts, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
public PhysicalFilter<Plan> withConjunctsAndChild(Set<Expression> conjuncts, Plan child) {
- return new PhysicalFilter<>(conjuncts, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalFilter<>(conjuncts, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalGenerate.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalGenerate.java
index 829ec03588d..d90db872d92 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalGenerate.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalGenerate.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.functions.Function;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Generate;
@@ -124,30 +125,29 @@ public class PhysicalGenerate<CHILD_TYPE extends Plan> extends PhysicalUnary<CHI
@Override
public PhysicalGenerate<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalGenerate<>(generators, generatorOutput, conjuncts, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalGenerate<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
- groupExpression, getLogicalProperties(), PhysicalProperties.ANY, null, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
+ groupExpression, getLogicalProperties(), PhysicalProperties.ANY, null, child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
- groupExpression, logicalProperties.get(), PhysicalProperties.ANY, null, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
+ groupExpression, logicalProperties.get(), PhysicalProperties.ANY, null, children.get(0)));
}
@Override
public PhysicalGenerate<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
- Optional.empty(), getLogicalProperties(), physicalProperties,
- statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalGenerate<>(generators, generatorOutput, conjuncts,
+ Optional.empty(), getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashAggregate.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashAggregate.java
index 3a53381e3bb..5872b169f0f 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashAggregate.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashAggregate.java
@@ -32,6 +32,7 @@ import org.apache.doris.nereids.trees.expressions.functions.agg.AggregateParam;
import org.apache.doris.nereids.trees.expressions.functions.agg.Count;
import org.apache.doris.nereids.trees.expressions.functions.agg.Ndv;
import org.apache.doris.nereids.trees.expressions.functions.agg.NullableAggregateFunction;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.AggMode;
import org.apache.doris.nereids.trees.plans.AggPhase;
import org.apache.doris.nereids.trees.plans.Plan;
@@ -252,38 +253,40 @@ public class PhysicalHashAggregate<CHILD_TYPE extends Plan> extends PhysicalUnar
@Override
public PhysicalHashAggregate<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalHashAggregate<>(groupByExpressions, outputExpressions, partitionExpressions,
- aggregateParam, maybeUsingStream, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashAggregate<>(groupByExpressions,
+ outputExpressions, partitionExpressions, aggregateParam, maybeUsingStream, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalHashAggregate<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalHashAggregate<>(groupByExpressions, outputExpressions, partitionExpressions,
- aggregateParam, maybeUsingStream, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashAggregate<>(groupByExpressions,
+ outputExpressions, partitionExpressions, aggregateParam, maybeUsingStream, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalHashAggregate<>(groupByExpressions, outputExpressions, partitionExpressions,
- aggregateParam, maybeUsingStream, groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashAggregate<>(groupByExpressions,
+ outputExpressions, partitionExpressions, aggregateParam, maybeUsingStream, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalHashAggregate<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalHashAggregate<>(groupByExpressions, outputExpressions, partitionExpressions,
- aggregateParam, maybeUsingStream, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashAggregate<>(groupByExpressions,
+ outputExpressions, partitionExpressions, aggregateParam, maybeUsingStream, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
public PhysicalHashAggregate<CHILD_TYPE> withAggOutput(List<NamedExpression> newOutput) {
- return new PhysicalHashAggregate<>(groupByExpressions, newOutput, partitionExpressions,
- aggregateParam, maybeUsingStream, Optional.empty(), getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashAggregate<>(groupByExpressions, newOutput,
+ partitionExpressions, aggregateParam, maybeUsingStream, Optional.empty(), getLogicalProperties(),
+ physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashJoin.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashJoin.java
index 6f048e4d183..44044755e51 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashJoin.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashJoin.java
@@ -28,6 +28,7 @@ import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.MarkJoinSlotReference;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.JoinType;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -160,10 +161,10 @@ public class PhysicalHashJoin<
@Override
public PhysicalHashJoin<Plan, Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- PhysicalHashJoin newJoin = new PhysicalHashJoin<>(joinType, hashJoinConjuncts,
- otherJoinConjuncts, markJoinConjuncts, hint, markJoinSlotReference,
+ PhysicalHashJoin newJoin = AbstractPlan.copyWithSameId(this, () -> new PhysicalHashJoin<>(joinType,
+ hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts, hint, markJoinSlotReference,
Optional.empty(), getLogicalProperties(), physicalProperties, statistics,
- children.get(0), children.get(1));
+ children.get(0), children.get(1)));
if (groupExpression.isPresent()) {
newJoin.setMutableState(MutableState.KEY_GROUP, groupExpression.get().getOwnerGroup().getGroupId().asInt());
}
@@ -173,25 +174,25 @@ public class PhysicalHashJoin<
@Override
public PhysicalHashJoin<LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> withGroupExpression(
Optional<GroupExpression> groupExpression) {
- return new PhysicalHashJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts,
- markJoinConjuncts, hint, markJoinSlotReference, groupExpression,
- getLogicalProperties(), null, null, left(), right());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashJoin<>(joinType, hashJoinConjuncts,
+ otherJoinConjuncts, markJoinConjuncts, hint, markJoinSlotReference, groupExpression,
+ getLogicalProperties(), null, null, left(), right()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new PhysicalHashJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts,
- markJoinConjuncts, hint, markJoinSlotReference, groupExpression,
- logicalProperties.get(), null, null, children.get(0), children.get(1));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashJoin<>(joinType, hashJoinConjuncts,
+ otherJoinConjuncts, markJoinConjuncts, hint, markJoinSlotReference, groupExpression,
+ logicalProperties.get(), null, null, children.get(0), children.get(1)));
}
public PhysicalHashJoin<LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalHashJoin<>(joinType, hashJoinConjuncts, otherJoinConjuncts,
- markJoinConjuncts, hint, markJoinSlotReference, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, left(), right());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHashJoin<>(joinType, hashJoinConjuncts,
+ otherJoinConjuncts, markJoinConjuncts, hint, markJoinSlotReference, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, left(), right()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHiveTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHiveTableSink.java
index 5d8edcab45c..6df97eee510 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHiveTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHiveTableSink.java
@@ -26,6 +26,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -72,9 +73,9 @@ public class PhysicalHiveTableSink<CHILD_TYPE extends Plan> extends PhysicalBase
@Override
public Plan withChildren(List<Plan> children) {
- return new PhysicalHiveTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHiveTableSink<>(
(HMSExternalDatabase) database, (HMSExternalTable) targetTable, cols, outputExprs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -84,24 +85,24 @@ public class PhysicalHiveTableSink<CHILD_TYPE extends Plan> extends PhysicalBase
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalHiveTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHiveTableSink<>(
(HMSExternalDatabase) database, (HMSExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), child());
+ groupExpression, getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalHiveTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHiveTableSink<>(
(HMSExternalDatabase) database, (HMSExternalTable) targetTable, cols, outputExprs,
- groupExpression, logicalProperties.get(), children.get(0));
+ groupExpression, logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalHiveTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHiveTableSink<>(
(HMSExternalDatabase) database, (HMSExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
/**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHudiScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHudiScan.java
index 27532246382..b1c99af04c4 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHudiScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHudiScan.java
@@ -27,6 +27,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.TableSample;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -91,26 +92,25 @@ public class PhysicalHudiScan extends PhysicalFileScan {
@Override
public PhysicalHudiScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalHudiScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, getLogicalProperties(), selectedPartitions, tableSample, tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHudiScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, getLogicalProperties(), selectedPartitions, tableSample,
+ tableSnapshot, scanParams, incrementalRelation, operativeSlots));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalHudiScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, logicalProperties.get(), selectedPartitions, tableSample, tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHudiScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, logicalProperties.get(), selectedPartitions, tableSample,
+ tableSnapshot, scanParams, incrementalRelation, operativeSlots));
}
@Override
public PhysicalHudiScan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalHudiScan(relationId, getTable(), qualifier, distributionSpec,
- groupExpression, getLogicalProperties(), physicalProperties, statistics,
- selectedPartitions, tableSample, tableSnapshot,
- scanParams, incrementalRelation, operativeSlots);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalHudiScan(relationId, getTable(), qualifier,
+ distributionSpec, groupExpression, getLogicalProperties(), physicalProperties, statistics,
+ selectedPartitions, tableSample, tableSnapshot, scanParams, incrementalRelation, operativeSlots));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIcebergTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIcebergTableSink.java
index 12839e93493..f0941257bf4 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIcebergTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIcebergTableSink.java
@@ -26,6 +26,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -73,10 +74,10 @@ public class PhysicalIcebergTableSink<CHILD_TYPE extends Plan> extends PhysicalB
@Override
public Plan withChildren(List<Plan> children) {
- return new PhysicalIcebergTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIcebergTableSink<>(
(IcebergExternalDatabase) database, (IcebergExternalTable) targetTable,
cols, outputExprs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -86,24 +87,24 @@ public class PhysicalIcebergTableSink<CHILD_TYPE extends Plan> extends PhysicalB
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalIcebergTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIcebergTableSink<>(
(IcebergExternalDatabase) database, (IcebergExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), child());
+ groupExpression, getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalIcebergTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIcebergTableSink<>(
(IcebergExternalDatabase) database, (IcebergExternalTable) targetTable, cols, outputExprs,
- groupExpression, logicalProperties.get(), children.get(0));
+ groupExpression, logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalIcebergTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIcebergTableSink<>(
(IcebergExternalDatabase) database, (IcebergExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
/**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIntersect.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIntersect.java
index ed7394ddb03..86f7ac51fea 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIntersect.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalIntersect.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Intersect;
@@ -88,28 +89,30 @@ public class PhysicalIntersect extends PhysicalSetOperation implements Intersect
@Override
public PhysicalIntersect withChildren(List<Plan> children) {
- return new PhysicalIntersect(qualifier, outputs, regularChildrenOutputs, getLogicalProperties(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIntersect(qualifier, outputs,
+ regularChildrenOutputs, getLogicalProperties(), children));
}
@Override
public PhysicalIntersect withGroupExpression(
Optional<GroupExpression> groupExpression) {
- return new PhysicalIntersect(qualifier, outputs, regularChildrenOutputs,
- groupExpression, getLogicalProperties(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIntersect(qualifier, outputs,
+ regularChildrenOutputs, groupExpression, getLogicalProperties(), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalIntersect(qualifier, outputs, regularChildrenOutputs,
- groupExpression, logicalProperties.get(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIntersect(qualifier, outputs,
+ regularChildrenOutputs, groupExpression, logicalProperties.get(), children));
}
@Override
public PhysicalIntersect withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalIntersect(qualifier, outputs, regularChildrenOutputs,
- Optional.empty(), getLogicalProperties(), physicalProperties, statistics, children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalIntersect(qualifier, outputs,
+ regularChildrenOutputs, Optional.empty(), getLogicalProperties(), physicalProperties,
+ statistics, children));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcScan.java
index f0d16a60f0a..41f75800394 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcScan.java
@@ -22,6 +22,7 @@ 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.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -92,21 +93,21 @@ public class PhysicalJdbcScan extends PhysicalCatalogRelation {
@Override
public PhysicalJdbcScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalJdbcScan(relationId, table, qualifier, groupExpression, getLogicalProperties(),
- null, null, operativeSlots, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcScan(relationId, table, qualifier,
+ groupExpression, getLogicalProperties(), null, null, operativeSlots, tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalJdbcScan(relationId, table, qualifier, groupExpression, logicalProperties.get(),
- null, null, operativeSlots, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcScan(relationId, table, qualifier,
+ groupExpression, logicalProperties.get(), null, null, operativeSlots, tableAlias));
}
@Override
public PhysicalJdbcScan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalJdbcScan(relationId, table, qualifier, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, operativeSlots, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcScan(relationId, table, qualifier,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, operativeSlots, tableAlias));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcTableSink.java
index 2b0f12c1dea..58afd3541bd 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalJdbcTableSink.java
@@ -24,6 +24,7 @@ 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.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -67,10 +68,10 @@ public class PhysicalJdbcTableSink<CHILD_TYPE extends Plan> extends PhysicalBase
@Override
public Plan withChildren(List<Plan> children) {
- return new PhysicalJdbcTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcTableSink<>(
(JdbcExternalDatabase) database, (JdbcExternalTable) targetTable,
cols, outputExprs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -80,24 +81,24 @@ public class PhysicalJdbcTableSink<CHILD_TYPE extends Plan> extends PhysicalBase
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalJdbcTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcTableSink<>(
(JdbcExternalDatabase) database, (JdbcExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), child());
+ groupExpression, getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalJdbcTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcTableSink<>(
(JdbcExternalDatabase) database, (JdbcExternalTable) targetTable, cols, outputExprs,
- groupExpression, logicalProperties.get(), children.get(0));
+ groupExpression, logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalJdbcTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalJdbcTableSink<>(
(JdbcExternalDatabase) database, (JdbcExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterialize.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterialize.java
index a91316807b2..5738a377823 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterialize.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterialize.java
@@ -28,6 +28,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.CatalogRelation;
@@ -191,9 +192,9 @@ public class PhysicalLazyMaterialize<CHILD_TYPE extends Plan> extends PhysicalUn
@Override
public Plan withChildren(List<Plan> children) {
- return new PhysicalLazyMaterialize<>(children.get(0),
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLazyMaterialize<>(children.get(0),
materializeInput, materializedSlots, relationToLazySlotMap,
- relationToRowId, materializeMap, null, null);
+ relationToRowId, materializeMap, null, null));
}
@Override
@@ -210,8 +211,9 @@ public class PhysicalLazyMaterialize<CHILD_TYPE extends Plan> extends PhysicalUn
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalLazyMaterialize(children.get(0), materializeInput, materializedSlots, relationToLazySlotMap,
- relationToRowId, materializeMap, physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLazyMaterialize(children.get(0),
+ materializeInput, materializedSlots, relationToLazySlotMap,
+ relationToRowId, materializeMap, physicalProperties, statistics));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeOlapScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeOlapScan.java
index cc5095644f3..76b0bf43e73 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeOlapScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeOlapScan.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.plans.physical;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.ExpressionUtils;
import org.apache.doris.statistics.Statistics;
@@ -114,7 +115,7 @@ public class PhysicalLazyMaterializeOlapScan extends PhysicalOlapScan {
@Override
public PhysicalLazyMaterializeOlapScan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalLazyMaterializeOlapScan(scan, rowId, lazySlots);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLazyMaterializeOlapScan(scan, rowId, lazySlots));
}
public SlotReference getRowId() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeTVFScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeTVFScan.java
index 03787887563..c5d7dddbbe9 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeTVFScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLazyMaterializeTVFScan.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.statistics.Statistics;
@@ -88,14 +89,16 @@ public class PhysicalLazyMaterializeTVFScan extends PhysicalTVFRelation {
Statistics statistics) {
PhysicalTVFRelation tvfRelation = new PhysicalTVFRelation(relationId, function, operativeSlots,
Optional.empty(), getLogicalProperties(), physicalProperties, statistics);
- return new PhysicalLazyMaterializeTVFScan(tvfRelation, rowId, lazySlots);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalLazyMaterializeTVFScan(tvfRelation, rowId, lazySlots));
}
@Override
public PhysicalLazyMaterializeTVFScan withGroupExpression(Optional<GroupExpression> groupExpression) {
PhysicalTVFRelation tvfRelation = new PhysicalTVFRelation(relationId, function, operativeSlots,
groupExpression, getLogicalProperties(), physicalProperties, statistics);
- return new PhysicalLazyMaterializeTVFScan(tvfRelation, rowId, lazySlots);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalLazyMaterializeTVFScan(tvfRelation, rowId, lazySlots));
}
@Override
@@ -103,6 +106,7 @@ public class PhysicalLazyMaterializeTVFScan extends PhysicalTVFRelation {
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
PhysicalTVFRelation tvfRelation = new PhysicalTVFRelation(relationId, function, operativeSlots,
groupExpression, logicalProperties.get(), physicalProperties, statistics);
- return new PhysicalLazyMaterializeTVFScan(tvfRelation, rowId, lazySlots);
+ return AbstractPlan.copyWithSameId(this, () ->
+ new PhysicalLazyMaterializeTVFScan(tvfRelation, rowId, lazySlots));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLimit.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLimit.java
index 27155ae57f7..61babb6de6b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLimit.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLimit.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.LimitPhase;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -103,15 +104,15 @@ public class PhysicalLimit<CHILD_TYPE extends Plan> extends PhysicalUnary<CHILD_
}
public Plan withLimit(long limit) {
- return new PhysicalLimit<>(limit, offset, phase, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLimit<>(limit, offset, phase, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalLimit<>(limit, offset, phase, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLimit<>(limit, offset, phase, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -121,21 +122,23 @@ public class PhysicalLimit<CHILD_TYPE extends Plan> extends PhysicalUnary<CHILD_
@Override
public PhysicalLimit<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalLimit<>(limit, offset, phase, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLimit<>(limit, offset, phase, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalLimit<>(limit, offset, phase, groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLimit<>(limit, offset, phase, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalLimit<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalLimit<>(limit, offset, phase, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalLimit<>(limit, offset, phase, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalMaxComputeTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalMaxComputeTableSink.java
index 3c59f737eb7..db9d7aec00b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalMaxComputeTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalMaxComputeTableSink.java
@@ -28,6 +28,7 @@ import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -74,10 +75,10 @@ public class PhysicalMaxComputeTableSink<CHILD_TYPE extends Plan> extends Physic
@Override
public Plan withChildren(List<Plan> children) {
- return new PhysicalMaxComputeTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalMaxComputeTableSink<>(
(MaxComputeExternalDatabase) database, (MaxComputeExternalTable) targetTable,
cols, outputExprs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -87,24 +88,24 @@ public class PhysicalMaxComputeTableSink<CHILD_TYPE extends Plan> extends Physic
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalMaxComputeTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalMaxComputeTableSink<>(
(MaxComputeExternalDatabase) database, (MaxComputeExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), child());
+ groupExpression, getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalMaxComputeTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalMaxComputeTableSink<>(
(MaxComputeExternalDatabase) database, (MaxComputeExternalTable) targetTable, cols, outputExprs,
- groupExpression, logicalProperties.get(), children.get(0));
+ groupExpression, logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalMaxComputeTableSink<>(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalMaxComputeTableSink<>(
(MaxComputeExternalDatabase) database, (MaxComputeExternalTable) targetTable, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalNestedLoopJoin.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalNestedLoopJoin.java
index c3a24b5e446..dfa1861f4b7 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalNestedLoopJoin.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalNestedLoopJoin.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.MarkJoinSlotReference;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.DistributeType;
import org.apache.doris.nereids.trees.plans.JoinType;
@@ -162,9 +163,9 @@ public class PhysicalNestedLoopJoin<
@Override
public PhysicalNestedLoopJoin<Plan, Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- PhysicalNestedLoopJoin newJoin = new PhysicalNestedLoopJoin<>(joinType,
+ PhysicalNestedLoopJoin newJoin = AbstractPlan.copyWithSameId(this, () -> new PhysicalNestedLoopJoin<>(joinType,
hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts, markJoinSlotReference, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics, children.get(0), children.get(1));
+ getLogicalProperties(), physicalProperties, statistics, children.get(0), children.get(1)));
if (groupExpression.isPresent()) {
newJoin.setMutableState(MutableState.KEY_GROUP, groupExpression.get().getOwnerGroup().getGroupId().asInt());
}
@@ -174,26 +175,26 @@ public class PhysicalNestedLoopJoin<
@Override
public PhysicalNestedLoopJoin<LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> withGroupExpression(
Optional<GroupExpression> groupExpression) {
- return new PhysicalNestedLoopJoin<>(joinType,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalNestedLoopJoin<>(joinType,
hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts, markJoinSlotReference,
- groupExpression, getLogicalProperties(), null, null, left(), right());
+ groupExpression, getLogicalProperties(), null, null, left(), right()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 2);
- return new PhysicalNestedLoopJoin<>(joinType,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalNestedLoopJoin<>(joinType,
hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts, markJoinSlotReference, groupExpression,
- logicalProperties.get(), null, null, children.get(0), children.get(1));
+ logicalProperties.get(), null, null, children.get(0), children.get(1)));
}
@Override
public PhysicalNestedLoopJoin<LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalNestedLoopJoin<>(joinType,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalNestedLoopJoin<>(joinType,
hashJoinConjuncts, otherJoinConjuncts, markJoinConjuncts, markJoinSlotReference, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, left(), right());
+ getLogicalProperties(), physicalProperties, statistics, left(), right()));
}
public void addBitmapRuntimeFilterCondition(Expression expr) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOdbcScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOdbcScan.java
index 8a6f542485f..4099e34c27e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOdbcScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOdbcScan.java
@@ -22,6 +22,7 @@ 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.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -86,21 +87,21 @@ public class PhysicalOdbcScan extends PhysicalCatalogRelation {
@Override
public PhysicalOdbcScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalOdbcScan(relationId, table, qualifier, groupExpression, getLogicalProperties(),
- null, null, operativeSlots, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOdbcScan(relationId, table, qualifier,
+ groupExpression, getLogicalProperties(), null, null, operativeSlots, tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalOdbcScan(relationId, table, qualifier, groupExpression, logicalProperties.get(),
- null, null, operativeSlots, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOdbcScan(relationId, table, qualifier,
+ groupExpression, logicalProperties.get(), null, null, operativeSlots, tableAlias));
}
@Override
public PhysicalOdbcScan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalOdbcScan(relationId, table, qualifier, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, operativeSlots, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOdbcScan(relationId, table, qualifier,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, operativeSlots, tableAlias));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java
index a2a4d1e152c..059a71ae745 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java
@@ -28,6 +28,7 @@ import org.apache.doris.nereids.trees.expressions.ExprId;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PreAggStatus;
@@ -300,28 +301,28 @@ public class PhysicalOlapScan extends PhysicalCatalogRelation implements OlapSca
@Override
public PhysicalOlapScan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalOlapScan(relationId, getTable(), qualifier, selectedIndexId, selectedTabletIds,
- selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapScan(relationId, getTable(), qualifier,
+ selectedIndexId, selectedTabletIds, selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs,
groupExpression, getLogicalProperties(), null, null, tableSample, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalOlapScan(relationId, getTable(), qualifier, selectedIndexId, selectedTabletIds,
- selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs, groupExpression,
- logicalProperties.get(), null, null, tableSample, operativeSlots, virtualColumns,
- scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapScan(relationId, getTable(), qualifier,
+ selectedIndexId, selectedTabletIds, selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs,
+ groupExpression, logicalProperties.get(), null, null, tableSample, operativeSlots, virtualColumns,
+ scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
public PhysicalOlapScan withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalOlapScan(relationId, getTable(), qualifier, selectedIndexId, selectedTabletIds,
- selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, tableSample, operativeSlots,
- virtualColumns, scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapScan(relationId, getTable(), qualifier,
+ selectedIndexId, selectedTabletIds, selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, tableSample, operativeSlots,
+ virtualColumns, scoreOrderKeys, scoreLimit, scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
@@ -344,11 +345,11 @@ public class PhysicalOlapScan extends PhysicalCatalogRelation implements OlapSca
@Override
public CatalogRelation withOperativeSlots(Collection<Slot> operativeSlots) {
- return new PhysicalOlapScan(relationId, (OlapTable) table, qualifier, selectedIndexId, selectedTabletIds,
- selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapScan(relationId, (OlapTable) table, qualifier,
+ selectedIndexId, selectedTabletIds, selectedPartitionIds, distributionSpec, preAggStatus, baseOutputs,
groupExpression, getLogicalProperties(), getPhysicalProperties(), statistics,
tableSample, operativeSlots, virtualColumns, scoreOrderKeys, scoreLimit,
- scoreRangeInfo, annOrderKeys, annLimit, tableAlias);
+ scoreRangeInfo, annOrderKeys, annLimit, tableAlias));
}
@Override
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 17e9d90296f..f13d4816e2e 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
@@ -32,6 +32,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
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;
@@ -155,10 +156,10 @@ public class PhysicalOlapTableSink<CHILD_TYPE extends Plan> extends PhysicalTabl
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1, "PhysicalOlapTableSink only accepts one child");
- return new PhysicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
- singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList,
- syncMvWhereClauses, targetTableSlots, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapTableSink<>(database, targetTable, cols,
+ partitionIds, outputExprs, singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy,
+ dmlCommandType, partitionExprList, syncMvWhereClauses, targetTableSlots, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -213,28 +214,28 @@ public class PhysicalOlapTableSink<CHILD_TYPE extends Plan> extends PhysicalTabl
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
- singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList,
- syncMvWhereClauses, targetTableSlots, groupExpression, getLogicalProperties(),
- child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapTableSink<>(database, targetTable, cols,
+ partitionIds, outputExprs, singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy,
+ dmlCommandType, partitionExprList, syncMvWhereClauses, targetTableSlots, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
- singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList,
- syncMvWhereClauses, targetTableSlots, groupExpression, logicalProperties.get(),
- children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapTableSink<>(database, targetTable, cols,
+ partitionIds, outputExprs, singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy,
+ dmlCommandType, partitionExprList, syncMvWhereClauses, targetTableSlots, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalOlapTableSink<>(database, targetTable, cols, partitionIds, outputExprs,
- singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy, dmlCommandType, partitionExprList,
- syncMvWhereClauses, targetTableSlots, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOlapTableSink<>(database, targetTable, cols,
+ partitionIds, outputExprs, singleReplicaLoad, isPartialUpdate, partialUpdateNewKeyPolicy,
+ dmlCommandType, partitionExprList, syncMvWhereClauses, targetTableSlots, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
/**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOneRowRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOneRowRelation.java
index f61c5584625..ad811526a54 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOneRowRelation.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOneRowRelation.java
@@ -32,6 +32,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.literal.Literal;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.ComputeResultSet;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -96,15 +97,15 @@ public class PhysicalOneRowRelation extends PhysicalRelation implements OneRowRe
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalOneRowRelation(relationId, projects, groupExpression,
- logicalPropertiesSupplier.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOneRowRelation(relationId, projects,
+ groupExpression, logicalPropertiesSupplier.get(), physicalProperties, statistics));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalOneRowRelation(relationId, projects, groupExpression,
- logicalProperties.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOneRowRelation(relationId, projects,
+ groupExpression, logicalProperties.get(), physicalProperties, statistics));
}
@Override
@@ -154,8 +155,8 @@ public class PhysicalOneRowRelation extends PhysicalRelation implements OneRowRe
@Override
public PhysicalOneRowRelation withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalOneRowRelation(relationId, projects, groupExpression,
- logicalPropertiesSupplier.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalOneRowRelation(relationId, projects,
+ groupExpression, logicalPropertiesSupplier.get(), physicalProperties, statistics));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPartitionTopN.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPartitionTopN.java
index 21eef99135b..4ca7b4dba36 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPartitionTopN.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPartitionTopN.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.PartitionTopnPhase;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -163,29 +164,31 @@ public class PhysicalPartitionTopN<CHILD_TYPE extends Plan> extends PhysicalUnar
@Override
public PhysicalPartitionTopN<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit,
- partitionLimit, phase, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalPartitionTopN<>(function, partitionKeys,
+ orderKeys, hasGlobalLimit, partitionLimit, phase, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalPartitionTopN<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit, phase,
- groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalPartitionTopN<>(function, partitionKeys,
+ orderKeys, hasGlobalLimit, partitionLimit, phase, groupExpression, getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit, phase,
- groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalPartitionTopN<>(function, partitionKeys,
+ orderKeys, hasGlobalLimit, partitionLimit, phase, groupExpression, logicalProperties.get(),
+ children.get(0)));
}
@Override
public PhysicalPartitionTopN<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalPartitionTopN<>(function, partitionKeys, orderKeys, hasGlobalLimit, partitionLimit, phase,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalPartitionTopN<>(function, partitionKeys,
+ orderKeys, hasGlobalLimit, partitionLimit, phase, groupExpression, getLogicalProperties(),
+ physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalProject.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalProject.java
index eb65a9c9f60..dd0d25cb360 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalProject.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalProject.java
@@ -29,6 +29,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.functions.NoneMovableFunction;
import org.apache.doris.nereids.trees.expressions.functions.scalar.Uuid;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Project;
@@ -161,32 +162,29 @@ public class PhysicalProject<CHILD_TYPE extends Plan> extends PhysicalUnary<CHIL
@Override
public PhysicalProject<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalProject<>(projects,
- groupExpression,
- getLogicalProperties(),
- physicalProperties,
- statistics,
- children.get(0)
- );
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalProject<>(projects,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalProject<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalProject<>(projects, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalProject<>(projects, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalProject<>(projects, groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalProject<>(projects, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalProject<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalProject<>(projects, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalProject<>(projects, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
/**
@@ -196,13 +194,8 @@ public class PhysicalProject<CHILD_TYPE extends Plan> extends PhysicalUnary<CHIL
* @return new project
*/
public PhysicalProject<Plan> withProjectionsAndChild(List<NamedExpression> projections, Plan child) {
- return new PhysicalProject<>(Utils.fastToImmutableList(projections),
- groupExpression,
- getLogicalProperties(),
- physicalProperties,
- statistics,
- child
- );
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalProject<>(Utils.fastToImmutableList(projections),
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, child));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalQuickSort.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalQuickSort.java
index a8bea1fbfa0..f79cd33c56f 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalQuickSort.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalQuickSort.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.PropagateFuncDeps;
@@ -80,27 +81,29 @@ public class PhysicalQuickSort<CHILD_TYPE extends Plan> extends AbstractPhysical
@Override
public PhysicalQuickSort<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalQuickSort<>(orderKeys, phase, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalQuickSort<>(orderKeys, phase, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalQuickSort<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalQuickSort<>(orderKeys, phase, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalQuickSort<>(orderKeys, phase, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalQuickSort<>(orderKeys, phase, groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalQuickSort<>(orderKeys, phase, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalQuickSort<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalQuickSort<>(orderKeys, phase, groupExpression, getLogicalProperties(), physicalProperties,
- statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalQuickSort<>(orderKeys, phase, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnion.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnion.java
index ce5b074a60f..41f99f30908 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnion.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnion.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.RecursiveCte;
@@ -177,29 +178,30 @@ public class PhysicalRecursiveUnion<LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TY
@Override
public PhysicalRecursiveUnion<Plan, Plan> withChildren(List<Plan> children) {
- return new PhysicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs, groupExpression,
- getLogicalProperties(), children.get(0), children.get(1));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnion<>(cteName, qualifier, outputs,
+ regularChildrenOutputs, groupExpression, getLogicalProperties(), children.get(0), children.get(1)));
}
@Override
public PhysicalRecursiveUnion<Plan, Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
- groupExpression, getLogicalProperties(), left(), right());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnion<>(cteName, qualifier, outputs,
+ regularChildrenOutputs, groupExpression, getLogicalProperties(), left(), right()));
}
@Override
public PhysicalRecursiveUnion<Plan, Plan> withGroupExprLogicalPropChildren(
Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
- groupExpression, logicalProperties.get(), left(), right());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnion<>(cteName, qualifier, outputs,
+ regularChildrenOutputs, groupExpression, logicalProperties.get(), left(), right()));
}
@Override
public PhysicalRecursiveUnion<Plan, Plan> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalRecursiveUnion<>(cteName, qualifier, outputs, regularChildrenOutputs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, left(), right());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnion<>(cteName, qualifier, outputs,
+ regularChildrenOutputs, groupExpression, getLogicalProperties(), physicalProperties, statistics,
+ left(), right()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionAnchor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionAnchor.java
index 1bef79ad50c..2e8cd6d03c5 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionAnchor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionAnchor.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -90,8 +91,8 @@ public class PhysicalRecursiveUnionAnchor<CHILD_TYPE extends Plan> extends Physi
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression, getLogicalProperties(),
- children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression,
+ getLogicalProperties(), children.get(0)));
}
@Override
@@ -106,14 +107,16 @@ public class PhysicalRecursiveUnionAnchor<CHILD_TYPE extends Plan> extends Physi
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression, logicalProperties.get(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression,
+ logicalProperties.get(), child()));
}
@Override
@@ -138,7 +141,7 @@ public class PhysicalRecursiveUnionAnchor<CHILD_TYPE extends Plan> extends Physi
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionAnchor<>(cteId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionProducer.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionProducer.java
index fa7098a4dd6..88643e43c14 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionProducer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRecursiveUnionProducer.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.properties.DataTrait;
import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
@@ -85,8 +86,8 @@ public class PhysicalRecursiveUnionProducer<CHILD_TYPE extends Plan> extends Phy
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalRecursiveUnionProducer<>(cteName, groupExpression, getLogicalProperties(),
- children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionProducer<>(cteName, groupExpression,
+ getLogicalProperties(), children.get(0)));
}
@Override
@@ -101,14 +102,16 @@ public class PhysicalRecursiveUnionProducer<CHILD_TYPE extends Plan> extends Phy
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalRecursiveUnionProducer<>(cteName, groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionProducer<>(cteName, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalRecursiveUnionProducer<>(cteName, groupExpression, logicalProperties.get(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionProducer<>(cteName, groupExpression,
+ logicalProperties.get(), child()));
}
@Override
@@ -133,7 +136,7 @@ public class PhysicalRecursiveUnionProducer<CHILD_TYPE extends Plan> extends Phy
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalRecursiveUnionProducer<>(cteName, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRecursiveUnionProducer<>(cteName, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRepeat.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRepeat.java
index 1160db440da..29d6da0abc9 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRepeat.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalRepeat.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Repeat;
@@ -159,42 +160,48 @@ public class PhysicalRepeat<CHILD_TYPE extends Plan> extends PhysicalUnary<CHILD
@Override
public PhysicalRepeat<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalRepeat<>(groupingSets, outputExpressions, groupingId, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRepeat<>(groupingSets, outputExpressions,
+ groupingId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalRepeat<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalRepeat<>(groupingSets, outputExpressions, groupingId, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRepeat<>(groupingSets, outputExpressions,
+ groupingId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1);
- return new PhysicalRepeat<>(groupingSets, outputExpressions, groupingId, groupExpression,
- logicalProperties.get(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRepeat<>(groupingSets, outputExpressions,
+ groupingId, groupExpression,
+ logicalProperties.get(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalRepeat<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalRepeat<>(groupingSets, outputExpressions, groupingId, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRepeat<>(groupingSets, outputExpressions,
+ groupingId, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
public PhysicalRepeat<CHILD_TYPE> withAggOutput(List<NamedExpression> newOutput) {
- return new PhysicalRepeat<>(groupingSets, newOutput, groupingId, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRepeat<>(groupingSets, newOutput, groupingId,
+ Optional.empty(),
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
public PhysicalRepeat<CHILD_TYPE> withGroupSetsAndOutput(List<List<Expression>> groupingSets,
List<NamedExpression> outputExpressionList) {
- return new PhysicalRepeat<>(groupingSets, outputExpressionList, groupingId, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalRepeat<>(groupingSets, outputExpressionList,
+ groupingId, Optional.empty(),
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalResultSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalResultSink.java
index 46df134c0cd..0b1b0663e39 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalResultSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalResultSink.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.ComputeResultSet;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -63,8 +64,8 @@ public class PhysicalResultSink<CHILD_TYPE extends Plan> extends PhysicalSink<CH
public PhysicalResultSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalResultSink's children size must be 1, but real is %s", children.size());
- return new PhysicalResultSink<>(outputExprs, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalResultSink<>(outputExprs, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
@@ -79,8 +80,8 @@ public class PhysicalResultSink<CHILD_TYPE extends Plan> extends PhysicalSink<CH
@Override
public PhysicalResultSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalResultSink<>(outputExprs, groupExpression, getLogicalProperties(),
- physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalResultSink<>(outputExprs, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
@@ -88,15 +89,15 @@ public class PhysicalResultSink<CHILD_TYPE extends Plan> extends PhysicalSink<CH
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalResultSink's children size must be 1, but real is %s", children.size());
- return new PhysicalResultSink<>(outputExprs, groupExpression, logicalProperties.get(),
- physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalResultSink<>(outputExprs, groupExpression,
+ logicalProperties.get(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalResultSink<Plan> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalResultSink<>(outputExprs, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalResultSink<>(outputExprs, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSchemaScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSchemaScan.java
index 37cd5ec7356..9d40135f2e7 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSchemaScan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalSchemaScan.java
@@ -22,6 +22,7 @@ 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.expressions.Expression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -100,25 +101,25 @@ public class PhysicalSchemaScan extends PhysicalCatalogRelation {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalSchemaScan(relationId, getTable(), qualifier,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalSchemaScan(relationId, getTable(), qualifier,
groupExpression, getLogicalProperties(), physicalProperties, statistics,
- schemaCatalog, schemaDatabase, schemaTable, frontendConjuncts);
+ schemaCatalog, schemaDatabase, schemaTable, frontendConjuncts));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalSchemaScan(relationId, getTable(), qualifier,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalSchemaScan(relationId, getTable(), qualifier,
groupExpression, logicalProperties.get(), physicalProperties, statistics,
- schemaCatalog, schemaDatabase, schemaTable, frontendConjuncts);
+ schemaCatalog, schemaDatabase, schemaTable, frontendConjuncts));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalSchemaScan(relationId, getTable(), qualifier,
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalSchemaScan(relationId, getTable(), qualifier,
groupExpression, getLogicalProperties(), physicalProperties, statistics,
- schemaCatalog, schemaDatabase, schemaTable, frontendConjuncts);
+ schemaCatalog, schemaDatabase, schemaTable, frontendConjuncts));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalStorageLayerAggregate.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalStorageLayerAggregate.java
index ef0f0de1523..9c7baa60f53 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalStorageLayerAggregate.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalStorageLayerAggregate.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.trees.expressions.functions.agg.AggregateFunctio
import org.apache.doris.nereids.trees.expressions.functions.agg.Count;
import org.apache.doris.nereids.trees.expressions.functions.agg.Max;
import org.apache.doris.nereids.trees.expressions.functions.agg.Min;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.util.Utils;
@@ -82,29 +83,29 @@ public class PhysicalStorageLayerAggregate extends PhysicalCatalogRelation {
}
public PhysicalStorageLayerAggregate withPhysicalOlapScan(PhysicalOlapScan physicalOlapScan) {
- return new PhysicalStorageLayerAggregate(physicalOlapScan, aggOp);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalStorageLayerAggregate(physicalOlapScan, aggOp));
}
@Override
public PhysicalStorageLayerAggregate withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalStorageLayerAggregate(relation, aggOp, groupExpression,
- getLogicalProperties(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalStorageLayerAggregate(relation, aggOp,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalStorageLayerAggregate(relation, aggOp, groupExpression,
- logicalProperties.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalStorageLayerAggregate(relation, aggOp,
+ groupExpression, logicalProperties.get(), physicalProperties, statistics));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalStorageLayerAggregate(
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalStorageLayerAggregate(
(PhysicalCatalogRelation) relation.withPhysicalPropertiesAndStats(null, statistics),
aggOp, groupExpression,
- getLogicalProperties(), physicalProperties, statistics);
+ getLogicalProperties(), physicalProperties, statistics));
}
/** PushAggOp */
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFRelation.java
index 84bf5aa4bf7..2d271b6dbb7 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFRelation.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFRelation.java
@@ -26,6 +26,7 @@ import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
import org.apache.doris.nereids.trees.expressions.StatementScopeIdGenerator;
import org.apache.doris.nereids.trees.expressions.functions.table.TableValuedFunction;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.BlockFuncDepsPropagation;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -66,22 +67,22 @@ public class PhysicalTVFRelation extends PhysicalRelation implements TVFRelation
@Override
public PhysicalTVFRelation withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalTVFRelation(relationId, function, operativeSlots, groupExpression, getLogicalProperties(),
- physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFRelation(relationId, function, operativeSlots,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalTVFRelation(relationId, function, operativeSlots, groupExpression,
- logicalProperties.get(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFRelation(relationId, function, operativeSlots,
+ groupExpression, logicalProperties.get(), physicalProperties, statistics));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalTVFRelation(relationId, function, operativeSlots, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFRelation(relationId, function, operativeSlots,
+ Optional.empty(), getLogicalProperties(), physicalProperties, statistics));
}
public List<Slot> getOperativeSlots() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFTableSink.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFTableSink.java
index 1220a98bb2f..e303d103580 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFTableSink.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTVFTableSink.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
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;
@@ -86,8 +87,9 @@ public class PhysicalTVFTableSink<CHILD_TYPE extends Plan> extends PhysicalSink<
public PhysicalTVFTableSink<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalTVFTableSink's children size must be 1, but real is %s", children.size());
- return new PhysicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFTableSink<>(tvfName, properties, cols,
+ outputExprs, groupExpression, getLogicalProperties(), physicalProperties, statistics,
+ children.get(0)));
}
@Override
@@ -102,8 +104,8 @@ public class PhysicalTVFTableSink<CHILD_TYPE extends Plan> extends PhysicalSink<
@Override
public PhysicalTVFTableSink<Plan> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFTableSink<>(tvfName, properties, cols,
+ outputExprs, groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
@@ -111,15 +113,16 @@ public class PhysicalTVFTableSink<CHILD_TYPE extends Plan> extends PhysicalSink<
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalTVFTableSink's children size must be 1, but real is %s", children.size());
- return new PhysicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
- groupExpression, logicalProperties.get(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFTableSink<>(tvfName, properties, cols,
+ outputExprs, groupExpression, logicalProperties.get(), physicalProperties, statistics,
+ children.get(0)));
}
@Override
public PhysicalTVFTableSink<Plan> withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalTVFTableSink<>(tvfName, properties, cols, outputExprs,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTVFTableSink<>(tvfName, properties, cols,
+ outputExprs, groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTopN.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTopN.java
index eeafbebd458..1d6ff2f28d9 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTopN.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalTopN.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.ObjectId;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
@@ -113,14 +114,14 @@ public class PhysicalTopN<CHILD_TYPE extends Plan> extends AbstractPhysicalSort<
public PhysicalTopN<Plan> withChildren(List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalTopN's children size must be 1, but real is %s", children.size());
- return new PhysicalTopN<>(orderKeys, limit, offset, phase, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTopN<>(orderKeys, limit, offset, phase,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public PhysicalTopN<CHILD_TYPE> withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalTopN<>(orderKeys, limit, offset, phase,
- groupExpression, getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTopN<>(orderKeys, limit, offset, phase,
+ groupExpression, getLogicalProperties(), child()));
}
@Override
@@ -128,15 +129,15 @@ public class PhysicalTopN<CHILD_TYPE extends Plan> extends AbstractPhysicalSort<
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkArgument(children.size() == 1,
"PhysicalTopN's children size must be 1, but real is %s", children.size());
- return new PhysicalTopN<>(orderKeys, limit, offset, phase,
- groupExpression, logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTopN<>(orderKeys, limit, offset, phase,
+ groupExpression, logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalTopN<CHILD_TYPE> withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalTopN<>(orderKeys, limit, offset, phase,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalTopN<>(orderKeys, limit, offset, phase,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, child()));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnion.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnion.java
index c00fcac10bc..59d907c28cf 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnion.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnion.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.NamedExpression;
import org.apache.doris.nereids.trees.expressions.Slot;
import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.ShuffleType;
@@ -142,28 +143,32 @@ public class PhysicalUnion extends PhysicalSetOperation implements Union {
@Override
public PhysicalUnion withChildren(List<Plan> children) {
- return new PhysicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList, groupExpression,
- getLogicalProperties(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalUnion(qualifier, outputs,
+ regularChildrenOutputs, constantExprsList, groupExpression,
+ getLogicalProperties(), children));
}
@Override
public PhysicalUnion withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList,
- groupExpression, getLogicalProperties(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalUnion(qualifier, outputs,
+ regularChildrenOutputs, constantExprsList,
+ groupExpression, getLogicalProperties(), children));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList,
- groupExpression, logicalProperties.get(), children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalUnion(qualifier, outputs,
+ regularChildrenOutputs, constantExprsList,
+ groupExpression, logicalProperties.get(), children));
}
@Override
public PhysicalUnion withPhysicalPropertiesAndStats(
PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalUnion(qualifier, outputs, regularChildrenOutputs, constantExprsList,
- groupExpression, getLogicalProperties(), physicalProperties, statistics, children);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalUnion(qualifier, outputs,
+ regularChildrenOutputs, constantExprsList,
+ groupExpression, getLogicalProperties(), physicalProperties, statistics, children));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWindow.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWindow.java
index 2ac48d8296b..a817ac7591b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWindow.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWindow.java
@@ -30,6 +30,7 @@ import org.apache.doris.nereids.trees.expressions.WindowExpression;
import org.apache.doris.nereids.trees.expressions.functions.window.DenseRank;
import org.apache.doris.nereids.trees.expressions.functions.window.Rank;
import org.apache.doris.nereids.trees.expressions.functions.window.RowNumber;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.algebra.Window;
@@ -140,35 +141,40 @@ public class PhysicalWindow<CHILD_TYPE extends Plan> extends PhysicalUnary<CHILD
@Override
public Plan withChildren(List<Plan> children) {
Preconditions.checkState(children.size() == 1);
- return new PhysicalWindow<>(windowFrameGroup, requireProperties, windowExpressions, isSkew, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWindow<>(windowFrameGroup, requireProperties,
+ windowExpressions, isSkew, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, children.get(0)));
}
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalWindow<>(windowFrameGroup, requireProperties, windowExpressions, isSkew, groupExpression,
- getLogicalProperties(), child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWindow<>(windowFrameGroup, requireProperties,
+ windowExpressions, isSkew, groupExpression,
+ getLogicalProperties(), child()));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
Preconditions.checkState(children.size() == 1);
- return new PhysicalWindow<>(windowFrameGroup, requireProperties, windowExpressions, isSkew, groupExpression,
- logicalProperties.get(), children.get(0));
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWindow<>(windowFrameGroup, requireProperties,
+ windowExpressions, isSkew, groupExpression,
+ logicalProperties.get(), children.get(0)));
}
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties,
Statistics statistics) {
- return new PhysicalWindow<>(windowFrameGroup, requireProperties, windowExpressions, isSkew, groupExpression,
- getLogicalProperties(), physicalProperties, statistics, child());
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWindow<>(windowFrameGroup, requireProperties,
+ windowExpressions, isSkew, groupExpression,
+ getLogicalProperties(), physicalProperties, statistics, child()));
}
public <C extends Plan> PhysicalWindow<C> withRequirePropertiesAndChild(RequireProperties requireProperties,
C newChild) {
- return new PhysicalWindow<>(windowFrameGroup, requireProperties, windowExpressions, isSkew, Optional.empty(),
- getLogicalProperties(), physicalProperties, statistics, newChild);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWindow<>(windowFrameGroup, requireProperties,
+ windowExpressions, isSkew, Optional.empty(),
+ getLogicalProperties(), physicalProperties, statistics, newChild));
}
@Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWorkTableReference.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWorkTableReference.java
index 83d31941c8c..0df3e3cce8f 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWorkTableReference.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalWorkTableReference.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.properties.LogicalProperties;
import org.apache.doris.nereids.properties.PhysicalProperties;
import org.apache.doris.nereids.trees.expressions.CTEId;
import org.apache.doris.nereids.trees.expressions.Slot;
+import org.apache.doris.nereids.trees.plans.AbstractPlan;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.RelationId;
@@ -77,17 +78,15 @@ public class PhysicalWorkTableReference extends PhysicalRelation {
@Override
public Plan withGroupExpression(Optional<GroupExpression> groupExpression) {
- return new PhysicalWorkTableReference(relationId, cteId, outputs, nameParts, groupExpression,
- getLogicalProperties(),
- physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWorkTableReference(relationId, cteId, outputs,
+ nameParts, groupExpression, getLogicalProperties(), physicalProperties, statistics));
}
@Override
public Plan withGroupExprLogicalPropChildren(Optional<GroupExpression> groupExpression,
Optional<LogicalProperties> logicalProperties, List<Plan> children) {
- return new PhysicalWorkTableReference(relationId, cteId, outputs, nameParts, groupExpression,
- getLogicalProperties(),
- physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWorkTableReference(relationId, cteId, outputs,
+ nameParts, groupExpression, getLogicalProperties(), physicalProperties, statistics));
}
@Override
@@ -112,9 +111,8 @@ public class PhysicalWorkTableReference extends PhysicalRelation {
@Override
public PhysicalPlan withPhysicalPropertiesAndStats(PhysicalProperties physicalProperties, Statistics statistics) {
- return new PhysicalWorkTableReference(relationId, cteId, outputs, nameParts, groupExpression,
- getLogicalProperties(),
- physicalProperties, statistics);
+ return AbstractPlan.copyWithSameId(this, () -> new PhysicalWorkTableReference(relationId, cteId, outputs,
+ nameParts, groupExpression, getLogicalProperties(), physicalProperties, statistics));
}
@Override
diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/PlanNodeIdPreservationTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/PlanNodeIdPreservationTest.java
new file mode 100644
index 00000000000..b76540bd2ee
--- /dev/null
+++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/PlanNodeIdPreservationTest.java
@@ -0,0 +1,131 @@
+// 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;
+
+import org.apache.doris.nereids.rules.exploration.join.JoinReorderContext;
+import org.apache.doris.nereids.trees.expressions.Alias;
+import org.apache.doris.nereids.trees.expressions.EqualTo;
+import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.expressions.literal.Literal;
+import org.apache.doris.nereids.trees.plans.logical.LogicalFilter;
+import org.apache.doris.nereids.trees.plans.logical.LogicalJoin;
+import org.apache.doris.nereids.trees.plans.logical.LogicalOneRowRelation;
+import org.apache.doris.nereids.trees.plans.logical.LogicalProject;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Verifies that withXxx() copy methods on plan nodes preserve the original node's ObjectId.
+ */
+class PlanNodeIdPreservationTest {
+
+ private LogicalOneRowRelation oneRow(int relationId) {
+ return new LogicalOneRowRelation(
+ new RelationId(relationId),
+ ImmutableList.of(new Alias(Literal.of(1L), "a"))
+ );
+ }
+
+ @Test
+ void testLogicalProjectWithChildrenPreservesId() {
+ LogicalOneRowRelation child = oneRow(1);
+ List<NamedExpression> projects = ImmutableList.of(new Alias(Literal.of(1L), "x"));
+ LogicalProject<Plan> original = new LogicalProject<>(projects, child);
+
+ LogicalOneRowRelation newChild = oneRow(2);
+ LogicalProject<Plan> copy = original.withChildren(ImmutableList.of(newChild));
+
+ Assertions.assertEquals(original.getId(), copy.getId(),
+ "withChildren should preserve the node id");
+ }
+
+ @Test
+ void testLogicalProjectWithProjectsPreservesId() {
+ LogicalOneRowRelation child = oneRow(1);
+ List<NamedExpression> projects = ImmutableList.of(new Alias(Literal.of(1L), "x"));
+ LogicalProject<Plan> original = new LogicalProject<>(projects, child);
+
+ List<NamedExpression> newProjects = ImmutableList.of(new Alias(Literal.of(2L), "y"));
+ LogicalProject<Plan> copy = original.withProjects(newProjects);
+
+ Assertions.assertEquals(original.getId(), copy.getId(),
+ "withProjects should preserve the node id");
+ }
+
+ @Test
+ void testLogicalFilterWithChildrenPreservesId() {
+ LogicalOneRowRelation child = oneRow(1);
+ LogicalFilter<Plan> original = new LogicalFilter<>(
+ ImmutableSet.of(new EqualTo(Literal.of(1), Literal.of(1))), child);
+
+ LogicalOneRowRelation newChild = oneRow(2);
+ LogicalFilter<Plan> copy = original.withChildren(ImmutableList.of(newChild));
+
+ Assertions.assertEquals(original.getId(), copy.getId(),
+ "withChildren on LogicalFilter should preserve the node id");
+ }
+
+ @Test
+ void testLogicalJoinWithChildrenPreservesId() {
+ LogicalOneRowRelation left = oneRow(1);
+ LogicalOneRowRelation right = oneRow(2);
+ LogicalJoin<Plan, Plan> original = new LogicalJoin<>(
+ JoinType.INNER_JOIN,
+ left,
+ right,
+ new JoinReorderContext()
+ );
+
+ LogicalOneRowRelation newLeft = oneRow(3);
+ LogicalOneRowRelation newRight = oneRow(4);
+ LogicalJoin<Plan, Plan> copy = (LogicalJoin<Plan, Plan>) original.withChildren(
+ ImmutableList.of(newLeft, newRight));
+
+ Assertions.assertEquals(original.getId(), copy.getId(),
+ "withChildren on LogicalJoin should preserve the node id");
+ }
+
+ @Test
+ void testWithGroupExpressionPreservesId() {
+ LogicalOneRowRelation child = oneRow(1);
+ List<NamedExpression> projects = ImmutableList.of(new Alias(Literal.of(1L), "x"));
+ LogicalProject<Plan> original = new LogicalProject<>(projects, child);
+
+ LogicalProject<Plan> copy = original.withGroupExpression(Optional.empty());
+
+ Assertions.assertEquals(original.getId(), copy.getId(),
+ "withGroupExpression should preserve the node id");
+ }
+
+ @Test
+ void testDistinctNodesHaveDifferentIds() {
+ LogicalOneRowRelation child = oneRow(1);
+ List<NamedExpression> projects = ImmutableList.of(new Alias(Literal.of(1L), "x"));
+ LogicalProject<Plan> node1 = new LogicalProject<>(projects, child);
+ LogicalProject<Plan> node2 = new LogicalProject<>(projects, child);
+
+ Assertions.assertNotEquals(node1.getId(), node2.getId(),
+ "independently constructed nodes must have different ids");
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org