Package org.apache.calcite.plan

Class RelOptUtil

java.lang.Object
org.apache.calcite.plan.RelOptUtil
public abstract class RelOptUtil extends Object
RelOptUtil defines static utility methods for use in optimizing RelNodes.

  • Field Details

  • Constructor Details

    • RelOptUtil

      public RelOptUtil()

  • Method Details

    • isPureLimit

      public static boolean isPureLimit(RelNode rel)
      Whether this node is a limit without sort specification.

    • isPureOrder

      public static boolean isPureOrder(RelNode rel)
      Whether this node is a sort without limit specification.

    • isLimit

      public static boolean isLimit(RelNode rel)
      Whether this node contains a limit specification.

    • isOrder

      public static boolean isOrder(RelNode rel)
      Whether this node contains a sort specification.

    • isOffset

      public static boolean isOffset(RelNode rel)
      Whether this node contains a offset specification.

    • findTables

      public static Set<RelOptTable> findTables(RelNode rel)
      Returns a set of tables used by this expression or its children.

    • findAllTables

      public static List<RelOptTable> findAllTables(RelNode rel)
      Returns a list of all tables used by this expression or its children.

    • findAllTableQualifiedNames

      public static List<String> findAllTableQualifiedNames(RelNode rel)
      Returns a list of all table qualified names used by this expression or its children.

    • getVariablesSet

      public static Set<CorrelationId> getVariablesSet(RelNode rel)
      Returns a list of variables set by a relational expression or its descendants.

    • getVariablesSetAndUsed

      @Deprecated public static List<CorrelationId> getVariablesSetAndUsed(RelNode rel0, RelNode rel1)
      Deprecated.

    • getVariablesUsed

      public static Set<CorrelationId> getVariablesUsed(RelNode rel)
      Returns the set of variables used by a relational expression or its descendants.

      The set may contain "duplicates" (variables with different ids that, when resolved, will reference the same source relational expression).

      The item type is the same as RexCorrelVariable.id.

    • getVariablesUsed

      public static Set<CorrelationId> getVariablesUsed(List<RexSubQuery> subQueries)
      Returns the set of variables used by the given list of sub-queries and its descendants.
      Parameters:
      subQueries - The sub-queries containing correlation variables
      Returns:
      A list of correlation identifiers found within the sub-queries. The type of the [CorrelationId] parameter corresponds to RexCorrelVariable.id.

    • correlationColumns

      public static ImmutableBitSet correlationColumns(CorrelationId id, RelNode rel)
      Finds which columns of a correlation variable are used within a relational expression.

    • notContainsCorrelation

      public static boolean notContainsCorrelation(RelNode r, CorrelationId correlationId, Litmus litmus)
      Returns true, and calls Litmus.succeed() if a given relational expression does not contain a given correlation.

    • go

      public static void go(RelVisitor visitor, RelNode p)
      Sets a RelVisitor going on a given relational expression, and returns the result.

    • getFieldTypeList

      public static List<RelDataType> getFieldTypeList(RelDataType type)
      Returns a list of the types of the fields in a given struct type. The list is immutable.
      Parameters:
      type - Struct type
      Returns:
      List of field types
      See Also:

    • areRowTypesEqual

      public static boolean areRowTypesEqual(RelDataType rowType1, RelDataType rowType2, boolean compareNames)

    • verifyTypeEquivalence

      public static void verifyTypeEquivalence(RelNode originalRel, RelNode newRel, Object equivalenceClass)
      Verifies that a row type being added to an equivalence class matches the existing type, raising an assertion if this is not the case.
      Parameters:
      originalRel - canonical rel for equivalence class
      newRel - rel being added to equivalence class
      equivalenceClass - object representing equivalence class

    • propagateRelHints

      public static RelNode propagateRelHints(RelNode originalRel, RelNode equiv)
      Copy the RelHints from originalRel to newRel if both of them are Hintable.

      The two relational expressions are assumed as semantically equivalent, that means the hints should be attached to the relational expression that expects to have them.

      Try to propagate the hints to the first relational expression that matches, this is needed because many planner rules would generate a sub-tree whose root rel type is different with the original matched rel.

      For the worst case, there is no relational expression that can apply these hints, and the whole sub-tree would be visited. We add a protection here: if the visiting depth is over than 3, just returns, because there are rare cases the new created sub-tree has layers bigger than that.

      This is a best effort, we do not know exactly how the nodes are transformed in all kinds of planner rules, so for some complex relational expressions, the hints would very probably lost.

      This function is experimental and would change without any notes.

      Parameters:
      originalRel - Original relational expression
      equiv - New equivalent relational expression
      Returns:
      A copy of newRel with attached qualified hints from originalRel, or newRel directly if one of them are not Hintable

    • propagateRelHints

      public static RelNode propagateRelHints(RelNode rel, boolean reset)
      Propagates the relational expression hints from root node to leaf node.
      Parameters:
      rel - The relational expression
      reset - Flag saying if to reset the existing hints before the propagation
      Returns:
      New relational expression with hints propagated

    • copyRelHints

      public static RelNode copyRelHints(RelNode originalRel, RelNode newRel)
      Copy the RelHints from originalRel to newRel if both of them are Hintable.

      The hints would be attached directly(e.g. without any filtering).

      Parameters:
      originalRel - Original relational expression
      newRel - New relational expression
      Returns:
      A copy of newRel with attached hints from originalRel, or newRel directly if one of them are not Hintable

    • copyRelHints

      public static RelNode copyRelHints(RelNode originalRel, RelNode newRel, boolean filterHints)
      Copy the RelHints from originalRel to newRel if both of them are Hintable.

      The hints would be filtered by the specified hint strategies if filterHints is true.

      Parameters:
      originalRel - Original relational expression
      newRel - New relational expression
      filterHints - Flag saying if to filter out unqualified hints for newRel
      Returns:
      A copy of newRel with attached hints from originalRel, or newRel directly if one of them are not Hintable

    • permutationIgnoreCast

      public static Mappings.TargetMapping permutationIgnoreCast(List<RexNode> nodes, RelDataType inputRowType)
      Returns a permutation describing where output fields come from. In the returned map, value of map.getTargetOpt(i) is n if field i projects input field n or applies a cast on n, -1 if it is another expression.

    • permutation

      public static Mappings.TargetMapping permutation(List<RexNode> nodes, RelDataType inputRowType)
      Returns a permutation describing where output fields come from. In the returned map, value of map.getTargetOpt(i) is n if field i projects input field n, -1 if it is an expression.

    • permutationPushDownProject

      public static Mappings.TargetMapping permutationPushDownProject(List<RexNode> nodes, RelDataType inputRowType, int sourceOffset, int targetOffset)
      Returns a permutation describing where the Project's fields come from after the Project is pushed down.

    • createExistsPlan

      @Deprecated public static RelNode createExistsPlan(RelOptCluster cluster, RelNode seekRel, @Nullable List<RexNode> conditions, @Nullable RexLiteral extraExpr, @Nullable String extraName)
      Deprecated.

    • createExistsPlan

      @Deprecated public static RelOptUtil.Exists createExistsPlan(RelNode seekRel, RelOptUtil.SubQueryType subQueryType, RelOptUtil.Logic logic, boolean notIn)
      Deprecated.

    • createExistsPlan

      public static RelOptUtil.Exists createExistsPlan(RelNode seekRel, RelOptUtil.SubQueryType subQueryType, RelOptUtil.Logic logic, boolean notIn, RelBuilder relBuilder)
      Creates a plan suitable for use in EXISTS or IN statements.
      Parameters:
      seekRel - A query rel, for example the resulting rel from 'select * from emp' or 'values (1,2,3)' or '('Foo', 34)'.
      subQueryType - Sub-query type
      logic - Whether to use 2- or 3-valued boolean logic
      notIn - Whether the operator is NOT IN
      relBuilder - Builder for relational expressions
      Returns:
      A pair of a relational expression which outer joins a boolean condition column, and a numeric offset. The offset is 2 if column 0 is the number of rows and column 1 is the number of rows with not-null keys; 0 otherwise.
      See Also:

    • createRenameRel

      @Deprecated public static RelNode createRenameRel(RelDataType outputType, RelNode rel)
      Deprecated.

    • createFilter

      @Deprecated public static RelNode createFilter(RelNode child, RexNode condition)
      Deprecated.

    • createFilter

      @Deprecated public static RelNode createFilter(RelNode child, RexNode condition, RelFactories.FilterFactory filterFactory)
      Deprecated.

    • createFilter

      public static RelNode createFilter(RelNode child, Iterable<? extends RexNode> conditions)
      Creates a filter, using the default filter factory, or returns the original relational expression if the condition is trivial.

    • createFilter

      public static RelNode createFilter(RelNode child, Iterable<? extends RexNode> conditions, RelFactories.FilterFactory filterFactory)
      Creates a filter using the default factory, or returns the original relational expression if the condition is trivial.

    • createNullFilter

      @Deprecated public static RelNode createNullFilter(RelNode rel, Integer @Nullable [] fieldOrdinals)
      Deprecated.

    • createCastRel

      public static RelNode createCastRel(RelNode rel, RelDataType castRowType, boolean rename)
      Creates a projection which casts a rel's output to a desired row type.

      No need to create new projection if rel is already a project, instead, create a projection with the input of rel and the new cast expressions.

      The desired row type and the row type to be converted must have the same number of fields.

      Parameters:
      rel - producer of rows to be converted
      castRowType - row type after cast
      rename - if true, use field names from castRowType; if false, preserve field names from rel
      Returns:
      conversion rel

    • createCastRel

      public static RelNode createCastRel(RelNode rel, RelDataType castRowType, boolean rename, RelFactories.ProjectFactory projectFactory)
      Creates a projection which casts a rel's output to a desired row type.

      No need to create new projection if rel is already a project, instead, create a projection with the input of rel and the new cast expressions.

      The desired row type and the row type to be converted must have the same number of fields.

      Parameters:
      rel - producer of rows to be converted
      castRowType - row type after cast
      rename - if true, use field names from castRowType; if false, preserve field names from rel
      projectFactory - Project Factory
      Returns:
      conversion rel

    • getAllFields

      public static Set<Integer> getAllFields(Aggregate aggregate)
      Gets all fields in an aggregate.

    • getAllFields2

      public static Set<Integer> getAllFields2(ImmutableBitSet groupSet, List<AggregateCall> aggCallList)
      Gets all fields in an aggregate.

    • createSingleValueAggRel

      public static RelNode createSingleValueAggRel(RelOptCluster cluster, RelNode rel)
      Creates a LogicalAggregate that removes all duplicates from the result of an underlying relational expression.
      Parameters:
      rel - underlying rel
      Returns:
      rel implementing SingleValueAgg

    • createDistinctRel

      @Deprecated public static RelNode createDistinctRel(RelNode rel)
      Deprecated.
      Use RelBuilder.distinct().

    • analyzeSimpleEquiJoin

      @Deprecated public static boolean analyzeSimpleEquiJoin(LogicalJoin join, int[] joinFieldOrdinals)
      Deprecated.

    • splitJoinCondition

      public static RexNode splitJoinCondition(RelNode left, RelNode right, RexNode condition, List<Integer> leftKeys, List<Integer> rightKeys, @Nullable List<Boolean> filterNulls)
      Splits out the equi-join components of a join condition, and returns what's left. For example, given the condition
      L.A = R.X AND L.B = L.C AND (L.D = 5 OR L.E = R.Y)

      returns

      • leftKeys = {A}
      • rightKeys = {X}
      • rest = L.B = L.C AND (L.D = 5 OR L.E = R.Y)
      Parameters:
      left - left input to join
      right - right input to join
      condition - join condition
      leftKeys - The ordinals of the fields from the left input which are equi-join keys
      rightKeys - The ordinals of the fields from the right input which are equi-join keys
      filterNulls - List of boolean values for each join key position indicating whether the operator filters out nulls or not. Value is true if the operator is EQUALS and false if the operator is IS NOT DISTINCT FROM (or an expanded version). If filterNulls is null, only join conditions with EQUALS operators are considered equi-join components. Rest (including IS NOT DISTINCT FROM) are returned in remaining join condition.
      Returns:
      remaining join filters that are not equijoins; may return a RexLiteral true, but never null

    • splitJoinCondition

      public static void splitJoinCondition(RelNode left, RelNode right, RexNode condition, List<Integer> leftKeys, List<Integer> rightKeys, @Nullable List<Boolean> filterNulls, List<RexNode> nonEquiList)
      As splitJoinCondition(RelNode, RelNode, RexNode, List, List, List), but writes non-equi conditions to a conjunctive list.

    • isEqui

      @Deprecated public static boolean isEqui(RelNode left, RelNode right, RexNode condition)
      Deprecated.

    • splitJoinCondition

      public static RexNode splitJoinCondition(List<RelDataTypeField> sysFieldList, RelNode leftRel, RelNode rightRel, RexNode condition, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, @Nullable List<Integer> filterNulls, @Nullable List<SqlOperator> rangeOp)
      Splits out the equi-join (and optionally, a single non-equi) components of a join condition, and returns what's left. Projection might be required by the caller to provide join keys that are not direct field references.
      Parameters:
      sysFieldList - list of system fields
      leftRel - left join input
      rightRel - right join input
      condition - join condition
      leftJoinKeys - The join keys from the left input which are equi-join keys
      rightJoinKeys - The join keys from the right input which are equi-join keys
      filterNulls - The join key positions for which null values will not match. null values only match for the "is not distinct from" condition.
      rangeOp - if null, only locate equi-joins; otherwise, locate a single non-equi join predicate and return its operator in this list; join keys associated with the non-equi join predicate are at the end of the key lists returned
      Returns:
      What's left, never null

    • splitJoinCondition

      public static RexNode splitJoinCondition(List<RelDataTypeField> sysFieldList, List<RelNode> inputs, RexNode condition, List<List<RexNode>> joinKeys, @Nullable List<Integer> filterNulls, @Nullable List<SqlOperator> rangeOp)
      Splits out the equi-join (and optionally, a single non-equi) components of a join condition, and returns what's left. Projection might be required by the caller to provide join keys that are not direct field references.
      Parameters:
      sysFieldList - list of system fields
      inputs - join inputs
      condition - join condition
      joinKeys - The join keys from the inputs which are equi-join keys
      filterNulls - The join key positions for which null values will not match. null values only match for the "is not distinct from" condition.
      rangeOp - if null, only locate equi-joins; otherwise, locate a single non-equi join predicate and return its operator in this list; join keys associated with the non-equi join predicate are at the end of the key lists returned
      Returns:
      What's left, never null

    • splitCorrelatedFilterCondition

      @Deprecated public static @Nullable RexNode splitCorrelatedFilterCondition(LogicalFilter filter, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys)
      Deprecated.

    • splitCorrelatedFilterCondition

      public static @Nullable RexNode splitCorrelatedFilterCondition(LogicalFilter filter, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess)

    • splitCorrelatedFilterCondition

      public static @Nullable RexNode splitCorrelatedFilterCondition(Filter filter, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess)

    • createEquiJoinCondition

      public static RexNode createEquiJoinCondition(RelNode left, List<Integer> leftKeys, RelNode right, List<Integer> rightKeys, RexBuilder rexBuilder)
      Builds an equi-join condition from a set of left and right keys.

    • op

      public static SqlOperator op(SqlKind kind, SqlOperator operator)
      Returns SqlOperator for given SqlKind or returns operator when SqlKind is not known.
      Parameters:
      kind - input kind
      operator - default operator value
      Returns:
      SqlOperator for the given kind
      See Also:

    • collapseExpandedIsNotDistinctFromExpr

      public static RexCall collapseExpandedIsNotDistinctFromExpr(RexCall call, RexBuilder rexBuilder)
      Collapses an expanded version of IS NOT DISTINCT FROM expression.

      Helper method for splitJoinCondition(RexBuilder, int, RexNode, List, List, List, List) and splitJoinCondition(List, List, RexNode, List, List, List, List).

      If the given expr call is an expanded version of IS NOT DISTINCT FROM function call, collapses it and return a IS NOT DISTINCT FROM function call.

      For example: t1.key IS NOT DISTINCT FROM t2.key can rewritten in expanded form as t1.key = t2.key OR (t1.key IS NULL AND t2.key IS NULL).

      Parameters:
      call - Function expression to try collapsing
      rexBuilder - RexBuilder instance to create new RexCall instances.
      Returns:
      If the given function is an expanded IS NOT DISTINCT FROM function call, return a IS NOT DISTINCT FROM function call. Otherwise return the input function call as it is.

    • projectJoinInputs

      @Deprecated public static void projectJoinInputs(RelNode[] inputRels, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, int systemColCount, List<Integer> leftKeys, List<Integer> rightKeys, List<Integer> outputProj)
      Deprecated.

    • createProjectJoinRel

      @Deprecated public static RelNode createProjectJoinRel(List<Integer> outputProj, RelNode joinRel)
      Deprecated.

    • registerAbstractRels

      @Deprecated public static void registerAbstractRels(RelOptPlanner planner)
      Deprecated.

    • registerAbstractRules

      public static void registerAbstractRules(RelOptPlanner planner)

    • registerAbstractRelationalRules

      public static void registerAbstractRelationalRules(RelOptPlanner planner)

    • registerDefaultRules

      public static void registerDefaultRules(RelOptPlanner planner, boolean enableMaterializations, boolean enableBindable)

    • dumpPlan

      public static String dumpPlan(String header, RelNode rel, SqlExplainFormat format, SqlExplainLevel detailLevel)
      Dumps a plan as a string.
      Parameters:
      header - Header to print before the plan. Ignored if the format is XML
      rel - Relational expression to explain
      format - Output format
      detailLevel - Detail level
      Returns:
      Plan

    • dumpPlan

      @Deprecated public static String dumpPlan(String header, RelNode rel, boolean asXml, SqlExplainLevel detailLevel)
      Deprecated.

    • createDmlRowType

      public static RelDataType createDmlRowType(SqlKind kind, RelDataTypeFactory typeFactory)
      Creates the row type descriptor for the result of a DML operation, which is a single column named ROWCOUNT of type BIGINT for INSERT; a single column named PLAN for EXPLAIN.
      Parameters:
      kind - Kind of node
      typeFactory - factory to use for creating type descriptor
      Returns:
      created type

    • eq

      public static boolean eq(String desc1, RelDataType type1, String desc2, RelDataType type2, Litmus litmus)
      Returns whether two types are equal using 'equals'.
      Parameters:
      desc1 - Description of first type
      type1 - First type
      desc2 - Description of second type
      type2 - Second type
      litmus - What to do if an error is detected (types are not equal)
      Returns:
      Whether the types are equal

    • equal

      public static boolean equal(String desc1, RelDataType type1, String desc2, RelDataType type2, Litmus litmus)
      Returns whether two types are equal using areRowTypesEqual(RelDataType, RelDataType, boolean). Both types must not be null.
      Parameters:
      desc1 - Description of role of first type
      type1 - First type
      desc2 - Description of role of second type
      type2 - Second type
      litmus - Whether to assert if they are not equal
      Returns:
      Whether the types are equal

    • getFullTypeDifferenceString

      public static String getFullTypeDifferenceString(String sourceDesc, RelDataType sourceType, String targetDesc, RelDataType targetType)
      Returns the detailed difference of two types.
      Parameters:
      sourceDesc - description of role of source type
      sourceType - source type
      targetDesc - description of role of target type
      targetType - target type
      Returns:
      the detailed difference of two types

    • equalType

      public static boolean equalType(String desc0, RelNode rel0, String desc1, RelNode rel1, Litmus litmus)
      Returns whether two relational expressions have the same row-type.

    • isDistinctFrom

      public static RexNode isDistinctFrom(RexBuilder rexBuilder, RexNode x, RexNode y, boolean neg)
      Returns a translation of the IS DISTINCT FROM (or IS NOT DISTINCT FROM) sql operator.
      Parameters:
      neg - if false, returns a translation of IS NOT DISTINCT FROM

    • toString

      public static String toString(RelNode rel)
      Converts a relational expression to a string, showing just basic attributes.

    • toString

      public static @PolyNull String toString(@PolyNull RelNode rel, SqlExplainLevel detailLevel)
      Converts a relational expression to a string; returns null if and only if rel is null.

    • renameIfNecessary

      @Deprecated public static RelNode renameIfNecessary(RelNode rel, RelDataType desiredRowType)
      Deprecated.

    • dumpType

      public static String dumpType(RelDataType type)

    • deduplicateColumns

      public static List<RelDataTypeField> deduplicateColumns(List<RelDataTypeField> baseColumns, List<RelDataTypeField> extendedColumns)
      Returns the set of columns with unique names, with prior columns taking precedence over columns that appear later in the list.

    • decomposeConjunction

      public static void decomposeConjunction(@Nullable RexNode rexPredicate, List<RexNode> rexList)
      Decomposes a predicate into a list of expressions that are AND'ed together.
      Parameters:
      rexPredicate - predicate to be analyzed
      rexList - list of decomposed RexNodes

    • decomposeConjunction

      public static void decomposeConjunction(@Nullable RexNode rexPredicate, List<RexNode> rexList, List<RexNode> notList)
      Decomposes a predicate into a list of expressions that are AND'ed together, and a list of expressions that are preceded by NOT.

      For example, a AND NOT b AND NOT (c and d) AND TRUE AND NOT FALSE returns rexList = [a], notList = [b, c AND d].

      TRUE and NOT FALSE expressions are ignored. FALSE and NOT TRUE expressions are placed on rexList and notList as other expressions.

      For example, a AND TRUE AND NOT TRUE returns rexList = [a], notList = [TRUE].

      Parameters:
      rexPredicate - predicate to be analyzed
      rexList - list of decomposed RexNodes (except those with NOT)
      notList - list of decomposed RexNodes that were prefixed NOT

    • decomposeDisjunction

      public static void decomposeDisjunction(@Nullable RexNode rexPredicate, List<RexNode> rexList)
      Decomposes a predicate into a list of expressions that are OR'ed together.
      Parameters:
      rexPredicate - predicate to be analyzed
      rexList - list of decomposed RexNodes

    • conjunctions

      public static List<RexNode> conjunctions(@Nullable RexNode rexPredicate)
      Returns a condition decomposed by AND.

      For example, conjunctions(TRUE) returns the empty list; conjunctions(FALSE) returns list {FALSE}.

    • disjunctions

      public static List<RexNode> disjunctions(RexNode rexPredicate)
      Returns a condition decomposed by OR.

      For example, disjunctions(FALSE) returns the empty list.

    • andJoinFilters

      public static RexNode andJoinFilters(RexBuilder rexBuilder, @Nullable RexNode left, @Nullable RexNode right)
      Ands two sets of join filters together, either of which can be null.
      Parameters:
      rexBuilder - rexBuilder to create AND expression
      left - filter on the left that the right will be AND'd to
      right - filter on the right
      Returns:
      AND'd filter
      See Also:

    • inferViewPredicates

      public static void inferViewPredicates(Map<Integer,RexNode> projectMap, List<RexNode> filters, RexNode constraint)
      Decomposes the WHERE clause of a view into predicates that constraint a column to a particular value.

      This method is key to the validation of a modifiable view. Columns that are constrained to a single value can be omitted from the SELECT clause of a modifiable view.

      Parameters:
      projectMap - Mapping from column ordinal to the expression that populate that column, to be populated by this method
      filters - List of remaining filters, to be populated by this method
      constraint - Constraint to be analyzed

    • getColumnConstraints

      public static Map<Integer,RexNode> getColumnConstraints(ModifiableView modifiableViewTable, RelDataType targetRowType, RelDataTypeFactory typeFactory)
      Returns a mapping of the column ordinal in the underlying table to a column constraint of the modifiable view.
      Parameters:
      modifiableViewTable - The modifiable view which has a constraint
      targetRowType - The target type

    • validateValueAgainstConstraint

      public static void validateValueAgainstConstraint(SqlNode sourceValue, RexNode targetConstraint, Supplier<CalciteContextException> errorSupplier)
      Ensures that a source value does not violate the constraint of the target column.
      Parameters:
      sourceValue - The insert value being validated
      targetConstraint - The constraint applied to sourceValue for validation
      errorSupplier - The function to apply when validation fails

    • adjustKeys

      public static List<Integer> adjustKeys(List<Integer> keys, int adjustment)
      Adjusts key values in a list by some fixed amount.
      Parameters:
      keys - list of key values
      adjustment - the amount to adjust the key values by
      Returns:
      modified list

    • simplifyJoin

      public static JoinRelType simplifyJoin(RelNode joinRel, com.google.common.collect.ImmutableList<RexNode> aboveFilters, JoinRelType joinType)
      Simplifies outer joins if filter above would reject nulls.
      Parameters:
      joinRel - Join
      aboveFilters - Filters from above
      joinType - Join type, can not be inner join

    • classifyFilters

      public static boolean classifyFilters(RelNode joinRel, List<RexNode> filters, boolean pushInto, boolean pushLeft, boolean pushRight, List<RexNode> joinFilters, List<RexNode> leftFilters, List<RexNode> rightFilters)
      Classifies filters according to where they should be processed. They either stay where they are, are pushed to the join (if they originated from above the join), or are pushed to one of the children. Filters that are pushed are added to list passed in as input parameters.
      Parameters:
      joinRel - join node
      filters - filters to be classified
      pushInto - whether filters can be pushed into the join
      pushLeft - true if filters can be pushed to the left
      pushRight - true if filters can be pushed to the right
      joinFilters - list of filters to push to the join
      leftFilters - list of filters to push to the left child
      rightFilters - list of filters to push to the right child
      Returns:
      whether at least one filter was pushed

    • classifyFilters

      @Deprecated public static boolean classifyFilters(RelNode joinRel, List<RexNode> filters, JoinRelType joinType, boolean pushInto, boolean pushLeft, boolean pushRight, List<RexNode> joinFilters, List<RexNode> leftFilters, List<RexNode> rightFilters)
      Deprecated.
      Use classifyFilters(RelNode, List, boolean, boolean, boolean, List, List, List)
      Classifies filters according to where they should be processed. They either stay where they are, are pushed to the join (if they originated from above the join), or are pushed to one of the children. Filters that are pushed are added to list passed in as input parameters.
      Parameters:
      joinRel - join node
      filters - filters to be classified
      joinType - join type
      pushInto - whether filters can be pushed into the ON clause
      pushLeft - true if filters can be pushed to the left
      pushRight - true if filters can be pushed to the right
      joinFilters - list of filters to push to the join
      leftFilters - list of filters to push to the left child
      rightFilters - list of filters to push to the right child
      Returns:
      whether at least one filter was pushed

    • splitFilters

      public static void splitFilters(ImmutableBitSet childBitmap, @Nullable RexNode predicate, List<RexNode> pushable, List<RexNode> notPushable)
      Splits a filter into two lists, depending on whether or not the filter only references its child input.
      Parameters:
      childBitmap - Fields in the child
      predicate - filters that will be split
      pushable - returns the list of filters that can be pushed to the child input
      notPushable - returns the list of filters that cannot be pushed to the child input

    • checkProjAndChildInputs

      @Deprecated public static boolean checkProjAndChildInputs(Project project, boolean checkNames)
      Deprecated.

    • createSwappedJoinExprs

      public static List<RexNode> createSwappedJoinExprs(RelNode newJoin, Join origJoin, boolean origOrder)
      Creates projection expressions reflecting the swapping of a join's input.
      Parameters:
      newJoin - the RelNode corresponding to the join with its inputs swapped
      origJoin - original LogicalJoin
      origOrder - if true, create the projection expressions to reflect the original (pre-swapped) join projection; otherwise, create the projection to reflect the order of the swapped projection
      Returns:
      array of expression representing the swapped join inputs

    • pushFilterPastProject

      @Deprecated public static RexNode pushFilterPastProject(RexNode filter, Project projRel)
      Deprecated.

    • pushPastProject

      public static RexNode pushPastProject(RexNode node, Project project)
      Converts an expression that is based on the output fields of a Project to an equivalent expression on the Project's input fields.
      Parameters:
      node - The expression to be converted
      project - Project underneath the expression
      Returns:
      converted expression

    • pushPastProject

      public static List<RexNode> pushPastProject(List<? extends RexNode> nodes, Project project)
      Converts a list of expressions that are based on the output fields of a Project to equivalent expressions on the Project's input fields.
      Parameters:
      nodes - The expressions to be converted
      project - Project underneath the expression
      Returns:
      converted expressions

    • pushPastProjectUnlessBloat

      public static @Nullable RexNode pushPastProjectUnlessBloat(RexNode node, Project project, int bloat)

    • pushPastProjectUnlessBloat

      public static @Nullable List<RexNode> pushPastProjectUnlessBloat(List<? extends RexNode> nodes, Project project, int bloat)
      As pushPastProject(org.apache.calcite.rex.RexNode, org.apache.calcite.rel.core.Project), but returns null if the resulting expressions are significantly more complex.
      Parameters:
      bloat - Maximum allowable increase in complexity

    • pushPastCalc

      public static RexNode pushPastCalc(RexNode node, Calc calc)
      Converts an expression that is based on the output fields of a Calc to an equivalent expression on the Calc's input fields.
      Parameters:
      node - The expression to be converted
      calc - Calc underneath the expression
      Returns:
      converted expression

    • projectMultiJoin

      public static MultiJoin projectMultiJoin(MultiJoin multiJoin, Project project)
      Creates a new MultiJoin to reflect projection references from a Project that is on top of the MultiJoin.
      Parameters:
      multiJoin - the original MultiJoin
      project - the Project on top of the MultiJoin
      Returns:
      the new MultiJoin

    • addTrait

      public static <T extends RelNode> T addTrait(T rel, RelTrait trait)

    • replaceInput

      public static RelNode replaceInput(RelNode parent, int ordinal, RelNode newInput)
      Returns a shallow copy of a relational expression with a particular input replaced.

    • createProject

      public static RelNode createProject(RelNode child, Mappings.TargetMapping mapping)
      Creates a LogicalProject that projects particular fields of its input, according to a mapping.

    • createProject

      public static RelNode createProject(RelNode child, Mappings.TargetMapping mapping, RelFactories.ProjectFactory projectFactory)

    • findTable

      public static @Nullable RelOptTable findTable(RelNode root, String tableName)
      Returns the relational table node for tableName if it occurs within a relational expression root otherwise an empty option is returned.

    • contains

      public static boolean contains(RelNode ancestor, RelNode target)
      Returns whether relational expression target occurs within a relational expression ancestor.

    • replace

      public static RelNode replace(RelNode query, RelNode find, RelNode replace)
      Within a relational expression query, replaces occurrences of find with replace.

    • getContext

      @Deprecated public static RelOptTable.ToRelContext getContext(RelOptCluster cluster)
      Deprecated.

    • countJoins

      public static int countJoins(RelNode rootRel)
      Returns the number of Join nodes in a tree.

    • permute

      public static RelDataType permute(RelDataTypeFactory typeFactory, RelDataType rowType, Mapping mapping)
      Permutes a record type according to a mapping.

    • createProject

      @Deprecated public static RelNode createProject(RelNode child, List<? extends RexNode> exprList, List<String> fieldNameList)
      Deprecated.

    • createProject

      @Deprecated public static RelNode createProject(RelNode child, List<Pair<RexNode,? extends @Nullable String>> projectList, boolean optimize)
      Deprecated.

    • createProject

      public static RelNode createProject(RelNode child, List<Integer> posList)
      Creates a relational expression that projects the given fields of the input.

      Optimizes if the fields are the identity projection.

      Parameters:
      child - Input relational expression
      posList - Source of each projected field
      Returns:
      Relational expression that projects given fields

    • createProject

      @Deprecated public static RelNode createProject(RelNode child, List<? extends RexNode> exprs, List<? extends @Nullable String> fieldNames, boolean optimize)
      Deprecated.

    • createProject

      @Deprecated public static RelNode createProject(RelNode child, List<? extends RexNode> exprs, List<? extends @Nullable String> fieldNames, boolean optimize, RelBuilder relBuilder)
      Deprecated.
      Use RelBuilder.projectNamed(Iterable, Iterable, boolean)

    • createRename

      @Deprecated public static RelNode createRename(RelNode rel, List<? extends @Nullable String> fieldNames)
      Deprecated.

    • permute

      public static RelNode permute(RelNode rel, Permutation permutation, @Nullable List<String> fieldNames)
      Creates a relational expression which permutes the output fields of a relational expression according to a permutation.

      Optimizations:

      • If the relational expression is a LogicalCalc or LogicalProject that is already acting as a permutation, combines the new permutation with the old;
      • If the permutation is the identity, returns the original relational expression.

      If a permutation is combined with its inverse, these optimizations would combine to remove them both.

      Parameters:
      rel - Relational expression
      permutation - Permutation to apply to fields
      fieldNames - Field names; if null, or if a particular entry is null, the name of the permuted field is used
      Returns:
      relational expression which permutes its input fields

    • createProject

      public static RelNode createProject(RelFactories.ProjectFactory factory, RelNode child, List<Integer> posList)
      Creates a relational expression that projects the given fields of the input.

      Optimizes if the fields are the identity projection.

      Parameters:
      factory - ProjectFactory
      child - Input relational expression
      posList - Source of each projected field
      Returns:
      Relational expression that projects given fields

    • projectMapping

      @Deprecated public static RelNode projectMapping(RelNode rel, Mapping mapping, @Nullable List<String> fieldNames, RelFactories.ProjectFactory projectFactory)
      Deprecated.

    • notContainsWindowedAgg

      public static boolean notContainsWindowedAgg(Calc calc)
      Predicate for if a Calc does not contain windowed aggregates.

    • notContainsWindowedAgg

      public static boolean notContainsWindowedAgg(Filter filter)
      Predicate for if a Filter does not contain windowed aggregates.

    • notContainsWindowedAgg

      public static boolean notContainsWindowedAgg(Project project)
      Predicate for if a Project does not contain windowed aggregates.

    • pushDownJoinConditions

      public static RelNode pushDownJoinConditions(Join originalJoin, RelBuilder relBuilder)
      Pushes down expressions in "equal" join condition.

      For example, given "emp JOIN dept ON emp.deptno + 1 = dept.deptno", adds a project above "emp" that computes the expression "emp.deptno + 1". The resulting join condition is a simple combination of AND, equals, and input fields, plus the remaining non-equal conditions.

      Parameters:
      originalJoin - Join whose condition is to be pushed down
      relBuilder - Factory to create project operator

    • pushDownJoinConditions

      @Deprecated public static RelNode pushDownJoinConditions(Join originalJoin)
      Deprecated.

    • pushDownJoinConditions

      @Deprecated public static RelNode pushDownJoinConditions(Join originalJoin, RelFactories.ProjectFactory projectFactory)
      Deprecated.