RelOptUtil (Calcite Core 1.2.0-incubating API)

java.lang.Object
- org.apache.calcite.plan.RelOptUtil

```
public abstract class RelOptUtil
extends Object
```
RelOptUtil defines static utility methods for use in optimizing RelNodes.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`RelOptUtil.InputFinder` Visitor which builds a bitmap of the inputs used by an expression.
`static class`	`RelOptUtil.InputReferencedVisitor` Shuttle that finds the set of inputs that are used.
`static class`	`RelOptUtil.Logic` Policies for handling two- and three-valued boolean logic.
`static class`	`RelOptUtil.RexInputConverter` Walks an expression tree, converting the index of RexInputRefs based on some adjustment factor.
`static class`	`RelOptUtil.SubqueryType` What kind of sub-query.
`static class`	`RelOptUtil.TypeDumper` Converts types to descriptive strings.
`static class`	`RelOptUtil.VariableUsedVisitor` Visitor that finds all variables used in an expression.

Field Summary

Fields
Modifier and Type	Field and Description
`static com.google.common.base.Predicate<Calc>`	`CALC_PREDICATE` Predicate for whether a calc contains multisets or windowed aggregates.
`static double`	`EPSILON`
`static com.google.common.base.Predicate<Filter>`	`FILTER_PREDICATE` Predicate for whether a filter contains multisets or windowed aggregates.
`static com.google.common.base.Predicate<Project>`	`PROJECT_PREDICATE` Predicate for whether a project contains multisets or windowed aggregates.

Constructor Summary

Constructors
Constructor and Description

RelOptUtil()

Constructors
Constructor and Description
`RelOptUtil()`

Method Summary

Methods
Modifier and Type	Method and Description
`static <T extends RelNode> T`	`addTrait(T rel, RelTrait trait)`
`static List<Integer>`	`adjustKeys(List<Integer> keys, int adjustment)` Adjusts key values in a list by some fixed amount.
`static boolean`	`analyzeSimpleEquiJoin(LogicalJoin join, int[] joinFieldOrdinals)`
`static RexNode`	`andJoinFilters(RexBuilder rexBuilder, RexNode left, RexNode right)` Ands two sets of join filters together, either of which can be null.
`static boolean`	`areRowTypesEqual(RelDataType rowType1, RelDataType rowType2, boolean compareNames)`
`static boolean`	`checkProjAndChildInputs(Project project, boolean checkNames)` Determines if a projection and its input reference identical input references.
`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)` Classifies filters according to where they should be processed.
`static List<RexNode>`	`conjunctions(RexNode rexPredicate)` Returns a condition decomposed by AND.
`static boolean`	`contains(RelNode ancestor, RelNode target)` Returns whether relational expression `target` occurs within a relational expression `ancestor`.
`static int`	`countJoins(RelNode rootRel)` Returns the number of `Join` nodes in a tree.
`static RelNode`	`createCastRel(RelNode rel, RelDataType castRowType, boolean rename)` Creates a projection which casts a rel's output to a desired row type.
`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.
`static RelNode`	`createDistinctRel(RelNode rel)` Creates a LogicalAggregate that removes all duplicates from the result of an underlying relational expression.
`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.
`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.
`static Pair<RelNode,Boolean>`	`createExistsPlan(RelNode seekRel, RelOptUtil.SubqueryType subqueryType, RelOptUtil.Logic logic, boolean needsOuterJoin)` Creates a plan suitable for use in `EXISTS` or `IN` statements.
`static RelNode`	`createExistsPlan(RelOptCluster cluster, RelNode seekRel, List<RexNode> conditions, RexLiteral extraExpr, String extraName)` Creates a plan suitable for use in `EXISTS` or `IN` statements.
`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.
`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.
`static RelNode`	`createFilter(RelNode child, RexNode condition)` Creates a relational expression which filters according to a given condition, returning the same fields as its input, using the default filter factory.
`static RelNode`	`createFilter(RelNode child, RexNode condition, RelFactories.FilterFactory filterFactory)` Creates a relational expression which filters according to a given condition, returning the same fields as its input.
`static RelNode`	`createNullFilter(RelNode rel, Integer[] fieldOrdinals)` Creates a filter which will remove rows containing NULL values.
`static RelNode`	`createProject(RelFactories.ProjectFactory factory, RelNode child, List<Integer> posList)` Creates a relational expression that projects the given fields of the input.
`static RelNode`	`createProject(RelNode child, List<? extends RexNode> exprList, List<String> fieldNameList)` Creates a relational expression which projects a list of expressions.
`static RelNode`	`createProject(RelNode child, List<? extends RexNode> exprs, List<String> fieldNames, boolean optimize)` Creates a relational expression which projects an array of expressions, and optionally optimizes.
`static RelNode`	`createProject(RelNode child, List<Integer> posList)` Creates a relational expression that projects the given fields of the input.
`static RelNode`	`createProject(RelNode child, List<Pair<RexNode,String>> projectList, boolean optimize)` Creates a relational expression which projects a list of (expression, name) pairs.
`static RelNode`	`createProject(RelNode child, Mappings.TargetMapping mapping)` Creates a `LogicalProject` that projects particular fields of its input, according to a mapping.
`static RelNode`	`createProjectJoinRel(List<Integer> outputProj, RelNode joinRel)` Creates a projection on top of a join, if the desired projection is a subset of the join columns
`static RelNode`	`createRename(RelNode rel, List<String> fieldNames)` Returns a relational expression which has the same fields as the underlying expression, but the fields have different names.
`static RelNode`	`createRenameRel(RelDataType outputType, RelNode rel)` Creates a LogicalProject which accomplishes a rename.
`static RelNode`	`createSingleValueAggRel(RelOptCluster cluster, RelNode rel)` Creates a LogicalAggregate that removes all duplicates from the result of an underlying relational expression.
`static List<RexNode>`	`createSwappedJoinExprs(RelNode newJoin, Join origJoin, boolean origOrder)` Creates projection expressions reflecting the swapping of a join's input.
`static void`	`decomposeConjunction(RexNode rexPredicate, List<RexNode> rexList)` Decomposes a predicate into a list of expressions that are AND'ed together.
`static void`	`decomposeConjunction(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.
`static void`	`decomposeDisjunction(RexNode rexPredicate, List<RexNode> rexList)` Decomposes a predicate into a list of expressions that are OR'ed together.
`static List<RexNode>`	`disjunctions(RexNode rexPredicate)` Returns a condition decomposed by OR.
`static String`	`dumpPlan(String header, RelNode rel, boolean asXml, SqlExplainLevel detailLevel)` Dumps a plan as a string.
`static String`	`dumpType(RelDataType type)`
`static boolean`	`eq(String desc1, RelDataType type1, String desc2, RelDataType type2, boolean fail)` Returns whether two types are equal using '='.
`static boolean`	`equal(String desc1, RelDataType type1, String desc2, RelDataType type2, boolean fail)` Returns whether two types are equal using `areRowTypesEqual(RelDataType, RelDataType, boolean)`.
`static boolean`	`equalType(String desc0, RelNode rel0, String desc1, RelNode rel1, boolean fail)` Returns whether two relational expressions have the same row-type.
`static RelOptTable.ToRelContext`	`getContext(RelOptCluster cluster)` Returns a simple `RelOptTable.ToRelContext`.
`static List<RelDataType>`	`getFieldTypeList(RelDataType type)` Returns a list of the types of the fields in a given struct type.
`static Set<String>`	`getVariablesSet(RelNode rel)` Returns a list of variables set by a relational expression or its descendants.
`static List<String>`	`getVariablesSetAndUsed(RelNode rel0, RelNode rel1)` Returns a set of distinct variables set by `rel0` and used by `rel1`.
`static Set<String>`	`getVariablesUsed(RelNode rel)` Returns a set of variables used by a relational expression or its descendants.
`static void`	`go(RelVisitor visitor, RelNode p)` Sets a `RelVisitor` going on a given relational expression, and returns the result.
`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.
`static boolean`	`isEqui(RelNode left, RelNode right, RexNode condition)` Returns whether a join condition is an "equi-join" condition.
`static Mappings.TargetMapping`	`permutation(List<RexNode> nodes, RelDataType inputRowType)` Returns a permutation describing where output fields come from.
`static RelDataType`	`permute(RelDataTypeFactory typeFactory, RelDataType rowType, Mapping mapping)` Permutes a record type according to a mapping.
`static RelNode`	`permute(RelNode rel, Permutation permutation, List<String> fieldNames)` Creates a relational expression which permutes the output fields of a relational expression according to a permutation.
`static void`	`projectJoinInputs(RelNode[] inputRels, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, int systemColCount, List<Integer> leftKeys, List<Integer> rightKeys, List<Integer> outputProj)` Adding projection to the inputs of a join to produce the required join keys.
`static RelNode`	`projectMapping(RelNode rel, Mapping mapping, List<String> fieldNames, RelFactories.ProjectFactory projectFactory)` Creates a relational expression which projects the output fields of a relational expression according to a partial mapping.
`static MultiJoin`	`projectMultiJoin(MultiJoin multiJoin, LogicalProject project)` Creates a new `MultiJoin` to reflect projection references from a `LogicalProject` that is on top of the `MultiJoin`.
`static RexNode`	`pushFilterPastProject(RexNode filter, Project projRel)` Converts a filter to the new filter that would result if the filter is pushed past a LogicalProject that it currently is referencing.
`static void`	`registerAbstractRels(RelOptPlanner planner)`
`static RelNode`	`renameIfNecessary(RelNode rel, RelDataType desiredRowType)` Renames a relational expression to make its field names the same as another row type.
`static RelNode`	`replace(RelNode query, RelNode find, RelNode replace)` Within a relational expression `query`, replaces occurrences of `find` with `replace`.
`static RelNode`	`replaceInput(RelNode parent, int ordinal, RelNode newInput)` Returns a shallow copy of a relational expression with a particular input replaced.
`static JoinRelType`	`simplifyJoin(RelNode joinRel, com.google.common.collect.ImmutableList<RexNode> aboveFilters, JoinRelType joinType)` Simplifies outer joins if filter above would reject nulls.
`static RexNode`	`splitCorrelatedFilterCondition(LogicalFilter filter, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys)`
`static RexNode`	`splitCorrelatedFilterCondition(LogicalFilter filter, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess)`
`static void`	`splitFilters(ImmutableBitSet childBitmap, 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
`static RexNode`	`splitJoinCondition(List<RelDataTypeField> sysFieldList, List<RelNode> inputs, RexNode condition, List<List<RexNode>> joinKeys, List<Integer> filterNulls, List<SqlOperator> rangeOp)` Splits out the equi-join (and optionally, a single non-equi) components of a join condition, and returns what's left.
`static RexNode`	`splitJoinCondition(List<RelDataTypeField> sysFieldList, RelNode leftRel, RelNode rightRel, RexNode condition, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, List<Integer> filterNulls, List<SqlOperator> rangeOp)` Splits out the equi-join (and optionally, a single non-equi) components of a join condition, and returns what's left.
`static RexNode`	`splitJoinCondition(RelNode left, RelNode right, RexNode condition, List<Integer> leftKeys, List<Integer> rightKeys)` Splits out the equi-join components of a join condition, and returns what's left.
`static String`	`toString(RelNode rel)` Converts a relational expression to a string, showing just basic attributes.
`static String`	`toString(RelNode rel, SqlExplainLevel detailLevel)` Converts a relational expression to a string.
`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.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - EPSILON
```
public static final double EPSILON
```
    See Also:
    Constant Field Values
  - FILTER_PREDICATE
```
public static final com.google.common.base.Predicate<Filter> FILTER_PREDICATE
```
    Predicate for whether a filter contains multisets or windowed aggregates.
  - PROJECT_PREDICATE
```
public static final com.google.common.base.Predicate<Project> PROJECT_PREDICATE
```
    Predicate for whether a project contains multisets or windowed aggregates.
  - CALC_PREDICATE
```
public static final com.google.common.base.Predicate<Calc> CALC_PREDICATE
```
    Predicate for whether a calc contains multisets or windowed aggregates.
- Constructor Detail
  - RelOptUtil
```
public RelOptUtil()
```
- Method Detail
  - getVariablesSet
```
public static Set<String> getVariablesSet(RelNode rel)
```
    Returns a list of variables set by a relational expression or its descendants.
  - getVariablesSetAndUsed
```
public static List<String> getVariablesSetAndUsed(RelNode rel0,
                                  RelNode rel1)
```
    Returns a set of distinct variables set by rel0 and used by rel1.
  - getVariablesUsed
```
public static Set<String> getVariablesUsed(RelNode rel)
```
    Returns a set of variables used by a relational expression or its descendants. The set may contain duplicates. The item type is the same as RexVariable.getName()
  - 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:
    RelDataType.getFieldNames()
  - 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
  - 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.
  - createExistsPlan
```
public static RelNode createExistsPlan(RelOptCluster cluster,
                       RelNode seekRel,
                       List<RexNode> conditions,
                       RexLiteral extraExpr,
                       String extraName)
```
    Creates a plan suitable for use in EXISTS or IN statements.
    See SqlToRelConverter.convertExists(org.apache.calcite.sql.SqlNode, org.apache.calcite.plan.RelOptUtil.SubqueryType, org.apache.calcite.plan.RelOptUtil.Logic, boolean)
    Note: this implementation of createExistsPlan is only called from net.sf.farrago.fennel.rel. The last two arguments do not apply to those invocations and can be removed from the method.
    
    Parameters:
    cluster - Cluster
    seekRel - A query rel, for example the resulting rel from 'select * from emp' or 'values (1,2,3)' or '('Foo', 34)'.
    conditions - May be null
    extraExpr - Column expression to add. "TRUE" for EXISTS and IN
    extraName - Name of expression to add.
    
    Returns:
    relational expression which outer joins a boolean condition column
  - createExistsPlan
```
public static Pair<RelNode,Boolean> createExistsPlan(RelNode seekRel,
                                     RelOptUtil.SubqueryType subqueryType,
                                     RelOptUtil.Logic logic,
                                     boolean needsOuterJoin)
```
    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
    needsOuterJoin - Whether query needs outer join
    
    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:
    SqlToRelConverter.convertExists(org.apache.calcite.sql.SqlNode, org.apache.calcite.plan.RelOptUtil.SubqueryType, org.apache.calcite.plan.RelOptUtil.Logic, boolean)
  - createRenameRel
```
public static RelNode createRenameRel(RelDataType outputType,
                      RelNode rel)
```
    Creates a LogicalProject which accomplishes a rename.
    
    Parameters:
    outputType - a row type descriptor whose field names the generated LogicalProject must match
    rel - the rel whose output is to be renamed; rel.getRowType() must be the same as outputType except for field names
    
    Returns:
    generated relational expression
  - createFilter
```
public static RelNode createFilter(RelNode child,
                   RexNode condition)
```
    Creates a relational expression which filters according to a given condition, returning the same fields as its input, using the default filter factory.
    
    Parameters:
    child - Child relational expression
    condition - Condition
    
    Returns:
    Relational expression
  - createFilter
```
public static RelNode createFilter(RelNode child,
                   RexNode condition,
                   RelFactories.FilterFactory filterFactory)
```
    Creates a relational expression which filters according to a given condition, returning the same fields as its input.
    
    Parameters:
    child - Child relational expression
    condition - Condition
    filterFactory - Filter factory
    
    Returns:
    Relational expression
  - 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
```
public static RelNode createNullFilter(RelNode rel,
                       Integer[] fieldOrdinals)
```
    Creates a filter which will remove rows containing NULL values.
    
    Parameters:
    rel - the rel to be filtered
    fieldOrdinals - array of 0-based field ordinals to filter, or null for all fields
    
    Returns:
    filtered rel
  - 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.
    
    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.
    
    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
  - 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
```
public static RelNode createDistinctRel(RelNode rel)
```
    Creates a LogicalAggregate that removes all duplicates from the result of an underlying relational expression.
    
    Parameters:
    rel - underlying rel
    
    Returns:
    rel implementing DISTINCT
  - analyzeSimpleEquiJoin
```
public static boolean analyzeSimpleEquiJoin(LogicalJoin join,
                            int[] joinFieldOrdinals)
```
  - splitJoinCondition
```
public static RexNode splitJoinCondition(RelNode left,
                         RelNode right,
                         RexNode condition,
                         List<Integer> leftKeys,
                         List<Integer> rightKeys)
```
    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
    
    Returns:
    remaining join filters that are not equijoins; may return a RexLiteral true, but never null
  - isEqui
```
public static boolean isEqui(RelNode left,
             RelNode right,
             RexNode condition)
```
    Returns whether a join condition is an "equi-join" condition.
    
    Parameters:
    left - Left input of join
    right - Right input of join
    condition - Condition
    
    Returns:
    Whether condition is equi-join
  - splitJoinCondition
```
public static RexNode splitJoinCondition(List<RelDataTypeField> sysFieldList,
                         RelNode leftRel,
                         RelNode rightRel,
                         RexNode condition,
                         List<RexNode> leftJoinKeys,
                         List<RexNode> rightJoinKeys,
                         List<Integer> filterNulls,
                         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,
                         List<Integer> filterNulls,
                         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
```
public static RexNode splitCorrelatedFilterCondition(LogicalFilter filter,
                                     List<RexInputRef> joinKeys,
                                     List<RexNode> correlatedJoinKeys)
```
  - splitCorrelatedFilterCondition
```
public static RexNode splitCorrelatedFilterCondition(LogicalFilter 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.
  - projectJoinInputs
```
public static void projectJoinInputs(RelNode[] inputRels,
                     List<RexNode> leftJoinKeys,
                     List<RexNode> rightJoinKeys,
                     int systemColCount,
                     List<Integer> leftKeys,
                     List<Integer> rightKeys,
                     List<Integer> outputProj)
```
    Adding projection to the inputs of a join to produce the required join keys.
    
    Parameters:
    inputRels - inputs to a join
    leftJoinKeys - expressions for LHS of join key
    rightJoinKeys - expressions for RHS of join key
    systemColCount - number of system columns, usually zero. These columns are projected at the leading edge of the output row.
    leftKeys - on return this contains the join key positions from the new project rel on the LHS.
    rightKeys - on return this contains the join key positions from the new project rel on the RHS.
    outputProj - on return this contains the positions of the original join output in the (to be formed by caller) LhxJoinRel. Caller needs to be responsible for adding projection on the new join output.
  - createProjectJoinRel
```
public static RelNode createProjectJoinRel(List<Integer> outputProj,
                           RelNode joinRel)
```
    Creates a projection on top of a join, if the desired projection is a subset of the join columns
    
    Parameters:
    outputProj - desired projection; if null, return original join node
    joinRel - the join node
    
    Returns:
    projected join node or the original join if projection is unnecessary
  - registerAbstractRels
```
public static void registerAbstractRels(RelOptPlanner planner)
```
  - dumpPlan
```
public static String dumpPlan(String header,
              RelNode rel,
              boolean asXml,
              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.
    asXml - Whether to format as XML.
    detailLevel - Detail level.
    
    Returns:
    Plan
  - 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,
         boolean fail)
```
    Returns whether two types are equal using '='.
    
    Parameters:
    desc1 - Description of first type
    type1 - First type
    desc2 - Description of second type
    type2 - Second type
    fail - Whether to assert if they are not equal
    
    Returns:
    Whether the types are equal
  - equal
```
public static boolean equal(String desc1,
            RelDataType type1,
            String desc2,
            RelDataType type2,
            boolean fail)
```
    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
    fail - Whether to assert if they are not equal
    
    Returns:
    Whether the types are equal
  - equalType
```
public static boolean equalType(String desc0,
                RelNode rel0,
                String desc1,
                RelNode rel1,
                boolean fail)
```
    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 String toString(RelNode rel,
              SqlExplainLevel detailLevel)
```
    Converts a relational expression to a string.
  - renameIfNecessary
```
public static RelNode renameIfNecessary(RelNode rel,
                        RelDataType desiredRowType)
```
    Renames a relational expression to make its field names the same as another row type. If the row type is already identical, or if the row type is too different (the fields are different in number or type) does nothing.
    
    Parameters:
    rel - Relational expression
    desiredRowType - Desired row type (including desired field names)
    
    Returns:
    Renamed relational expression, or the original expression if there is nothing to do or nothing we can do.
  - dumpType
```
public static String dumpType(RelDataType type)
```
  - decomposeConjunction
```
public static void decomposeConjunction(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(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(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(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,
                     RexNode left,
                     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:
    RexUtil.composeConjunction(org.apache.calcite.rex.RexBuilder, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, boolean)
  - 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,
                      JoinRelType joinType,
                      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
    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,
                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
```
public static boolean checkProjAndChildInputs(Project project,
                              boolean checkNames)
```
    Determines if a projection and its input reference identical input references.
    
    Parameters:
    project - projection being examined
    checkNames - if true, also compare that the names of the project fields and its child fields
    
    Returns:
    if checkNames is false, true is returned if the project and its child reference the same input references, regardless of the names of the project and child fields; if checkNames is true, then true is returned if the input references are the same but the field names are different
  - 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
```
public static RexNode pushFilterPastProject(RexNode filter,
                            Project projRel)
```
    Converts a filter to the new filter that would result if the filter is pushed past a LogicalProject that it currently is referencing.
    
    Parameters:
    filter - the filter to be converted
    projRel - project rel underneath the filter
    
    Returns:
    converted filter
  - projectMultiJoin
```
public static MultiJoin projectMultiJoin(MultiJoin multiJoin,
                         LogicalProject project)
```
    Creates a new MultiJoin to reflect projection references from a LogicalProject that is on top of the MultiJoin.
    
    Parameters:
    multiJoin - the original MultiJoin
    project - the LogicalProject 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.
  - 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
```
public static RelOptTable.ToRelContext getContext(RelOptCluster cluster)
```
    Returns a simple RelOptTable.ToRelContext.
  - 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
```
public static RelNode createProject(RelNode child,
                    List<? extends RexNode> exprList,
                    List<String> fieldNameList)
```
    Creates a relational expression which projects a list of expressions.
    
    Parameters:
    child - input relational expression
    exprList - list of expressions for the input columns
    fieldNameList - aliases of the expressions, or null to generate
  - createProject
```
public static RelNode createProject(RelNode child,
                    List<Pair<RexNode,String>> projectList,
                    boolean optimize)
```
    Creates a relational expression which projects a list of (expression, name) pairs.
    
    Parameters:
    child - input relational expression
    projectList - list of (expression, name) pairs
    optimize - Whether to optimize
  - 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
```
public static RelNode createProject(RelNode child,
                    List<? extends RexNode> exprs,
                    List<String> fieldNames,
                    boolean optimize)
```
    Creates a relational expression which projects an array of expressions, and optionally optimizes.
    The result may not be a LogicalProject. If the projection is trivial, child is returned directly; and future versions may return other formulations of expressions, such as LogicalCalc.
    
    Parameters:
    child - input relational expression
    exprs - list of expressions for the input columns
    fieldNames - aliases of the expressions, or null to generate
    optimize - Whether to return child unchanged if the projections are trivial.
  - createRename
```
public static RelNode createRename(RelNode rel,
                   List<String> fieldNames)
```
    Returns a relational expression which has the same fields as the underlying expression, but the fields have different names.
    
    Parameters:
    rel - Relational expression
    fieldNames - Field names
    
    Returns:
    Renamed relational expression
  - permute
```
public static RelNode permute(RelNode rel,
              Permutation permutation,
              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
```
public static RelNode projectMapping(RelNode rel,
                     Mapping mapping,
                     List<String> fieldNames,
                     RelFactories.ProjectFactory projectFactory)
```
    Creates a relational expression which projects the output fields of a relational expression according to a partial mapping.
    A partial mapping is weaker than a permutation: every target has one source, but a source may have 0, 1 or more than one targets. Usually the result will have fewer fields than the source, unless some source fields are projected multiple times.
    This method could optimize the result as permute(org.apache.calcite.rel.type.RelDataTypeFactory, org.apache.calcite.rel.type.RelDataType, org.apache.calcite.util.mapping.Mapping) does, but does not at present.
    
    Parameters:
    rel - Relational expression
    mapping - Mapping from source fields to target fields. The mapping type must obey the constraints MappingType.isMandatorySource() and MappingType.isSingleSource(), as does MappingType.INVERSE_FUNCTION.
    fieldNames - Field names; if null, or if a particular entry is null, the name of the permuted field is used
    
    Returns:
    relational expression which projects a subset of the input fields

Class RelOptUtil

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EPSILON

FILTER_PREDICATE

PROJECT_PREDICATE

CALC_PREDICATE

Constructor Detail

RelOptUtil

Method Detail

getVariablesSet

getVariablesSetAndUsed

getVariablesUsed

go

getFieldTypeList

areRowTypesEqual

verifyTypeEquivalence

permutation

createExistsPlan

createExistsPlan

createRenameRel

createFilter

createFilter

createFilter

createFilter

createNullFilter

createCastRel

createCastRel

createSingleValueAggRel

createDistinctRel

analyzeSimpleEquiJoin

splitJoinCondition

isEqui

splitJoinCondition

splitJoinCondition

splitCorrelatedFilterCondition

splitCorrelatedFilterCondition

createEquiJoinCondition

projectJoinInputs

createProjectJoinRel

registerAbstractRels

dumpPlan

createDmlRowType

eq

equal

equalType

isDistinctFrom

toString

toString

renameIfNecessary

dumpType

decomposeConjunction

decomposeConjunction

decomposeDisjunction

conjunctions

disjunctions

andJoinFilters

adjustKeys

simplifyJoin

classifyFilters

splitFilters

checkProjAndChildInputs

createSwappedJoinExprs

pushFilterPastProject

projectMultiJoin

addTrait

replaceInput

createProject

contains

replace

getContext

countJoins

permute

createProject

createProject

createProject