RelOptUtil (Apache Calcite 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.Exists` Result of calling `createExistsPlan(org.apache.calcite.plan.RelOptCluster, org.apache.calcite.rel.RelNode, java.util.List<org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexLiteral, java.lang.String)`.
`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` Deprecated.
`static double`	`EPSILON`
`static com.google.common.base.Predicate<Filter>`	`FILTER_PREDICATE` Deprecated.
`static com.google.common.base.Predicate<Project>`	`PROJECT_PREDICATE` Deprecated.

Constructor Summary

Constructors
Constructor and Description

RelOptUtil()

Constructors
Constructor and Description
`RelOptUtil()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated 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)` Deprecated.
`static RexNode`	`andJoinFilters(RexBuilder rexBuilder, @Nullable RexNode left, @Nullable 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)` Deprecated.
`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.
`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)`
`static RexCall`	`collapseExpandedIsNotDistinctFromExpr(RexCall call, RexBuilder rexBuilder)` Collapses an expanded version of `IS NOT DISTINCT FROM` expression.
`static List<RexNode>`	`conjunctions(@Nullable 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 RelNode`	`copyRelHints(RelNode originalRel, RelNode newRel)` Copy the `RelHint`s from `originalRel` to `newRel` if both of them are `Hintable`.
`static RelNode`	`copyRelHints(RelNode originalRel, RelNode newRel, boolean filterHints)` Copy the `RelHint`s from `originalRel` to `newRel` if both of them are `Hintable`.
`static ImmutableBitSet`	`correlationColumns(CorrelationId id, RelNode rel)` Finds which columns of a correlation variable are used within a relational expression.
`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)` Deprecated. Use `RelBuilder.distinct()`.
`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 RelOptUtil.Exists`	`createExistsPlan(RelNode seekRel, RelOptUtil.SubQueryType subQueryType, RelOptUtil.Logic logic, boolean notIn)` Deprecated.
`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.
`static RelNode`	`createExistsPlan(RelOptCluster cluster, RelNode seekRel, @Nullable List<RexNode> conditions, @Nullable RexLiteral extraExpr, @Nullable String extraName)` Deprecated.
`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)` Deprecated.
`static RelNode`	`createFilter(RelNode child, RexNode condition, RelFactories.FilterFactory filterFactory)` Deprecated.
`static RelNode`	`createNullFilter(RelNode rel, Integer[] fieldOrdinals)` Deprecated.
`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> exprs, List<? extends String> fieldNames, boolean optimize)` Deprecated.
`static RelNode`	`createProject(RelNode child, List<? extends RexNode> exprs, List<? extends String> fieldNames, boolean optimize, RelBuilder relBuilder)` Deprecated. Use `RelBuilder.projectNamed(Iterable, Iterable, boolean)`
`static RelNode`	`createProject(RelNode child, List<? extends RexNode> exprList, List<String> fieldNameList)` Deprecated.
`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,? extends String>> projectList, boolean optimize)` Deprecated.
`static RelNode`	`createProject(RelNode child, Mappings.TargetMapping mapping)` Creates a `LogicalProject` that projects particular fields of its input, according to a mapping.
`static RelNode`	`createProject(RelNode child, Mappings.TargetMapping mapping, RelFactories.ProjectFactory projectFactory)`
`static RelNode`	`createProjectJoinRel(List<Integer> outputProj, RelNode joinRel)` Deprecated.
`static RelNode`	`createRename(RelNode rel, List<? extends String> fieldNames)` Deprecated.
`static RelNode`	`createRenameRel(RelDataType outputType, RelNode rel)` Deprecated.
`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(@Nullable RexNode rexPredicate, List<RexNode> rexList)` Decomposes a predicate into a list of expressions that are AND'ed together.
`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.
`static void`	`decomposeDisjunction(@Nullable RexNode rexPredicate, List<RexNode> rexList)` Decomposes a predicate into a list of expressions that are OR'ed together.
`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.
`static List<RexNode>`	`disjunctions(RexNode rexPredicate)` Returns a condition decomposed by OR.
`static String`	`dumpPlan(String header, RelNode rel, boolean asXml, SqlExplainLevel detailLevel)` Deprecated.
`static String`	`dumpPlan(String header, RelNode rel, SqlExplainFormat format, SqlExplainLevel detailLevel)` Dumps a plan as a string.
`static String`	`dumpType(RelDataType type)`
`static boolean`	`eq(String desc1, RelDataType type1, String desc2, RelDataType type2, Litmus litmus)` Returns whether two types are equal using 'equals'.
`static boolean`	`equal(String desc1, RelDataType type1, String desc2, RelDataType type2, Litmus litmus)` Returns whether two types are equal using `areRowTypesEqual(RelDataType, RelDataType, boolean)`.
`static boolean`	`equalType(String desc0, RelNode rel0, String desc1, RelNode rel1, Litmus litmus)` Returns whether two relational expressions have the same row-type.
`static List<String>`	`findAllTableQualifiedNames(RelNode rel)` Returns a list of all table qualified names used by this expression or its children.
`static List<RelOptTable>`	`findAllTables(RelNode rel)` Returns a list of all tables used by this expression or its children.
`static Set<RelOptTable>`	`findTables(RelNode rel)` Returns a set of tables used by this expression or its children.
`static Set<Integer>`	`getAllFields(Aggregate aggregate)` Gets all fields in an aggregate.
`static Set<Integer>`	`getAllFields2(ImmutableBitSet groupSet, List<AggregateCall> aggCallList)` Gets all fields in an aggregate.
`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.
`static RelOptTable.ToRelContext`	`getContext(RelOptCluster cluster)` Deprecated.
`static List<RelDataType>`	`getFieldTypeList(RelDataType type)` Returns a list of the types of the fields in a given struct type.
`static String`	`getFullTypeDifferenceString(String sourceDesc, RelDataType sourceType, String targetDesc, RelDataType targetType)` Returns the detailed difference of two types.
`static Set<CorrelationId>`	`getVariablesSet(RelNode rel)` Returns a list of variables set by a relational expression or its descendants.
`static List<CorrelationId>`	`getVariablesSetAndUsed(RelNode rel0, RelNode rel1)` Deprecated.
`static Set<CorrelationId>`	`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 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.
`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)` Deprecated.
`static boolean`	`isLimit(RelNode rel)` Whether this node contains a limit specification.
`static boolean`	`isOrder(RelNode rel)` Whether this node contains a sort specification.
`static boolean`	`isPureLimit(RelNode rel)` Whether this node is a limit without sort specification.
`static boolean`	`isPureOrder(RelNode rel)` Whether this node is a sort without limit specification.
`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.
`static boolean`	`notContainsWindowedAgg(Calc calc)` Predicate for if a `Calc` does not contain windowed aggregates.
`static boolean`	`notContainsWindowedAgg(Filter filter)` Predicate for if a `Filter` does not windowed aggregates.
`static boolean`	`notContainsWindowedAgg(Project project)` Predicate for if a `Project` does not contain windowed aggregates.
`static SqlOperator`	`op(SqlKind kind, SqlOperator operator)` Returns `SqlOperator` for given `SqlKind` or returns `operator` when `SqlKind` is not known.
`static Mappings.TargetMapping`	`permutation(List<RexNode> nodes, RelDataType inputRowType)` Returns a permutation describing where output fields come from.
`static Mappings.TargetMapping`	`permutationIgnoreCast(List<RexNode> nodes, RelDataType inputRowType)` Returns a permutation describing where output fields come from.
`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.
`static RelDataType`	`permute(RelDataTypeFactory typeFactory, RelDataType rowType, Mapping mapping)` Permutes a record type according to a mapping.
`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.
`static void`	`projectJoinInputs(RelNode[] inputRels, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, int systemColCount, List<Integer> leftKeys, List<Integer> rightKeys, List<Integer> outputProj)` Deprecated.
`static RelNode`	`projectMapping(RelNode rel, Mapping mapping, @Nullable List<String> fieldNames, RelFactories.ProjectFactory projectFactory)` Deprecated.
`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`.
`static RelNode`	`propagateRelHints(RelNode rel, boolean reset)` Propagates the relational expression hints from root node to leaf node.
`static RelNode`	`propagateRelHints(RelNode originalRel, RelNode equiv)` Copy the `RelHint`s from `originalRel` to `newRel` if both of them are `Hintable`.
`static RelNode`	`pushDownJoinConditions(Join originalJoin)` Deprecated.
`static RelNode`	`pushDownJoinConditions(Join originalJoin, RelBuilder relBuilder)` Pushes down expressions in "equal" join condition.
`static RelNode`	`pushDownJoinConditions(Join originalJoin, RelFactories.ProjectFactory projectFactory)` Deprecated.
`static RexNode`	`pushFilterPastProject(RexNode filter, Project projRel)` Deprecated.
`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.
`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.
`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.
`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.
`static void`	`registerAbstractRelationalRules(RelOptPlanner planner)`
`static void`	`registerAbstractRels(RelOptPlanner planner)` Deprecated.
`static void`	`registerAbstractRules(RelOptPlanner planner)`
`static void`	`registerDefaultRules(RelOptPlanner planner, boolean enableMaterializations, boolean enableBindable)`
`static RelNode`	`renameIfNecessary(RelNode rel, RelDataType desiredRowType)` Deprecated.
`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 @Nullable RexNode`	`splitCorrelatedFilterCondition(Filter filter, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess)`
`static @Nullable RexNode`	`splitCorrelatedFilterCondition(LogicalFilter filter, List<RexInputRef> joinKeys, List<RexNode> correlatedJoinKeys)` Deprecated.
`static @Nullable RexNode`	`splitCorrelatedFilterCondition(LogicalFilter filter, List<RexNode> joinKeys, List<RexNode> correlatedJoinKeys, boolean extractCorrelatedFieldAccess)`
`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.
`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.
`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.
`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.
`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.
`static String`	`toString(RelNode rel)` Converts a relational expression to a string, showing just basic attributes.
`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.
`static void`	`validateValueAgainstConstraint(SqlNode sourceValue, RexNode targetConstraint, Supplier<CalciteContextException> errorSupplier)` Ensures that a source value does not violate the constraint of the target column.
`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

@Deprecated
public static final com.google.common.base.Predicate<Filter> FILTER_PREDICATE

Deprecated.

PROJECT_PREDICATE

@Deprecated
public static final com.google.common.base.Predicate<Project> PROJECT_PREDICATE

Deprecated.

CALC_PREDICATE

@Deprecated
public static final com.google.common.base.Predicate<Calc> CALC_PREDICATE

Deprecated.

Constructor Detail
- RelOptUtil
```
public RelOptUtil()
```

Method Detail

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.

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 a 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.

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:

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

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:

SqlToRelConverter#convertExists

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[] 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:

RexUtil.op(SqlKind)

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:

RexUtil.composeConjunction(org.apache.calcite.rex.RexBuilder, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>)

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 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)

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 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 String> fieldNames,
                                                boolean optimize)

Deprecated.

createProject

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

Deprecated. Use RelBuilder.projectNamed(Iterable, Iterable, boolean)

createRename

@Deprecated
public static RelNode createRename(RelNode rel,
                                               List<? extends 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 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.

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

isPureLimit

isPureOrder

isLimit

isOrder

findTables

findAllTables

findAllTableQualifiedNames

getVariablesSet

getVariablesSetAndUsed

getVariablesUsed

correlationColumns

notContainsCorrelation

go

getFieldTypeList

areRowTypesEqual

verifyTypeEquivalence

propagateRelHints

propagateRelHints

copyRelHints

copyRelHints

permutationIgnoreCast

permutation

permutationPushDownProject

createExistsPlan

createExistsPlan

createExistsPlan

createRenameRel

createFilter

createFilter

createFilter

createFilter

createNullFilter

createCastRel

createCastRel

getAllFields

getAllFields2

createSingleValueAggRel

createDistinctRel

analyzeSimpleEquiJoin

splitJoinCondition

splitJoinCondition

isEqui

splitJoinCondition

splitJoinCondition

splitCorrelatedFilterCondition

splitCorrelatedFilterCondition

splitCorrelatedFilterCondition

createEquiJoinCondition

op

collapseExpandedIsNotDistinctFromExpr

projectJoinInputs

createProjectJoinRel

registerAbstractRels

registerAbstractRules

registerAbstractRelationalRules

registerDefaultRules

dumpPlan

dumpPlan

createDmlRowType

eq

equal

getFullTypeDifferenceString

equalType

isDistinctFrom

toString

toString