| /* |
| * 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.calcite.rel.rules; |
| |
| import org.apache.calcite.plan.Contexts; |
| import org.apache.calcite.plan.RelOptRuleCall; |
| import org.apache.calcite.plan.RelOptRuleOperand; |
| import org.apache.calcite.plan.RelOptUtil; |
| import org.apache.calcite.plan.RelRule; |
| import org.apache.calcite.plan.Strong; |
| import org.apache.calcite.rel.RelNode; |
| import org.apache.calcite.rel.core.Join; |
| import org.apache.calcite.rel.core.JoinRelType; |
| import org.apache.calcite.rel.core.Project; |
| import org.apache.calcite.rel.core.RelFactories.ProjectFactory; |
| import org.apache.calcite.rel.logical.LogicalJoin; |
| import org.apache.calcite.rel.logical.LogicalProject; |
| import org.apache.calcite.rel.type.RelDataType; |
| import org.apache.calcite.rel.type.RelDataTypeField; |
| import org.apache.calcite.rex.RexBuilder; |
| import org.apache.calcite.rex.RexLocalRef; |
| import org.apache.calcite.rex.RexNode; |
| import org.apache.calcite.rex.RexProgram; |
| import org.apache.calcite.rex.RexProgramBuilder; |
| import org.apache.calcite.sql.validate.SqlValidatorUtil; |
| import org.apache.calcite.tools.RelBuilder; |
| import org.apache.calcite.tools.RelBuilderFactory; |
| import org.apache.calcite.util.Pair; |
| |
| import org.checkerframework.checker.nullness.qual.Nullable; |
| import org.immutables.value.Value; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import static java.util.Objects.requireNonNull; |
| |
| /** |
| * Planner rule that matches a |
| * {@link org.apache.calcite.rel.core.Join} one of whose inputs is a |
| * {@link org.apache.calcite.rel.logical.LogicalProject}, and |
| * pulls the project up. |
| * |
| * <p>Projections are pulled up if the |
| * {@link org.apache.calcite.rel.logical.LogicalProject} doesn't originate from |
| * a null generating input in an outer join. |
| */ |
| @Value.Enclosing |
| public class JoinProjectTransposeRule |
| extends RelRule<JoinProjectTransposeRule.Config> |
| implements TransformationRule { |
| |
| /** Creates a JoinProjectTransposeRule. */ |
| protected JoinProjectTransposeRule(Config config) { |
| super(config); |
| } |
| |
| @Deprecated // to be removed before 2.0 |
| public JoinProjectTransposeRule(RelOptRuleOperand operand, |
| String description, boolean includeOuter, |
| RelBuilderFactory relBuilderFactory) { |
| this(Config.DEFAULT.withDescription(description) |
| .withRelBuilderFactory(relBuilderFactory) |
| .withOperandSupplier(b -> b.exactly(operand)) |
| .as(Config.class) |
| .withIncludeOuter(includeOuter)); |
| } |
| |
| @Deprecated // to be removed before 2.0 |
| public JoinProjectTransposeRule( |
| RelOptRuleOperand operand, |
| String description) { |
| this(Config.DEFAULT.withDescription(description) |
| .withOperandSupplier(b -> b.exactly(operand)) |
| .as(Config.class)); |
| } |
| |
| @Deprecated // to be removed before 2.0 |
| public JoinProjectTransposeRule(RelOptRuleOperand operand, |
| String description, ProjectFactory projectFactory) { |
| this(Config.DEFAULT.withDescription(description) |
| .withRelBuilderFactory(RelBuilder.proto(Contexts.of(projectFactory))) |
| .withOperandSupplier(b -> b.exactly(operand)) |
| .as(Config.class)); |
| } |
| |
| @Deprecated // to be removed before 2.0 |
| public JoinProjectTransposeRule(RelOptRuleOperand operand, |
| String description, boolean includeOuter, |
| ProjectFactory projectFactory) { |
| this(Config.DEFAULT.withDescription(description) |
| .withRelBuilderFactory(RelBuilder.proto(Contexts.of(projectFactory))) |
| .withOperandSupplier(b -> b.exactly(operand)) |
| .as(Config.class) |
| .withIncludeOuter(includeOuter)); |
| } |
| |
| //~ Methods ---------------------------------------------------------------- |
| |
| @Override public void onMatch(RelOptRuleCall call) { |
| final Join join = call.rel(0); |
| final JoinRelType joinType = join.getJoinType(); |
| |
| Project leftProject; |
| Project rightProject; |
| RelNode leftJoinChild; |
| RelNode rightJoinChild; |
| |
| // If 1) the rule works on outer joins, or |
| // 2) input's projection doesn't generate nulls |
| final boolean includeOuter = config.isIncludeOuter(); |
| if (hasLeftChild(call) |
| && (includeOuter || !joinType.generatesNullsOnLeft())) { |
| leftProject = call.rel(1); |
| leftJoinChild = getProjectChild(call, leftProject, true); |
| } else { |
| leftProject = null; |
| leftJoinChild = call.rel(1); |
| } |
| if (hasRightChild(call) |
| && (includeOuter || !joinType.generatesNullsOnRight())) { |
| rightProject = getRightChild(call); |
| rightJoinChild = getProjectChild(call, rightProject, false); |
| } else { |
| rightProject = null; |
| rightJoinChild = join.getRight(); |
| } |
| |
| // Skip projects containing over clause |
| if (leftProject != null && leftProject.containsOver()) { |
| leftProject = null; |
| leftJoinChild = join.getLeft(); |
| } |
| if (rightProject != null && rightProject.containsOver()) { |
| rightProject = null; |
| rightJoinChild = join.getRight(); |
| } |
| |
| if ((leftProject == null) && (rightProject == null)) { |
| return; |
| } |
| |
| if (includeOuter) { |
| if (leftProject != null && joinType.generatesNullsOnLeft() |
| && !Strong.allStrong(leftProject.getProjects())) { |
| return; |
| } |
| |
| if (rightProject != null && joinType.generatesNullsOnRight() |
| && !Strong.allStrong(rightProject.getProjects())) { |
| return; |
| } |
| } |
| |
| // Construct two RexPrograms and combine them. The bottom program |
| // is a join of the projection expressions from the left and/or |
| // right projects that feed into the join. The top program contains |
| // the join condition. |
| |
| // Create a row type representing a concatenation of the inputs |
| // underneath the projects that feed into the join. This is the input |
| // into the bottom RexProgram. Note that the join type is an inner |
| // join because the inputs haven't actually been joined yet. |
| final RelDataType joinChildrenRowType = |
| SqlValidatorUtil.deriveJoinRowType( |
| leftJoinChild.getRowType(), |
| rightJoinChild.getRowType(), |
| JoinRelType.INNER, |
| join.getCluster().getTypeFactory(), |
| null, |
| Collections.emptyList()); |
| |
| // Create projection expressions, combining the projection expressions |
| // from the projects that feed into the join. For the RHS projection |
| // expressions, shift them to the right by the number of fields on |
| // the LHS. If the join input was not a projection, simply create |
| // references to the inputs. |
| final int nProjExprs = join.getRowType().getFieldCount(); |
| final List<Pair<RexNode, String>> projects = new ArrayList<>(); |
| final RexBuilder rexBuilder = join.getCluster().getRexBuilder(); |
| |
| createProjectExprs( |
| leftProject, |
| leftJoinChild, |
| 0, |
| rexBuilder, |
| joinChildrenRowType.getFieldList(), |
| projects); |
| |
| final List<RelDataTypeField> leftFields = |
| leftJoinChild.getRowType().getFieldList(); |
| final int nFieldsLeft = leftFields.size(); |
| createProjectExprs( |
| rightProject, |
| rightJoinChild, |
| nFieldsLeft, |
| rexBuilder, |
| joinChildrenRowType.getFieldList(), |
| projects); |
| |
| final List<RelDataType> projTypes = new ArrayList<>(); |
| for (int i = 0; i < nProjExprs; i++) { |
| projTypes.add(projects.get(i).left.getType()); |
| } |
| RelDataType projRowType = |
| rexBuilder.getTypeFactory().createStructType( |
| projTypes, |
| Pair.right(projects)); |
| |
| // create the RexPrograms and merge them |
| final RexProgram bottomProgram = |
| RexProgram.create( |
| joinChildrenRowType, |
| Pair.left(projects), |
| null, |
| projRowType, |
| rexBuilder); |
| final RexProgramBuilder topProgramBuilder = |
| new RexProgramBuilder( |
| projRowType, |
| rexBuilder); |
| topProgramBuilder.addIdentity(); |
| topProgramBuilder.addCondition(join.getCondition()); |
| final RexProgram topProgram = topProgramBuilder.getProgram(); |
| final RexProgram mergedProgram = |
| RexProgramBuilder.mergePrograms( |
| topProgram, |
| bottomProgram, |
| rexBuilder); |
| |
| // expand out the join condition and construct a new LogicalJoin that |
| // directly references the join children without the intervening |
| // ProjectRels |
| final RexNode newCondition = |
| mergedProgram.expandLocalRef( |
| requireNonNull(mergedProgram.getCondition(), |
| () -> "mergedProgram.getCondition() for " + mergedProgram)); |
| final Join newJoin = |
| join.copy(join.getTraitSet(), newCondition, |
| leftJoinChild, rightJoinChild, join.getJoinType(), |
| join.isSemiJoinDone()); |
| |
| // expand out the new projection expressions; if the join is an |
| // outer join, modify the expressions to reference the join output |
| final List<RexNode> newProjExprs = new ArrayList<>(); |
| final List<RexLocalRef> projList = mergedProgram.getProjectList(); |
| final List<RelDataTypeField> newJoinFields = |
| newJoin.getRowType().getFieldList(); |
| final int nJoinFields = newJoinFields.size(); |
| int[] adjustments = new int[nJoinFields]; |
| for (int i = 0; i < nProjExprs; i++) { |
| RexNode newExpr = mergedProgram.expandLocalRef(projList.get(i)); |
| if (joinType.isOuterJoin()) { |
| newExpr = |
| newExpr.accept( |
| new RelOptUtil.RexInputConverter( |
| rexBuilder, |
| joinChildrenRowType.getFieldList(), |
| newJoinFields, |
| adjustments)); |
| } |
| newProjExprs.add(newExpr); |
| } |
| |
| // finally, create the projection on top of the join |
| final RelBuilder relBuilder = call.builder(); |
| relBuilder.push(newJoin); |
| relBuilder.project(newProjExprs, join.getRowType().getFieldNames()); |
| // if the join was outer, we might need a cast after the |
| // projection to fix differences wrt nullability of fields |
| if (joinType.isOuterJoin()) { |
| relBuilder.convert(join.getRowType(), false); |
| } |
| |
| call.transformTo(relBuilder.build()); |
| } |
| |
| /** Returns whether the rule was invoked with a left project child. */ |
| protected boolean hasLeftChild(RelOptRuleCall call) { |
| return call.rel(1) instanceof Project; |
| } |
| |
| /** Returns whether the rule was invoked with 2 children. */ |
| protected boolean hasRightChild(RelOptRuleCall call) { |
| return call.rels.length == 3; |
| } |
| |
| /** Returns the Project corresponding to the right child. */ |
| protected Project getRightChild(RelOptRuleCall call) { |
| return call.rel(2); |
| } |
| |
| /** |
| * Returns the child of the project that will be used as input into the new |
| * LogicalJoin once the projects are pulled above the LogicalJoin. |
| * |
| * @param call RelOptRuleCall |
| * @param project project RelNode |
| * @param leftChild true if the project corresponds to the left projection |
| * @return child of the project that will be used as input into the new |
| * LogicalJoin once the projects are pulled above the LogicalJoin |
| */ |
| protected RelNode getProjectChild( |
| RelOptRuleCall call, |
| Project project, |
| boolean leftChild) { |
| return project.getInput(); |
| } |
| |
| /** |
| * Creates projection expressions corresponding to one of the inputs into |
| * the join. |
| * |
| * @param project the projection input into the join (if it exists) |
| * @param joinChild the child of the projection input (if there is a |
| * projection); otherwise, this is the join input |
| * @param adjustmentAmount the amount the expressions need to be shifted by |
| * @param rexBuilder rex builder |
| * @param joinChildrenFields concatenation of the fields from the left and |
| * right join inputs (once the projections have been |
| * removed) |
| * @param projects Projection expressions & names to be created |
| */ |
| protected void createProjectExprs( |
| @Nullable Project project, |
| RelNode joinChild, |
| int adjustmentAmount, |
| RexBuilder rexBuilder, |
| List<RelDataTypeField> joinChildrenFields, |
| List<Pair<RexNode, String>> projects) { |
| List<RelDataTypeField> childFields = |
| joinChild.getRowType().getFieldList(); |
| if (project != null) { |
| List<Pair<RexNode, String>> namedProjects = |
| project.getNamedProjects(); |
| int nChildFields = childFields.size(); |
| int[] adjustments = new int[nChildFields]; |
| for (int i = 0; i < nChildFields; i++) { |
| adjustments[i] = adjustmentAmount; |
| } |
| for (Pair<RexNode, String> pair : namedProjects) { |
| RexNode e = pair.left; |
| if (adjustmentAmount != 0) { |
| // shift the references by the adjustment amount |
| e = e.accept( |
| new RelOptUtil.RexInputConverter( |
| rexBuilder, |
| childFields, |
| joinChildrenFields, |
| adjustments)); |
| } |
| projects.add(Pair.of(e, pair.right)); |
| } |
| } else { |
| // no projection; just create references to the inputs |
| for (int i = 0; i < childFields.size(); i++) { |
| final RelDataTypeField field = childFields.get(i); |
| projects.add( |
| Pair.of( |
| rexBuilder.makeInputRef(field.getType(), |
| i + adjustmentAmount), |
| field.getName())); |
| } |
| } |
| } |
| |
| /** Rule configuration. */ |
| @Value.Immutable |
| public interface Config extends RelRule.Config { |
| Config DEFAULT = ImmutableJoinProjectTransposeRule.Config.of() |
| .withOperandSupplier(b0 -> |
| b0.operand(LogicalJoin.class).inputs( |
| b1 -> b1.operand(LogicalProject.class).anyInputs(), |
| b2 -> b2.operand(LogicalProject.class).anyInputs())) |
| .withDescription("JoinProjectTransposeRule(Project-Project)"); |
| |
| Config LEFT = DEFAULT |
| .withOperandSupplier(b0 -> |
| b0.operand(LogicalJoin.class).inputs( |
| b1 -> b1.operand(LogicalProject.class).anyInputs())) |
| .withDescription("JoinProjectTransposeRule(Project-Other)") |
| .as(Config.class); |
| |
| Config RIGHT = DEFAULT |
| .withOperandSupplier(b0 -> |
| b0.operand(LogicalJoin.class).inputs( |
| b1 -> b1.operand(RelNode.class).anyInputs(), |
| b2 -> b2.operand(LogicalProject.class).anyInputs())) |
| .withDescription("JoinProjectTransposeRule(Other-Project)") |
| .as(Config.class); |
| |
| Config OUTER = DEFAULT |
| .withDescription( |
| "Join(IncludingOuter)ProjectTransposeRule(Project-Project)") |
| .as(Config.class) |
| .withIncludeOuter(true); |
| |
| Config LEFT_OUTER = LEFT |
| .withDescription( |
| "Join(IncludingOuter)ProjectTransposeRule(Project-Other)") |
| .as(Config.class) |
| .withIncludeOuter(true); |
| |
| Config RIGHT_OUTER = RIGHT |
| .withDescription( |
| "Join(IncludingOuter)ProjectTransposeRule(Other-Project)") |
| .as(Config.class) |
| .withIncludeOuter(true); |
| |
| @Override default JoinProjectTransposeRule toRule() { |
| return new JoinProjectTransposeRule(this); |
| } |
| |
| /** Whether to include outer joins, default false. */ |
| @Value.Default default boolean isIncludeOuter() { |
| return false; |
| } |
| |
| /** Sets {@link #isIncludeOuter()}. */ |
| Config withIncludeOuter(boolean includeOuter); |
| } |
| } |
