This is an automated email from the ASF dual-hosted git repository.
lingmiao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-doris.git
The following commit(s) were added to refs/heads/master by this push:
new 99b8e08a5f [Enhancement](Optimizer) Nereids pattern matching base
framework (#9474)
99b8e08a5f is described below
commit 99b8e08a5f06cc294f9f31d299b7a11b8010b001
Author: 924060929 <924060...@qq.com>
AuthorDate: Tue May 10 10:06:04 2022 +0800
[Enhancement](Optimizer) Nereids pattern matching base framework (#9474)
This pr provide a new pattern matching framework for Nereids optimizer.
The new pattern matching framework contains this concepts:
1. `Pattern`/`PatternDescriptor`: the tree node's multiple hierarchy shape,
e.g. `logicalJoin(logicalJoin(), any()` pattern describe a plan that root is a
`LogicalJoin` and the left child is `LogicalJoin` too.
2. `MatchedAction`: a callback function when the pattern matched, usually
you can create new plan to replace the origin matched plan.
3. `MatchingContext`: the param pass through MatchedAction, contains the
matched plan root and the PlannerContext.
4. `PatternMatcher`: contains PatternDescriptor and MatchedAction
5. `Rule`: a rewrite rule contains RuleType, PatternPromise, Pattern and
transform function(equals to MatchedAction)
6. `RuleFactory`: the factory can help us build Rules easily. RuleFactory
extends Patterns interface, and have some predefined pattern descriptors.
for example, Join commutative:
```java
public class JoinCommutative extends OneExplorationRuleFactory {
@Override
public Rule<Plan> build() {
return innerLogicalJoin().thenApply(ctx -> {
return new LogicalJoin(
JoinType.INNER_JOIN,
ctx.root.getOnClause(),
ctx.root.right(),
ctx.root.left()
);
}).toRule(RuleType.LOGICAL_JOIN_COMMUTATIVE);
}
}
```
the code above show the three step to create a Rule
1. 'innerLogicalJoin()' declare pattern is an inner logical join.
'innerLogicalJoin' is a predefined pattern.
2. invoke 'thenApply()' function to combine a MatchedAction, return a new
LogicalJoin with exchange children.
3. invoke 'toRule()' function to convert to Rule
You can think the Rule contains three parts:
1. Pattern
2. transform function / MatchedAction
3. RuleType and RulePromise
So
1. `innerLogicalJoin()` create a `PatternDescriptor`, which contains a
`Pattern`
2. `PatternDescriptor.then()` convert `PatternDescriptor` to
`PatternMatcher,` witch contains Pattern and MatchedAction
3. `PatternMatcher.toRule()` convert `PatternMatcher` to a Rule
This three step inspired by the currying in function programing.
It should be noted, #9446 provide a generic type for TreeNode's children,
so we can infer multiple hierarchy type in this pattern matching framework, so
you can get the really tree node type without unsafely cast. like this:
```java
logicalJoin(logicalJoin(), any()).then(j -> {
// j can be inferred type to LogicalJoin<LogicalJoin<Plan, Plan>, Plan>
// so j.left() can be inferred type to LogicalJoin<Plan, Plan>,
// so you don't need to cast j.left() from 'Plan' to 'LogicalJoin'
var node = j.left().left();
})
```
---
.../doris/nereids/analyzer/UnboundAlias.java | 2 +-
.../java/org/apache/doris/nereids/jobs/Job.java | 3 +-
.../doris/nereids/jobs/cascades/ApplyRuleJob.java | 8 +-
.../nereids/jobs/cascades/ExplorePlanJob.java | 5 +-
.../nereids/jobs/cascades/OptimizePlanJob.java | 12 +-
.../UnaryNode.java => pattern/MatchedAction.java} | 22 +-
.../Plan.java => pattern/MatchingContext.java} | 44 ++-
.../org/apache/doris/nereids/pattern/Pattern.java | 76 +++-
.../doris/nereids/pattern/PatternDescriptor.java | 62 ++++
.../doris/nereids/pattern/PatternMatcher.java | 81 +++++
.../org/apache/doris/nereids/pattern/Patterns.java | 386 +++++++++++++++++++++
.../{RuleType.java => OnePlanRuleFactory.java} | 24 +-
.../rules/{RuleType.java => OneRuleFactory.java} | 30 +-
.../rules/{RuleType.java => PlanRuleFactory.java} | 24 +-
.../java/org/apache/doris/nereids/rules/Rule.java | 8 +-
.../rules/{RuleType.java => RuleFactory.java} | 31 +-
.../org/apache/doris/nereids/rules/RuleSet.java | 56 ++-
.../org/apache/doris/nereids/rules/RuleType.java | 2 +
...{AnalysisRule.java => AnalysisRuleFactory.java} | 13 +-
...ationRule.java => AnalysisUnboundRelation.java} | 48 ++-
...alysisRule.java => OneAnalysisRuleFactory.java} | 13 +-
...rationRule.java => ExplorationRuleFactory.java} | 13 +-
...onRule.java => JoinAssociativeLeftToRight.java} | 27 +-
.../{ExplorationRule.java => JoinCommutative.java} | 22 +-
...ionRule.java => OneExplorationRuleFactory.java} | 13 +-
...ressionRule.java => ExpressionRuleFactory.java} | 15 +-
...sionRule.java => OneExpressionRuleFactory.java} | 15 +-
...ionRule.java => ImplementationRuleFactory.java} | 13 +-
...ntationRule.java => LogicalJoinToHashJoin.java} | 20 +-
.../implementation/LogicalJoinToHashJoinRule.java | 53 ---
...Rule.java => OneImplementationRuleFactory.java} | 13 +-
...RewriteRule.java => OneRewriteRuleFactory.java} | 13 +-
.../{RewriteRule.java => RewriteRuleFactory.java} | 13 +-
.../doris/nereids/trees/AbstractTreeNode.java | 9 +-
.../org/apache/doris/nereids/trees/BinaryNode.java | 4 +-
.../org/apache/doris/nereids/trees/NodeType.java | 4 +-
.../org/apache/doris/nereids/trees/TreeNode.java | 6 +-
.../org/apache/doris/nereids/trees/UnaryNode.java | 2 +-
.../doris/nereids/trees/expressions/Alias.java | 2 +-
.../trees/expressions/BinaryExpression.java | 14 +-
.../nereids/trees/expressions/BinaryPredicate.java | 4 +-
.../nereids/trees/expressions/UnaryExpression.java | 2 +-
.../doris/nereids/trees/plans/AbstractPlan.java | 5 -
.../doris/nereids/trees/plans/BinaryPlan.java | 14 +-
.../org/apache/doris/nereids/trees/plans/Plan.java | 2 -
.../doris/nereids/trees/plans/UnaryPlan.java | 2 +-
.../nereids/trees/plans/logical/LogicalBinary.java | 4 +-
.../nereids/trees/plans/logical/LogicalFilter.java | 2 +-
.../nereids/trees/plans/logical/LogicalJoin.java | 4 +-
.../trees/plans/logical/LogicalProject.java | 2 +-
.../nereids/trees/plans/logical/LogicalUnary.java | 2 +-
.../trees/plans/physical/PhysicalBinary.java | 4 +-
.../plans/physical/PhysicalBroadcastHashJoin.java | 4 +-
.../trees/plans/physical/PhysicalFilter.java | 2 +-
.../trees/plans/physical/PhysicalProject.java | 2 +-
.../trees/plans/physical/PhysicalUnary.java | 2 +-
56 files changed, 907 insertions(+), 371 deletions(-)
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
index e86923fa8a..4b7301734e 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
@@ -29,7 +29,7 @@ import java.util.List;
/**
* Expression for unbound alias.
*/
-public class UnboundAlias<CHILD_TYPE extends Expression<CHILD_TYPE>>
+public class UnboundAlias<CHILD_TYPE extends Expression>
extends UnaryExpression<UnboundAlias<CHILD_TYPE>, CHILD_TYPE>
implements NamedExpression<UnboundAlias<CHILD_TYPE>> {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/Job.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/Job.java
index b9a7f02666..dacafdfafa 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/Job.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/Job.java
@@ -22,6 +22,7 @@ import org.apache.doris.nereids.PlannerContext;
import org.apache.doris.nereids.memo.PlanReference;
import org.apache.doris.nereids.rules.Rule;
import org.apache.doris.nereids.rules.RuleSet;
+import org.apache.doris.nereids.trees.plans.Plan;
import java.util.List;
@@ -45,7 +46,7 @@ public abstract class Job {
return context.getOptimizerContext().getRuleSet();
}
- public void prunedInvalidRules(PlanReference planReference, List<Rule>
candidateRules) {
+ public void prunedInvalidRules(PlanReference planReference,
List<Rule<Plan>> candidateRules) {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ApplyRuleJob.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ApplyRuleJob.java
index 627594a694..264f9030c6 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ApplyRuleJob.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ApplyRuleJob.java
@@ -34,7 +34,7 @@ import java.util.List;
*/
public class ApplyRuleJob extends Job {
private final PlanReference planReference;
- private final Rule rule;
+ private final Rule<Plan> rule;
private final boolean exploredOnly;
/**
@@ -44,7 +44,7 @@ public class ApplyRuleJob extends Job {
* @param rule rule to be applied
* @param context context of optimization
*/
- public ApplyRuleJob(PlanReference planReference, Rule rule, PlannerContext
context) {
+ public ApplyRuleJob(PlanReference planReference, Rule<Plan> rule,
PlannerContext context) {
super(JobType.APPLY_RULE, context);
this.planReference = planReference;
this.rule = rule;
@@ -63,8 +63,8 @@ public class ApplyRuleJob extends Job {
if (!rule.check(plan, context)) {
continue;
}
- List<Plan<?>> newPlanList = rule.transform(plan, context);
- for (Plan<?> newPlan : newPlanList) {
+ List<Plan> newPlanList = rule.transform(plan, context);
+ for (Plan newPlan : newPlanList) {
PlanReference newReference =
context.getOptimizerContext().getMemo()
.newPlanReference(newPlan, planReference.getParent());
// TODO need to check return is a new Reference, other wise
will be into a dead loop
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ExplorePlanJob.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ExplorePlanJob.java
index 9c84534ad1..5943967416 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ExplorePlanJob.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/ExplorePlanJob.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.memo.Group;
import org.apache.doris.nereids.memo.PlanReference;
import org.apache.doris.nereids.pattern.Pattern;
import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.trees.plans.Plan;
import java.util.Comparator;
import java.util.List;
@@ -47,7 +48,7 @@ public class ExplorePlanJob extends Job {
@Override
public void execute() {
- List<Rule> explorationRules = getRuleSet().getExplorationRules();
+ List<Rule<Plan>> explorationRules = getRuleSet().getExplorationRules();
prunedInvalidRules(planReference, explorationRules);
explorationRules.sort(Comparator.comparingInt(o ->
o.getRulePromise().promise()));
@@ -55,7 +56,7 @@ public class ExplorePlanJob extends Job {
pushTask(new ApplyRuleJob(planReference, rule, context));
for (int i = 0; i < rule.getPattern().children().size(); ++i) {
Pattern childPattern = rule.getPattern().child(i);
- if (!childPattern.children().isEmpty()) {
+ if (childPattern.arity() > 0) {
Group childSet = planReference.getChildren().get(i);
pushTask(new ExploreGroupJob(childSet, context));
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/OptimizePlanJob.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/OptimizePlanJob.java
index e3337b06b0..4bb7964997 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/OptimizePlanJob.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/jobs/cascades/OptimizePlanJob.java
@@ -24,9 +24,9 @@ import org.apache.doris.nereids.memo.Group;
import org.apache.doris.nereids.memo.PlanReference;
import org.apache.doris.nereids.pattern.Pattern;
import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.trees.plans.Plan;
-import com.clearspring.analytics.util.Lists;
-
+import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
@@ -43,9 +43,9 @@ public class OptimizePlanJob extends Job {
@Override
public void execute() {
- List<Rule> validRules = Lists.newArrayList();
- List<Rule> explorationRules = getRuleSet().getExplorationRules();
- List<Rule> implementationRules = getRuleSet().getImplementationRules();
+ List<Rule<Plan>> validRules = new ArrayList<>();
+ List<Rule<Plan>> explorationRules = getRuleSet().getExplorationRules();
+ List<Rule<Plan>> implementationRules =
getRuleSet().getImplementationRules();
prunedInvalidRules(planReference, explorationRules);
prunedInvalidRules(planReference, implementationRules);
validRules.addAll(explorationRules);
@@ -59,7 +59,7 @@ public class OptimizePlanJob extends Job {
// child before applying the rule. (assumes task pool is
effectively a stack)
for (int i = 0; i < rule.getPattern().children().size(); ++i) {
Pattern childPattern = rule.getPattern().child(i);
- if (!childPattern.children().isEmpty()) {
+ if (childPattern.arity() > 0) {
Group childSet = planReference.getChildren().get(i);
pushTask(new ExploreGroupJob(childSet, context));
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/MatchedAction.java
similarity index 66%
copy from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/MatchedAction.java
index d7d2efb459..67877c6f87 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/MatchedAction.java
@@ -15,22 +15,14 @@
// specific language governing permissions and limitations
// under the License.
-package org.apache.doris.nereids.trees;
+package org.apache.doris.nereids.pattern;
+
+import org.apache.doris.nereids.trees.TreeNode;
/**
- * interface for all tree node that have one child.
+ * Define an callback action when match a pattern, usually implement as a rule
body.
+ * e.g. exchange join children for JoinCommutative Rule
*/
-public interface UnaryNode<
- NODE_TYPE extends UnaryNode<NODE_TYPE, CHILD_TYPE>,
- CHILD_TYPE extends TreeNode<CHILD_TYPE>>
- extends TreeNode<NODE_TYPE> {
-
- default CHILD_TYPE child() {
- return child(0);
- }
-
- @Override
- default int arity() {
- return 1;
- }
+public interface MatchedAction<INPUT_TYPE extends TreeNode, OUTPUT_TYPE
extends TreeNode> {
+ OUTPUT_TYPE apply(MatchingContext<INPUT_TYPE> ctx);
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/MatchingContext.java
similarity index 53%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/MatchingContext.java
index 1f07641152..460a982a70 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/MatchingContext.java
@@ -15,33 +15,29 @@
// specific language governing permissions and limitations
// under the License.
-package org.apache.doris.nereids.trees.plans;
+package org.apache.doris.nereids.pattern;
-import org.apache.doris.nereids.exceptions.UnboundException;
-import org.apache.doris.nereids.memo.PlanReference;
-import org.apache.doris.nereids.trees.NodeType;
+import org.apache.doris.nereids.PlannerContext;
import org.apache.doris.nereids.trees.TreeNode;
-import org.apache.doris.nereids.trees.expressions.Slot;
-
-import java.util.List;
/**
- * Abstract class for all plan node.
+ * Define a context when match a pattern pass through a MatchedAction.
*/
-public interface Plan<PLAN_TYPE extends Plan<PLAN_TYPE>> extends
TreeNode<PLAN_TYPE> {
- NodeType getType();
-
- List<Slot> getOutput() throws UnboundException;
-
- PlanReference getPlanReference();
-
- void setPlanReference(PlanReference planReference);
-
- String treeString();
-
- @Override
- List<Plan> children();
-
- @Override
- Plan child(int index);
+public class MatchingContext<T extends TreeNode> {
+ public final T root;
+ public final Pattern<T> pattern;
+ public final PlannerContext plannerContext;
+
+ /**
+ * the MatchingContext is the param pass through the MatchedAction.
+ *
+ * @param root the matched tree node root
+ * @param pattern the defined pattern
+ * @param plannerContext the planner context
+ */
+ public MatchingContext(T root, Pattern<T> pattern, PlannerContext
plannerContext) {
+ this.root = root;
+ this.pattern = pattern;
+ this.plannerContext = plannerContext;
+ }
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Pattern.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Pattern.java
index ae166af3e8..1c1e2dcd10 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Pattern.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Pattern.java
@@ -19,17 +19,23 @@ package org.apache.doris.nereids.pattern;
import org.apache.doris.nereids.trees.AbstractTreeNode;
import org.apache.doris.nereids.trees.NodeType;
-import org.apache.doris.nereids.trees.plans.Plan;
+import org.apache.doris.nereids.trees.TreeNode;
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
import java.util.Objects;
+import java.util.function.Predicate;
+
/**
* Pattern node used in pattern matching.
*/
-public class Pattern extends AbstractTreeNode<Pattern> {
- public static final Pattern PATTERN_MULTI_LEAF_INSTANCE = new
Pattern(NodeType.PATTERN_MULTI_LEAF);
- public static final Pattern PATTERN_LEAF_INSTANCE = new
Pattern(NodeType.PATTERN_LEAF);
+public class Pattern<T extends TreeNode> extends AbstractTreeNode<Pattern<T>> {
+ public static final Pattern ANY = new Pattern(NodeType.ANY);
+ public static final Pattern MULTI = new Pattern(NodeType.MULTI);
+ public final List<Predicate<T>> predicates;
private final NodeType nodeType;
/**
@@ -41,6 +47,20 @@ public class Pattern extends AbstractTreeNode<Pattern> {
public Pattern(NodeType nodeType, Pattern... children) {
super(NodeType.PATTERN, children);
this.nodeType = nodeType;
+ this.predicates = ImmutableList.of();
+ }
+
+ /**
+ * Constructor for Pattern.
+ *
+ * @param nodeType node type to matching
+ * @param predicates custom matching predicate
+ * @param children sub pattern
+ */
+ public Pattern(NodeType nodeType, List<Predicate<T>> predicates,
Pattern... children) {
+ super(NodeType.PATTERN, children);
+ this.nodeType = nodeType;
+ this.predicates = ImmutableList.copyOf(predicates);
}
/**
@@ -55,23 +75,49 @@ public class Pattern extends AbstractTreeNode<Pattern> {
/**
* Return ture if current Pattern match Plan in params.
*
- * @param plan wait to match
+ * @param root wait to match
* @return ture if current Pattern match Plan in params
*/
- public boolean matchRoot(Plan<?> plan) {
- if (plan == null) {
+ public boolean matchRoot(T root) {
+ if (root == null) {
return false;
}
- if (plan.children().size() < this.children().size() &&
children.contains(PATTERN_MULTI_LEAF_INSTANCE)) {
+ if (root.children().size() < this.children().size() &&
!children.contains(MULTI)) {
return false;
}
- if (nodeType == NodeType.PATTERN_MULTI_LEAF || nodeType ==
NodeType.PATTERN_LEAF) {
+ if (nodeType == NodeType.MULTI || nodeType == NodeType.ANY) {
return true;
}
- return getNodeType().equals(plan.getType());
+ return getNodeType().equals(root.getType())
+ && predicates.stream().allMatch(predicate ->
predicate.test(root));
+ }
+
+ /**
+ * Return ture if children patterns match Plan in params.
+ *
+ * @param root wait to match
+ * @return ture if children Patterns match root's children in params
+ */
+ public boolean matchChildren(T root) {
+ for (int i = 0; i < arity(); i++) {
+ if (!child(i).match(root.child(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Return ture if children patterns match Plan in params.
+ *
+ * @param root wait to match
+ * @return ture if current pattern and children patterns match root in
params
+ */
+ public boolean match(T root) {
+ return matchRoot(root) && matchChildren(root);
}
@Override
@@ -90,4 +136,14 @@ public class Pattern extends AbstractTreeNode<Pattern> {
public int hashCode() {
return Objects.hash(nodeType);
}
+
+ @Override
+ public List<Pattern> children() {
+ return (List) children;
+ }
+
+ @Override
+ public Pattern child(int index) {
+ return (Pattern) children.get(index);
+ }
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternDescriptor.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternDescriptor.java
new file mode 100644
index 0000000000..5b945e8e92
--- /dev/null
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternDescriptor.java
@@ -0,0 +1,62 @@
+// 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.pattern;
+
+import org.apache.doris.nereids.rules.RulePromise;
+import org.apache.doris.nereids.trees.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+/**
+ * Define a descriptor to wrap a pattern tree to define a pattern shape.
+ * It can support pattern generic type to MatchedAction.
+ */
+public class PatternDescriptor<INPUT_TYPE extends RULE_TYPE, RULE_TYPE extends
TreeNode> {
+ public final Pattern<INPUT_TYPE> pattern;
+ public final RulePromise defaultPromise;
+ public final List<Predicate<INPUT_TYPE>> predicates = new ArrayList<>();
+
+ public PatternDescriptor(Pattern<INPUT_TYPE> pattern, RulePromise
defaultPromise) {
+ this.pattern = Objects.requireNonNull(pattern, "pattern can not be
null");
+ this.defaultPromise = Objects.requireNonNull(defaultPromise,
"defaultPromise can not be null");
+ }
+
+ public PatternDescriptor<INPUT_TYPE, RULE_TYPE> when(Predicate<INPUT_TYPE>
predicate) {
+ predicates.add(predicate);
+ return this;
+ }
+
+ public <OUTPUT_TYPE extends RULE_TYPE> PatternMatcher<INPUT_TYPE,
OUTPUT_TYPE, RULE_TYPE> then(
+ Function<INPUT_TYPE, OUTPUT_TYPE> matchedAction) {
+ return new PatternMatcher<>(patternWithPredicates(), defaultPromise,
ctx -> matchedAction.apply(ctx.root));
+ }
+
+ public <OUTPUT_TYPE extends RULE_TYPE> PatternMatcher<INPUT_TYPE,
OUTPUT_TYPE, RULE_TYPE> thenApply(
+ MatchedAction<INPUT_TYPE, OUTPUT_TYPE> matchedAction) {
+ return new PatternMatcher<>(patternWithPredicates(), defaultPromise,
matchedAction);
+ }
+
+ public Pattern<INPUT_TYPE> patternWithPredicates() {
+ Pattern[] children = pattern.children().toArray(new Pattern[0]);
+ return new Pattern<>(pattern.getNodeType(), predicates, children);
+ }
+}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatcher.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatcher.java
new file mode 100644
index 0000000000..0df03564ab
--- /dev/null
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatcher.java
@@ -0,0 +1,81 @@
+// 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.pattern;
+
+import org.apache.doris.nereids.PlannerContext;
+import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.rules.RulePromise;
+import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.trees.TreeNode;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Define a class combine Pattern and MatchedAction.
+ * It also Provided a function to convert to a rule.
+ */
+public class PatternMatcher<
+ INPUT_TYPE extends RULE_TYPE,
+ OUTPUT_TYPE extends RULE_TYPE,
+ RULE_TYPE extends TreeNode> {
+
+ public final Pattern<INPUT_TYPE> pattern;
+ public final RulePromise defaultRulePromise;
+ public final MatchedAction<INPUT_TYPE, OUTPUT_TYPE> matchedAction;
+
+ /**
+ * PatternMatcher wrap a pattern, defaultRulePromise and matchedAction.
+ *
+ * @param pattern pattern
+ * @param defaultRulePromise defaultRulePromise
+ * @param matchedAction matched callback function
+ */
+ public PatternMatcher(Pattern<INPUT_TYPE> pattern, RulePromise
defaultRulePromise,
+ MatchedAction<INPUT_TYPE, OUTPUT_TYPE> matchedAction) {
+ this.pattern = Objects.requireNonNull(pattern, "pattern can not be
null");
+ this.defaultRulePromise = Objects.requireNonNull(
+ defaultRulePromise, "defaultRulePromise can not be null");
+ this.matchedAction = Objects.requireNonNull(matchedAction,
"matchedAction can not be null");
+ }
+
+ public Rule<RULE_TYPE> toRule(RuleType ruleType) {
+ return toRule(ruleType, defaultRulePromise);
+ }
+
+ /**
+ * convert current PatternMatcher to a rule.
+ *
+ * @param ruleType what type of the new rule?
+ * @param rulePromise what priority of the new rule?
+ * @return Rule
+ */
+ public Rule<RULE_TYPE> toRule(RuleType ruleType, RulePromise rulePromise) {
+ return new Rule<RULE_TYPE>(ruleType, pattern, rulePromise) {
+ @Override
+ public List<RULE_TYPE> transform(RULE_TYPE originPlan,
PlannerContext context) {
+ MatchingContext<INPUT_TYPE> matchingContext =
+ new MatchingContext<>((INPUT_TYPE) originPlan,
pattern, context);
+ OUTPUT_TYPE replacePlan = matchedAction.apply(matchingContext);
+ return ImmutableList.of(replacePlan == null ? originPlan :
replacePlan);
+ }
+ };
+ }
+}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Patterns.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Patterns.java
new file mode 100644
index 0000000000..c73a45cc3c
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Patterns.java
@@ -0,0 +1,386 @@
+// 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.pattern;
+
+import org.apache.doris.nereids.analyzer.UnboundAlias;
+import org.apache.doris.nereids.analyzer.UnboundRelation;
+import org.apache.doris.nereids.analyzer.UnboundSlot;
+import org.apache.doris.nereids.analyzer.UnboundStar;
+import org.apache.doris.nereids.rules.RulePromise;
+import org.apache.doris.nereids.trees.NodeType;
+import org.apache.doris.nereids.trees.TreeNode;
+import org.apache.doris.nereids.trees.expressions.Alias;
+import org.apache.doris.nereids.trees.expressions.BinaryPredicate;
+import org.apache.doris.nereids.trees.expressions.BinaryPredicate.Operator;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.Literal;
+import org.apache.doris.nereids.trees.expressions.SlotReference;
+import org.apache.doris.nereids.trees.plans.JoinType;
+import org.apache.doris.nereids.trees.plans.Plan;
+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.LogicalProject;
+import org.apache.doris.nereids.trees.plans.logical.LogicalRelation;
+import org.apache.doris.nereids.trees.plans.physical.PhysicalBroadcastHashJoin;
+import org.apache.doris.nereids.trees.plans.physical.PhysicalFilter;
+import org.apache.doris.nereids.trees.plans.physical.PhysicalOlapScan;
+import org.apache.doris.nereids.trees.plans.physical.PhysicalProject;
+
+/**
+ * An interface provided some PatternDescriptor.
+ * Child Interface(RuleFactory) can use to declare a pattern shape, then
convert to a rule.
+ * In the future, we will generate this interface by codegen.
+ */
+public interface Patterns {
+ // need implement
+ RulePromise defaultPromise();
+
+ // logical pattern descriptors
+
+ default <T extends RULE_TYPE, RULE_TYPE extends TreeNode>
PatternDescriptor<T, RULE_TYPE> any() {
+ return new PatternDescriptor<>(Pattern.ANY, defaultPromise());
+ }
+
+ default <T extends RULE_TYPE, RULE_TYPE extends TreeNode>
PatternDescriptor<T, RULE_TYPE> multi() {
+ return new PatternDescriptor<>(Pattern.MULTI, defaultPromise());
+ }
+
+ /**
+ * create a unboundRelation pattern.
+ */
+ default PatternDescriptor<UnboundRelation, Plan> unboundRelation() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_UNBOUND_RELATION),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalFilter pattern.
+ */
+ default PatternDescriptor<LogicalFilter<Plan>, Plan> logicalFilter() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_FILTER),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalFilter pattern with child pattern.
+ */
+ default <T extends Plan> PatternDescriptor<LogicalFilter<T>, Plan>
+ logicalFilter(PatternDescriptor<T, Plan> childPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_FILTER, childPattern.pattern),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalProject pattern.
+ */
+ default PatternDescriptor<LogicalProject<Plan>, Plan> logicalProject() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_PROJECT),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalProject pattern.
+ */
+ default <T extends Plan> PatternDescriptor<LogicalProject, Plan>
+ logicalProject(PatternDescriptor<T, Plan> childPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_PROJECT, childPattern.pattern),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalJoin pattern.
+ */
+ default PatternDescriptor<LogicalJoin<Plan, Plan>, Plan> logicalJoin() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_JOIN),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalJoin pattern with join type.
+ */
+ default PatternDescriptor<LogicalJoin<Plan, Plan>, Plan>
logicalJoin(JoinType joinType) {
+ return new PatternDescriptor<LogicalJoin<Plan, Plan>, Plan>(
+ new Pattern<>(NodeType.LOGICAL_JOIN),
+ defaultPromise()
+ ).when(j -> j.getJoinType() == joinType);
+ }
+
+ /**
+ * create a logicalJoin pattern with joinType and children patterns.
+ */
+ default <C1 extends Plan, C2 extends Plan>
PatternDescriptor<LogicalJoin<C1, C2>, Plan> logicalJoin(
+ JoinType joinType, PatternDescriptor<C1, Plan> leftChildPattern,
+ PatternDescriptor<C2, Plan> rightChildPattern) {
+ return new PatternDescriptor<LogicalJoin<C1, C2>, Plan>(
+ new Pattern<>(NodeType.LOGICAL_JOIN, leftChildPattern.pattern,
rightChildPattern.pattern),
+ defaultPromise()
+ ).when(j -> j.getJoinType() == joinType);
+ }
+
+ /**
+ * create a logicalJoin pattern with children patterns.
+ */
+ default <C1 extends Plan, C2 extends Plan>
PatternDescriptor<LogicalJoin<C1, C2>, Plan> logicalJoin(
+ PatternDescriptor<C1, Plan> leftChildPattern,
PatternDescriptor<C2, Plan> rightChildPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_JOIN, leftChildPattern.pattern,
rightChildPattern.pattern),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a logicalJoin pattern with joinType is inner.
+ */
+ default PatternDescriptor<LogicalJoin<Plan, Plan>, Plan>
innerLogicalJoin() {
+ return new PatternDescriptor<LogicalJoin<Plan, Plan>, Plan>(
+ new Pattern<>(NodeType.LOGICAL_JOIN),
+ defaultPromise()
+ ).when(j -> j.getJoinType() == JoinType.INNER_JOIN);
+ }
+
+ /**
+ * create a logical join pattern with join type is inner and children
patterns.
+ */
+ default <C1 extends Plan, C2 extends Plan>
PatternDescriptor<LogicalJoin<C1, C2>, Plan> innerLogicalJoin(
+ PatternDescriptor<C1, Plan> leftChildPattern,
PatternDescriptor<C2, Plan> rightChildPattern) {
+ return new PatternDescriptor<LogicalJoin<C1, C2>, Plan>(
+ new Pattern<>(NodeType.LOGICAL_JOIN, leftChildPattern.pattern,
rightChildPattern.pattern),
+ defaultPromise()
+ ).when(j -> j.getJoinType() == JoinType.INNER_JOIN);
+ }
+
+ /**
+ * create a logicalRelation pattern.
+ */
+ default PatternDescriptor<LogicalRelation, Plan> logicalRelation() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LOGICAL_BOUND_RELATION),
+ defaultPromise()
+ );
+ }
+
+ // physical pattern descriptors
+
+ /**
+ * create a physicalFilter pattern.
+ */
+ default PatternDescriptor<PhysicalFilter<Plan>, Plan> physicalFilter() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_FILTER),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a physicalFilter pattern with child pattern.
+ */
+ default <T extends Plan> PatternDescriptor<PhysicalFilter<T>, Plan>
+ physicalFilter(PatternDescriptor<T, Plan> childPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_FILTER, childPattern.pattern),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a physicalProject pattern.
+ */
+ default PatternDescriptor<PhysicalProject<Plan>, Plan> physicalProject() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_PROJECT),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a physicalProject pattern with child pattern.
+ */
+ default <T extends Plan> PatternDescriptor<PhysicalProject<T>, Plan>
+ physicalProject(PatternDescriptor<T, Plan> childPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_PROJECT, childPattern.pattern),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a physicalBroadcastHashJoin pattern.
+ */
+ default PatternDescriptor<PhysicalBroadcastHashJoin<Plan, Plan>, Plan>
physicalBroadcastHashJoin() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_BROADCAST_HASH_JOIN),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a physicalBroadcastHashJoin pattern with children patterns.
+ */
+ default <C1 extends Plan, C2 extends Plan>
PatternDescriptor<PhysicalBroadcastHashJoin<C1, C2>, Plan>
+ physicalBroadcastHashJoin(PatternDescriptor<C1, Plan>
leftChildPattern,
+ PatternDescriptor<C2, Plan> rightChildPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_BROADCAST_HASH_JOIN,
+ leftChildPattern.pattern,
+ rightChildPattern.pattern
+ ),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a physicalOlapScan pattern.
+ */
+ default PatternDescriptor<PhysicalOlapScan, Plan> physicalOlapScan() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.PHYSICAL_OLAP_SCAN),
+ defaultPromise()
+ );
+ }
+
+ // expression pattern descriptors
+
+ /**
+ * create a unboundAlias pattern.
+ */
+ default PatternDescriptor<UnboundAlias<Expression>, Expression>
unboundAlias() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.UNBOUND_ALIAS),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a unboundAlias pattern.
+ */
+ default <T extends Expression> PatternDescriptor<UnboundAlias<T>,
Expression>
+ unboundAlias(PatternDescriptor<T, Expression> childPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.UNBOUND_ALIAS, childPattern.pattern),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a unboundSlot pattern.
+ */
+ default PatternDescriptor<UnboundSlot, Expression> unboundSlot() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.UNBOUND_SLOT),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a unboundStar pattern.
+ */
+ default PatternDescriptor<UnboundStar, Expression> unboundStar() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.UNBOUND_STAR),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a literal pattern.
+ */
+ default PatternDescriptor<Literal, Expression> literal() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.LITERAL),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a slotReference pattern.
+ */
+ default PatternDescriptor<SlotReference, Expression> slotReference() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.SLOT_REFERENCE),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a binaryPredicate pattern.
+ */
+ default PatternDescriptor<BinaryPredicate<Expression, Expression>,
Expression> binaryPredicate() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.BINARY_PREDICATE),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a binaryPredicate pattern with operator type.
+ */
+ default PatternDescriptor<BinaryPredicate<Expression, Expression>,
Expression> binaryPredicate(Operator operator) {
+ return new PatternDescriptor<BinaryPredicate<Expression, Expression>,
Expression>(
+ new Pattern<>(NodeType.BINARY_PREDICATE),
+ defaultPromise()
+ ).when(p -> p.getOperator() == operator);
+ }
+
+ /**
+ * create a binaryPredicate pattern with children patterns.
+ */
+ default <C1 extends Expression, C2 extends Expression>
PatternDescriptor<BinaryPredicate<C1, C2>, Expression>
+ binaryPredicate(PatternDescriptor<C1, Expression> leftChildPattern,
+ PatternDescriptor<C2, Expression> rightChildPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.BINARY_PREDICATE,
+ leftChildPattern.pattern,
+ rightChildPattern.pattern
+ ),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a alias pattern.
+ */
+ default PatternDescriptor<Alias<Expression>, Expression> alias() {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.ALIAS),
+ defaultPromise()
+ );
+ }
+
+ /**
+ * create a alias pattern with child pattern.
+ */
+ default <T extends Expression> PatternDescriptor<Alias<T>, Expression>
+ alias(PatternDescriptor<T, Expression> childPattern) {
+ return new PatternDescriptor<>(
+ new Pattern<>(NodeType.ALIAS, childPattern.pattern),
+ defaultPromise()
+ );
+ }
+}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/OnePlanRuleFactory.java
similarity index 69%
copy from fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/OnePlanRuleFactory.java
index 8de67fe29d..96a0c3d8d3 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/OnePlanRuleFactory.java
@@ -17,26 +17,10 @@
package org.apache.doris.nereids.rules;
+import org.apache.doris.nereids.trees.plans.Plan;
+
/**
- * Type of rules, each rule has its unique type.
+ * abstract class for all rule factories build one plan rule.
*/
-public enum RuleType {
- // binding rules
- BINDING_UNBOUND_RELATION_RULE,
-
- // rewrite rules
- COLUMN_PRUNE_PROJECTION,
-
- // exploration rules
-
- // implementation rules
- LOGICAL_JOIN_TO_HASH_JOIN_RULE,
-
- // sentinel, use to count rules
- SENTINEL,
- ;
-
- public int type() {
- return ordinal();
- }
+public abstract class OnePlanRuleFactory extends OneRuleFactory<Plan>
implements PlanRuleFactory {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/OneRuleFactory.java
similarity index 67%
copy from fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/OneRuleFactory.java
index 8de67fe29d..5f774a49c9 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/OneRuleFactory.java
@@ -17,26 +17,20 @@
package org.apache.doris.nereids.rules;
-/**
- * Type of rules, each rule has its unique type.
- */
-public enum RuleType {
- // binding rules
- BINDING_UNBOUND_RELATION_RULE,
-
- // rewrite rules
- COLUMN_PRUNE_PROJECTION,
-
- // exploration rules
+import org.apache.doris.nereids.trees.TreeNode;
- // implementation rules
- LOGICAL_JOIN_TO_HASH_JOIN_RULE,
+import com.google.common.collect.ImmutableList;
- // sentinel, use to count rules
- SENTINEL,
- ;
+import java.util.List;
- public int type() {
- return ordinal();
+/**
+ * abstract class for all rule factories build one rule.
+ */
+public abstract class OneRuleFactory<TYPE extends TreeNode> implements
RuleFactory<TYPE> {
+ @Override
+ public final List<Rule<TYPE>> buildRules() {
+ return ImmutableList.of(build());
}
+
+ public abstract Rule<TYPE> build();
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java
similarity index 69%
copy from fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java
index 8de67fe29d..5c97a3d794 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java
@@ -17,26 +17,10 @@
package org.apache.doris.nereids.rules;
+import org.apache.doris.nereids.trees.plans.Plan;
+
/**
- * Type of rules, each rule has its unique type.
+ * interface for all plan rule factories.
*/
-public enum RuleType {
- // binding rules
- BINDING_UNBOUND_RELATION_RULE,
-
- // rewrite rules
- COLUMN_PRUNE_PROJECTION,
-
- // exploration rules
-
- // implementation rules
- LOGICAL_JOIN_TO_HASH_JOIN_RULE,
-
- // sentinel, use to count rules
- SENTINEL,
- ;
-
- public int type() {
- return ordinal();
- }
+public interface PlanRuleFactory extends RuleFactory<Plan> {
}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/Rule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/Rule.java
index 014f5fd35f..c61004ac9a 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/Rule.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/Rule.java
@@ -20,14 +20,14 @@ package org.apache.doris.nereids.rules;
import org.apache.doris.common.AnalysisException;
import org.apache.doris.nereids.PlannerContext;
import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.trees.plans.Plan;
+import org.apache.doris.nereids.trees.TreeNode;
import java.util.List;
/**
* Abstract class for all rules.
*/
-public abstract class Rule {
+public abstract class Rule<TYPE extends TreeNode> {
private final RuleType ruleType;
private final Pattern pattern;
private final RulePromise rulePromise;
@@ -57,9 +57,9 @@ public abstract class Rule {
return pattern;
}
- public boolean check(Plan<?> plan, PlannerContext context) {
+ public boolean check(TYPE node, PlannerContext context) {
return true;
}
- public abstract List<Plan<?>> transform(Plan<?> plan, PlannerContext
context) throws AnalysisException;
+ public abstract List<TYPE> transform(TYPE node, PlannerContext context)
throws AnalysisException;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleFactory.java
similarity index 69%
copy from fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
copy to fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleFactory.java
index 8de67fe29d..dd1e991b59 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleFactory.java
@@ -17,26 +17,19 @@
package org.apache.doris.nereids.rules;
-/**
- * Type of rules, each rule has its unique type.
- */
-public enum RuleType {
- // binding rules
- BINDING_UNBOUND_RELATION_RULE,
-
- // rewrite rules
- COLUMN_PRUNE_PROJECTION,
+import org.apache.doris.nereids.pattern.Patterns;
+import org.apache.doris.nereids.trees.TreeNode;
- // exploration rules
+import java.util.List;
- // implementation rules
- LOGICAL_JOIN_TO_HASH_JOIN_RULE,
-
- // sentinel, use to count rules
- SENTINEL,
- ;
+/**
+ * interface for all rule factories for build some rules.
+ */
+public interface RuleFactory<TYPE extends TreeNode> extends Patterns {
+ // need implement
+ List<Rule<TYPE>> buildRules();
- public int type() {
- return ordinal();
- }
+ // need implement
+ @Override
+ RulePromise defaultPromise();
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleSet.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleSet.java
index 3eb4eb85d6..5d039a0cb1 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleSet.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleSet.java
@@ -17,10 +17,16 @@
package org.apache.doris.nereids.rules;
-import org.apache.doris.nereids.rules.analysis.AnalysisUnboundRelationRule;
+import org.apache.doris.nereids.rules.analysis.AnalysisUnboundRelation;
+import org.apache.doris.nereids.rules.exploration.JoinAssociativeLeftToRight;
+import org.apache.doris.nereids.rules.exploration.JoinCommutative;
+import org.apache.doris.nereids.rules.implementation.LogicalJoinToHashJoin;
+import org.apache.doris.nereids.trees.TreeNode;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.plans.Plan;
-import com.clearspring.analytics.util.Lists;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
import java.util.List;
@@ -28,15 +34,49 @@ import java.util.List;
* Containers for set of different type rules.
*/
public class RuleSet {
- public static List<Rule> ANALYSIS_RULES = ImmutableList.<Rule>builder()
- .add(new AnalysisUnboundRelationRule())
+ public static final List<Rule<Plan>> ANALYSIS_RULES = planRuleFactories()
+ .add(new AnalysisUnboundRelation())
.build();
- public List<Rule> getExplorationRules() {
- return Lists.newArrayList();
+ public static final List<Rule<Plan>> EXPLORATION_RULES =
planRuleFactories()
+ .add(new JoinCommutative())
+ .add(new JoinAssociativeLeftToRight())
+ .build();
+
+ public static final List<Rule<Plan>> IMPLEMENTATION_RULES =
planRuleFactories()
+ .add(new LogicalJoinToHashJoin())
+ .build();
+
+ public List<Rule<Plan>> getAnalysisRules() {
+ return ANALYSIS_RULES;
+ }
+
+ public List<Rule<Plan>> getExplorationRules() {
+ return EXPLORATION_RULES;
+ }
+
+ public List<Rule<Plan>> getImplementationRules() {
+ return IMPLEMENTATION_RULES;
+ }
+
+ private static RuleFactories<Plan> planRuleFactories() {
+ return new RuleFactories();
}
- public List<Rule> getImplementationRules() {
- return Lists.newArrayList();
+ private static RuleFactories<Expression> expressionRuleFactories() {
+ return new RuleFactories();
+ }
+
+ private static class RuleFactories<TYPE extends TreeNode> {
+ final Builder<Rule<TYPE>> rules = ImmutableList.builder();
+
+ public RuleFactories<TYPE> add(RuleFactory<TYPE> ruleFactory) {
+ rules.addAll(ruleFactory.buildRules());
+ return this;
+ }
+
+ public List<Rule<TYPE>> build() {
+ return rules.build();
+ }
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
index 8de67fe29d..fee8a666e2 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/RuleType.java
@@ -28,6 +28,8 @@ public enum RuleType {
COLUMN_PRUNE_PROJECTION,
// exploration rules
+ LOGICAL_JOIN_COMMUTATIVE,
+ LOGICAL_JOIN_ASSOCIATIVE_LEFT_TO_RIGHT,
// implementation rules
LOGICAL_JOIN_TO_HASH_JOIN_RULE,
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRuleFactory.java
similarity index 71%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRuleFactory.java
index c28a00ec86..0938297883 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRuleFactory.java
@@ -17,16 +17,15 @@
package org.apache.doris.nereids.rules.analysis;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.rules.PlanRuleFactory;
import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
/**
- * Abstract class for all rules used in analysis stage.
+ * interface for all rule factories used in analysis stage.
*/
-public abstract class AnalysisRule extends Rule {
- public AnalysisRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.ANALYSIS);
+public interface AnalysisRuleFactory extends PlanRuleFactory {
+ @Override
+ default RulePromise defaultPromise() {
+ return RulePromise.ANALYSIS;
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java
similarity index 56%
rename from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelationRule.java
rename to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java
index 5444196b11..557d1cc2f6 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java
@@ -20,16 +20,12 @@ package org.apache.doris.nereids.rules.analysis;
import org.apache.doris.catalog.Catalog;
import org.apache.doris.catalog.Database;
import org.apache.doris.catalog.Table;
-import org.apache.doris.common.AnalysisException;
-import org.apache.doris.nereids.PlannerContext;
-import org.apache.doris.nereids.analyzer.UnboundRelation;
-import org.apache.doris.nereids.pattern.Pattern;
+import org.apache.doris.nereids.rules.Rule;
import org.apache.doris.nereids.rules.RuleType;
-import org.apache.doris.nereids.trees.NodeType;
import org.apache.doris.nereids.trees.plans.Plan;
import org.apache.doris.nereids.trees.plans.logical.LogicalRelation;
+import org.apache.doris.qe.ConnectContext;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.util.List;
@@ -37,29 +33,27 @@ import java.util.List;
/**
* Rule to bind relations in query plan.
*/
-public class AnalysisUnboundRelationRule extends AnalysisRule {
- public AnalysisUnboundRelationRule() {
- super(RuleType.BINDING_UNBOUND_RELATION_RULE, new
Pattern(NodeType.LOGICAL_UNBOUND_RELATION));
- }
-
+public class AnalysisUnboundRelation extends OneAnalysisRuleFactory {
@Override
- public List<Plan<?>> transform(Plan<?> plan, PlannerContext context)
throws AnalysisException {
- UnboundRelation unboundRelation = (UnboundRelation) plan;
- List<String> nameParts = unboundRelation.getNameParts();
- switch (nameParts.size()) {
- case 1: {
- List<String> qualifier = Lists.newArrayList(
- context.getConnectContext().getDatabase(),
nameParts.get(0));
- Table table = getTable(qualifier,
context.getConnectContext().getCatalog());
- return ImmutableList.of(new LogicalRelation(table, qualifier));
+ public Rule<Plan> build() {
+ // fixme, just for example now
+ return unboundRelation().thenApply(ctx -> {
+ ConnectContext connectContext =
ctx.plannerContext.getConnectContext();
+ List<String> nameParts = ctx.root.getNameParts();
+ switch (nameParts.size()) {
+ case 1: {
+ List<String> qualifier =
Lists.newArrayList(connectContext.getDatabase(), nameParts.get(0));
+ Table table = getTable(qualifier,
connectContext.getCatalog());
+ return new LogicalRelation(table, qualifier);
+ }
+ case 2: {
+ Table table = getTable(nameParts,
connectContext.getCatalog());
+ return new LogicalRelation(table, nameParts);
+ }
+ default:
+ throw new IllegalStateException("Table name [" +
ctx.root.getTableName() + "] is invalid.");
}
- case 2: {
- Table table = getTable(nameParts,
context.getConnectContext().getCatalog());
- return ImmutableList.of(new LogicalRelation(table, nameParts));
- }
- default:
- throw new AnalysisException("Table name [" +
unboundRelation.getTableName() + "] is invalid.");
- }
+ }).toRule(RuleType.BINDING_UNBOUND_RELATION_RULE);
}
private Table getTable(List<String> qualifier, Catalog catalog) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/OneAnalysisRuleFactory.java
similarity index 67%
rename from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRule.java
rename to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/OneAnalysisRuleFactory.java
index c28a00ec86..595c631813 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/OneAnalysisRuleFactory.java
@@ -17,16 +17,11 @@
package org.apache.doris.nereids.rules.analysis;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.rules.OnePlanRuleFactory;
/**
- * Abstract class for all rules used in analysis stage.
+ * abstract class for all rule factories build one rule used in analysis stage.
*/
-public abstract class AnalysisRule extends Rule {
- public AnalysisRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.ANALYSIS);
- }
+public abstract class OneAnalysisRuleFactory
+ extends OnePlanRuleFactory implements AnalysisRuleFactory {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRuleFactory.java
similarity index 71%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRuleFactory.java
index 4f47d12f47..4e449a5146 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRuleFactory.java
@@ -17,16 +17,15 @@
package org.apache.doris.nereids.rules.exploration;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.rules.PlanRuleFactory;
import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
/**
- * Abstract class for all exploration rules.
+ * interface for all exploration rule factories.
*/
-public abstract class ExplorationRule extends Rule {
- public ExplorationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.EXPLORE);
+public interface ExplorationRuleFactory extends PlanRuleFactory {
+ @Override
+ default RulePromise defaultPromise() {
+ return RulePromise.EXPLORE;
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinAssociativeLeftToRight.java
similarity index 50%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinAssociativeLeftToRight.java
index 4f47d12f47..07085b5865 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinAssociativeLeftToRight.java
@@ -17,16 +17,31 @@
package org.apache.doris.nereids.rules.exploration;
-import org.apache.doris.nereids.pattern.Pattern;
import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.trees.plans.JoinType;
+import org.apache.doris.nereids.trees.plans.Plan;
+import org.apache.doris.nereids.trees.plans.logical.LogicalJoin;
/**
- * Abstract class for all exploration rules.
+ * Rule factory for change inner join left associative to right.
*/
-public abstract class ExplorationRule extends Rule {
- public ExplorationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.EXPLORE);
+public class JoinAssociativeLeftToRight extends OneExplorationRuleFactory {
+ @Override
+ public Rule<Plan> build() {
+ return innerLogicalJoin(innerLogicalJoin(), any()).then(root -> {
+ // fixme, just for example now
+ return new LogicalJoin(
+ JoinType.INNER_JOIN,
+ root.getOnClause(),
+ root.left().left(),
+ new LogicalJoin(
+ JoinType.INNER_JOIN,
+ root.getOnClause(),
+ root.left().right(),
+ root.right()
+ )
+ );
+ }).toRule(RuleType.LOGICAL_JOIN_ASSOCIATIVE_LEFT_TO_RIGHT);
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinCommutative.java
similarity index 59%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinCommutative.java
index 4f47d12f47..4f582487f9 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinCommutative.java
@@ -17,16 +17,26 @@
package org.apache.doris.nereids.rules.exploration;
-import org.apache.doris.nereids.pattern.Pattern;
import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.trees.plans.JoinType;
+import org.apache.doris.nereids.trees.plans.Plan;
+import org.apache.doris.nereids.trees.plans.logical.LogicalJoin;
/**
- * Abstract class for all exploration rules.
+ * rule factory for exchange inner join's children.
*/
-public abstract class ExplorationRule extends Rule {
- public ExplorationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.EXPLORE);
+public class JoinCommutative extends OneExplorationRuleFactory {
+ @Override
+ public Rule<Plan> build() {
+ return innerLogicalJoin().then(join -> {
+ // fixme, just for example now
+ return new LogicalJoin(
+ JoinType.INNER_JOIN,
+ join.getOnClause(),
+ join.right(),
+ join.left()
+ );
+ }).toRule(RuleType.LOGICAL_JOIN_COMMUTATIVE);
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/OneExplorationRuleFactory.java
similarity index 67%
rename from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
rename to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/OneExplorationRuleFactory.java
index 4f47d12f47..a25dfe0e1d 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/ExplorationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/OneExplorationRuleFactory.java
@@ -17,16 +17,11 @@
package org.apache.doris.nereids.rules.exploration;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.rules.OnePlanRuleFactory;
/**
- * Abstract class for all exploration rules.
+ * abstract class for all rule factories build one rule used in exploration
stage.
*/
-public abstract class ExplorationRule extends Rule {
- public ExplorationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.EXPLORE);
- }
+public abstract class OneExplorationRuleFactory
+ extends OnePlanRuleFactory implements ExplorationRuleFactory {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRuleFactory.java
similarity index 71%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRuleFactory.java
index a1de729789..79246fdc34 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRuleFactory.java
@@ -17,17 +17,16 @@
package org.apache.doris.nereids.rules.expression;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.rules.RuleFactory;
import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.trees.expressions.Expression;
/**
- * Abstract class for all expression rules.
+ * interface for all expression rule factories.
*/
-public abstract class ExpressionRule extends Rule {
- public ExpressionRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.EXPRESSION);
+public interface ExpressionRuleFactory extends RuleFactory<Expression> {
+ @Override
+ default RulePromise defaultPromise() {
+ return RulePromise.EXPRESSION;
}
-
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/OneExpressionRuleFactory.java
similarity index 67%
rename from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRule.java
rename to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/OneExpressionRuleFactory.java
index a1de729789..86ca045617 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/ExpressionRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/expression/OneExpressionRuleFactory.java
@@ -17,17 +17,12 @@
package org.apache.doris.nereids.rules.expression;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.rules.OneRuleFactory;
+import org.apache.doris.nereids.trees.expressions.Expression;
/**
- * Abstract class for all expression rules.
+ * abstract class for all rule factories build one rule used for expressions.
*/
-public abstract class ExpressionRule extends Rule {
- public ExpressionRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.EXPRESSION);
- }
-
+public abstract class OneExpressionRuleFactory
+ extends OneRuleFactory<Expression> implements ExpressionRuleFactory {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRuleFactory.java
similarity index 71%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRuleFactory.java
index 3b31f4a792..ae15eed50e 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRuleFactory.java
@@ -17,16 +17,15 @@
package org.apache.doris.nereids.rules.implementation;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.rules.PlanRuleFactory;
import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
/**
- * Abstract class for all implementation rules.
+ * interface for all implementation rule factories.
*/
-public abstract class ImplementationRule extends Rule {
- public ImplementationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.IMPLEMENT);
+public interface ImplementationRuleFactory extends PlanRuleFactory {
+ @Override
+ default RulePromise defaultPromise() {
+ return RulePromise.IMPLEMENT;
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java
similarity index 61%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java
index 3b31f4a792..062191be38 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java
@@ -17,16 +17,24 @@
package org.apache.doris.nereids.rules.implementation;
-import org.apache.doris.nereids.pattern.Pattern;
import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.trees.plans.Plan;
+import org.apache.doris.nereids.trees.plans.physical.PhysicalBroadcastHashJoin;
+
/**
- * Abstract class for all implementation rules.
+ * Implementation rule that convert logical join to physical hash join.
*/
-public abstract class ImplementationRule extends Rule {
- public ImplementationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.IMPLEMENT);
+public class LogicalJoinToHashJoin extends OneImplementationRuleFactory {
+ @Override
+ public Rule<Plan> build() {
+ // fixme, just for example now
+ return logicalJoin().then(join -> new PhysicalBroadcastHashJoin(
+ join.getJoinType(),
+ join.left(),
+ join.right(),
+ join.getOnClause()
+ )).toRule(RuleType.LOGICAL_JOIN_TO_HASH_JOIN_RULE);
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoinRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoinRule.java
deleted file mode 100644
index 9f93ee267c..0000000000
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoinRule.java
+++ /dev/null
@@ -1,53 +0,0 @@
-// 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.rules.implementation;
-
-import com.google.common.collect.ImmutableList;
-import org.apache.doris.nereids.PlannerContext;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.RuleType;
-import org.apache.doris.nereids.trees.NodeType;
-import org.apache.doris.nereids.trees.plans.Plan;
-
-import java.util.List;
-
-/**
- * Implementation rule that convert logical join to physical hash join.
- */
-public class LogicalJoinToHashJoinRule extends ImplementationRule {
- /**
- * Constructor for LogicalJoinToHashJoinRule.
- */
- public LogicalJoinToHashJoinRule() {
- super(RuleType.LOGICAL_JOIN_TO_HASH_JOIN_RULE,
- new Pattern(NodeType.LOGICAL_JOIN,
- Pattern.PATTERN_LEAF_INSTANCE,
- Pattern.PATTERN_LEAF_INSTANCE));
- }
-
- @Override
- public List<Plan<?>> transform(Plan<?> plan, PlannerContext context) {
- // LogicalJoin originPlan = (LogicalJoin) plan;
- // PhysicalBroadcastHashJoin physicalBroadcastHashJoin = new
PhysicalBroadcastHashJoin(
- // originPlan.getJoinType(),
- // originPlan.getOnClause(),
- // );
- // return Lists.newArrayList(physicalBroadcastHashJoin);
- return ImmutableList.of();
- }
-}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/OneImplementationRuleFactory.java
similarity index 67%
rename from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
rename to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/OneImplementationRuleFactory.java
index 3b31f4a792..80b57bfc41 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/ImplementationRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/OneImplementationRuleFactory.java
@@ -17,16 +17,11 @@
package org.apache.doris.nereids.rules.implementation;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.rules.OnePlanRuleFactory;
/**
- * Abstract class for all implementation rules.
+ * abstract class for all rule factories build one rule used in implementation
stage.
*/
-public abstract class ImplementationRule extends Rule {
- public ImplementationRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.IMPLEMENT);
- }
+public abstract class OneImplementationRuleFactory
+ extends OnePlanRuleFactory implements ImplementationRuleFactory {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/OneRewriteRuleFactory.java
similarity index 68%
copy from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRule.java
copy to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/OneRewriteRuleFactory.java
index 0106a22971..5ba245cf7f 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/OneRewriteRuleFactory.java
@@ -17,16 +17,11 @@
package org.apache.doris.nereids.rules.rewrite;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
-import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
+import org.apache.doris.nereids.rules.OnePlanRuleFactory;
/**
- * Abstract class for all rewrite rules.
+ * abstract class for all rule factories build one rule used in rewrite stage.
*/
-public abstract class RewriteRule extends Rule {
- public RewriteRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.REWRITE);
- }
+public abstract class OneRewriteRuleFactory
+ extends OnePlanRuleFactory implements RewriteRuleFactory {
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRule.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRuleFactory.java
similarity index 72%
rename from
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRule.java
rename to
fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRuleFactory.java
index 0106a22971..03c220f03b 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRule.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/rewrite/RewriteRuleFactory.java
@@ -17,16 +17,15 @@
package org.apache.doris.nereids.rules.rewrite;
-import org.apache.doris.nereids.pattern.Pattern;
-import org.apache.doris.nereids.rules.Rule;
+import org.apache.doris.nereids.rules.PlanRuleFactory;
import org.apache.doris.nereids.rules.RulePromise;
-import org.apache.doris.nereids.rules.RuleType;
/**
- * Abstract class for all rewrite rules.
+ * interface for all rewrite rule factories.
*/
-public abstract class RewriteRule extends Rule {
- public RewriteRule(RuleType ruleType, Pattern pattern) {
- super(ruleType, pattern, RulePromise.REWRITE);
+public interface RewriteRuleFactory extends PlanRuleFactory {
+ @Override
+ default RulePromise defaultPromise() {
+ return RulePromise.REWRITE;
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/AbstractTreeNode.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/AbstractTreeNode.java
index 5236742398..ca54dc36b4 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/AbstractTreeNode.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/AbstractTreeNode.java
@@ -45,12 +45,17 @@ public abstract class AbstractTreeNode<NODE_TYPE extends
AbstractTreeNode<NODE_T
}
@Override
- public <CHILD_TYPE extends TreeNode<CHILD_TYPE>> List<CHILD_TYPE>
children() {
+ public NodeType getType() {
+ return type;
+ }
+
+ @Override
+ public <CHILD_TYPE extends TreeNode> List<CHILD_TYPE> children() {
return (List) children;
}
@Override
- public <CHILD_TYPE extends TreeNode<CHILD_TYPE>> CHILD_TYPE child(int
index) {
+ public <CHILD_TYPE extends TreeNode> CHILD_TYPE child(int index) {
return (CHILD_TYPE) children.get(index);
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/BinaryNode.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/BinaryNode.java
index 4f8fdc592d..920a3cc8fd 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/BinaryNode.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/BinaryNode.java
@@ -22,8 +22,8 @@ package org.apache.doris.nereids.trees;
*/
public interface BinaryNode<
NODE_TYPE extends BinaryNode<NODE_TYPE, LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
- LEFT_CHILD_TYPE extends TreeNode<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends TreeNode<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends TreeNode,
+ RIGHT_CHILD_TYPE extends TreeNode>
extends TreeNode<NODE_TYPE> {
default LEFT_CHILD_TYPE left() {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/NodeType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/NodeType.java
index ee6ca56f0e..71a9830415 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/NodeType.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/NodeType.java
@@ -48,6 +48,6 @@ public enum NodeType {
// pattern
PATTERN,
- PATTERN_LEAF,
- PATTERN_MULTI_LEAF,
+ ANY,
+ MULTI,
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/TreeNode.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/TreeNode.java
index d3d0fd7acf..7d678ed754 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/TreeNode.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/TreeNode.java
@@ -27,9 +27,11 @@ import java.util.List;
*/
public interface TreeNode<NODE_TYPE extends TreeNode<NODE_TYPE>> {
- <CHILD_TYPE extends TreeNode<CHILD_TYPE>> List<CHILD_TYPE> children();
+ NodeType getType();
- <CHILD_TYPE extends TreeNode<CHILD_TYPE>> CHILD_TYPE child(int index);
+ <CHILD_TYPE extends TreeNode> List<CHILD_TYPE> children();
+
+ <CHILD_TYPE extends TreeNode> CHILD_TYPE child(int index);
int arity();
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
index d7d2efb459..1aed540e60 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/UnaryNode.java
@@ -22,7 +22,7 @@ package org.apache.doris.nereids.trees;
*/
public interface UnaryNode<
NODE_TYPE extends UnaryNode<NODE_TYPE, CHILD_TYPE>,
- CHILD_TYPE extends TreeNode<CHILD_TYPE>>
+ CHILD_TYPE extends TreeNode>
extends TreeNode<NODE_TYPE> {
default CHILD_TYPE child() {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
index 68fab2561f..c688df8915 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
@@ -27,7 +27,7 @@ import java.util.List;
/**
* Expression for alias, such as col1 as c1.
*/
-public class Alias<CHILD_TYPE extends Expression<CHILD_TYPE>>
+public class Alias<CHILD_TYPE extends Expression>
extends UnaryExpression<Alias<CHILD_TYPE>, CHILD_TYPE>
implements NamedExpression<Alias<CHILD_TYPE>> {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryExpression.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryExpression.java
index e22f344279..7cac178f55 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryExpression.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryExpression.java
@@ -25,12 +25,22 @@ import org.apache.doris.nereids.trees.NodeType;
*/
public abstract class BinaryExpression<
EXPR_TYPE extends BinaryExpression<EXPR_TYPE, LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
- LEFT_CHILD_TYPE extends Expression<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Expression<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Expression,
+ RIGHT_CHILD_TYPE extends Expression>
extends AbstractExpression<EXPR_TYPE>
implements BinaryNode<EXPR_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
public BinaryExpression(NodeType type, LEFT_CHILD_TYPE left,
RIGHT_CHILD_TYPE right) {
super(type, left, right);
}
+
+ @Override
+ public LEFT_CHILD_TYPE left() {
+ return BinaryNode.super.left();
+ }
+
+ @Override
+ public RIGHT_CHILD_TYPE right() {
+ return BinaryNode.super.right();
+ }
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryPredicate.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryPredicate.java
index b036496a55..f962732627 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryPredicate.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryPredicate.java
@@ -27,8 +27,8 @@ import org.apache.doris.nereids.types.DataType;
* Binary predicate expression.
*/
public class BinaryPredicate<
- LEFT_CHILD_TYPE extends Expression<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Expression<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Expression,
+ RIGHT_CHILD_TYPE extends Expression>
extends BinaryExpression<BinaryPredicate<LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryExpression.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryExpression.java
index dcec019145..7729720d42 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryExpression.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryExpression.java
@@ -25,7 +25,7 @@ import org.apache.doris.nereids.trees.UnaryNode;
*/
public abstract class UnaryExpression<
EXPR_TYPE extends UnaryExpression<EXPR_TYPE, CHILD_TYPE>,
- CHILD_TYPE extends Expression<CHILD_TYPE>>
+ CHILD_TYPE extends Expression>
extends AbstractExpression<EXPR_TYPE>
implements UnaryNode<EXPR_TYPE, CHILD_TYPE> {
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 501edb6f69..a16ff1b4f6 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
@@ -44,11 +44,6 @@ public abstract class AbstractPlan<PLAN_TYPE extends
AbstractPlan<PLAN_TYPE>>
super(type, children);
}
- @Override
- public NodeType getType() {
- return type;
- }
-
@Override
public abstract List<Slot> getOutput() throws UnboundException;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/BinaryPlan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/BinaryPlan.java
index 9bd1df54b2..180069bd13 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/BinaryPlan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/BinaryPlan.java
@@ -26,8 +26,8 @@ import java.util.List;
*/
public interface BinaryPlan<
PLAN_TYPE extends BinaryPlan<PLAN_TYPE, LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
- LEFT_CHILD_TYPE extends Plan<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Plan<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Plan,
+ RIGHT_CHILD_TYPE extends Plan>
extends Plan<PLAN_TYPE>, BinaryNode<PLAN_TYPE, LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE> {
@Override
@@ -35,4 +35,14 @@ public interface BinaryPlan<
@Override
Plan child(int index);
+
+ @Override
+ default LEFT_CHILD_TYPE left() {
+ return BinaryNode.super.left();
+ }
+
+ @Override
+ default RIGHT_CHILD_TYPE right() {
+ return BinaryNode.super.right();
+ }
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
index 1f07641152..92a98a13fc 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plan.java
@@ -19,7 +19,6 @@ package org.apache.doris.nereids.trees.plans;
import org.apache.doris.nereids.exceptions.UnboundException;
import org.apache.doris.nereids.memo.PlanReference;
-import org.apache.doris.nereids.trees.NodeType;
import org.apache.doris.nereids.trees.TreeNode;
import org.apache.doris.nereids.trees.expressions.Slot;
@@ -29,7 +28,6 @@ import java.util.List;
* Abstract class for all plan node.
*/
public interface Plan<PLAN_TYPE extends Plan<PLAN_TYPE>> extends
TreeNode<PLAN_TYPE> {
- NodeType getType();
List<Slot> getOutput() throws UnboundException;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/UnaryPlan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/UnaryPlan.java
index 4ed3c73b75..595205017d 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/UnaryPlan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/UnaryPlan.java
@@ -26,7 +26,7 @@ import java.util.List;
*/
public interface UnaryPlan<
PLAN_TYPE extends UnaryPlan<PLAN_TYPE, CHILD_TYPE>,
- CHILD_TYPE extends Plan<CHILD_TYPE>>
+ CHILD_TYPE extends Plan>
extends Plan<PLAN_TYPE>, UnaryNode<PLAN_TYPE, CHILD_TYPE> {
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBinary.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBinary.java
index 1b3b34ab8d..de7dab4629 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBinary.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalBinary.java
@@ -26,8 +26,8 @@ import org.apache.doris.nereids.trees.plans.Plan;
*/
public abstract class LogicalBinary<
PLAN_TYPE extends LogicalBinary<PLAN_TYPE, LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
- LEFT_CHILD_TYPE extends Plan<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Plan<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Plan,
+ RIGHT_CHILD_TYPE extends Plan>
extends AbstractLogicalPlan<PLAN_TYPE>
implements BinaryPlan<PLAN_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
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 8c8e2739a9..a4f48cf83e 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
@@ -28,7 +28,7 @@ import java.util.List;
/**
* Logical filter plan node.
*/
-public class LogicalFilter<CHILD_TYPE extends Plan<CHILD_TYPE>>
+public class LogicalFilter<CHILD_TYPE extends Plan>
extends LogicalUnary<LogicalFilter<CHILD_TYPE>, CHILD_TYPE> {
private final Expression predicates;
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 c1473dcbfd..04b23ea76f 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
@@ -33,8 +33,8 @@ import java.util.List;
* Logical join plan node.
*/
public class LogicalJoin<
- LEFT_CHILD_TYPE extends Plan<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Plan<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Plan,
+ RIGHT_CHILD_TYPE extends Plan>
extends LogicalBinary<LogicalJoin<LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE>,
LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
private final JoinType joinType;
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 5417f17861..c706c1301e 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
@@ -31,7 +31,7 @@ import java.util.List;
/**
* Logical project plan node.
*/
-public class LogicalProject<CHILD_TYPE extends Plan<CHILD_TYPE>>
+public class LogicalProject<CHILD_TYPE extends Plan>
extends LogicalUnary<LogicalProject<CHILD_TYPE>, CHILD_TYPE> {
private final List<? extends NamedExpression> projects;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnary.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnary.java
index bf51bc53bb..a2e002dde6 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnary.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalUnary.java
@@ -26,7 +26,7 @@ import org.apache.doris.nereids.trees.plans.UnaryPlan;
*/
public abstract class LogicalUnary<
PLAN_TYPE extends LogicalUnary<PLAN_TYPE, CHILD_TYPE>,
- CHILD_TYPE extends Plan<CHILD_TYPE>>
+ CHILD_TYPE extends Plan>
extends AbstractLogicalPlan<PLAN_TYPE>
implements UnaryPlan<PLAN_TYPE, CHILD_TYPE> {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBinary.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBinary.java
index da4967176a..5c7b468a85 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBinary.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBinary.java
@@ -26,8 +26,8 @@ import org.apache.doris.nereids.trees.plans.Plan;
*/
public abstract class PhysicalBinary<
PLAN_TYPE extends PhysicalBinary<PLAN_TYPE, LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
- LEFT_CHILD_TYPE extends Plan<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Plan<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Plan,
+ RIGHT_CHILD_TYPE extends Plan>
extends AbstractPhysicalPlan<PLAN_TYPE>
implements BinaryPlan<PLAN_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBroadcastHashJoin.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBroadcastHashJoin.java
index 347725623b..48c6be6ab4 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBroadcastHashJoin.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBroadcastHashJoin.java
@@ -30,8 +30,8 @@ import java.util.Optional;
* Physical node represents broadcast hash join.
*/
public class PhysicalBroadcastHashJoin<
- LEFT_CHILD_TYPE extends Plan<LEFT_CHILD_TYPE>,
- RIGHT_CHILD_TYPE extends Plan<RIGHT_CHILD_TYPE>>
+ LEFT_CHILD_TYPE extends Plan,
+ RIGHT_CHILD_TYPE extends Plan>
extends PhysicalBinary<PhysicalBroadcastHashJoin<LEFT_CHILD_TYPE,
RIGHT_CHILD_TYPE>,
LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
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 aa47c633e5..e7f8170ba3 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,7 +24,7 @@ import org.apache.doris.nereids.trees.plans.Plan;
/**
* Physical filter plan node.
*/
-public class PhysicalFilter<CHILD_TYPE extends Plan<CHILD_TYPE>>
+public class PhysicalFilter<CHILD_TYPE extends Plan>
extends PhysicalUnary<PhysicalFilter<CHILD_TYPE>, CHILD_TYPE> {
private final Expression predicates;
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 4e8733cd4b..2bd995acce 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
@@ -28,7 +28,7 @@ import java.util.List;
/**
* Physical project plan node.
*/
-public class PhysicalProject<CHILD_TYPE extends Plan<CHILD_TYPE>>
+public class PhysicalProject<CHILD_TYPE extends Plan>
extends PhysicalUnary<PhysicalProject<CHILD_TYPE>, CHILD_TYPE> {
private final List<? extends NamedExpression> projects;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnary.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnary.java
index 03305653ab..776d55702a 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnary.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalUnary.java
@@ -26,7 +26,7 @@ import org.apache.doris.nereids.trees.plans.UnaryPlan;
*/
public abstract class PhysicalUnary<
PLAN_TYPE extends PhysicalUnary<PLAN_TYPE, CHILD_TYPE>,
- CHILD_TYPE extends Plan<CHILD_TYPE>>
+ CHILD_TYPE extends Plan>
extends AbstractPhysicalPlan<PLAN_TYPE>
implements UnaryPlan<PLAN_TYPE, CHILD_TYPE> {
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
