diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundRelation.java index 57cce5345f..ca69806022 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundRelation.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundRelation.java @@ -19,9 +19,9 @@ package org.apache.doris.nereids.analyzer; import org.apache.doris.nereids.analyzer.identifier.TableIdentifier; import org.apache.doris.nereids.exceptions.UnboundException; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.logical.LogicalLeafOperator; import org.apache.doris.nereids.trees.expressions.Slot; -import org.apache.doris.nereids.trees.plans.logical.LogicalLeaf; import org.apache.doris.nereids.util.Utils; import com.clearspring.analytics.util.Lists; @@ -32,11 +32,11 @@ import java.util.List; /** * Represent a relation plan node that has not been bound. */ -public class UnboundRelation extends LogicalLeaf { +public class UnboundRelation extends LogicalLeafOperator { private final List nameParts; public UnboundRelation(List nameParts) { - super(NodeType.LOGICAL_UNBOUND_RELATION); + super(OperatorType.LOGICAL_UNBOUND_RELATION); this.nameParts = nameParts; } @@ -46,7 +46,7 @@ public class UnboundRelation extends LogicalLeaf { * @param identifier relation identifier */ public UnboundRelation(TableIdentifier identifier) { - super(NodeType.LOGICAL_UNBOUND_RELATION); + super(OperatorType.LOGICAL_UNBOUND_RELATION); this.nameParts = Lists.newArrayList(); if (identifier.getDatabaseName().isPresent()) { nameParts.add(identifier.getDatabaseName().get()); @@ -64,8 +64,9 @@ public class UnboundRelation extends LogicalLeaf { } @Override - public List getOutput() throws UnboundException { - throw new UnboundException("output"); + public List doComputeOutput() { + // fixme: throw unchecked exception + throw new IllegalStateException(new UnboundException("output")); } @Override 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 75ba54a907..8b3ce263d7 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 @@ -59,7 +59,7 @@ public class ApplyRuleJob extends Job { // TODO: need to find all plan reference tree that match this pattern PatternMatching patternMatching = new PatternMatching(); - for (Plan plan : patternMatching) { + for (Plan plan : patternMatching) { if (!rule.check(plan, context)) { continue; } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Group.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Group.java index b12751567a..754772105d 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Group.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Group.java @@ -18,7 +18,6 @@ package org.apache.doris.nereids.memo; import org.apache.doris.common.Pair; -import org.apache.doris.nereids.exceptions.UnboundException; import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.properties.PhysicalProperties; import org.apache.doris.nereids.trees.plans.logical.LogicalPlan; @@ -55,12 +54,7 @@ public class Group { } else { this.physicalPlanList.add(groupExpression); } - logicalProperties = new LogicalProperties(); - try { - logicalProperties.setOutput(groupExpression.getPlan().getOutput()); - } catch (UnboundException e) { - throw new RuntimeException(e); - } + logicalProperties = groupExpression.getParent().getLogicalProperties(); groupExpression.setParent(this); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/GroupExpression.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/GroupExpression.java index dd30aec39a..85e7069e5a 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/GroupExpression.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/GroupExpression.java @@ -32,11 +32,11 @@ import java.util.List; public class GroupExpression { private Group parent; private List children; - private final Plan plan; + private final Plan plan; private final BitSet ruleMasks; private boolean statDerived; - public GroupExpression(Plan plan) { + public GroupExpression(Plan plan) { this(plan, Lists.newArrayList()); } @@ -46,7 +46,7 @@ public class GroupExpression { * @param plan {@link Plan} to reference * @param children children groups in memo */ - public GroupExpression(Plan plan, List children) { + public GroupExpression(Plan plan, List children) { this.plan = plan; this.children = children; this.ruleMasks = new BitSet(RuleType.SENTINEL.ordinal()); @@ -65,7 +65,7 @@ public class GroupExpression { this.parent = parent; } - public Plan getPlan() { + public Plan getPlan() { return plan; } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Memo.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Memo.java index 0741f7f439..2a22d8732a 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Memo.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/memo/Memo.java @@ -50,9 +50,9 @@ public class Memo { * @return Reference of plan in Memo */ // TODO: need to merge PlanRefSet if new PlanRef is same with some one already in memo - public GroupExpression newGroupExpression(Plan plan, Group target) { + public GroupExpression newGroupExpression(Plan plan, Group target) { List childGroupExpr = Lists.newArrayList(); - for (Plan childrenPlan : plan.children()) { + for (Plan childrenPlan : plan.children()) { childGroupExpr.add(newGroupExpression(childrenPlan, null)); } GroupExpression newGroupExpression = new GroupExpression(plan); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/AbstractOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/AbstractOperator.java new file mode 100644 index 0000000000..54064a6f2f --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/AbstractOperator.java @@ -0,0 +1,36 @@ +// 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.operators; + +import java.util.Objects; + +/** + * Abstract class for all concrete operator. + */ +public abstract class AbstractOperator> implements Operator { + protected final OperatorType type; + + public AbstractOperator(OperatorType type) { + this.type = Objects.requireNonNull(type, "type can not be null"); + } + + @Override + public OperatorType getType() { + return type; + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/Operator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/Operator.java new file mode 100644 index 0000000000..eb9d1bda63 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/Operator.java @@ -0,0 +1,25 @@ +// 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.operators; + +/** + * interface for all concrete operator. + */ +public interface Operator> { + OperatorType getType(); +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/OperatorType.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/OperatorType.java new file mode 100644 index 0000000000..6ba4ee6d13 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/OperatorType.java @@ -0,0 +1,40 @@ +// 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.operators; + +/** + * Types for all Operator in Nereids, include PlanOperator and Pattern placeholder type. + */ +public enum OperatorType { + // logical plan + LOGICAL_UNBOUND_RELATION, + LOGICAL_BOUND_RELATION, + LOGICAL_PROJECT, + LOGICAL_FILTER, + LOGICAL_JOIN, + + // physical plan + PHYSICAL_OLAP_SCAN, + PHYSICAL_PROJECT, + PHYSICAL_FILTER, + PHYSICAL_BROADCAST_HASH_JOIN, + + // pattern + ANY, + MULTI, +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/BinaryPlanOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/BinaryPlanOperator.java new file mode 100644 index 0000000000..aa46862efc --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/BinaryPlanOperator.java @@ -0,0 +1,29 @@ +// 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.operators.plans; + +import org.apache.doris.nereids.trees.plans.Plan; + +/** + * interface for all concrete binary plan operator. + */ +public interface BinaryPlanOperator< + TYPE extends BinaryPlanOperator, + LEFT_INPUT_TYPE extends Plan, + RIGHT_INPUT_TYPE extends Plan> extends PlanOperator { +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/JoinType.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/JoinType.java similarity index 98% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/JoinType.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/JoinType.java index ab75a50600..f22634d649 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/JoinType.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/JoinType.java @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans; +package org.apache.doris.nereids.operators.plans; import org.apache.doris.analysis.JoinOperator; import org.apache.doris.common.AnalysisException; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/LeafPlanOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/LeafPlanOperator.java new file mode 100644 index 0000000000..3fc89d8d26 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/LeafPlanOperator.java @@ -0,0 +1,24 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.operators.plans; + +/** + * interface for all concrete leaf plan operator. + */ +public interface LeafPlanOperator> extends PlanOperator { +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/PlanOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/PlanOperator.java new file mode 100644 index 0000000000..43adb3a4bf --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/PlanOperator.java @@ -0,0 +1,26 @@ +// 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.operators.plans; + +import org.apache.doris.nereids.operators.Operator; + +/** + * interface for all concrete plan operator. + */ +public interface PlanOperator> extends Operator { +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/UnaryPlanOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/UnaryPlanOperator.java new file mode 100644 index 0000000000..8dfa3f19c4 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/UnaryPlanOperator.java @@ -0,0 +1,28 @@ +// 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.operators.plans; + +import org.apache.doris.nereids.trees.plans.Plan; + +/** + * interface for all concrete unary plan operator. + */ +public interface UnaryPlanOperator< + TYPE extends UnaryPlanOperator, + INPUT_TYPE extends Plan> extends PlanOperator { +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalBinaryOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalBinaryOperator.java new file mode 100644 index 0000000000..e04db83982 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalBinaryOperator.java @@ -0,0 +1,48 @@ +// 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.operators.plans.logical; + +import org.apache.doris.nereids.operators.AbstractOperator; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.BinaryPlanOperator; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * Abstract class for all logical binary operator that have two inputs. + */ +public abstract class LogicalBinaryOperator< + TYPE extends LogicalBinaryOperator, + LEFT_INPUT_TYPE extends Plan, + RIGHT_INPUT_TYPE extends Plan> + extends AbstractOperator + implements LogicalOperator, BinaryPlanOperator { + + public LogicalBinaryOperator(OperatorType type) { + super(type); + } + + @Override + public final List computeOutput(Plan... inputs) { + return doComputeOutput((LEFT_INPUT_TYPE) inputs[0], (RIGHT_INPUT_TYPE) inputs[1]); + } + + public abstract List doComputeOutput(LEFT_INPUT_TYPE left, RIGHT_INPUT_TYPE right); +} 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/operators/plans/logical/LogicalFilter.java similarity index 70% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalFilter.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalFilter.java index a4f48cf83e..4d5ffd6862 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/operators/plans/logical/LogicalFilter.java @@ -15,36 +15,37 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.logical; +package org.apache.doris.nereids.operators.plans.logical; -import org.apache.doris.nereids.exceptions.UnboundException; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import org.apache.doris.nereids.trees.expressions.Expression; import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.Plan; import java.util.List; +import java.util.Objects; /** - * Logical filter plan node. + * Logical filter plan operator. */ -public class LogicalFilter - extends LogicalUnary, CHILD_TYPE> { +public class LogicalFilter + extends LogicalUnaryOperator, INPUT_TYPE> { private final Expression predicates; - public LogicalFilter(Expression predicates, CHILD_TYPE child) { - super(NodeType.LOGICAL_FILTER, child); - this.predicates = predicates; + public LogicalFilter(Expression predicates) { + super(OperatorType.LOGICAL_FILTER); + this.predicates = Objects.requireNonNull(predicates, "predicates can not be null"); } public Expression getPredicates() { return predicates; } + @Override - public List getOutput() throws UnboundException { - return output; + public List doComputeOutput(INPUT_TYPE input) { + return input.getOutput(); } @Override 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/operators/plans/logical/LogicalJoin.java similarity index 51% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalJoin.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalJoin.java index fd4783c3ca..2ecdbafb4c 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/operators/plans/logical/LogicalJoin.java @@ -15,30 +15,30 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.logical; +package org.apache.doris.nereids.operators.plans.logical; -import org.apache.doris.nereids.exceptions.UnboundException; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.JoinType; +import org.apache.doris.nereids.rules.exploration.JoinReorderContext; import org.apache.doris.nereids.trees.expressions.Expression; import org.apache.doris.nereids.trees.expressions.Slot; -import org.apache.doris.nereids.trees.plans.JoinType; import org.apache.doris.nereids.trees.plans.Plan; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.lang3.StringUtils; +import com.google.common.collect.ImmutableList; import java.util.List; +import java.util.Objects; +import java.util.Optional; /** - * Logical join plan node. + * Logical join plan operator. */ -public class LogicalJoin< - LEFT_CHILD_TYPE extends Plan, - RIGHT_CHILD_TYPE extends Plan> - extends LogicalBinary, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> { +public class LogicalJoin + extends LogicalBinaryOperator, + LEFT_INPUT_TYPE, RIGHT_INPUT_TYPE> { private final JoinType joinType; - private final Expression onClause; + private final Optional onClause; // Use for top-to-down join reorder private final JoinReorderContext joinReorderContext = new JoinReorderContext(); @@ -47,17 +47,24 @@ public class LogicalJoin< * Constructor for LogicalJoinPlan. * * @param joinType logical type for join - * @param onClause on clause for join node - * @param left left child of join node - * @param right right child of join node */ - public LogicalJoin(JoinType joinType, Expression onClause, LEFT_CHILD_TYPE left, RIGHT_CHILD_TYPE right) { - super(NodeType.LOGICAL_JOIN, left, right); - this.joinType = joinType; - this.onClause = onClause; + public LogicalJoin(JoinType joinType) { + this(joinType, Optional.empty()); } - public Expression getOnClause() { + /** + * Constructor for LogicalJoinPlan. + * + * @param joinType logical type for join + * @param onClause on clause for join node + */ + public LogicalJoin(JoinType joinType, Optional onClause) { + super(OperatorType.LOGICAL_JOIN); + this.joinType = Objects.requireNonNull(joinType, "joinType can not be null"); + this.onClause = Objects.requireNonNull(onClause, "onClause can not be null"); + } + + public Optional getOnClause() { return onClause; } @@ -66,22 +73,18 @@ public class LogicalJoin< } @Override - public List getOutput() throws UnboundException { - if (CollectionUtils.isEmpty(output)) { - switch (joinType) { - case LEFT_SEMI_JOIN: - output.addAll(left().getOutput()); - break; - case RIGHT_SEMI_JOIN: - output.addAll(right().getOutput()); - break; - default: - output.addAll(left().getOutput()); - output.addAll(right().getOutput()); - break; - } + public List doComputeOutput(LEFT_INPUT_TYPE leftInput, RIGHT_INPUT_TYPE rightInput) { + switch (joinType) { + case LEFT_SEMI_JOIN: + return ImmutableList.copyOf(leftInput.getOutput()); + case RIGHT_SEMI_JOIN: + return ImmutableList.copyOf(rightInput.getOutput()); + default: + return ImmutableList.builder() + .addAll(leftInput.getOutput()) + .addAll(rightInput.getOutput()) + .build(); } - return output; } @Override @@ -90,9 +93,6 @@ public class LogicalJoin< if (onClause != null) { sb.append(", ").append(onClause); } - if (CollectionUtils.isNotEmpty(output)) { - sb.append(", output: ").append(StringUtils.join(output, ", ")); - } return sb.append(")").toString(); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalLeafOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalLeafOperator.java new file mode 100644 index 0000000000..5c856d5e34 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalLeafOperator.java @@ -0,0 +1,45 @@ +// 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.operators.plans.logical; + +import org.apache.doris.nereids.operators.AbstractOperator; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.LeafPlanOperator; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * Abstract class for all logical operator that have no input. + */ +public abstract class LogicalLeafOperator> + extends AbstractOperator + implements LogicalOperator, LeafPlanOperator { + + public LogicalLeafOperator(OperatorType type) { + super(type); + } + + @Override + public final List computeOutput(Plan... inputs) { + return doComputeOutput(); + } + + public abstract List doComputeOutput(); +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalOperator.java new file mode 100644 index 0000000000..4c22b7371d --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalOperator.java @@ -0,0 +1,31 @@ +// 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.operators.plans.logical; + +import org.apache.doris.nereids.operators.plans.PlanOperator; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * interface for all concrete logical plan operator. + */ +public interface LogicalOperator> extends PlanOperator { + List computeOutput(Plan... inputs); +} 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/operators/plans/logical/LogicalProject.java similarity index 62% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalProject.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalProject.java index c706c1301e..9428a69121 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/operators/plans/logical/LogicalProject.java @@ -15,37 +15,36 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.logical; +package org.apache.doris.nereids.operators.plans.logical; import org.apache.doris.nereids.exceptions.UnboundException; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import org.apache.doris.nereids.trees.expressions.NamedExpression; import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.Plan; -import com.google.common.collect.Lists; +import com.google.common.collect.ImmutableList; import org.apache.commons.lang3.StringUtils; import java.util.List; +import java.util.Objects; /** - * Logical project plan node. + * Logical project plan operator. */ -public class LogicalProject - extends LogicalUnary, CHILD_TYPE> { +public class LogicalProject + extends LogicalUnaryOperator, INPUT_TYPE> { private final List projects; /** - * Constructor for LogicalProjectPlan. + * Constructor for LogicalProject. * * @param projects project list - * @param child child plan node */ - public LogicalProject(List projects, CHILD_TYPE child) { - super(NodeType.LOGICAL_PROJECT, child); - this.projects = projects; - updateOutput(); + public LogicalProject(List projects) { + super(OperatorType.LOGICAL_PROJECT); + this.projects = Objects.requireNonNull(projects, "projects can not be null"); } /** @@ -58,20 +57,17 @@ public class LogicalProject } @Override - public List getOutput() { - return output; - } - - private void updateOutput() { - output = Lists.newArrayListWithCapacity(projects.size()); - for (NamedExpression projection : projects) { - try { - output.add(projection.toSlot()); - } catch (UnboundException e) { - output.clear(); - break; - } - } + public List doComputeOutput(INPUT_TYPE input) { + // fixme: not throw a checked exception + return projects.stream() + .map(namedExpr -> { + try { + return namedExpr.toSlot(); + } catch (UnboundException e) { + throw new IllegalStateException(e); + } + }) + .collect(ImmutableList.toImmutableList()); } @Override diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalRelation.java similarity index 71% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRelation.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalRelation.java index b991415a98..61048e994b 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalRelation.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalRelation.java @@ -15,22 +15,23 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.logical; +package org.apache.doris.nereids.operators.plans.logical; import org.apache.doris.catalog.Table; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.expressions.SlotReference; +import com.google.common.collect.ImmutableList; import org.apache.commons.lang3.StringUtils; import java.util.List; -import java.util.stream.Collectors; +import java.util.Objects; /** - * Logical relation plan node. + * Logical relation plan operator. */ -public class LogicalRelation extends LogicalLeaf { +public class LogicalRelation extends LogicalLeafOperator { private final Table table; private final List qualifier; @@ -42,13 +43,9 @@ public class LogicalRelation extends LogicalLeaf { * @param qualifier qualified relation name */ public LogicalRelation(Table table, List qualifier) { - super(NodeType.LOGICAL_BOUND_RELATION); - this.table = table; - this.qualifier = qualifier; - this.output = table.getBaseSchema() - .stream() - .map(col -> SlotReference.fromColumn(col, qualifier)) - .collect(Collectors.toList()); + super(OperatorType.LOGICAL_BOUND_RELATION); + this.table = Objects.requireNonNull(table, "table can not be null"); + this.qualifier = Objects.requireNonNull(qualifier, "qualifier can not be null"); } public Table getTable() { @@ -60,14 +57,15 @@ public class LogicalRelation extends LogicalLeaf { } @Override - public List getOutput() { - return output; + public String toString() { + return "Relation(" + StringUtils.join(qualifier, ".") + "." + table.getName() + ")"; } @Override - public String toString() { - return "Relation(" + StringUtils.join(qualifier, ".") + "." + table.getName() - + ", output: " + StringUtils.join(output, ", ") - + ")"; + public List doComputeOutput() { + return table.getBaseSchema() + .stream() + .map(col -> SlotReference.fromColumn(col, qualifier)) + .collect(ImmutableList.toImmutableList()); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalUnaryOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalUnaryOperator.java new file mode 100644 index 0000000000..f8a67075f6 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/logical/LogicalUnaryOperator.java @@ -0,0 +1,47 @@ +// 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.operators.plans.logical; + +import org.apache.doris.nereids.operators.AbstractOperator; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.UnaryPlanOperator; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * Abstract class for all logical operator that have one input. + */ +public abstract class LogicalUnaryOperator< + TYPE extends LogicalUnaryOperator, + INPUT_TYPE extends Plan> + extends AbstractOperator + implements LogicalOperator, UnaryPlanOperator { + + public LogicalUnaryOperator(OperatorType type) { + super(type); + } + + @Override + public final List computeOutput(Plan... inputs) { + return doComputeOutput((INPUT_TYPE) inputs[0]); + } + + public abstract List doComputeOutput(INPUT_TYPE input); +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalBinaryOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalBinaryOperator.java new file mode 100644 index 0000000000..59341f07c7 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalBinaryOperator.java @@ -0,0 +1,52 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.operators.plans.physical; + +import org.apache.doris.nereids.operators.AbstractOperator; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.BinaryPlanOperator; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * Abstract class for all physical operator that have two inputs. + */ +public abstract class PhysicalBinaryOperator< + TYPE extends PhysicalBinaryOperator, + LEFT_INPUT_TYPE extends Plan, + RIGHT_INPUT_TYPE extends Plan> + extends AbstractOperator + implements PhysicalOperator, BinaryPlanOperator { + + public PhysicalBinaryOperator(OperatorType type) { + super(type); + } + + @Override + public final List computeOutputs(LogicalProperties logicalProperties, Plan... inputs) { + return doComputeOutput(logicalProperties, (LEFT_INPUT_TYPE) inputs[0], (RIGHT_INPUT_TYPE) inputs[1]); + } + + public List doComputeOutput(LogicalProperties logicalProperties, + LEFT_INPUT_TYPE left, RIGHT_INPUT_TYPE right) { + return logicalProperties.getOutput(); + } +} 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/operators/plans/physical/PhysicalBroadcastHashJoin.java similarity index 58% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalBroadcastHashJoin.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalBroadcastHashJoin.java index 48c6be6ab4..cf03bf55f9 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/operators/plans/physical/PhysicalBroadcastHashJoin.java @@ -15,28 +15,34 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.physical; +package org.apache.doris.nereids.operators.plans.physical; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.JoinType; import org.apache.doris.nereids.trees.expressions.Expression; -import org.apache.doris.nereids.trees.plans.JoinType; import org.apache.doris.nereids.trees.plans.Plan; -import org.apache.commons.lang3.StringUtils; - +import java.util.Objects; import java.util.Optional; /** - * Physical node represents broadcast hash join. + * Physical operator represents broadcast hash join. */ -public class PhysicalBroadcastHashJoin< - LEFT_CHILD_TYPE extends Plan, - RIGHT_CHILD_TYPE extends Plan> - extends PhysicalBinary, - LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> { +public class PhysicalBroadcastHashJoin + extends PhysicalBinaryOperator, + LEFT_INPUT_TYPE, RIGHT_INPUT_TYPE> { private final JoinType joinType; - private final Expression onClause; + private final Optional onClause; + + /** + * Constructor for PhysicalBroadcastHashJoin. + * + * @param joinType logical join type in Nereids + */ + public PhysicalBroadcastHashJoin(JoinType joinType) { + this(joinType, Optional.empty()); + } /** * Constructor for PhysicalBroadcastHashJoin. @@ -44,11 +50,10 @@ public class PhysicalBroadcastHashJoin< * @param joinType logical join type in Nereids * @param onClause on clause expression */ - public PhysicalBroadcastHashJoin(JoinType joinType, LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild, - Expression onClause) { - super(NodeType.PHYSICAL_BROADCAST_HASH_JOIN, leftChild, rightChild); - this.joinType = joinType; - this.onClause = onClause; + public PhysicalBroadcastHashJoin(JoinType joinType, Optional onClause) { + super(OperatorType.PHYSICAL_BROADCAST_HASH_JOIN); + this.joinType = Objects.requireNonNull(joinType, "joinType can not be null"); + this.onClause = Objects.requireNonNull(onClause, "onClause can not be null"); } public JoinType getJoinType() { @@ -56,7 +61,7 @@ public class PhysicalBroadcastHashJoin< } public Optional getOnClause() { - return Optional.ofNullable(onClause); + return onClause; } @Override @@ -65,9 +70,6 @@ public class PhysicalBroadcastHashJoin< if (onClause != null) { sb.append(", ").append(onClause); } - if (logicalProperties != null && !logicalProperties.getOutput().isEmpty()) { - sb.append(", output: ").append(StringUtils.join(logicalProperties.getOutput(), ", ")); - } return sb.append(")").toString(); } } 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/operators/plans/physical/PhysicalFilter.java similarity index 72% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalFilter.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalFilter.java index e7f8170ba3..e3a8229b90 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/operators/plans/physical/PhysicalFilter.java @@ -15,23 +15,25 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.physical; +package org.apache.doris.nereids.operators.plans.physical; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import org.apache.doris.nereids.trees.expressions.Expression; import org.apache.doris.nereids.trees.plans.Plan; +import java.util.Objects; + /** - * Physical filter plan node. + * Physical filter plan operator. */ -public class PhysicalFilter - extends PhysicalUnary, CHILD_TYPE> { +public class PhysicalFilter + extends PhysicalUnaryOperator, INPUT_TYPE> { private final Expression predicates; - public PhysicalFilter(Expression predicates, CHILD_TYPE child) { - super(NodeType.PHYSICAL_FILTER, child); - this.predicates = predicates; + public PhysicalFilter(Expression predicates) { + super(OperatorType.PHYSICAL_FILTER); + this.predicates = Objects.requireNonNull(predicates, "predicates can not be null"); } public Expression getPredicates() { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalLeafOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalLeafOperator.java new file mode 100644 index 0000000000..103cd17fa5 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalLeafOperator.java @@ -0,0 +1,48 @@ +// 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.operators.plans.physical; + +import org.apache.doris.nereids.operators.AbstractOperator; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.LeafPlanOperator; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * Abstract class for all physical operator that have no input. + */ +public abstract class PhysicalLeafOperator> + extends AbstractOperator + implements PhysicalOperator, LeafPlanOperator { + + public PhysicalLeafOperator(OperatorType type) { + super(type); + } + + @Override + public final List computeOutputs(LogicalProperties logicalProperties, Plan... inputs) { + return doComputeOutput(logicalProperties); + } + + public List doComputeOutput(LogicalProperties logicalProperties) { + return logicalProperties.getOutput(); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalOlapScan.java similarity index 88% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalOlapScan.java index 4507591a93..62d9b3babc 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalOlapScan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalOlapScan.java @@ -15,11 +15,11 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.physical; +package org.apache.doris.nereids.operators.plans.physical; import org.apache.doris.catalog.OlapTable; import org.apache.doris.catalog.Partition; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import com.clearspring.analytics.util.Lists; import org.apache.commons.lang3.StringUtils; @@ -27,7 +27,7 @@ import org.apache.commons.lang3.StringUtils; import java.util.List; /** - * Physical olap scan plan node. + * Physical olap scan plan operator. */ public class PhysicalOlapScan extends PhysicalScan { private final long selectedIndexId; @@ -41,7 +41,7 @@ public class PhysicalOlapScan extends PhysicalScan { * @param qualifier table's name */ public PhysicalOlapScan(OlapTable olapTable, List qualifier) { - super(NodeType.PHYSICAL_OLAP_SCAN, olapTable, qualifier); + super(OperatorType.PHYSICAL_OLAP_SCAN, olapTable, qualifier); this.selectedIndexId = olapTable.getBaseIndexId(); this.selectedTabletId = Lists.newArrayList(); this.selectedPartitionId = olapTable.getPartitionIds(); @@ -65,8 +65,7 @@ public class PhysicalOlapScan extends PhysicalScan { @Override public String toString() { return "Scan Olap Table " + StringUtils.join(qualifier, ".") + "." + table.getName() - + " (output: " + logicalProperties.getOutput() - + ", selected index id: " + selectedTabletId + + " (selected index id: " + selectedTabletId + ", selected partition ids: " + selectedPartitionId + ", selected tablet ids: " + selectedTabletId + ")"; diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalOperator.java new file mode 100644 index 0000000000..4982ec342d --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalOperator.java @@ -0,0 +1,32 @@ +// 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.operators.plans.physical; + +import org.apache.doris.nereids.operators.plans.PlanOperator; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * interface for all concrete physical operator. + */ +public interface PhysicalOperator> extends PlanOperator { + List computeOutputs(LogicalProperties logicalProperties, Plan... inputs); +} 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/operators/plans/physical/PhysicalProject.java similarity index 74% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalProject.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalProject.java index 2bd995acce..bd74fc813b 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/operators/plans/physical/PhysicalProject.java @@ -15,27 +15,28 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.physical; +package org.apache.doris.nereids.operators.plans.physical; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import org.apache.doris.nereids.trees.expressions.NamedExpression; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.commons.lang3.StringUtils; import java.util.List; +import java.util.Objects; /** - * Physical project plan node. + * Physical project plan operator. */ -public class PhysicalProject - extends PhysicalUnary, CHILD_TYPE> { +public class PhysicalProject + extends PhysicalUnaryOperator, INPUT_TYPE> { private final List projects; - public PhysicalProject(List projects, CHILD_TYPE child) { - super(NodeType.PHYSICAL_PROJECT, child); - this.projects = projects; + public PhysicalProject(List projects) { + super(OperatorType.PHYSICAL_PROJECT); + this.projects = Objects.requireNonNull(projects, "projects can not be null"); } public List getProjects() { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalScan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalScan.java similarity index 68% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalScan.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalScan.java index 250932cbff..77ce5570b2 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalScan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalScan.java @@ -15,18 +15,19 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.physical; +package org.apache.doris.nereids.operators.plans.physical; import org.apache.doris.catalog.Table; -import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.operators.OperatorType; import java.util.List; +import java.util.Objects; /** - * Abstract class for all physical scan node. + * Abstract class for all physical scan operator. */ -public abstract class PhysicalScan> - extends PhysicalLeaf { +public abstract class PhysicalScan> + extends PhysicalLeafOperator { protected final Table table; protected final List qualifier; @@ -38,10 +39,10 @@ public abstract class PhysicalScan> * @param table scan table * @param qualifier table's name */ - public PhysicalScan(NodeType type, Table table, List qualifier) { + public PhysicalScan(OperatorType type, Table table, List qualifier) { super(type); - this.table = table; - this.qualifier = qualifier; + this.table = Objects.requireNonNull(table, "table can not be null"); + this.qualifier = Objects.requireNonNull(qualifier, "qualifier can not be null"); } public Table getTable() { diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalUnaryOperator.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalUnaryOperator.java new file mode 100644 index 0000000000..1b85c9ebdd --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/operators/plans/physical/PhysicalUnaryOperator.java @@ -0,0 +1,50 @@ +// 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.operators.plans.physical; + +import org.apache.doris.nereids.operators.AbstractOperator; +import org.apache.doris.nereids.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.UnaryPlanOperator; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.trees.expressions.Slot; +import org.apache.doris.nereids.trees.plans.Plan; + +import java.util.List; + +/** + * Abstract class for all physical operator that have one input. + */ +public abstract class PhysicalUnaryOperator< + TYPE extends PhysicalUnaryOperator, + INPUT_TYPE extends Plan> + extends AbstractOperator + implements PhysicalOperator, UnaryPlanOperator { + + public PhysicalUnaryOperator(OperatorType type) { + super(type); + } + + @Override + public final List computeOutputs(LogicalProperties logicalProperties, Plan... inputs) { + return doComputeOutput(logicalProperties, (INPUT_TYPE) inputs[0]); + } + + public List doComputeOutput(LogicalProperties logicalProperties, INPUT_TYPE input) { + return logicalProperties.getOutput(); + } +} diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java index 779ca0ef93..5b20cfcb3d 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java @@ -49,6 +49,10 @@ 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.operators.plans.JoinType; +import org.apache.doris.nereids.operators.plans.logical.LogicalFilter; +import org.apache.doris.nereids.operators.plans.logical.LogicalJoin; +import org.apache.doris.nereids.operators.plans.logical.LogicalProject; import org.apache.doris.nereids.trees.expressions.Alias; import org.apache.doris.nereids.trees.expressions.EqualTo; import org.apache.doris.nereids.trees.expressions.Expression; @@ -60,11 +64,10 @@ import org.apache.doris.nereids.trees.expressions.Literal; import org.apache.doris.nereids.trees.expressions.NamedExpression; import org.apache.doris.nereids.trees.expressions.Not; import org.apache.doris.nereids.trees.expressions.NullSafeEqual; -import org.apache.doris.nereids.trees.plans.JoinType; -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.LogicalBinary; +import org.apache.doris.nereids.trees.plans.logical.LogicalLeaf; import org.apache.doris.nereids.trees.plans.logical.LogicalPlan; -import org.apache.doris.nereids.trees.plans.logical.LogicalProject; +import org.apache.doris.nereids.trees.plans.logical.LogicalUnary; import com.google.common.collect.Lists; import org.antlr.v4.runtime.ParserRuleContext; @@ -75,6 +78,7 @@ import org.antlr.v4.runtime.tree.TerminalNode; import org.apache.commons.collections.CollectionUtils; import java.util.List; +import java.util.Optional; import java.util.function.BiFunction; import java.util.function.Supplier; import java.util.stream.Collectors; @@ -89,7 +93,7 @@ public class LogicalPlanBuilder extends DorisParserBaseVisitor { */ private final BiFunction withWhereClause = (WhereClauseContext ctx, LogicalPlan plan) - -> new LogicalFilter(expression((ctx.booleanExpression())), plan); + -> new LogicalUnary(new LogicalFilter(expression((ctx.booleanExpression()))), plan); protected T typedVisit(ParseTree ctx) { return (T) ctx.accept(this); @@ -201,7 +205,7 @@ public class LogicalPlanBuilder extends DorisParserBaseVisitor { LogicalPlan withProject; if (CollectionUtils.isNotEmpty(namedExpressions)) { - withProject = new LogicalProject(namedExpressions, withFilter); + withProject = new LogicalUnary(new LogicalProject(namedExpressions), withFilter); } else { withProject = withFilter; } @@ -217,7 +221,7 @@ public class LogicalPlanBuilder extends DorisParserBaseVisitor { if (left == null) { left = right; } else { - left = new LogicalJoin(JoinType.INNER_JOIN, null, left, right); + left = new LogicalBinary(new LogicalJoin(JoinType.INNER_JOIN, null), left, right); } left = withJoinRelations(left, relation); } @@ -257,7 +261,10 @@ public class LogicalPlanBuilder extends DorisParserBaseVisitor { condition = expression(joinCriteria.booleanExpression()); } - last = new LogicalJoin(joinType, condition, last, plan(join.relationPrimary())); + last = new LogicalBinary( + new LogicalJoin(joinType, Optional.ofNullable(condition)), + last, plan(join.relationPrimary()) + ); } return last; } @@ -270,7 +277,7 @@ public class LogicalPlanBuilder extends DorisParserBaseVisitor { List tableId = visitMultipartIdentifier(ctx.multipartIdentifier()); UnboundRelation relation = new UnboundRelation(tableId); // TODO: sample and time travel, alias, sub query - return relation; + return new LogicalLeaf(relation); } /** 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 1c1e2dcd10..e15e42e701 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 @@ -17,6 +17,7 @@ package org.apache.doris.nereids.pattern; +import org.apache.doris.nereids.operators.OperatorType; import org.apache.doris.nereids.trees.AbstractTreeNode; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.TreeNode; @@ -32,34 +33,34 @@ import java.util.function.Predicate; * Pattern node used in pattern matching. */ public class Pattern extends AbstractTreeNode> { - public static final Pattern ANY = new Pattern(NodeType.ANY); - public static final Pattern MULTI = new Pattern(NodeType.MULTI); + public static final Pattern ANY = new Pattern(OperatorType.ANY); + public static final Pattern MULTI = new Pattern(OperatorType.MULTI); - public final List> predicates; - private final NodeType nodeType; + private final List> predicates; + private final OperatorType operatorType; /** * Constructor for Pattern. * - * @param nodeType node type to matching + * @param operatorType operator type to matching * @param children sub pattern */ - public Pattern(NodeType nodeType, Pattern... children) { + public Pattern(OperatorType operatorType, Pattern... children) { super(NodeType.PATTERN, children); - this.nodeType = nodeType; + this.operatorType = operatorType; this.predicates = ImmutableList.of(); } /** * Constructor for Pattern. * - * @param nodeType node type to matching + * @param operatorType operator type to matching * @param predicates custom matching predicate * @param children sub pattern */ - public Pattern(NodeType nodeType, List> predicates, Pattern... children) { + public Pattern(OperatorType operatorType, List> predicates, Pattern... children) { super(NodeType.PATTERN, children); - this.nodeType = nodeType; + this.operatorType = operatorType; this.predicates = ImmutableList.copyOf(predicates); } @@ -68,8 +69,8 @@ public class Pattern extends AbstractTreeNode> { * * @return node type in pattern */ - public NodeType getNodeType() { - return nodeType; + public OperatorType getOperatorType() { + return operatorType; } /** @@ -87,11 +88,11 @@ public class Pattern extends AbstractTreeNode> { return false; } - if (nodeType == NodeType.MULTI || nodeType == NodeType.ANY) { + if (operatorType == OperatorType.MULTI || operatorType == OperatorType.ANY) { return true; } - return getNodeType().equals(root.getType()) + return getOperatorType().equals(root.getType()) && predicates.stream().allMatch(predicate -> predicate.test(root)); } @@ -129,12 +130,12 @@ public class Pattern extends AbstractTreeNode> { return false; } Pattern pattern = (Pattern) o; - return nodeType == pattern.nodeType; + return operatorType == pattern.operatorType; } @Override public int hashCode() { - return Objects.hash(nodeType); + return Objects.hash(operatorType); } @Override 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 index 5b945e8e92..d8bd2154a8 100644 --- 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 @@ -57,6 +57,6 @@ public class PatternDescriptor patternWithPredicates() { Pattern[] children = pattern.children().toArray(new Pattern[0]); - return new Pattern<>(pattern.getNodeType(), predicates, children); + return new Pattern<>(pattern.getOperatorType(), predicates, children); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatching.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatching.java index 73ffa296dc..28c2a5e79c 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatching.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/PatternMatching.java @@ -24,24 +24,24 @@ import java.util.Iterator; /** * Get all pattern matching subtree in query plan. */ -public class PatternMatching implements Iterable> { +public class PatternMatching implements Iterable> { @Override - public Iterator> iterator() { + public Iterator> iterator() { return new PatternMatchingIterator(); } /** * Iterator to get all subtrees. */ - public static class PatternMatchingIterator implements Iterator> { + public static class PatternMatchingIterator implements Iterator> { @Override public boolean hasNext() { return false; } @Override - public Plan next() { + public Plan next() { return null; } } 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 index 3e35bae60b..91e196f5da 100644 --- 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 @@ -17,28 +17,26 @@ 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.operators.OperatorType; +import org.apache.doris.nereids.operators.plans.JoinType; +import org.apache.doris.nereids.operators.plans.logical.LogicalFilter; +import org.apache.doris.nereids.operators.plans.logical.LogicalJoin; +import org.apache.doris.nereids.operators.plans.logical.LogicalProject; +import org.apache.doris.nereids.operators.plans.logical.LogicalRelation; +import org.apache.doris.nereids.operators.plans.physical.PhysicalBroadcastHashJoin; +import org.apache.doris.nereids.operators.plans.physical.PhysicalFilter; +import org.apache.doris.nereids.operators.plans.physical.PhysicalOlapScan; +import org.apache.doris.nereids.operators.plans.physical.PhysicalProject; 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.EqualTo; -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; +import org.apache.doris.nereids.trees.plans.logical.LogicalBinary; +import org.apache.doris.nereids.trees.plans.logical.LogicalLeaf; +import org.apache.doris.nereids.trees.plans.logical.LogicalUnary; +import org.apache.doris.nereids.trees.plans.physical.PhysicalBinary; +import org.apache.doris.nereids.trees.plans.physical.PhysicalLeaf; +import org.apache.doris.nereids.trees.plans.physical.PhysicalUnary; /** * An interface provided some PatternDescriptor. @@ -62,9 +60,9 @@ public interface Patterns { /** * create a unboundRelation pattern. */ - default PatternDescriptor unboundRelation() { + default PatternDescriptor, Plan> unboundRelation() { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_UNBOUND_RELATION), + new Pattern<>(OperatorType.LOGICAL_UNBOUND_RELATION), defaultPromise() ); } @@ -72,9 +70,9 @@ public interface Patterns { /** * create a logicalFilter pattern. */ - default PatternDescriptor, Plan> logicalFilter() { + default PatternDescriptor, Plan> logicalFilter() { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_FILTER), + new Pattern<>(OperatorType.LOGICAL_FILTER), defaultPromise() ); } @@ -82,10 +80,10 @@ public interface Patterns { /** * create a logicalFilter pattern with child pattern. */ - default PatternDescriptor, Plan> + default PatternDescriptor, Plan> logicalFilter(PatternDescriptor childPattern) { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_FILTER, childPattern.pattern), + new Pattern<>(OperatorType.LOGICAL_FILTER, childPattern.pattern), defaultPromise() ); } @@ -93,9 +91,9 @@ public interface Patterns { /** * create a logicalProject pattern. */ - default PatternDescriptor, Plan> logicalProject() { + default PatternDescriptor, Plan> logicalProject() { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_PROJECT), + new Pattern<>(OperatorType.LOGICAL_PROJECT), defaultPromise() ); } @@ -103,10 +101,10 @@ public interface Patterns { /** * create a logicalProject pattern. */ - default PatternDescriptor + default PatternDescriptor, Plan> logicalProject(PatternDescriptor childPattern) { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_PROJECT, childPattern.pattern), + new Pattern<>(OperatorType.LOGICAL_PROJECT, childPattern.pattern), defaultPromise() ); } @@ -114,9 +112,9 @@ public interface Patterns { /** * create a logicalJoin pattern. */ - default PatternDescriptor, Plan> logicalJoin() { + default PatternDescriptor, Plan> logicalJoin() { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_JOIN), + new Pattern<>(OperatorType.LOGICAL_JOIN), defaultPromise() ); } @@ -124,32 +122,34 @@ public interface Patterns { /** * create a logicalJoin pattern with join type. */ - default PatternDescriptor, Plan> logicalJoin(JoinType joinType) { - return new PatternDescriptor, Plan>( - new Pattern<>(NodeType.LOGICAL_JOIN), + default PatternDescriptor, Plan> logicalJoin(JoinType joinType) { + return new PatternDescriptor, Plan>( + new Pattern<>(OperatorType.LOGICAL_JOIN), defaultPromise() - ).when(j -> j.getJoinType() == joinType); + ).when(j -> j.op.getJoinType() == joinType); } /** * create a logicalJoin pattern with joinType and children patterns. */ - default PatternDescriptor, Plan> logicalJoin( - JoinType joinType, PatternDescriptor leftChildPattern, - PatternDescriptor rightChildPattern) { - return new PatternDescriptor, Plan>( - new Pattern<>(NodeType.LOGICAL_JOIN, leftChildPattern.pattern, rightChildPattern.pattern), + default + PatternDescriptor, Plan> logicalJoin( + JoinType joinType, PatternDescriptor leftChildPattern, + PatternDescriptor rightChildPattern) { + return new PatternDescriptor, Plan>( + new Pattern<>(OperatorType.LOGICAL_JOIN, leftChildPattern.pattern, rightChildPattern.pattern), defaultPromise() - ).when(j -> j.getJoinType() == joinType); + ).when(j -> j.op.getJoinType() == joinType); } /** * create a logicalJoin pattern with children patterns. */ - default PatternDescriptor, Plan> logicalJoin( - PatternDescriptor leftChildPattern, PatternDescriptor rightChildPattern) { + default + PatternDescriptor, Plan> logicalJoin( + PatternDescriptor leftChildPattern, PatternDescriptor rightChildPattern) { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_JOIN, leftChildPattern.pattern, rightChildPattern.pattern), + new Pattern<>(OperatorType.LOGICAL_JOIN, leftChildPattern.pattern, rightChildPattern.pattern), defaultPromise() ); } @@ -157,30 +157,31 @@ public interface Patterns { /** * create a logicalJoin pattern with joinType is inner. */ - default PatternDescriptor, Plan> innerLogicalJoin() { - return new PatternDescriptor, Plan>( - new Pattern<>(NodeType.LOGICAL_JOIN), + default PatternDescriptor, Plan> innerLogicalJoin() { + return new PatternDescriptor, Plan>( + new Pattern<>(OperatorType.LOGICAL_JOIN), defaultPromise() - ).when(j -> j.getJoinType() == JoinType.INNER_JOIN); + ).when(j -> j.op.getJoinType() == JoinType.INNER_JOIN); } /** * create a logical join pattern with join type is inner and children patterns. */ - default PatternDescriptor, Plan> innerLogicalJoin( - PatternDescriptor leftChildPattern, PatternDescriptor rightChildPattern) { - return new PatternDescriptor, Plan>( - new Pattern<>(NodeType.LOGICAL_JOIN, leftChildPattern.pattern, rightChildPattern.pattern), + default + PatternDescriptor, Plan> innerLogicalJoin( + PatternDescriptor leftChildPattern, PatternDescriptor rightChildPattern) { + return new PatternDescriptor, Plan>( + new Pattern<>(OperatorType.LOGICAL_JOIN, leftChildPattern.pattern, rightChildPattern.pattern), defaultPromise() - ).when(j -> j.getJoinType() == JoinType.INNER_JOIN); + ).when(j -> j.op.getJoinType() == JoinType.INNER_JOIN); } /** * create a logicalRelation pattern. */ - default PatternDescriptor logicalRelation() { + default PatternDescriptor, Plan> logicalRelation() { return new PatternDescriptor<>( - new Pattern<>(NodeType.LOGICAL_BOUND_RELATION), + new Pattern<>(OperatorType.LOGICAL_BOUND_RELATION), defaultPromise() ); } @@ -190,9 +191,9 @@ public interface Patterns { /** * create a physicalFilter pattern. */ - default PatternDescriptor, Plan> physicalFilter() { + default PatternDescriptor, Plan> physicalFilter() { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_FILTER), + new Pattern<>(OperatorType.PHYSICAL_FILTER), defaultPromise() ); } @@ -200,10 +201,10 @@ public interface Patterns { /** * create a physicalFilter pattern with child pattern. */ - default PatternDescriptor, Plan> + default PatternDescriptor, Plan> physicalFilter(PatternDescriptor childPattern) { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_FILTER, childPattern.pattern), + new Pattern<>(OperatorType.PHYSICAL_FILTER, childPattern.pattern), defaultPromise() ); } @@ -211,9 +212,9 @@ public interface Patterns { /** * create a physicalProject pattern. */ - default PatternDescriptor, Plan> physicalProject() { + default PatternDescriptor, Plan> physicalProject() { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_PROJECT), + new Pattern<>(OperatorType.PHYSICAL_PROJECT), defaultPromise() ); } @@ -221,10 +222,10 @@ public interface Patterns { /** * create a physicalProject pattern with child pattern. */ - default PatternDescriptor, Plan> + default PatternDescriptor, Plan> physicalProject(PatternDescriptor childPattern) { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_PROJECT, childPattern.pattern), + new Pattern<>(OperatorType.PHYSICAL_PROJECT, childPattern.pattern), defaultPromise() ); } @@ -232,9 +233,10 @@ public interface Patterns { /** * create a physicalBroadcastHashJoin pattern. */ - default PatternDescriptor, Plan> physicalBroadcastHashJoin() { + default PatternDescriptor, Plan> + physicalBroadcastHashJoin() { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_BROADCAST_HASH_JOIN), + new Pattern<>(OperatorType.PHYSICAL_BROADCAST_HASH_JOIN), defaultPromise() ); } @@ -242,11 +244,12 @@ public interface Patterns { /** * create a physicalBroadcastHashJoin pattern with children patterns. */ - default PatternDescriptor, Plan> - physicalBroadcastHashJoin(PatternDescriptor leftChildPattern, - PatternDescriptor rightChildPattern) { + default + PatternDescriptor, Plan> + physicalBroadcastHashJoin(PatternDescriptor leftChildPattern, + PatternDescriptor rightChildPattern) { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_BROADCAST_HASH_JOIN, + new Pattern<>(OperatorType.PHYSICAL_BROADCAST_HASH_JOIN, leftChildPattern.pattern, rightChildPattern.pattern ), @@ -257,118 +260,9 @@ public interface Patterns { /** * create a physicalOlapScan pattern. */ - default PatternDescriptor physicalOlapScan() { + default PatternDescriptor, Plan> physicalOlapScan() { return new PatternDescriptor<>( - new Pattern<>(NodeType.PHYSICAL_OLAP_SCAN), - defaultPromise() - ); - } - - // expression pattern descriptors - - /** - * create a unboundAlias pattern. - */ - default PatternDescriptor, Expression> unboundAlias() { - return new PatternDescriptor<>( - new Pattern<>(NodeType.UNBOUND_ALIAS), - defaultPromise() - ); - } - - /** - * create a unboundAlias pattern. - */ - default PatternDescriptor, Expression> - unboundAlias(PatternDescriptor childPattern) { - return new PatternDescriptor<>( - new Pattern<>(NodeType.UNBOUND_ALIAS, childPattern.pattern), - defaultPromise() - ); - } - - /** - * create a unboundSlot pattern. - */ - default PatternDescriptor unboundSlot() { - return new PatternDescriptor<>( - new Pattern<>(NodeType.UNBOUND_SLOT), - defaultPromise() - ); - } - - /** - * create a unboundStar pattern. - */ - default PatternDescriptor unboundStar() { - return new PatternDescriptor<>( - new Pattern<>(NodeType.UNBOUND_STAR), - defaultPromise() - ); - } - - /** - * create a literal pattern. - */ - default PatternDescriptor literal() { - return new PatternDescriptor<>( - new Pattern<>(NodeType.LITERAL), - defaultPromise() - ); - } - - /** - * create a slotReference pattern. - */ - default PatternDescriptor slotReference() { - return new PatternDescriptor<>( - new Pattern<>(NodeType.SLOT_REFERENCE), - defaultPromise() - ); - } - - /** - * TODO create a ComparisonPredicate pattern. - */ - - /** - * TODO create a ComparisonPredicate pattern with children patterns. - */ - - /** - * create a equal to predicate pattern. - */ - default PatternDescriptor, Expression> equalTo() { - return new PatternDescriptor<>(new Pattern<>(NodeType.EQUAL_TO), defaultPromise()); - } - - /** - * create a equal to predicate pattern with children patterns. - */ - default PatternDescriptor, Expression> equalTo( - PatternDescriptor leftChildPattern, PatternDescriptor rightChildPattern) { - return new PatternDescriptor<>( - new Pattern<>(NodeType.EQUAL_TO, leftChildPattern.pattern, rightChildPattern.pattern), - defaultPromise()); - } - - /** - * create a alias pattern. - */ - default PatternDescriptor, Expression> alias() { - return new PatternDescriptor<>( - new Pattern<>(NodeType.ALIAS), - defaultPromise() - ); - } - - /** - * create a alias pattern with child pattern. - */ - default PatternDescriptor, Expression> - alias(PatternDescriptor childPattern) { - return new PatternDescriptor<>( - new Pattern<>(NodeType.ALIAS, childPattern.pattern), + new Pattern<>(OperatorType.PHYSICAL_OLAP_SCAN), defaultPromise() ); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/LogicalProperties.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/LogicalProperties.java index 28e0910984..80af9bcd59 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/LogicalProperties.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/properties/LogicalProperties.java @@ -19,7 +19,7 @@ package org.apache.doris.nereids.properties; import org.apache.doris.nereids.trees.expressions.Slot; -import com.clearspring.analytics.util.Lists; +import com.google.common.collect.ImmutableList; import java.util.List; @@ -27,13 +27,13 @@ import java.util.List; * Logical properties used for analysis and optimize in Nereids. */ public class LogicalProperties { - protected List output = Lists.newArrayList(); + protected List output; + + public LogicalProperties(List output) { + this.output = ImmutableList.copyOf(output); + } public List getOutput() { return output; } - - public void setOutput(List output) { - this.output = output; - } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java index 5c97a3d794..eec473b5c9 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/PlanRuleFactory.java @@ -18,9 +18,10 @@ package org.apache.doris.nereids.rules; import org.apache.doris.nereids.trees.plans.Plan; +import org.apache.doris.nereids.trees.plans.Plans; /** * interface for all plan rule factories. */ -public interface PlanRuleFactory extends RuleFactory { +public interface PlanRuleFactory extends RuleFactory, Plans { } 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 441ea80e2b..33439b5094 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 @@ -22,7 +22,6 @@ import org.apache.doris.nereids.rules.exploration.join.JoinCommutative; import org.apache.doris.nereids.rules.exploration.join.JoinLeftAssociative; 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.google.common.collect.ImmutableList; @@ -63,10 +62,6 @@ public class RuleSet { return new RuleFactories(); } - private static RuleFactories expressionRuleFactories() { - return new RuleFactories(); - } - private static class RuleFactories { final Builder> rules = ImmutableList.builder(); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java index 557d1cc2f6..235574fe18 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/analysis/AnalysisUnboundRelation.java @@ -20,10 +20,10 @@ 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.nereids.operators.plans.logical.LogicalRelation; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; 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.Lists; @@ -39,19 +39,19 @@ public class AnalysisUnboundRelation extends OneAnalysisRuleFactory { // fixme, just for example now return unboundRelation().thenApply(ctx -> { ConnectContext connectContext = ctx.plannerContext.getConnectContext(); - List nameParts = ctx.root.getNameParts(); + List nameParts = ctx.root.op.getNameParts(); switch (nameParts.size()) { case 1: { List qualifier = Lists.newArrayList(connectContext.getDatabase(), nameParts.get(0)); Table table = getTable(qualifier, connectContext.getCatalog()); - return new LogicalRelation(table, qualifier); + return plan(new LogicalRelation(table, qualifier)); } case 2: { Table table = getTable(nameParts, connectContext.getCatalog()); - return new LogicalRelation(table, nameParts); + return plan(new LogicalRelation(table, nameParts)); } default: - throw new IllegalStateException("Table name [" + ctx.root.getTableName() + "] is invalid."); + throw new IllegalStateException("Table name [" + ctx.root.op.getTableName() + "] is invalid."); } }).toRule(RuleType.BINDING_UNBOUND_RELATION_RULE); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/JoinReorderContext.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinReorderContext.java similarity index 96% rename from fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/JoinReorderContext.java rename to fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinReorderContext.java index c56da73b4c..170c286351 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/JoinReorderContext.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/JoinReorderContext.java @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -package org.apache.doris.nereids.trees.plans.logical; +package org.apache.doris.nereids.rules.exploration; /** diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinCommutative.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinCommutative.java index b7c3071c86..2d7ef47f57 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinCommutative.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinCommutative.java @@ -17,11 +17,11 @@ package org.apache.doris.nereids.rules.exploration.join; +import org.apache.doris.nereids.operators.plans.logical.LogicalJoin; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.rules.exploration.OneExplorationRuleFactory; import org.apache.doris.nereids.trees.plans.Plan; -import org.apache.doris.nereids.trees.plans.logical.LogicalJoin; /** * rule factory for exchange inner join's children. @@ -50,8 +50,10 @@ public class JoinCommutative extends OneExplorationRuleFactory { @Override public Rule build() { - return innerLogicalJoin().then(join -> { - return new LogicalJoin(join.getJoinType().swap(), join.getOnClause(), join.right(), join.left()); - }).toRule(RuleType.LOGICAL_JOIN_COMMUTATIVE); + return innerLogicalJoin().then(join -> plan( + new LogicalJoin(join.op.getJoinType().swap(), join.op.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/join/JoinExchange.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinExchange.java index fe5cdc1b6b..bc7df948e8 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinExchange.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinExchange.java @@ -17,11 +17,12 @@ package org.apache.doris.nereids.rules.exploration.join; +import org.apache.doris.nereids.operators.plans.logical.LogicalJoin; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.rules.exploration.OneExplorationRuleFactory; import org.apache.doris.nereids.trees.plans.Plan; -import org.apache.doris.nereids.trees.plans.logical.LogicalJoin; +import org.apache.doris.nereids.trees.plans.logical.LogicalBinary; /** @@ -38,19 +39,26 @@ public class JoinExchange extends OneExplorationRuleFactory { @Override public Rule build() { return innerLogicalJoin(innerLogicalJoin(), innerLogicalJoin()).then(topJoin -> { - LogicalJoin leftJoin = topJoin.left(); - LogicalJoin rightJoin = topJoin.left(); + LogicalBinary leftJoin = topJoin.left(); + LogicalBinary rightJoin = topJoin.right(); Plan a = leftJoin.left(); Plan b = leftJoin.right(); Plan c = rightJoin.left(); Plan d = rightJoin.right(); - LogicalJoin newLeftJoin = new LogicalJoin(leftJoin.getJoinType(), leftJoin.getOnClause(), a, c); - LogicalJoin newRightJoin = new LogicalJoin(rightJoin.getJoinType(), rightJoin.getOnClause(), b, d); - LogicalJoin newTopJoin = - new LogicalJoin(topJoin.getJoinType(), topJoin.getOnClause(), newLeftJoin, newRightJoin); - + Plan newLeftJoin = plan( + new LogicalJoin(leftJoin.op.getJoinType(), leftJoin.op.getOnClause()), + a, c + ); + Plan newRightJoin = plan( + new LogicalJoin(rightJoin.op.getJoinType(), rightJoin.op.getOnClause()), + b, d + ); + Plan newTopJoin = plan( + new LogicalJoin(topJoin.op.getJoinType(), topJoin.op.getOnClause()), + newLeftJoin, newRightJoin + ); return newTopJoin; }).toRule(RuleType.LOGICAL_JOIN_EXCHANGE); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLAsscom.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLAsscom.java index 7552e94653..1c19a66e84 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLAsscom.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLAsscom.java @@ -17,12 +17,12 @@ package org.apache.doris.nereids.rules.exploration.join; +import org.apache.doris.nereids.operators.plans.logical.LogicalJoin; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.rules.exploration.OneExplorationRuleFactory; import org.apache.doris.nereids.trees.plans.Plan; -import org.apache.doris.nereids.trees.plans.logical.LogicalJoin; - +import org.apache.doris.nereids.trees.plans.logical.LogicalBinary; /** * Rule for change inner join left associative to right. @@ -38,16 +38,21 @@ public class JoinLAsscom extends OneExplorationRuleFactory { @Override public Rule build() { return innerLogicalJoin(innerLogicalJoin(), any()).then(topJoin -> { - LogicalJoin bottomJoin = topJoin.left(); + LogicalBinary bottomJoin = topJoin.left(); - Plan c = topJoin.right(); Plan a = bottomJoin.left(); Plan b = bottomJoin.right(); + Plan c = topJoin.right(); - LogicalJoin newBottomJoin = - new LogicalJoin(bottomJoin.getJoinType(), bottomJoin.getOnClause(), a, c); - LogicalJoin newTopJoin = - new LogicalJoin(bottomJoin.getJoinType(), topJoin.getOnClause(), newBottomJoin, b); + Plan newBottomJoin = plan( + new LogicalJoin(bottomJoin.op.getJoinType(), bottomJoin.op.getOnClause()), + a, c + ); + + Plan newTopJoin = plan( + new LogicalJoin(bottomJoin.op.getJoinType(), topJoin.op.getOnClause()), + newBottomJoin, b + ); return newTopJoin; }).toRule(RuleType.LOGICAL_JOIN_L_ASSCOM); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLeftAssociative.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLeftAssociative.java index 214b0336a9..9070ae2624 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLeftAssociative.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/exploration/join/JoinLeftAssociative.java @@ -17,12 +17,12 @@ package org.apache.doris.nereids.rules.exploration.join; +import org.apache.doris.nereids.operators.plans.JoinType; +import org.apache.doris.nereids.operators.plans.logical.LogicalJoin; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.rules.exploration.OneExplorationRuleFactory; -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; /** * Rule factory for change inner join left associative to right. @@ -39,16 +39,14 @@ public class JoinLeftAssociative extends OneExplorationRuleFactory { public Rule 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() - ) + return plan( + new LogicalJoin(JoinType.INNER_JOIN, root.op.getOnClause()), + root.left().left(), + plan( + new LogicalJoin(JoinType.INNER_JOIN, root.op.getOnClause()), + root.left().right(), + root.right() + ) ); }).toRule(RuleType.LOGICAL_LEFT_JOIN_ASSOCIATIVE); } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java index 062191be38..e7537aa102 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/rules/implementation/LogicalJoinToHashJoin.java @@ -17,11 +17,10 @@ package org.apache.doris.nereids.rules.implementation; +import org.apache.doris.nereids.operators.plans.physical.PhysicalBroadcastHashJoin; import org.apache.doris.nereids.rules.Rule; import org.apache.doris.nereids.rules.RuleType; import org.apache.doris.nereids.trees.plans.Plan; -import org.apache.doris.nereids.trees.plans.physical.PhysicalBroadcastHashJoin; - /** * Implementation rule that convert logical join to physical hash join. @@ -30,11 +29,10 @@ public class LogicalJoinToHashJoin extends OneImplementationRuleFactory { @Override public Rule build() { // fixme, just for example now - return logicalJoin().then(join -> new PhysicalBroadcastHashJoin( - join.getJoinType(), - join.left(), - join.right(), - join.getOnClause() + return logicalJoin().then(join -> plan( + new PhysicalBroadcastHashJoin(join.op.getJoinType(), join.op.getOnClause()), + join.getLogicalProperties(), + join.left(), join.right() )).toRule(RuleType.LOGICAL_JOIN_TO_HASH_JOIN_RULE); } } 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 bf048208a3..3e42bc1930 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 @@ -21,20 +21,9 @@ package org.apache.doris.nereids.trees; * Types for all TreeNode in Nereids, include Plan and Expression. */ public enum NodeType { - // logical plan + // plan LOGICAL, - LOGICAL_UNBOUND_RELATION, - LOGICAL_BOUND_RELATION, - LOGICAL_PROJECT, - LOGICAL_FILTER, - LOGICAL_JOIN, - - // physical plan PHYSICAL, - PHYSICAL_OLAP_SCAN, - PHYSICAL_PROJECT, - PHYSICAL_FILTER, - PHYSICAL_BROADCAST_HASH_JOIN, // expressions EXPRESSION, @@ -54,7 +43,5 @@ public enum NodeType { ALIAS, // pattern - PATTERN, - ANY, - MULTI, + PATTERN } 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 5ce38b34e7..468e5b1ef2 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 @@ -17,15 +17,15 @@ package org.apache.doris.nereids.trees.plans; -import org.apache.doris.nereids.exceptions.UnboundException; +import org.apache.doris.nereids.operators.plans.PlanOperator; import org.apache.doris.nereids.trees.AbstractTreeNode; import org.apache.doris.nereids.trees.NodeType; -import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; import java.util.List; +import java.util.Objects; /** * Abstract class for all concrete plan node. @@ -33,17 +33,22 @@ import java.util.List; * @param either {@link org.apache.doris.nereids.trees.plans.logical.LogicalPlan} * or {@link org.apache.doris.nereids.trees.plans.physical.PhysicalPlan} */ -public abstract class AbstractPlan> - extends AbstractTreeNode implements Plan { +public abstract class AbstractPlan< + PLAN_TYPE extends AbstractPlan, + OP_TYPE extends PlanOperator> + extends AbstractTreeNode implements Plan { - protected List output; + public final OP_TYPE op; - public AbstractPlan(NodeType type, Plan...children) { + public AbstractPlan(NodeType type, OP_TYPE operator, Plan... children) { super(type, children); + this.op = Objects.requireNonNull(operator, "operator can not be null"); } @Override - public abstract List getOutput() throws UnboundException; + public OP_TYPE getOperator() { + return op; + } @Override public List children() { @@ -67,7 +72,7 @@ public abstract class AbstractPlan> return StringUtils.join(lines, "\n"); } - private void treeString(List lines, int depth, List lastChildren, Plan plan) { + private void treeString(List lines, int depth, List lastChildren, Plan plan) { StringBuilder sb = new StringBuilder(); if (depth > 0) { if (lastChildren.size() > 1) { 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 180069bd13..849f4f3e07 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 @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans; +import org.apache.doris.nereids.operators.plans.BinaryPlanOperator; import org.apache.doris.nereids.trees.BinaryNode; import java.util.List; @@ -25,10 +26,11 @@ import java.util.List; * interface for all plan that have two children. */ public interface BinaryPlan< - PLAN_TYPE extends BinaryPlan, + PLAN_TYPE extends BinaryPlan, + OP_TYPE extends BinaryPlanOperator, LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends Plan> - extends Plan, BinaryNode { + extends Plan, BinaryNode { @Override List children(); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/LeafPlan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/LeafPlan.java index 2749d96fc5..6e869ea65b 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/LeafPlan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/LeafPlan.java @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans; +import org.apache.doris.nereids.operators.plans.LeafPlanOperator; import org.apache.doris.nereids.trees.LeafNode; import java.util.List; @@ -24,8 +25,10 @@ import java.util.List; /** * Abstract class for all plan node that have no child. */ -public interface LeafPlan> - extends Plan, LeafNode { +public interface LeafPlan< + PLAN_TYPE extends LeafPlan, + OP_TYPE extends LeafPlanOperator> + extends Plan, LeafNode { @Override List children(); 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 a40b3a8be5..c359a93ed7 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 @@ -17,7 +17,8 @@ package org.apache.doris.nereids.trees.plans; -import org.apache.doris.nereids.exceptions.UnboundException; +import org.apache.doris.nereids.operators.plans.PlanOperator; +import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.trees.TreeNode; import org.apache.doris.nereids.trees.expressions.Slot; @@ -26,9 +27,15 @@ import java.util.List; /** * Abstract class for all plan node. */ -public interface Plan> extends TreeNode { +public interface Plan< + PLAN_TYPE extends Plan, + OP_TYPE extends PlanOperator> extends TreeNode { - List getOutput() throws UnboundException; + OP_TYPE getOperator(); + + LogicalProperties getLogicalProperties(); + + List getOutput(); String treeString(); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plans.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plans.java new file mode 100644 index 0000000000..487d32a662 --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/Plans.java @@ -0,0 +1,71 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package org.apache.doris.nereids.trees.plans; + +import org.apache.doris.nereids.operators.plans.logical.LogicalBinaryOperator; +import org.apache.doris.nereids.operators.plans.logical.LogicalLeafOperator; +import org.apache.doris.nereids.operators.plans.logical.LogicalUnaryOperator; +import org.apache.doris.nereids.operators.plans.physical.PhysicalBinaryOperator; +import org.apache.doris.nereids.operators.plans.physical.PhysicalLeafOperator; +import org.apache.doris.nereids.operators.plans.physical.PhysicalUnaryOperator; +import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.trees.plans.logical.LogicalBinary; +import org.apache.doris.nereids.trees.plans.logical.LogicalLeaf; +import org.apache.doris.nereids.trees.plans.logical.LogicalUnary; +import org.apache.doris.nereids.trees.plans.physical.PhysicalBinary; +import org.apache.doris.nereids.trees.plans.physical.PhysicalLeaf; +import org.apache.doris.nereids.trees.plans.physical.PhysicalUnary; + +/** + * An interface provided some builder of Plan. + * Child Interface(PlanRuleFactory) can use to build some plan for transform rule. + * You can simply use the override plan function to build a plan by the operator type. + */ +public interface Plans { + default LogicalLeaf plan(OP_TYPE op) { + return new LogicalLeaf(op); + } + + default LogicalUnary + plan(OP_TYPE op, CHILD_TYPE child) { + return new LogicalUnary(op, child); + } + + default + LogicalBinary + plan(OP_TYPE op, LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild) { + return new LogicalBinary(op, leftChild, rightChild); + } + + default PhysicalLeaf + plan(OP_TYPE op, LogicalProperties logicalProperties) { + return new PhysicalLeaf(op, logicalProperties); + } + + default PhysicalUnary + plan(OP_TYPE op, LogicalProperties logicalProperties, CHILD_TYPE child) { + return new PhysicalUnary(op, logicalProperties, child); + } + + default + PhysicalBinary + plan(OP_TYPE op, LogicalProperties logicalProperties, + LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild) { + return new PhysicalBinary(op, logicalProperties, leftChild, rightChild); + } +} 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 595205017d..82e221b249 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 @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans; +import org.apache.doris.nereids.operators.plans.UnaryPlanOperator; import org.apache.doris.nereids.trees.UnaryNode; import java.util.List; @@ -25,9 +26,10 @@ import java.util.List; * interface for all plan node that have one child. */ public interface UnaryPlan< - PLAN_TYPE extends UnaryPlan, + PLAN_TYPE extends UnaryPlan, + OP_TYPE extends UnaryPlanOperator, CHILD_TYPE extends Plan> - extends Plan, UnaryNode { + extends Plan, UnaryNode { @Override List children(); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/AbstractLogicalPlan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/AbstractLogicalPlan.java index 28ef99f0c4..36d1eabd2d 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/AbstractLogicalPlan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/AbstractLogicalPlan.java @@ -17,18 +17,38 @@ package org.apache.doris.nereids.trees.plans.logical; +import org.apache.doris.nereids.operators.plans.logical.LogicalOperator; +import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.trees.NodeType; +import org.apache.doris.nereids.trees.expressions.Slot; import org.apache.doris.nereids.trees.plans.AbstractPlan; import org.apache.doris.nereids.trees.plans.Plan; +import java.util.List; + /** * Abstract class for all concrete logical plan. */ -public abstract class AbstractLogicalPlan> - extends AbstractPlan - implements LogicalPlan { +public abstract class AbstractLogicalPlan< + PLAN_TYPE extends AbstractLogicalPlan, + OP_TYPE extends LogicalOperator> + extends AbstractPlan + implements LogicalPlan { - public AbstractLogicalPlan(NodeType type, Plan... children) { - super(type, children); + protected final LogicalProperties logicalProperties; + + public AbstractLogicalPlan(NodeType type, OP_TYPE operator, Plan... children) { + super(type, operator, children); + this.logicalProperties = new LogicalProperties(operator.computeOutput(children)); + } + + @Override + public LogicalProperties getLogicalProperties() { + return logicalProperties; + } + + @Override + public List getOutput() { + return logicalProperties.getOutput(); } } 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 de7dab4629..84a0939d58 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 @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans.logical; +import org.apache.doris.nereids.operators.plans.logical.LogicalBinaryOperator; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.plans.BinaryPlan; import org.apache.doris.nereids.trees.plans.Plan; @@ -24,14 +25,15 @@ import org.apache.doris.nereids.trees.plans.Plan; /** * Abstract class for all logical plan that have two children. */ -public abstract class LogicalBinary< - PLAN_TYPE extends LogicalBinary, +public class LogicalBinary< + OP_TYPE extends LogicalBinaryOperator, LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends Plan> - extends AbstractLogicalPlan - implements BinaryPlan { + extends AbstractLogicalPlan, OP_TYPE> + implements BinaryPlan, + OP_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> { - public LogicalBinary(NodeType type, LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild) { - super(type, leftChild, rightChild); + public LogicalBinary(OP_TYPE operator, LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild) { + super(NodeType.LOGICAL, operator, leftChild, rightChild); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLeaf.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLeaf.java index 0afd7a3c4d..385a87984e 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLeaf.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalLeaf.java @@ -17,17 +17,18 @@ package org.apache.doris.nereids.trees.plans.logical; +import org.apache.doris.nereids.operators.plans.logical.LogicalLeafOperator; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.plans.LeafPlan; /** * Abstract class for all logical plan that have no child. */ -public abstract class LogicalLeaf> - extends AbstractLogicalPlan - implements LeafPlan { +public class LogicalLeaf + extends AbstractLogicalPlan, OP_TYPE> + implements LeafPlan, OP_TYPE> { - public LogicalLeaf(NodeType type) { - super(type); + public LogicalLeaf(OP_TYPE operator) { + super(NodeType.LOGICAL, operator); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPlan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPlan.java index 838b495ce6..1c66e122fc 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPlan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/logical/LogicalPlan.java @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans.logical; +import org.apache.doris.nereids.operators.plans.logical.LogicalOperator; import org.apache.doris.nereids.trees.plans.Plan; import java.util.List; @@ -25,7 +26,10 @@ import java.util.function.BiFunction; /** * Abstract class for all logical plan in Nereids. */ -public interface LogicalPlan> extends Plan { +public interface LogicalPlan< + PLAN_TYPE extends LogicalPlan, + OP_TYPE extends LogicalOperator> + extends Plan { @Override List children(); 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 a2e002dde6..a61a9263a4 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 @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans.logical; +import org.apache.doris.nereids.operators.plans.logical.LogicalUnaryOperator; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.UnaryPlan; @@ -24,13 +25,11 @@ import org.apache.doris.nereids.trees.plans.UnaryPlan; /** * Abstract class for all logical plan that have one child. */ -public abstract class LogicalUnary< - PLAN_TYPE extends LogicalUnary, - CHILD_TYPE extends Plan> - extends AbstractLogicalPlan - implements UnaryPlan { +public class LogicalUnary + extends AbstractLogicalPlan, OP_TYPE> + implements UnaryPlan, OP_TYPE, CHILD_TYPE> { - public LogicalUnary(NodeType type, CHILD_TYPE child) { - super(type, child); + public LogicalUnary(OP_TYPE operator, CHILD_TYPE child) { + super(NodeType.LOGICAL, operator, child); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/AbstractPhysicalPlan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/AbstractPhysicalPlan.java index 336fce0447..13f9a75ca8 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/AbstractPhysicalPlan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/AbstractPhysicalPlan.java @@ -17,6 +17,7 @@ package org.apache.doris.nereids.trees.plans.physical; +import org.apache.doris.nereids.operators.plans.physical.PhysicalOperator; import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.properties.PhysicalProperties; import org.apache.doris.nereids.trees.NodeType; @@ -25,28 +26,42 @@ import org.apache.doris.nereids.trees.plans.AbstractPlan; import org.apache.doris.nereids.trees.plans.Plan; import java.util.List; +import java.util.Objects; /** * Abstract class for all concrete physical plan. */ -public abstract class AbstractPhysicalPlan> - extends AbstractPlan - implements PhysicalPlan { +public abstract class AbstractPhysicalPlan< + PLAN_TYPE extends AbstractPhysicalPlan, + OP_TYPE extends PhysicalOperator> + extends AbstractPlan + implements PhysicalPlan { - protected LogicalProperties logicalProperties; - protected PhysicalProperties physicalProperties; + protected final LogicalProperties logicalProperties; + protected final PhysicalProperties physicalProperties; - public AbstractPhysicalPlan(NodeType type, Plan... children) { - super(type, children); - } - - @Override - public void setLogicalProperties(LogicalProperties logicalProperties) { - this.logicalProperties = logicalProperties; + /** + * create physical plan by op, logicalProperties and children. + */ + public AbstractPhysicalPlan(NodeType type, OP_TYPE operator, + LogicalProperties logicalProperties, Plan... children) { + super(type, operator, children); + this.logicalProperties = Objects.requireNonNull(logicalProperties, "logicalProperties can not be null"); + // TODO: compute physical properties + this.physicalProperties = new PhysicalProperties(); } @Override public List getOutput() { return logicalProperties.getOutput(); } + + @Override + public LogicalProperties getLogicalProperties() { + return logicalProperties; + } + + public PhysicalProperties getPhysicalProperties() { + return physicalProperties; + } } 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 5c7b468a85..d215e51623 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 @@ -17,6 +17,8 @@ package org.apache.doris.nereids.trees.plans.physical; +import org.apache.doris.nereids.operators.plans.physical.PhysicalBinaryOperator; +import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.plans.BinaryPlan; import org.apache.doris.nereids.trees.plans.Plan; @@ -24,14 +26,17 @@ import org.apache.doris.nereids.trees.plans.Plan; /** * Abstract class for all physical plan that have two children. */ -public abstract class PhysicalBinary< - PLAN_TYPE extends PhysicalBinary, +public class PhysicalBinary< + OP_TYPE extends PhysicalBinaryOperator, LEFT_CHILD_TYPE extends Plan, RIGHT_CHILD_TYPE extends Plan> - extends AbstractPhysicalPlan - implements BinaryPlan { + extends AbstractPhysicalPlan, OP_TYPE> + implements BinaryPlan< + PhysicalBinary, + OP_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> { - public PhysicalBinary(NodeType type, LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild) { - super(type, leftChild, rightChild); + public PhysicalBinary(OP_TYPE operator, LogicalProperties logicalProperties, + LEFT_CHILD_TYPE leftChild, RIGHT_CHILD_TYPE rightChild) { + super(NodeType.PHYSICAL, operator, logicalProperties, leftChild, rightChild); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLeaf.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLeaf.java index 5138bea6d3..b209cb0371 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLeaf.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalLeaf.java @@ -17,17 +17,19 @@ package org.apache.doris.nereids.trees.plans.physical; +import org.apache.doris.nereids.operators.plans.physical.PhysicalLeafOperator; +import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.plans.LeafPlan; /** * Abstract class for all physical plan that have no child. */ -public abstract class PhysicalLeaf> - extends AbstractPhysicalPlan - implements LeafPlan { +public class PhysicalLeaf + extends AbstractPhysicalPlan, OP_TYPE> + implements LeafPlan, OP_TYPE> { - public PhysicalLeaf(NodeType type) { - super(type); + public PhysicalLeaf(OP_TYPE operator, LogicalProperties logicalProperties) { + super(NodeType.PHYSICAL, operator, logicalProperties); } } diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPlan.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPlan.java index e62d37786c..ed03a95033 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPlan.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalPlan.java @@ -17,7 +17,7 @@ package org.apache.doris.nereids.trees.plans.physical; -import org.apache.doris.nereids.properties.LogicalProperties; +import org.apache.doris.nereids.operators.plans.physical.PhysicalOperator; import org.apache.doris.nereids.trees.plans.Plan; import java.util.List; @@ -25,12 +25,14 @@ import java.util.List; /** * interface for all physical plan. */ -public interface PhysicalPlan> extends Plan { +public interface PhysicalPlan< + PLAN_TYPE extends PhysicalPlan, + OP_TYPE extends PhysicalOperator> + extends Plan { + @Override List children(); @Override Plan child(int index); - - void setLogicalProperties(LogicalProperties logicalProperties); } 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 776d55702a..4a27fdd3ce 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 @@ -17,6 +17,8 @@ package org.apache.doris.nereids.trees.plans.physical; +import org.apache.doris.nereids.operators.plans.physical.PhysicalUnaryOperator; +import org.apache.doris.nereids.properties.LogicalProperties; import org.apache.doris.nereids.trees.NodeType; import org.apache.doris.nereids.trees.plans.Plan; import org.apache.doris.nereids.trees.plans.UnaryPlan; @@ -24,13 +26,12 @@ import org.apache.doris.nereids.trees.plans.UnaryPlan; /** * Abstract class for all physical plan that have one child. */ -public abstract class PhysicalUnary< - PLAN_TYPE extends PhysicalUnary, +public class PhysicalUnary - extends AbstractPhysicalPlan - implements UnaryPlan { + extends AbstractPhysicalPlan, OP_TYPE> + implements UnaryPlan, OP_TYPE, CHILD_TYPE> { - public PhysicalUnary(NodeType type, CHILD_TYPE child) { - super(type, child); + public PhysicalUnary(OP_TYPE operator, LogicalProperties logicalProperties, CHILD_TYPE child) { + super(NodeType.PHYSICAL, operator, logicalProperties, child); } }