RexUtil (Apache Calcite API)

java.lang.Object
- org.apache.calcite.rex.RexUtil

```
public class RexUtil
extends Object
```
Utility methods concerning row-expressions.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`RexUtil.ExprSimplifier` Deprecated.
`static class`	`RexUtil.FieldAccessFinder` Visitor which builds a bitmap of the inputs used by an expression.
`static class`	`RexUtil.FixNullabilityShuttle` Shuttle that fixes up an expression to match changes in nullability of input fields.
`static class`	`RexUtil.RexFinder` Visitor that tells whether a node matching a particular description exists in a tree.
`static class`	`RexUtil.SubQueryFinder` Visitor that throws `Util.FoundOne` if applied to an expression that contains a `RexSubQuery`.

Field Summary

Fields
Modifier and Type Field and Description

static RexExecutor EXECUTOR
Executor for a bit of constant reduction.

Fields
Modifier and Type	Field and Description
`static RexExecutor`	`EXECUTOR` Executor for a bit of constant reduction.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <E> boolean`	`all(List<? extends E> list, org.apache.calcite.linq4j.function.Predicate1<E> predicate)` Returns whether `predicate` is true for all elements of `list`.
`static boolean`	`allLiterals(List<RexNode> expressionOperands)` Returns whether every expression in a list is a literal.
`static RexNode`	`andNot(RexBuilder rexBuilder, RexNode e, Iterable<? extends RexNode> notTerms)` Creates the expression `e1 AND NOT notTerm1 AND NOT notTerm2 ...`.
`static RexNode`	`andNot(RexBuilder rexBuilder, RexNode e, RexNode... notTerms)` Creates the expression `e1 AND NOT notTerm1 AND NOT notTerm2 ...`.
`static List<RexNode>`	`apply(Mappings.TargetMapping mapping, Iterable<? extends RexNode> nodes)` Applies a mapping to an iterable over expressions.
`static List<RelCollation>`	`apply(Mappings.TargetMapping mapping, List<RelCollation> collationList)` Applies a mapping to a collation list.
`static RelCollation`	`apply(Mappings.TargetMapping mapping, RelCollation collation)` Applies a mapping to a collation.
`static @Nullable RelFieldCollation`	`apply(Mappings.TargetMapping mapping, RelFieldCollation fieldCollation)` Applies a mapping to a field collation.
`static RexNode`	`apply(Mappings.TargetMapping mapping, RexNode node)` Applies a mapping to an expression.
`static <T extends RexNode> T[]`	`apply(RexVisitor<T> shuttle, T[] exprs)` Applies a shuttle to an array of expressions.
`static void`	`apply(RexVisitor<Void> visitor, List<? extends RexNode> exprs, @Nullable RexNode expr)` Applies a visitor to a list of expressions and, if specified, a single expression.
`static void`	`apply(RexVisitor<Void> visitor, RexNode[] exprs, @Nullable RexNode expr)` Applies a visitor to an array of expressions and, if specified, a single expression.
`static List<RelFieldCollation>`	`applyFields(Mappings.TargetMapping mapping, List<RelFieldCollation> fieldCollations)` Applies a mapping to a list of field collations.
`static boolean`	`canReinterpretOverflow(RexCall call)`
`static boolean`	`compatibleTypes(List<RexNode> exprs, RelDataType type, Litmus litmus)` Returns whether the type of an array of expressions is compatible with a struct type.
`static RexNode`	`composeConjunction(RexBuilder rexBuilder, Iterable<? extends RexNode> nodes)` As `composeConjunction(RexBuilder, Iterable, boolean)` but never returns null.
`static @Nullable RexNode`	`composeConjunction(RexBuilder rexBuilder, Iterable<? extends RexNode> nodes, boolean nullOnEmpty)` Converts a collection of expressions into an AND.
`static RexNode`	`composeDisjunction(RexBuilder rexBuilder, Iterable<? extends RexNode> nodes)` Converts a collection of expressions into an OR.
`static @Nullable RexNode`	`composeDisjunction(RexBuilder rexBuilder, Iterable<? extends RexNode> nodes, boolean nullOnEmpty)` Converts a collection of expressions into an OR, optionally returning null if the list is empty.
`static boolean`	`containComplexExprs(List<RexNode> exprs)` Returns whether a list of expressions contains complex expressions, that is, a call whose arguments are not `RexVariable` (or a subtype such as `RexInputRef`) or `RexLiteral`.
`static boolean`	`containIdentity(List<? extends RexNode> exprs, RelDataType rowType, Litmus litmus)` Returns whether the leading edge of a given array of expressions is wholly `RexInputRef` objects with types corresponding to the underlying datatype.
`static boolean`	`containNoCommonExprs(List<RexNode> exprs, Litmus litmus)` Returns whether an array of expressions has any common sub-expressions.
`static boolean`	`containNoForwardRefs(List<RexNode> exprs, RelDataType inputRowType, Litmus litmus)` Returns whether an array of expressions contains no forward references.
`static boolean`	`containsCorrelation(RexNode condition)` Returns whether an expression contains a `RexCorrelVariable`.
`static boolean`	`containsFieldAccess(RexNode node)` Returns whether a given tree contains any `RexFieldAccess` nodes.
`static boolean`	`containsInputRef(RexNode node)` Returns whether a given tree contains any {link RexInputRef} nodes.
`static boolean`	`containsTableInputRef(List<RexNode> nodes)` Returns whether any of the given expression trees contains a {link RexTableInputRef} node.
`static @Nullable RexTableInputRef`	`containsTableInputRef(RexNode node)` Returns whether a given tree contains any {link RexTableInputRef} nodes.
`static RelDataType`	`createStructType(RelDataTypeFactory typeFactory, List<? extends RexNode> exprs, @Nullable List<? extends String> names, SqlValidatorUtil.Suggester suggester)` Creates a record type with specified field names.
`static RelDataType`	`createStructType(RelDataTypeFactory typeFactory, List<? extends RexNode> exprs, List<String> names)` Deprecated.
`static RelDataType`	`createStructType(RelDataTypeFactory typeFactory, List<RexNode> exprs)` Creates a record type with anonymous field names.
`static boolean`	`eq(RexNode e1, RexNode e2)` Deprecated.
`static <E> boolean`	`exists(List<? extends E> list, org.apache.calcite.linq4j.function.Predicate1<E> predicate)` Returns whether there is an element in `list` for which `predicate` is true.
`static RexNode`	`expandSearch(RexBuilder rexBuilder, @Nullable RexProgram program, RexNode node)` Expands all the calls to `SqlStdOperatorTable.SEARCH` in an expression.
`static RexNode`	`expandSearch(RexBuilder rexBuilder, @Nullable RexProgram program, RexNode node, int maxComplexity)` Expands calls to `SqlStdOperatorTable.SEARCH` whose complexity is greater than `maxComplexity` in an expression.
`static List<RelDataTypeFamily>`	`families(List<RelDataType> types)`
`static RexUtil.RexFinder`	`find(RexInputRef ref)` Returns a visitor that finds a particular `RexInputRef`.
`static RexUtil.RexFinder`	`find(Set<SqlKind> kinds)` Returns a visitor that finds nodes of given `SqlKind`s.
`static RexUtil.RexFinder`	`find(SqlKind kind)` Returns a visitor that finds nodes of a given `SqlKind`.
`static @Nullable RexCall`	`findOperatorCall(SqlOperator operator, RexNode node)` Returns whether a given node contains a RexCall with a specified operator.
`static List<RexNode>`	`fixUp(RexBuilder rexBuilder, List<RexNode> nodes, List<RelDataType> fieldTypes)` Fixes up the type of all `RexInputRef`s in an expression to match differences in nullability.
`static List<RexNode>`	`fixUp(RexBuilder rexBuilder, List<RexNode> nodes, RelDataType rowType)` Deprecated.
`static List<RexNode>`	`flatten(List<? extends RexNode> exprs, SqlOperator op)` Converts a list of operands into a list that is flat with respect to the given operator.
`static RexNode`	`flatten(RexBuilder rexBuilder, RexNode node)` Flattens an expression.
`static com.google.common.collect.ImmutableList<RexNode>`	`flattenAnd(Iterable<? extends RexNode> nodes)` Flattens a list of AND nodes.
`static com.google.common.collect.ImmutableList<RexNode>`	`flattenOr(Iterable<? extends RexNode> nodes)` Flattens a list of OR nodes.
`static Set<RexTableInputRef.RelTableRef>`	`gatherTableReferences(List<RexNode> nodes)` Gather all table references in input expressions.
`static List<RexNode>`	`generateCastExpressions(RexBuilder rexBuilder, RelDataType lhsRowType, List<RexNode> rhsExps)` Generates a cast for a row type.
`static List<RexNode>`	`generateCastExpressions(RexBuilder rexBuilder, RelDataType lhsRowType, RelDataType rhsRowType)` Generates a cast from one row type to another.
`static ImmutableBitSet`	`getNonConstColumns(ImmutableBitSet columns, List<RexNode> expressions)` Given some expressions and columns, gets the indices of the non-constant ones.
`static ImmutableBitSet`	`getNonConstColumns(List<RexNode> expressions)` Given some expressions, gets the indices of the non-constant ones.
`static double`	`getSelectivity(@Nullable RexNode exp)` Returns a guess for the selectivity of an expression.
`static @Nullable RexNode`	`invert(RexBuilder rexBuilder, RexCall call)`
`static boolean`	`isAtomic(RexNode expr)`
`static boolean`	`isCallTo(RexNode expr, SqlOperator op)` Returns whether a `node` is a `call` to a given `operator`.
`static boolean`	`isCasePredicate(RexCall call, int i)` Returns whether a given operand of a CASE expression is a predicate.
`static boolean`	`isConstant(RexNode node)` Returns whether node is made up of constants.
`static boolean`	`isDeterministic(RexNode e)` Returns whether a given expression is deterministic.
`static boolean`	`isFlat(RexNode expr)` Returns false if the expression can be optimized by flattening calls to an associative operator such as AND and OR.
`static boolean`	`isIdentity(List<? extends RexNode> exps, RelDataType inputRowType)` Returns whether a list of expressions projects the incoming fields.
`static boolean`	`isLiteral(RexNode node, boolean allowCast)` Returns whether a node represents a literal.
`static boolean`	`isLosslessCast(RelDataType source, RelDataType target)` Returns whether the conversion from `source` to `target` type is a 'loss-less' cast, that is, a cast from which the original value of the field can be certainly recovered.
`static boolean`	`isLosslessCast(RexNode node)` Returns whether the input is a 'loss-less' cast, that is, a cast from which the original value of the field can be certainly recovered.
`static boolean`	`isNull(RexNode expr)` Returns whether a node represents the NULL value or a series of nested `CAST(NULL AS type)` calls.
`static boolean`	`isNullabilityCast(RelDataTypeFactory typeFactory, RexNode node)` Returns whether an expression is a cast just for the purposes of nullability, not changing any other aspect of the type.
`static boolean`	`isNullLiteral(RexNode node, boolean allowCast)` Returns whether a node represents the NULL value.
`static boolean`	`isReferenceOrAccess(RexNode node, boolean allowCast)` Returns whether a node represents an input reference or field access.
`static Pair<RexNode,String>`	`makeKey(RexNode expr)` Creates a key for `RexNode` which is the same as another key of another RexNode only if the two have both the same type and textual representation.
`static @Nullable RexNode`	`negate(RexBuilder rexBuilder, RexCall call)`
`static int`	`nodeCount(List<? extends RexNode> nodes)` Returns the number of nodes (including leaves) in a list of expressions.
`static RexNode`	`not(RexNode e)` Negates a logical expression by adding or removing a NOT.
`static com.google.common.base.Function<RexNode,RexNode>`	`notFn(RexBuilder rexBuilder)` Deprecated. Use `not(org.apache.calcite.rex.RexNode)`
`static SqlOperator`	`op(SqlKind kind)`
`static <C extends RexNode> com.google.common.collect.ImmutableMap<RexNode,C>`	`predicateConstants(Class<C> clazz, RexBuilder rexBuilder, List<RexNode> predicates)` Creates a map containing each (e, constant) pair that occurs within a predicate list.
`static RexNode`	`pullFactors(RexBuilder rexBuilder, RexNode node)` Creates an equivalent version of a node where common factors among ORs are pulled up.
`static boolean`	`removeAll(List<RexNode> targets, RexNode e)` Removes all expressions from a list that are equivalent to a given expression.
`static RexNode`	`removeCast(RexNode e)` Removes any casts.
`static RexNode`	`removeNullabilityCast(RelDataTypeFactory typeFactory, RexNode node)` Removes any casts that change nullability but not type.
`static boolean`	`requiresDecimalExpansion(List<RexNode> operands, boolean recurse)` Determines whether any operand of a set requires decimal expansion.
`static boolean`	`requiresDecimalExpansion(RexNode expr, boolean recurse)` Determines whether a `RexCall` requires decimal expansion.
`static boolean`	`requiresDecimalExpansion(RexProgram program, boolean recurse)` Returns whether a `RexProgram` contains expressions which require decimal expansion.
`static List<RexNode>`	`retainDeterministic(List<RexNode> list)`
`static <C extends Comparable<C>> RexNode`	`sargRef(RexBuilder rexBuilder, RexNode ref, Sarg<C> sarg, RelDataType type, RexUnknownAs unknownAs)`
`static RexShuttle`	`searchShuttle(RexBuilder rexBuilder, @Nullable RexProgram program, int maxComplexity)` Creates a shuttle that expands calls to `SqlStdOperatorTable.SEARCH`.
`static List<RexNode>`	`shift(Iterable<RexNode> nodes, int offset)` Shifts every `RexInputRef` in an expression by `offset`.
`static RexNode`	`shift(RexNode node, int offset)` Shifts every `RexInputRef` in an expression by `offset`.
`static RexNode`	`shift(RexNode node, int start, int offset)` Shifts every `RexInputRef` in an expression higher than `start` by `offset`.
`static <C extends Comparable<C>> RexNode`	`simpleSarg(RexBuilder rexBuilder, RexNode ref, Sarg<C> sarg, RexUnknownAs unknownAs)` Expands an 'all' or 'none' sarg.
`static RexNode`	`simplify(RexBuilder rexBuilder, RexNode e)` Deprecated. Create a `RexSimplify`, then call its `RexSimplify.simplify(RexNode, RexUnknownAs)` method.
`static RexNode`	`simplify(RexBuilder rexBuilder, RexNode e, boolean unknownAsFalse)` Deprecated. Create a `RexSimplify`, then call its `RexSimplify.simplify(RexNode, RexUnknownAs)` method.
`static RexNode`	`simplifyAnd(RexBuilder rexBuilder, RexCall e, boolean unknownAsFalse)` Deprecated.
`static RexNode`	`simplifyAnd2(RexBuilder rexBuilder, List<RexNode> terms, List<RexNode> notTerms)` Deprecated.
`static RexNode`	`simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder, List<RexNode> terms, List<RexNode> notTerms)` Deprecated.
`static RexNode`	`simplifyAnds(RexBuilder rexBuilder, Iterable<? extends RexNode> nodes)` Deprecated. Use `RexSimplify.simplifyAnds(Iterable, RexUnknownAs)`.
`static RexNode`	`simplifyAnds(RexBuilder rexBuilder, Iterable<? extends RexNode> nodes, boolean unknownAsFalse)` Deprecated.
`static RexNode`	`simplifyOr(RexBuilder rexBuilder, RexCall call)` Deprecated.
`static RexNode`	`simplifyOrs(RexBuilder rexBuilder, List<RexNode> terms)` Deprecated.
`static RexNode`	`simplifyPreservingType(RexBuilder rexBuilder, RexNode e)` Deprecated. Use `RexSimplify.simplifyPreservingType(RexNode)`, which allows you to specify an `RexExecutor`.
`static List<String>`	`strings(List<RexNode> list)` Transforms a list of expressions to the list of digests.
`static RexNode`	`swapColumnReferences(RexBuilder rexBuilder, RexNode node, Map<RexTableInputRef,Set<RexTableInputRef>> ec)` Given an expression, it will swap its column references `RexTableInputRef` using the contents in the map (in particular, the first element of the set in the map value).
`static RexNode`	`swapColumnTableReferences(RexBuilder rexBuilder, RexNode node, Map<RexTableInputRef,? extends Set<RexTableInputRef>> ec, @Nullable Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)` Given an expression, it will swap the column references `RexTableInputRef` using the contents in the first map (in particular, the first element of the set in the map value), and then it will swap the table references contained in its `RexTableInputRef` using the contents in the second map.
`static RexNode`	`swapTableColumnReferences(RexBuilder rexBuilder, RexNode node, @Nullable Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, @Nullable Map<RexTableInputRef,Set<RexTableInputRef>> ec)` Given an expression, it will swap the table references contained in its `RexTableInputRef` using the contents in the first map, and then it will swap the column references `RexTableInputRef` using the contents in the second map (in particular, the first element of the set in the map value).
`static RexNode`	`swapTableReferences(RexBuilder rexBuilder, RexNode node, Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)` Given an expression, it will swap the table references contained in its `RexTableInputRef` using the contents in the map.
`static RexNode`	`toCnf(RexBuilder rexBuilder, int maxCnfNodeCount, RexNode rex)` Similar to `toCnf(RexBuilder, RexNode)`; however, it lets you specify a threshold in the number of nodes that can be created out of the conversion.
`static RexNode`	`toCnf(RexBuilder rexBuilder, RexNode rex)` Converts an expression to conjunctive normal form (CNF).
`static RexNode`	`toDnf(RexBuilder rexBuilder, RexNode rex)` Converts an expression to disjunctive normal form (DNF).
`static List<RelDataType>`	`types(List<? extends RexNode> nodes)` Transforms a list of expressions into a list of their types.

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

Field Detail
- EXECUTOR
```
public static final RexExecutor EXECUTOR
```
  Executor for a bit of constant reduction. The user can pass in another executor.

Method Detail

getSelectivity
```
public static double getSelectivity(@Nullable RexNode exp)
```
Returns a guess for the selectivity of an expression.

Parameters:

exp - expression of interest, or null for none (implying a selectivity of 1.0)

Returns:

guessed selectivity

generateCastExpressions

public static List<RexNode> generateCastExpressions(RexBuilder rexBuilder,
                                                    RelDataType lhsRowType,
                                                    RelDataType rhsRowType)

Generates a cast from one row type to another.

Parameters:: rexBuilder - RexBuilder to use for constructing casts; lhsRowType - target row type; rhsRowType - source row type; fields must be 1-to-1 with lhsRowType, in same order
Returns:: cast expressions

generateCastExpressions

public static List<RexNode> generateCastExpressions(RexBuilder rexBuilder,
                                                    RelDataType lhsRowType,
                                                    List<RexNode> rhsExps)

Generates a cast for a row type.

Parameters:: rexBuilder - RexBuilder to use for constructing casts; lhsRowType - target row type; rhsExps - expressions to be cast
Returns:: cast expressions

isNullLiteral
```
public static boolean isNullLiteral(RexNode node,
                                    boolean allowCast)
```
Returns whether a node represents the NULL value.
Examples:
- For RexLiteral Unknown, returns false.
- For CAST(NULL AS type), returns true if allowCast is true, false otherwise.
- For CAST(CAST(NULL AS type) AS type)), returns false.

isNull
```
public static boolean isNull(RexNode expr)
```
Returns whether a node represents the NULL value or a series of nested CAST(NULL AS type) calls. For example: isNull(CAST(CAST(NULL as INTEGER) AS VARCHAR(1))) returns true.

isLiteral
```
public static boolean isLiteral(RexNode node,
                                boolean allowCast)
```
Returns whether a node represents a literal.
Examples:
- For CAST(literal AS type), returns true if allowCast is true, false otherwise.
- For CAST(CAST(literal AS type) AS type)), returns false.
Parameters:

node - The node, never null.

allowCast - whether to regard CAST(literal) as a literal

Returns:

Whether the node is a literal

allLiterals
```
public static boolean allLiterals(List<RexNode> expressionOperands)
```
Returns whether every expression in a list is a literal.

Parameters:

expressionOperands - list of expressions to check

Returns:

true if every expression from the specified list is literal.

isReferenceOrAccess
```
public static boolean isReferenceOrAccess(RexNode node,
                                          boolean allowCast)
```
Returns whether a node represents an input reference or field access.

Parameters:

node - The node, never null.

allowCast - whether to regard CAST(x) as true

Returns:

Whether the node is a reference or access

isNullabilityCast

public static boolean isNullabilityCast(RelDataTypeFactory typeFactory,
                                        RexNode node)

Returns whether an expression is a cast just for the purposes of nullability, not changing any other aspect of the type.

removeNullabilityCast

public static RexNode removeNullabilityCast(RelDataTypeFactory typeFactory,
                                            RexNode node)

Removes any casts that change nullability but not type.

For example, CAST(1 = 0 AS BOOLEAN) becomes 1 = 0.

removeCast
```
public static RexNode removeCast(RexNode e)
```
Removes any casts.
For example, CAST('1' AS INTEGER) becomes '1'.

predicateConstants

public static <C extends RexNode> com.google.common.collect.ImmutableMap<RexNode,C> predicateConstants(Class<C> clazz,
                                                                                                       RexBuilder rexBuilder,
                                                                                                       List<RexNode> predicates)

Creates a map containing each (e, constant) pair that occurs within a predicate list.

Type Parameters:: C - what to consider a constant: RexLiteral to use a narrow definition of constant, or RexNode to use isConstant(RexNode)
Parameters:: clazz - Class of expression that is considered constant; rexBuilder - Rex builder; predicates - Predicate list
Returns:: Map from values to constants

nodeCount
```
public static int nodeCount(List<? extends RexNode> nodes)
```
Returns the number of nodes (including leaves) in a list of expressions.

See Also:

RexNode.nodeCount()

find

public static RexUtil.RexFinder find(SqlKind kind)

Returns a visitor that finds nodes of a given SqlKind.

find

public static RexUtil.RexFinder find(Set<SqlKind> kinds)

Returns a visitor that finds nodes of given SqlKinds.

find

public static RexUtil.RexFinder find(RexInputRef ref)

Returns a visitor that finds a particular RexInputRef.

expandSearch

public static RexNode expandSearch(RexBuilder rexBuilder,
                                   @Nullable RexProgram program,
                                   RexNode node)

Expands all the calls to SqlStdOperatorTable.SEARCH in an expression.

expandSearch

public static RexNode expandSearch(RexBuilder rexBuilder,
                                   @Nullable RexProgram program,
                                   RexNode node,
                                   int maxComplexity)

Expands calls to SqlStdOperatorTable.SEARCH whose complexity is greater than maxComplexity in an expression.

searchShuttle
```
public static RexShuttle searchShuttle(RexBuilder rexBuilder,
                                       @Nullable RexProgram program,
                                       int maxComplexity)
```
Creates a shuttle that expands calls to SqlStdOperatorTable.SEARCH.
If maxComplexity is non-negative, a Sarg whose complexity is greater than maxComplexity is retained (not expanded); this gives a means to simplify simple expressions such as x IS NULL or x > 10 while keeping more complex expressions such as x IN (3, 5, 7) OR x IS NULL as a Sarg.

sargRef

public static <C extends Comparable<C>> RexNode sargRef(RexBuilder rexBuilder,
                                                        RexNode ref,
                                                        Sarg<C> sarg,
                                                        RelDataType type,
                                                        RexUnknownAs unknownAs)

simpleSarg

public static <C extends Comparable<C>> RexNode simpleSarg(RexBuilder rexBuilder,
                                                           RexNode ref,
                                                           Sarg<C> sarg,
                                                           RexUnknownAs unknownAs)

Expands an 'all' or 'none' sarg.

isConstant
```
public static boolean isConstant(RexNode node)
```
Returns whether node is made up of constants.

Parameters:

node - Node to inspect

Returns:

true if node is made up of constants, false otherwise

isDeterministic
```
public static boolean isDeterministic(RexNode e)
```
Returns whether a given expression is deterministic.

Parameters:

e - Expression

Returns:

true if tree result is deterministic, false otherwise

retainDeterministic

public static List<RexNode> retainDeterministic(List<RexNode> list)

findOperatorCall

public static @Nullable RexCall findOperatorCall(SqlOperator operator,
                                                 RexNode node)

Returns whether a given node contains a RexCall with a specified operator.

Parameters:: operator - Operator to look for; node - a RexNode tree

containsInputRef
```
public static boolean containsInputRef(RexNode node)
```
Returns whether a given tree contains any {link RexInputRef} nodes.

Parameters:

node - a RexNode tree

containsFieldAccess
```
public static boolean containsFieldAccess(RexNode node)
```
Returns whether a given tree contains any RexFieldAccess nodes.

Parameters:

node - a RexNode tree

requiresDecimalExpansion
```
public static boolean requiresDecimalExpansion(RexNode expr,
                                               boolean recurse)
```
Determines whether a RexCall requires decimal expansion. It usually requires expansion if it has decimal operands.
Exceptions to this rule are:
- isNull doesn't require expansion
- It's okay to cast decimals to and from char types
- It's okay to cast nulls as decimals
- Casts require expansion if their return type is decimal
- Reinterpret casts can handle a decimal operand
Parameters:

expr - expression possibly in need of expansion

recurse - whether to check nested calls

Returns:

whether the expression requires expansion

requiresDecimalExpansion

public static boolean requiresDecimalExpansion(List<RexNode> operands,
                                               boolean recurse)

Determines whether any operand of a set requires decimal expansion.

requiresDecimalExpansion

public static boolean requiresDecimalExpansion(RexProgram program,
                                               boolean recurse)

Returns whether a RexProgram contains expressions which require decimal expansion.

canReinterpretOverflow

public static boolean canReinterpretOverflow(RexCall call)

containNoCommonExprs

public static boolean containNoCommonExprs(List<RexNode> exprs,
                                           Litmus litmus)

Returns whether an array of expressions has any common sub-expressions.

containNoForwardRefs
```
public static boolean containNoForwardRefs(List<RexNode> exprs,
                                           RelDataType inputRowType,
                                           Litmus litmus)
```
Returns whether an array of expressions contains no forward references. That is, if expression #i contains a RexInputRef referencing field i or greater.

Parameters:

exprs - Array of expressions

inputRowType - Input row type

litmus - What to do if an error is detected (there is a forward reference)

Returns:

Whether there is a forward reference

containComplexExprs
```
public static boolean containComplexExprs(List<RexNode> exprs)
```
Returns whether a list of expressions contains complex expressions, that is, a call whose arguments are not RexVariable (or a subtype such as RexInputRef) or RexLiteral.

containsTableInputRef
```
public static boolean containsTableInputRef(List<RexNode> nodes)
```
Returns whether any of the given expression trees contains a {link RexTableInputRef} node.

Parameters:

nodes - a list of RexNode trees

Returns:

true if at least one was found, otherwise false

containsTableInputRef
```
public static @Nullable RexTableInputRef containsTableInputRef(RexNode node)
```
Returns whether a given tree contains any {link RexTableInputRef} nodes.

Parameters:

node - a RexNode tree

Returns:

first such node found or null if it there is no such node

isAtomic

public static boolean isAtomic(RexNode expr)

isCallTo

public static boolean isCallTo(RexNode expr,
                               SqlOperator op)

Returns whether a node is a call to a given operator.

createStructType

public static RelDataType createStructType(RelDataTypeFactory typeFactory,
                                           List<RexNode> exprs)

Creates a record type with anonymous field names.

Parameters:: typeFactory - Type factory; exprs - Expressions
Returns:: Record type

createStructType
```
public static RelDataType createStructType(RelDataTypeFactory typeFactory,
                                           List<? extends RexNode> exprs,
                                           @Nullable List<? extends String> names,
                                           SqlValidatorUtil.Suggester suggester)
```
Creates a record type with specified field names.
The array of field names may be null, or any of the names within it can be null. We recommend using explicit names where possible, because it makes it much easier to figure out the intent of fields when looking at planner output.

Parameters:

typeFactory - Type factory

exprs - Expressions

names - Field names, may be null, or elements may be null

suggester - Generates alternative names if names is not null and its elements are not unique

Returns:

Record type

createStructType

@Deprecated
public static RelDataType createStructType(RelDataTypeFactory typeFactory,
                                                       List<? extends RexNode> exprs,
                                                       List<String> names)

Deprecated.

compatibleTypes
```
public static boolean compatibleTypes(List<RexNode> exprs,
                                      RelDataType type,
                                      Litmus litmus)
```
Returns whether the type of an array of expressions is compatible with a struct type.

Parameters:

exprs - Array of expressions

type - Type

litmus - What to do if an error is detected (there is a mismatch)

Returns:

Whether every expression has the same type as the corresponding member of the struct type

See Also:

RelOptUtil.eq(String, RelDataType, String, RelDataType, org.apache.calcite.util.Litmus)

makeKey
```
public static Pair<RexNode,String> makeKey(RexNode expr)
```
Creates a key for RexNode which is the same as another key of another RexNode only if the two have both the same type and textual representation. For example, "10" integer and "10" bigint result in different keys.

containIdentity

public static boolean containIdentity(List<? extends RexNode> exprs,
                                      RelDataType rowType,
                                      Litmus litmus)

Returns whether the leading edge of a given array of expressions is wholly RexInputRef objects with types corresponding to the underlying datatype.

isIdentity

public static boolean isIdentity(List<? extends RexNode> exps,
                                 RelDataType inputRowType)

Returns whether a list of expressions projects the incoming fields.

composeConjunction

public static RexNode composeConjunction(RexBuilder rexBuilder,
                                         Iterable<? extends RexNode> nodes)

As composeConjunction(RexBuilder, Iterable, boolean) but never returns null.

composeConjunction
```
public static @Nullable RexNode composeConjunction(RexBuilder rexBuilder,
                                                   Iterable<? extends RexNode> nodes,
                                                   boolean nullOnEmpty)
```
Converts a collection of expressions into an AND. If there are zero expressions, returns TRUE. If there is one expression, returns just that expression. If any of the expressions are FALSE, returns FALSE. Removes expressions that always evaluate to TRUE. Returns null only if nullOnEmpty and expression is TRUE.

flattenAnd

public static com.google.common.collect.ImmutableList<RexNode> flattenAnd(Iterable<? extends RexNode> nodes)

Flattens a list of AND nodes.

Treats null nodes as literal TRUE (i.e. ignores them).

composeDisjunction
```
public static RexNode composeDisjunction(RexBuilder rexBuilder,
                                         Iterable<? extends RexNode> nodes)
```
Converts a collection of expressions into an OR. If there are zero expressions, returns FALSE. If there is one expression, returns just that expression. If any of the expressions are TRUE, returns TRUE. Removes expressions that always evaluate to FALSE. Flattens expressions that are ORs.

composeDisjunction

public static @Nullable RexNode composeDisjunction(RexBuilder rexBuilder,
                                                   Iterable<? extends RexNode> nodes,
                                                   boolean nullOnEmpty)

Converts a collection of expressions into an OR, optionally returning null if the list is empty.

flattenOr

public static com.google.common.collect.ImmutableList<RexNode> flattenOr(Iterable<? extends RexNode> nodes)

Flattens a list of OR nodes.

apply

public static List<RelCollation> apply(Mappings.TargetMapping mapping,
                                       List<RelCollation> collationList)

Applies a mapping to a collation list.

Parameters:: mapping - Mapping; collationList - Collation list
Returns:: collation list with mapping applied to each field

apply

public static RelCollation apply(Mappings.TargetMapping mapping,
                                 RelCollation collation)

Applies a mapping to a collation.

Parameters:: mapping - Mapping; collation - Collation
Returns:: collation with mapping applied

apply

public static @Nullable RelFieldCollation apply(Mappings.TargetMapping mapping,
                                                RelFieldCollation fieldCollation)

Applies a mapping to a field collation.

If the field is not mapped, returns null.

Parameters:: mapping - Mapping; fieldCollation - Field collation
Returns:: collation with mapping applied

applyFields

public static List<RelFieldCollation> applyFields(Mappings.TargetMapping mapping,
                                                  List<RelFieldCollation> fieldCollations)

Applies a mapping to a list of field collations.

Parameters:: mapping - Mapping; fieldCollations - Field collations
Returns:: collations with mapping applied

apply

public static RexNode apply(Mappings.TargetMapping mapping,
                            RexNode node)

Applies a mapping to an expression.

apply

public static List<RexNode> apply(Mappings.TargetMapping mapping,
                                  Iterable<? extends RexNode> nodes)

Applies a mapping to an iterable over expressions.

apply

public static <T extends RexNode> T[] apply(RexVisitor<T> shuttle,
                                            T[] exprs)

Applies a shuttle to an array of expressions. Creates a copy first.

Parameters:: shuttle - Shuttle; exprs - Array of expressions

apply
```
public static void apply(RexVisitor<Void> visitor,
                         RexNode[] exprs,
                         @Nullable RexNode expr)
```
Applies a visitor to an array of expressions and, if specified, a single expression.

Parameters:

visitor - Visitor

exprs - Array of expressions

expr - Single expression, may be null

apply

public static void apply(RexVisitor<Void> visitor,
                         List<? extends RexNode> exprs,
                         @Nullable RexNode expr)

Applies a visitor to a list of expressions and, if specified, a single expression.

Parameters:: visitor - Visitor; exprs - List of expressions; expr - Single expression, may be null

flatten

public static RexNode flatten(RexBuilder rexBuilder,
                              RexNode node)

Flattens an expression.

Returns the same expression if it is already flat.

flatten

public static List<RexNode> flatten(List<? extends RexNode> exprs,
                                    SqlOperator op)

Converts a list of operands into a list that is flat with respect to the given operator. The operands are assumed to be flat already.

isFlat
```
public static boolean isFlat(RexNode expr)
```
Returns false if the expression can be optimized by flattening calls to an associative operator such as AND and OR.

isLosslessCast
```
public static boolean isLosslessCast(RexNode node)
```
Returns whether the input is a 'loss-less' cast, that is, a cast from which the original value of the field can be certainly recovered.
For instance, int → bigint is loss-less (as you can cast back to int without loss of information), but bigint → int is not loss-less.
The implementation of this method does not return false positives. However, it is not complete.

Parameters:

node - input node to verify if it represents a loss-less cast

Returns:

true iff the node is a loss-less cast

isLosslessCast
```
@API(since="1.22",
     status=EXPERIMENTAL)
public static boolean isLosslessCast(RelDataType source,
                                                                                  RelDataType target)
```
Returns whether the conversion from source to target type is a 'loss-less' cast, that is, a cast from which the original value of the field can be certainly recovered.
For instance, int → bigint is loss-less (as you can cast back to int without loss of information), but bigint → int is not loss-less.
The implementation of this method does not return false positives. However, it is not complete.

Parameters:

source - source type

target - target type

Returns:

true iff the conversion is a loss-less cast

toCnf
```
public static RexNode toCnf(RexBuilder rexBuilder,
                            RexNode rex)
```
Converts an expression to conjunctive normal form (CNF).
The following expression is in CNF:
(a OR b) AND (c OR d)

The following expression is not in CNF:
(a AND b) OR c

but can be converted to CNF:
(a OR c) AND (b OR c)

The following expression is not in CNF:
NOT (a OR NOT b)

but can be converted to CNF by applying de Morgan's theorem:
NOT a AND b

Expressions not involving AND, OR or NOT at the top level are in CNF.

toCnf
```
public static RexNode toCnf(RexBuilder rexBuilder,
                            int maxCnfNodeCount,
                            RexNode rex)
```
Similar to toCnf(RexBuilder, RexNode); however, it lets you specify a threshold in the number of nodes that can be created out of the conversion.
If the number of resulting nodes exceeds that threshold, stops conversion and returns the original expression.
If the threshold is negative it is ignored.
Leaf nodes in the expression do not count towards the threshold.

toDnf
```
public static RexNode toDnf(RexBuilder rexBuilder,
                            RexNode rex)
```
Converts an expression to disjunctive normal form (DNF).
DNF: It is a form of logical formula which is disjunction of conjunctive clauses.
All logical formulas can be converted into DNF.
The following expression is in DNF:
(a AND b) OR (c AND d)

The following expression is not in CNF:
(a OR b) AND c

but can be converted to DNF:
(a AND c) OR (b AND c)

The following expression is not in CNF:
NOT (a OR NOT b)

but can be converted to DNF by applying de Morgan's theorem:
NOT a AND b

Expressions not involving AND, OR or NOT at the top level are in DNF.

exists

public static <E> boolean exists(List<? extends E> list,
                                 org.apache.calcite.linq4j.function.Predicate1<E> predicate)

Returns whether there is an element in list for which predicate is true.

all

public static <E> boolean all(List<? extends E> list,
                              org.apache.calcite.linq4j.function.Predicate1<E> predicate)

Returns whether predicate is true for all elements of list.

shift

public static RexNode shift(RexNode node,
                            int offset)

Shifts every RexInputRef in an expression by offset.

shift

public static List<RexNode> shift(Iterable<RexNode> nodes,
                                  int offset)

Shifts every RexInputRef in an expression by offset.

shift

public static RexNode shift(RexNode node,
                            int start,
                            int offset)

Shifts every RexInputRef in an expression higher than start by offset.

pullFactors
```
public static RexNode pullFactors(RexBuilder rexBuilder,
                                  RexNode node)
```
Creates an equivalent version of a node where common factors among ORs are pulled up.
For example,
(a AND b) OR (a AND c AND d)

becomes
a AND (b OR (c AND d))

Note that this result is not in CNF (see toCnf(RexBuilder, RexNode)) because there is an AND inside an OR.
This form is useful if, say, a contains columns from only the left-hand side of a join, and can be pushed to the left input.

Parameters:

rexBuilder - Rex builder

node - Expression to transform

Returns:

Equivalent expression with common factors pulled up

fixUp

@Deprecated
public static List<RexNode> fixUp(RexBuilder rexBuilder,
                                              List<RexNode> nodes,
                                              RelDataType rowType)

Deprecated.

fixUp

public static List<RexNode> fixUp(RexBuilder rexBuilder,
                                  List<RexNode> nodes,
                                  List<RelDataType> fieldTypes)

Fixes up the type of all RexInputRefs in an expression to match differences in nullability.

Such differences in nullability occur when expressions are moved through outer joins.

Throws if there any greater inconsistencies of type.

types

public static List<RelDataType> types(List<? extends RexNode> nodes)

Transforms a list of expressions into a list of their types.

families

public static List<RelDataTypeFamily> families(List<RelDataType> types)

removeAll

public static boolean removeAll(List<RexNode> targets,
                                RexNode e)

Removes all expressions from a list that are equivalent to a given expression. Returns whether any were removed.

eq
```
@Deprecated
public static boolean eq(RexNode e1,
                                     RexNode e2)
```
Deprecated.

Returns whether two RexNodes are structurally equal.
This method considers structure, not semantics. 'x < y' is not equivalent to 'y > x'.

simplifyPreservingType
```
@Deprecated
public static RexNode simplifyPreservingType(RexBuilder rexBuilder,
                                                         RexNode e)
```
Deprecated. Use RexSimplify.simplifyPreservingType(RexNode), which allows you to specify an RexExecutor.

Simplifies a boolean expression, always preserving its type and its nullability.
This is useful if you are simplifying expressions in a Project.

simplify
```
@Deprecated
public static RexNode simplify(RexBuilder rexBuilder,
                                           RexNode e)
```
Deprecated. Create a RexSimplify, then call its RexSimplify.simplify(RexNode, RexUnknownAs) method.

Simplifies a boolean expression, leaving UNKNOWN values as UNKNOWN, and using the default executor.

simplify
```
@Deprecated
public static RexNode simplify(RexBuilder rexBuilder,
                                           RexNode e,
                                           boolean unknownAsFalse)
```
Deprecated. Create a RexSimplify, then call its RexSimplify.simplify(RexNode, RexUnknownAs) method.
Simplifies a boolean expression, using the default executor.
In particular:
- simplify(x = 1 AND y = 2 AND NOT x = 1) returns y = 2
- simplify(x = 1 AND FALSE) returns FALSE
If the expression is a predicate in a WHERE clause, UNKNOWN values have the same effect as FALSE. In situations like this, specify unknownAsFalse = true, so and we can switch from 3-valued logic to simpler 2-valued logic and make more optimizations.
Parameters:

rexBuilder - Rex builder

e - Expression to simplify

unknownAsFalse - Whether to convert UNKNOWN values to FALSE

simplifyAnds

@Deprecated
public static RexNode simplifyAnds(RexBuilder rexBuilder,
                                               Iterable<? extends RexNode> nodes)

Deprecated. Use RexSimplify.simplifyAnds(Iterable, RexUnknownAs).

Simplifies a conjunction of boolean expressions.

simplifyAnds

@Deprecated
public static RexNode simplifyAnds(RexBuilder rexBuilder,
                                               Iterable<? extends RexNode> nodes,
                                               boolean unknownAsFalse)

Deprecated.

not
```
public static RexNode not(RexNode e)
```
Negates a logical expression by adding or removing a NOT.

op

@API(since="1.27.0",
     status=EXPERIMENTAL)
public static SqlOperator op(SqlKind kind)

simplifyAnd

@Deprecated
public static RexNode simplifyAnd(RexBuilder rexBuilder,
                                              RexCall e,
                                              boolean unknownAsFalse)

Deprecated.

simplifyAnd2

@Deprecated
public static RexNode simplifyAnd2(RexBuilder rexBuilder,
                                               List<RexNode> terms,
                                               List<RexNode> notTerms)

Deprecated.

simplifyAnd2ForUnknownAsFalse

@Deprecated
public static RexNode simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder,
                                                                List<RexNode> terms,
                                                                List<RexNode> notTerms)

Deprecated.

negate

public static @Nullable RexNode negate(RexBuilder rexBuilder,
                                       RexCall call)

invert

public static @Nullable RexNode invert(RexBuilder rexBuilder,
                                       RexCall call)

simplifyOr

@Deprecated
public static RexNode simplifyOr(RexBuilder rexBuilder,
                                             RexCall call)

Deprecated.

simplifyOrs

@Deprecated
public static RexNode simplifyOrs(RexBuilder rexBuilder,
                                              List<RexNode> terms)

Deprecated.

andNot

public static RexNode andNot(RexBuilder rexBuilder,
                             RexNode e,
                             RexNode... notTerms)

Creates the expression e1 AND NOT notTerm1 AND NOT notTerm2 ....

andNot

public static RexNode andNot(RexBuilder rexBuilder,
                             RexNode e,
                             Iterable<? extends RexNode> notTerms)

Creates the expression e1 AND NOT notTerm1 AND NOT notTerm2 ....

Examples:

andNot(p) returns "p"
andNot(p, n1, n2) returns "p AND NOT n1 AND NOT n2"
andNot(x = 10, x = 20, y = 30, x = 30) returns "x = 10 AND NOT (y = 30)"

isCasePredicate
```
public static boolean isCasePredicate(RexCall call,
                                      int i)
```
Returns whether a given operand of a CASE expression is a predicate.
A switched case (CASE x WHEN x1 THEN v1 ... ELSE e END) has an even number of arguments and odd-numbered arguments are predicates.
A condition case (CASE WHEN p1 THEN v1 ... ELSE e END) has an odd number of arguments and even-numbered arguments are predicates, except for the last argument.

notFn

@Deprecated
public static com.google.common.base.Function<RexNode,RexNode> notFn(RexBuilder rexBuilder)

Deprecated. Use not(org.apache.calcite.rex.RexNode)

Returns a function that applies NOT to its argument.

containsCorrelation
```
public static boolean containsCorrelation(RexNode condition)
```
Returns whether an expression contains a RexCorrelVariable.

swapTableReferences

public static RexNode swapTableReferences(RexBuilder rexBuilder,
                                          RexNode node,
                                          Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)

Given an expression, it will swap the table references contained in its RexTableInputRef using the contents in the map.

swapColumnReferences

public static RexNode swapColumnReferences(RexBuilder rexBuilder,
                                           RexNode node,
                                           Map<RexTableInputRef,Set<RexTableInputRef>> ec)

Given an expression, it will swap its column references RexTableInputRef using the contents in the map (in particular, the first element of the set in the map value).

swapTableColumnReferences

public static RexNode swapTableColumnReferences(RexBuilder rexBuilder,
                                                RexNode node,
                                                @Nullable Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping,
                                                @Nullable Map<RexTableInputRef,Set<RexTableInputRef>> ec)

Given an expression, it will swap the table references contained in its RexTableInputRef using the contents in the first map, and then it will swap the column references RexTableInputRef using the contents in the second map (in particular, the first element of the set in the map value).

swapColumnTableReferences

public static RexNode swapColumnTableReferences(RexBuilder rexBuilder,
                                                RexNode node,
                                                Map<RexTableInputRef,? extends Set<RexTableInputRef>> ec,
                                                @Nullable Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)

Given an expression, it will swap the column references RexTableInputRef using the contents in the first map (in particular, the first element of the set in the map value), and then it will swap the table references contained in its RexTableInputRef using the contents in the second map.

gatherTableReferences
```
public static Set<RexTableInputRef.RelTableRef> gatherTableReferences(List<RexNode> nodes)
```
Gather all table references in input expressions.

Parameters:

nodes - expressions

Returns:

set of table references

getNonConstColumns
```
public static ImmutableBitSet getNonConstColumns(List<RexNode> expressions)
```
Given some expressions, gets the indices of the non-constant ones.

getNonConstColumns

public static ImmutableBitSet getNonConstColumns(ImmutableBitSet columns,
                                                 List<RexNode> expressions)

Given some expressions and columns, gets the indices of the non-constant ones.

strings
```
public static List<String> strings(List<RexNode> list)
```
Transforms a list of expressions to the list of digests.

Class RexUtil

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EXECUTOR

Method Detail

getSelectivity

generateCastExpressions

generateCastExpressions

isNullLiteral

isNull

isLiteral

allLiterals

isReferenceOrAccess

isNullabilityCast

removeNullabilityCast

removeCast

predicateConstants

nodeCount

find

find

find

expandSearch

expandSearch

searchShuttle

sargRef

simpleSarg

isConstant

isDeterministic

retainDeterministic

findOperatorCall

containsInputRef

containsFieldAccess

requiresDecimalExpansion

requiresDecimalExpansion

requiresDecimalExpansion

canReinterpretOverflow

containNoCommonExprs

containNoForwardRefs

containComplexExprs

containsTableInputRef

containsTableInputRef

isAtomic

isCallTo

createStructType

createStructType

createStructType

compatibleTypes

makeKey

containIdentity

isIdentity

composeConjunction

composeConjunction

flattenAnd

composeDisjunction

composeDisjunction

flattenOr

apply

apply

apply

applyFields

apply

apply

apply

apply

apply

flatten

flatten

isFlat

isLosslessCast

isLosslessCast

toCnf

toCnf

toDnf

exists

all

shift

shift