Class RexUtil
- java.lang.Object
-
- org.apache.calcite.rex.RexUtil
-
public class RexUtil extends java.lang.Object
Utility methods concerning row-expressions.
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description private static class
RexUtil.CnfHelper
(package private) static class
RexUtil.ConstantFinder
Walks over an expression and determines whether it is constant.private static class
RexUtil.CorrelationFinder
Visitor that throwsUtil.FoundOne
if applied to an expression that contains aRexCorrelVariable
.private static class
RexUtil.DnfHelper
private static class
RexUtil.ExpressionNormalizer
Walks over expressions and builds a bank of common sub-expressions.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.private static class
RexUtil.ForwardRefFinder
Walks over an expression and throws an exception if it finds anRexInputRef
with an ordinal beyond the number of fields in the input row type, or aRexLocalRef
with ordinal greater than that set usingRexUtil.ForwardRefFinder.setLimit(int)
.private static class
RexUtil.RexShiftShuttle
Shuttle that addsoffset
to eachRexInputRef
in an expression.static class
RexUtil.SubQueryFinder
Visitor that throwsUtil.FoundOne
if applied to an expression that contains aRexSubQuery
.
-
Field Summary
Fields Modifier and Type Field Description static RexExecutor
EXECUTOR
Executor for a bit of constant reduction.
-
Constructor Summary
Constructors Modifier Constructor Description private
RexUtil()
-
Method Summary
All Methods Static Methods Concrete Methods Deprecated Methods Modifier and Type Method Description private static void
addAnd(com.google.common.collect.ImmutableList.Builder<RexNode> builder, java.util.Set<RexNode> digests, RexNode node)
private static RexNode
addNot(RexNode e)
private static void
addOr(com.google.common.collect.ImmutableList.Builder<RexNode> builder, java.util.Set<RexNode> set, RexNode node)
static <E> boolean
all(java.util.List<? extends E> list, Predicate1<E> predicate)
Returns whetherpredicate
is true for all elements oflist
.static boolean
allLiterals(java.util.List<RexNode> expressionOperands)
Returns whether every expression in a list is a literal.static RexNode
andNot(RexBuilder rexBuilder, RexNode e, java.lang.Iterable<? extends RexNode> notTerms)
Creates the expressione1 AND NOT notTerm1 AND NOT notTerm2 ...
.static RexNode
andNot(RexBuilder rexBuilder, RexNode e, RexNode... notTerms)
Creates the expressione1 AND NOT notTerm1 AND NOT notTerm2 ...
.static void
apply(RexVisitor<java.lang.Void> visitor, java.util.List<? extends RexNode> exprs, RexNode expr)
Applies a visitor to a list of expressions and, if specified, a single expression.static void
apply(RexVisitor<java.lang.Void> visitor, RexNode[] exprs, RexNode expr)
Applies a visitor to an array of expressions and, if specified, a single expression.static <T extends RexNode>
T[]apply(RexVisitor<T> shuttle, T[] exprs)
Applies a shuttle to an array of expressions.static java.lang.Iterable<RexNode>
apply(Mappings.TargetMapping mapping, java.lang.Iterable<? extends RexNode> nodes)
Applies a mapping to an iterable over expressions.static java.util.List<RelCollation>
apply(Mappings.TargetMapping mapping, java.util.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 java.util.List<RelFieldCollation>
applyFields(Mappings.TargetMapping mapping, java.util.List<RelFieldCollation> fieldCollations)
Applies a mapping to a list of field collations.private static boolean
canAssignFrom(RelDataType type1, RelDataType type2)
Returns whether a value oftype2
can be assigned to a variable oftype1
.static boolean
canReinterpretOverflow(RexCall call)
static boolean
compatibleTypes(java.util.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, java.lang.Iterable<? extends RexNode> nodes)
AscomposeConjunction(RexBuilder, Iterable, boolean)
but never returns null.static RexNode
composeConjunction(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes, boolean nullOnEmpty)
Converts a collection of expressions into an AND.static RexNode
composeDisjunction(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes)
Converts a collection of expressions into an OR.static RexNode
composeDisjunction(RexBuilder rexBuilder, java.lang.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(java.util.List<RexNode> exprs)
Returns whether a list of expressions contains complex expressions, that is, a call whose arguments are notRexVariable
(or a subtype such asRexInputRef
) orRexLiteral
.static boolean
containIdentity(java.util.List<? extends RexNode> exprs, RelDataType rowType, Litmus litmus)
Returns whether the leading edge of a given array of expressions is whollyRexInputRef
objects with types corresponding to the underlying datatype.static boolean
containNoCommonExprs(java.util.List<RexNode> exprs, Litmus litmus)
Returns whether an array of expressions has any common sub-expressions.static boolean
containNoForwardRefs(java.util.List<RexNode> exprs, RelDataType inputRowType, Litmus litmus)
Returns whether an array of expressions contains no forward references.(package private) static boolean
containNoNonTrivialAggs(java.util.List<RexNode> exprs, Litmus litmus)
Returns whether an array of exp contains no aggregate function calls whose arguments are notRexInputRef
s.static boolean
containsCorrelation(RexNode condition)
Returns whether an expression contains aRexCorrelVariable
.private static boolean
containsFalse(java.lang.Iterable<RexNode> nodes)
static boolean
containsFieldAccess(RexNode node)
Returns whether a given tree contains anyRexFieldAccess
nodes.static boolean
containsInputRef(RexNode node)
Returns whether a given tree contains any {link RexInputRef} nodes.static boolean
containsTableInputRef(java.util.List<RexNode> nodes)
Returns whether any of the given expression trees contains a {link RexTableInputRef} node.static RexTableInputRef
containsTableInputRef(RexNode node)
Returns whether a given tree contains any {link RexTableInputRef} nodes.private static boolean
containsTrue(java.lang.Iterable<RexNode> nodes)
static RelDataType
createStructType(RelDataTypeFactory typeFactory, java.util.List<? extends RexNode> exprs, java.util.List<java.lang.String> names)
Deprecated.static RelDataType
createStructType(RelDataTypeFactory typeFactory, java.util.List<? extends RexNode> exprs, java.util.List<java.lang.String> names, SqlValidatorUtil.Suggester suggester)
Creates a record type with specified field names.static RelDataType
createStructType(RelDataTypeFactory typeFactory, java.util.List<RexNode> exprs)
Creates a record type with anonymous field names.private static void
decompose(java.util.Set<RexNode> set, RexNode rexNode)
Tries to decompose the RexNode which is a RexCall into non-literal RexNodes.static boolean
eq(RexNode e1, RexNode e2)
Deprecated.static <E> boolean
exists(java.util.List<? extends E> list, Predicate1<E> predicate)
Returns whether there is an element inlist
for whichpredicate
is true.static java.util.List<RelDataTypeFamily>
families(java.util.List<RelDataType> types)
static RexCall
findOperatorCall(SqlOperator operator, RexNode node)
Returns whether a given node contains a RexCall with a specified operatorstatic java.util.List<RexNode>
fixUp(RexBuilder rexBuilder, java.util.List<RexNode> nodes, java.util.List<RelDataType> fieldTypes)
Fixes up the type of allRexInputRef
s in an expression to match differences in nullability.static java.util.List<RexNode>
fixUp(RexBuilder rexBuilder, java.util.List<RexNode> nodes, RelDataType rowType)
Deprecated.static java.util.List<RexNode>
flatten(java.util.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(java.lang.Iterable<? extends RexNode> nodes)
Flattens a list of AND nodes.static com.google.common.collect.ImmutableList<RexNode>
flattenOr(java.lang.Iterable<? extends RexNode> nodes)
Flattens a list of OR nodes.private static void
flattenRecurse(java.util.List<RexNode> list, java.util.List<? extends RexNode> exprs, SqlOperator op)
private static <C extends RexNode>
voidgatherConstraint(java.lang.Class<C> clazz, RexNode left, RexNode right, java.util.Map<RexNode,C> map, java.util.Set<RexNode> excludeSet, RexBuilder rexBuilder)
private static <C extends RexNode>
voidgatherConstraints(java.lang.Class<C> clazz, RexNode predicate, java.util.Map<RexNode,C> map, java.util.Set<RexNode> excludeSet, RexBuilder rexBuilder)
static java.util.Set<RexTableInputRef.RelTableRef>
gatherTableReferences(java.util.List<RexNode> nodes)
Gather all table references in input expressions.static java.util.List<RexNode>
generateCastExpressions(RexBuilder rexBuilder, RelDataType lhsRowType, java.util.List<RexNode> rhsExps)
Generates a cast for a row type.static java.util.List<RexNode>
generateCastExpressions(RexBuilder rexBuilder, RelDataType lhsRowType, RelDataType rhsRowType)
Generates a cast from one row type to anotherstatic double
getSelectivity(RexNode exp)
Returns a guess for the selectivity of an expression.static RexNode
invert(RexBuilder rexBuilder, RexCall call)
private static boolean
isAssociative(SqlOperator op)
Returns whether an operator is associative.static boolean
isAtomic(RexNode expr)
static boolean
isCallTo(RexNode expr, SqlOperator op)
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.private static boolean
isFlat(java.util.List<? extends RexNode> exprs, SqlOperator op)
Returns whether a call toop
withexprs
as arguments would be considered "flat".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(java.util.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(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 nestedCAST(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,java.lang.String>
makeKey(RexNode expr)
Creates a key forRexNode
which is the same as another key of another RexNode only if the two have both the same type and textual representation.static RexNode
negate(RexBuilder rexBuilder, RexCall call)
(package private) static RexNode
not(RexBuilder rexBuilder, RexNode input)
Applies NOT to an expression.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.(package private) static SqlOperator
op(SqlKind kind)
private static boolean
overlap(RexNode rexNode, java.util.Set<RexNode> set)
static <C extends RexNode>
com.google.common.collect.ImmutableMap<RexNode,C>predicateConstants(java.lang.Class<C> clazz, RexBuilder rexBuilder, java.util.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(java.util.List<RexNode> targets, RexNode e)
Removes all expressions from a list that are equivalent to a given expression.static RexNode
removeNullabilityCast(RelDataTypeFactory typeFactory, RexNode node)
Removes any casts that change nullability but not type.static boolean
requiresDecimalExpansion(java.util.List<RexNode> operands, boolean recurse)
Determines whether any operand of a set requires decimal expansionstatic boolean
requiresDecimalExpansion(RexNode expr, boolean recurse)
Determines whether aRexCall
requires decimal expansion.static boolean
requiresDecimalExpansion(RexProgram program, boolean recurse)
Returns whether aRexProgram
contains expressions which require decimal expansion.static java.util.List<RexNode>
retainDeterministic(java.util.List<RexNode> list)
static java.lang.Iterable<RexNode>
shift(java.lang.Iterable<RexNode> nodes, int offset)
Shifts everyRexInputRef
in an expression byoffset
.static RexNode
shift(RexNode node, int offset)
Shifts everyRexInputRef
in an expression byoffset
.static RexNode
shift(RexNode node, int start, int offset)
static RexNode
simplify(RexBuilder rexBuilder, RexNode e)
Deprecated.Create aRexSimplify
, then call itsRexSimplify.simplify(RexNode, RexUnknownAs)
method.static RexNode
simplify(RexBuilder rexBuilder, RexNode e, boolean unknownAsFalse)
Deprecated.Create aRexSimplify
, then call itsRexSimplify.simplify(RexNode, RexUnknownAs)
method.static RexNode
simplifyAnd(RexBuilder rexBuilder, RexCall e, boolean unknownAsFalse)
Deprecated.static RexNode
simplifyAnd2(RexBuilder rexBuilder, java.util.List<RexNode> terms, java.util.List<RexNode> notTerms)
Deprecated.static RexNode
simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder, java.util.List<RexNode> terms, java.util.List<RexNode> notTerms)
Deprecated.static RexNode
simplifyAnds(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes)
Deprecated.static RexNode
simplifyAnds(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes, boolean unknownAsFalse)
Deprecated.static RexNode
simplifyOr(RexBuilder rexBuilder, RexCall call)
Deprecated.static RexNode
simplifyOrs(RexBuilder rexBuilder, java.util.List<RexNode> terms)
Deprecated.static RexNode
simplifyPreservingType(RexBuilder rexBuilder, RexNode e)
Deprecated.UseRexSimplify.simplifyPreservingType(RexNode)
, which allows you to specify anRexExecutor
.static java.util.List<java.lang.String>
strings(java.util.List<RexNode> list)
Transforms a list of expressions to the list of digests.static RexNode
swapColumnReferences(RexBuilder rexBuilder, RexNode node, java.util.Map<RexTableInputRef,java.util.Set<RexTableInputRef>> ec)
Given an expression, it will swap its column referencesRexTableInputRef
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, java.util.Map<RexTableInputRef,java.util.Set<RexTableInputRef>> ec, java.util.Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)
Given an expression, it will swap the column referencesRexTableInputRef
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 itsRexTableInputRef
using the contents in the second map.static RexNode
swapTableColumnReferences(RexBuilder rexBuilder, RexNode node, java.util.Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, java.util.Map<RexTableInputRef,java.util.Set<RexTableInputRef>> ec)
Given an expression, it will swap the table references contained in itsRexTableInputRef
using the contents in the first map, and then it will swap the column referencesRexTableInputRef
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, java.util.Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)
Given an expression, it will swap the table references contained in itsRexTableInputRef
using the contents in the map.static RexNode
toCnf(RexBuilder rexBuilder, int maxCnfNodeCount, RexNode rex)
Similar totoCnf(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 java.util.List<RelDataType>
types(java.util.List<? extends RexNode> nodes)
Transforms a list of expressions into a list of their types.
-
-
-
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(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 java.util.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 castslhsRowType
- target row typerhsRowType
- source row type; fields must be 1-to-1 with lhsRowType, in same order- Returns:
- cast expressions
-
generateCastExpressions
public static java.util.List<RexNode> generateCastExpressions(RexBuilder rexBuilder, RelDataType lhsRowType, java.util.List<RexNode> rhsExps)
Generates a cast for a row type.- Parameters:
rexBuilder
- RexBuilder to use for constructing castslhsRowType
- target row typerhsExps
- 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 ifallowCast
is true, false otherwise. - For
CAST(CAST(NULL AS type) AS type))
, returns false.
- For
-
isNull
public static boolean isNull(RexNode expr)
Returns whether a node represents the NULL value or a series of nestedCAST(NULL AS type)
calls. For example:isNull(CAST(CAST(NULL as INTEGER) AS VARCHAR(1)))
returnstrue
.
-
isLiteral
public static boolean isLiteral(RexNode node, boolean allowCast)
Returns whether a node represents a literal.Examples:
- For
CAST(literal AS type)
, returns true ifallowCast
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
- For
-
allLiterals
public static boolean allLiterals(java.util.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)
becomes1 = 0
.
-
predicateConstants
public static <C extends RexNode> com.google.common.collect.ImmutableMap<RexNode,C> predicateConstants(java.lang.Class<C> clazz, RexBuilder rexBuilder, java.util.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, orRexNode
to useisConstant(RexNode)
- Parameters:
clazz
- Class of expression that is considered constantrexBuilder
- Rex builderpredicates
- Predicate list- Returns:
- Map from values to constants
-
decompose
private static void decompose(java.util.Set<RexNode> set, RexNode rexNode)
Tries to decompose the RexNode which is a RexCall into non-literal RexNodes.
-
gatherConstraints
private static <C extends RexNode> void gatherConstraints(java.lang.Class<C> clazz, RexNode predicate, java.util.Map<RexNode,C> map, java.util.Set<RexNode> excludeSet, RexBuilder rexBuilder)
-
gatherConstraint
private static <C extends RexNode> void gatherConstraint(java.lang.Class<C> clazz, RexNode left, RexNode right, java.util.Map<RexNode,C> map, java.util.Set<RexNode> excludeSet, RexBuilder rexBuilder)
-
canAssignFrom
private static boolean canAssignFrom(RelDataType type1, RelDataType type2)
Returns whether a value oftype2
can be assigned to a variable oftype1
.For example:
canAssignFrom(BIGINT, TINYINT)
returnstrue
canAssignFrom(TINYINT, BIGINT)
returnsfalse
canAssignFrom(BIGINT, VARCHAR)
returnsfalse
-
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 java.util.List<RexNode> retainDeterministic(java.util.List<RexNode> list)
-
findOperatorCall
public static RexCall findOperatorCall(SqlOperator operator, RexNode node)
Returns whether a given node contains a RexCall with a specified operator- Parameters:
operator
- Operator to look fornode
- 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 anyRexFieldAccess
nodes.- Parameters:
node
- a RexNode tree
-
requiresDecimalExpansion
public static boolean requiresDecimalExpansion(RexNode expr, boolean recurse)
Determines whether aRexCall
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 expansionrecurse
- whether to check nested calls- Returns:
- whether the expression requires expansion
-
requiresDecimalExpansion
public static boolean requiresDecimalExpansion(java.util.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 aRexProgram
contains expressions which require decimal expansion.
-
canReinterpretOverflow
public static boolean canReinterpretOverflow(RexCall call)
-
containNoCommonExprs
public static boolean containNoCommonExprs(java.util.List<RexNode> exprs, Litmus litmus)
Returns whether an array of expressions has any common sub-expressions.
-
containNoForwardRefs
public static boolean containNoForwardRefs(java.util.List<RexNode> exprs, RelDataType inputRowType, Litmus litmus)
Returns whether an array of expressions contains no forward references. That is, if expression #i contains aRexInputRef
referencing field i or greater.- Parameters:
exprs
- Array of expressionsinputRowType
- Input row typelitmus
- What to do if an error is detected (there is a forward reference)- Returns:
- Whether there is a forward reference
-
containNoNonTrivialAggs
static boolean containNoNonTrivialAggs(java.util.List<RexNode> exprs, Litmus litmus)
Returns whether an array of exp contains no aggregate function calls whose arguments are notRexInputRef
s.- Parameters:
exprs
- Expressionslitmus
- Whether to assert if there is such a function call
-
containComplexExprs
public static boolean containComplexExprs(java.util.List<RexNode> exprs)
Returns whether a list of expressions contains complex expressions, that is, a call whose arguments are notRexVariable
(or a subtype such asRexInputRef
) orRexLiteral
.
-
containsTableInputRef
public static boolean containsTableInputRef(java.util.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 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)
-
createStructType
public static RelDataType createStructType(RelDataTypeFactory typeFactory, java.util.List<RexNode> exprs)
Creates a record type with anonymous field names.- Parameters:
typeFactory
- Type factoryexprs
- Expressions- Returns:
- Record type
-
createStructType
public static RelDataType createStructType(RelDataTypeFactory typeFactory, java.util.List<? extends RexNode> exprs, java.util.List<java.lang.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 factoryexprs
- Expressionsnames
- Field names, may be null, or elements may be nullsuggester
- Generates alternative names ifnames
is not null and its elements are not unique- Returns:
- Record type
-
createStructType
@Deprecated public static RelDataType createStructType(RelDataTypeFactory typeFactory, java.util.List<? extends RexNode> exprs, java.util.List<java.lang.String> names)
Deprecated.
-
compatibleTypes
public static boolean compatibleTypes(java.util.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 expressionstype
- Typelitmus
- 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,java.lang.String> makeKey(RexNode expr)
Creates a key forRexNode
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(java.util.List<? extends RexNode> exprs, RelDataType rowType, Litmus litmus)
Returns whether the leading edge of a given array of expressions is whollyRexInputRef
objects with types corresponding to the underlying datatype.
-
isIdentity
public static boolean isIdentity(java.util.List<? extends RexNode> exps, RelDataType inputRowType)
Returns whether a list of expressions projects the incoming fields.
-
composeConjunction
@Nonnull public static RexNode composeConjunction(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes)
AscomposeConjunction(RexBuilder, Iterable, boolean)
but never returns null.
-
composeConjunction
public static RexNode composeConjunction(RexBuilder rexBuilder, java.lang.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 ifnullOnEmpty
and expression is TRUE.
-
flattenAnd
public static com.google.common.collect.ImmutableList<RexNode> flattenAnd(java.lang.Iterable<? extends RexNode> nodes)
Flattens a list of AND nodes.Treats null nodes as literal TRUE (i.e. ignores them).
-
addAnd
private static void addAnd(com.google.common.collect.ImmutableList.Builder<RexNode> builder, java.util.Set<RexNode> digests, RexNode node)
-
composeDisjunction
@Nonnull public static RexNode composeDisjunction(RexBuilder rexBuilder, java.lang.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 RexNode composeDisjunction(RexBuilder rexBuilder, java.lang.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(java.lang.Iterable<? extends RexNode> nodes)
Flattens a list of OR nodes.
-
addOr
private static void addOr(com.google.common.collect.ImmutableList.Builder<RexNode> builder, java.util.Set<RexNode> set, RexNode node)
-
apply
public static java.util.List<RelCollation> apply(Mappings.TargetMapping mapping, java.util.List<RelCollation> collationList)
Applies a mapping to a collation list.- Parameters:
mapping
- MappingcollationList
- 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
- Mappingcollation
- 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
- MappingfieldCollation
- Field collation- Returns:
- collation with mapping applied
-
applyFields
public static java.util.List<RelFieldCollation> applyFields(Mappings.TargetMapping mapping, java.util.List<RelFieldCollation> fieldCollations)
Applies a mapping to a list of field collations.- Parameters:
mapping
- MappingfieldCollations
- 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 java.lang.Iterable<RexNode> apply(Mappings.TargetMapping mapping, java.lang.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
- Shuttleexprs
- Array of expressions
-
apply
public static void apply(RexVisitor<java.lang.Void> visitor, RexNode[] exprs, RexNode expr)
Applies a visitor to an array of expressions and, if specified, a single expression.- Parameters:
visitor
- Visitorexprs
- Array of expressionsexpr
- Single expression, may be null
-
apply
public static void apply(RexVisitor<java.lang.Void> visitor, java.util.List<? extends RexNode> exprs, RexNode expr)
Applies a visitor to a list of expressions and, if specified, a single expression.- Parameters:
visitor
- Visitorexprs
- List of expressionsexpr
- 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 java.util.List<RexNode> flatten(java.util.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
private static boolean isFlat(java.util.List<? extends RexNode> exprs, SqlOperator op)
Returns whether a call toop
withexprs
as arguments would be considered "flat".For example,
isFlat([w, AND[x, y], z, AND)
returns false;isFlat([w, x, y, z], AND)
returns true.
-
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.
-
flattenRecurse
private static void flattenRecurse(java.util.List<RexNode> list, java.util.List<? extends RexNode> exprs, SqlOperator op)
-
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.
-
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 totoCnf(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.
-
isAssociative
private static boolean isAssociative(SqlOperator op)
Returns whether an operator is associative. AND is associative, which means that "(x AND y) and z" is equivalent to "x AND (y AND z)". We might well flatten the tree, and write "AND(x, y, z)".
-
exists
public static <E> boolean exists(java.util.List<? extends E> list, Predicate1<E> predicate)
Returns whether there is an element inlist
for whichpredicate
is true.
-
all
public static <E> boolean all(java.util.List<? extends E> list, Predicate1<E> predicate)
Returns whetherpredicate
is true for all elements oflist
.
-
shift
public static RexNode shift(RexNode node, int offset)
Shifts everyRexInputRef
in an expression byoffset
.
-
shift
public static java.lang.Iterable<RexNode> shift(java.lang.Iterable<RexNode> nodes, int offset)
Shifts everyRexInputRef
in an expression byoffset
.
-
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 buildernode
- Expression to transform- Returns:
- Equivalent expression with common factors pulled up
-
fixUp
@Deprecated public static java.util.List<RexNode> fixUp(RexBuilder rexBuilder, java.util.List<RexNode> nodes, RelDataType rowType)
Deprecated.
-
fixUp
public static java.util.List<RexNode> fixUp(RexBuilder rexBuilder, java.util.List<RexNode> nodes, java.util.List<RelDataType> fieldTypes)
Fixes up the type of allRexInputRef
s 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 java.util.List<RelDataType> types(java.util.List<? extends RexNode> nodes)
Transforms a list of expressions into a list of their types.
-
families
public static java.util.List<RelDataTypeFamily> families(java.util.List<RelDataType> types)
-
removeAll
public static boolean removeAll(java.util.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 twoRexNode
s 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.UseRexSimplify.simplifyPreservingType(RexNode)
, which allows you to specify anRexExecutor
.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 aRexSimplify
, then call itsRexSimplify.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 aRexSimplify
, then call itsRexSimplify.simplify(RexNode, RexUnknownAs)
method.Simplifies a boolean expression, using the default executor.In particular:
simplify(x = 1 AND y = 2 AND NOT x = 1)
returnsy = 2
simplify(x = 1 AND FALSE)
returnsFALSE
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 buildere
- Expression to simplifyunknownAsFalse
- Whether to convert UNKNOWN values to FALSE
-
simplifyAnds
@Deprecated public static RexNode simplifyAnds(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes)
Deprecated.Simplifies a conjunction of boolean expressions.
-
simplifyAnds
@Deprecated public static RexNode simplifyAnds(RexBuilder rexBuilder, java.lang.Iterable<? extends RexNode> nodes, boolean unknownAsFalse)
Deprecated.
-
op
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, java.util.List<RexNode> terms, java.util.List<RexNode> notTerms)
Deprecated.
-
simplifyAnd2ForUnknownAsFalse
@Deprecated public static RexNode simplifyAnd2ForUnknownAsFalse(RexBuilder rexBuilder, java.util.List<RexNode> terms, java.util.List<RexNode> notTerms)
Deprecated.
-
negate
public static RexNode negate(RexBuilder rexBuilder, RexCall call)
-
invert
public static 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, java.util.List<RexNode> terms)
Deprecated.
-
andNot
public static RexNode andNot(RexBuilder rexBuilder, RexNode e, RexNode... notTerms)
Creates the expressione1 AND NOT notTerm1 AND NOT notTerm2 ...
.
-
andNot
@Nonnull public static RexNode andNot(RexBuilder rexBuilder, RexNode e, java.lang.Iterable<? extends RexNode> notTerms)
Creates the expressione1 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.
-
containsFalse
private static boolean containsFalse(java.lang.Iterable<RexNode> nodes)
-
containsTrue
private static boolean containsTrue(java.lang.Iterable<RexNode> nodes)
-
notFn
@Deprecated public static com.google.common.base.Function<RexNode,RexNode> notFn(RexBuilder rexBuilder)
Deprecated.Returns a function that applies NOT to its argument.
-
not
static RexNode not(RexBuilder rexBuilder, RexNode input)
Applies NOT to an expression.
-
containsCorrelation
public static boolean containsCorrelation(RexNode condition)
Returns whether an expression contains aRexCorrelVariable
.
-
swapTableReferences
public static RexNode swapTableReferences(RexBuilder rexBuilder, RexNode node, java.util.Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)
Given an expression, it will swap the table references contained in itsRexTableInputRef
using the contents in the map.
-
swapColumnReferences
public static RexNode swapColumnReferences(RexBuilder rexBuilder, RexNode node, java.util.Map<RexTableInputRef,java.util.Set<RexTableInputRef>> ec)
Given an expression, it will swap its column referencesRexTableInputRef
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, java.util.Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, java.util.Map<RexTableInputRef,java.util.Set<RexTableInputRef>> ec)
Given an expression, it will swap the table references contained in itsRexTableInputRef
using the contents in the first map, and then it will swap the column referencesRexTableInputRef
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, java.util.Map<RexTableInputRef,java.util.Set<RexTableInputRef>> ec, java.util.Map<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping)
Given an expression, it will swap the column referencesRexTableInputRef
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 itsRexTableInputRef
using the contents in the second map.
-
gatherTableReferences
public static java.util.Set<RexTableInputRef.RelTableRef> gatherTableReferences(java.util.List<RexNode> nodes)
Gather all table references in input expressions.- Parameters:
nodes
- expressions- Returns:
- set of table references
-
strings
public static java.util.List<java.lang.String> strings(java.util.List<RexNode> list)
Transforms a list of expressions to the list of digests.
-
-