RexUtil (Calcite Core 1.2.0-incubating 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.FieldAccessFinder
Visitor which builds a bitmap of the inputs used by an expression.

Nested Classes
Modifier and Type	Class and Description
`static class`	`RexUtil.FieldAccessFinder` Visitor which builds a bitmap of the inputs used by an expression.

Method Summary

Methods
Modifier and Type	Method and Description
`static <E> boolean`	`all(List<? extends E> list, Predicate1<E> predicate)` Returns whether `predicate` is true for all elements of `list`.
`static Iterable<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 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, RexNode expr)` Applies a visitor to a list of expressions and, if specified, a single expression.
`static void`	`apply(RexVisitor<Void> visitor, RexNode[] exprs, 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, boolean fail)` Returns whether the type of an array of expressions is compatible with a struct type.
`static 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, boolean nullOnEmpty)` Converts a collection of expressions into an OR.
`static boolean`	`containCommonExprs(List<RexNode> exprs, boolean fail)` Returns whether an array of expressions has any common sub-expressions.
`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`	`containForwardRefs(List<RexNode> exprs, RelDataType inputRowType, boolean fail)` Returns whether an array of expressions contains a forward reference.
`static boolean`	`containIdentity(List<? extends RexNode> exprs, RelDataType rowType, boolean fail)` Returns whether the leading edge of a given array of expressions is wholly `RexInputRef` objects with types corresponding to the underlying datatype.
`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 RelDataType`	`createStructType(RelDataTypeFactory typeFactory, List<? extends RexNode> exprs, List<String> names)` Creates a record type with specified field names.
`static RelDataType`	`createStructType(RelDataTypeFactory typeFactory, List<RexNode> exprs)` Creates a record type with anonymous field names.
`static <E> boolean`	`exists(List<? extends E> list, Predicate1<E> predicate)` Returns whether there is an element in `list` for which `predicate` is true.
`static List<RelDataTypeFamily>`	`families(List<RelDataType> types)`
`static 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, RelDataType rowType)` Fixes up the type of all `RexInputRef`s in an expression to match differences in nullability.
`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 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 double`	`getSelectivity(RexNode exp)` Returns a guess for the selectivity of an expression.
`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`	`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`	`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 Pair<String,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 RexNode`	`pullFactors(RexBuilder rexBuilder, RexNode node)` Creates an equivalent version of a node where common factors among ORs are pulled up.
`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 Iterable<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 RexNode`	`toCnf(RexBuilder rexBuilder, RexNode rex)` Converts an expression to conjunctive normal form (CNF).
`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

- Method Detail
  - getSelectivity
```
public static double getSelectivity(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.
  - 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.
  - findOperatorCall
```
public static RexCall findOperatorCall(SqlOperator operator,
                       RexNode node)
```
    Returns whether a given node contains a RexCall with a specified operator
    
    Parameters:
    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)
```
  - containCommonExprs
```
public static boolean containCommonExprs(List<RexNode> exprs,
                         boolean fail)
```
    Returns whether an array of expressions has any common sub-expressions.
  - containForwardRefs
```
public static boolean containForwardRefs(List<RexNode> exprs,
                         RelDataType inputRowType,
                         boolean fail)
```
    Returns whether an array of expressions contains a forward reference. That is, if expression #i contains a RexInputRef referencing field i or greater.
    
    Parameters:
    exprs - Array of expressions
    inputRowType - Input row type
    fail - Whether to assert if 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.
  - 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,
                           List<String> names)
```
    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
    
    Returns:
    Record type
  - compatibleTypes
```
public static boolean compatibleTypes(List<RexNode> exprs,
                      RelDataType type,
                      boolean fail)
```
    Returns whether the type of an array of expressions is compatible with a struct type.
    
    Parameters:
    exprs - Array of expressions
    type - Type
    fail - Whether to fail if 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, boolean)
  - makeKey
```
public static Pair<String,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,
                      boolean fail)
```
    Returns whether the leading edge of a given array of expressions is wholly RexInputRef objects with types corresponding to the underlying datatype.
  - composeConjunction
```
public static 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. 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,
                         boolean nullOnEmpty)
```
    Converts a collection of expressions into an OR. If there are zero expressions, returns FALSE. If there is one expression, returns just that expression. Removes expressions that always evaluate to FALSE. Flattens expressions that are ORs.
  - 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 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 Iterable<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,
         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,
         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.
  - 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.
  - exists
```
public static <E> boolean exists(List<? extends E> list,
                 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,
              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 Iterable<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
```
public static List<RexNode> fixUp(RexBuilder rexBuilder,
                  List<RexNode> nodes,
                  RelDataType rowType)
```
    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)
```

Class RexUtil

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getSelectivity

generateCastExpressions

generateCastExpressions

isNullLiteral

isNull

isNullabilityCast

findOperatorCall

containsInputRef

containsFieldAccess

requiresDecimalExpansion

requiresDecimalExpansion

requiresDecimalExpansion

canReinterpretOverflow

containCommonExprs

containForwardRefs

containComplexExprs

isAtomic

isCallTo

createStructType

createStructType

compatibleTypes

makeKey

containIdentity

composeConjunction

flattenAnd

composeDisjunction

flattenOr

apply

apply

apply

applyFields

apply

apply

apply

apply

apply

flatten

flatten

isFlat

toCnf

exists

all

shift

shift

shift

pullFactors

fixUp

types

families