public class RexSimplify
extends java.lang.Object
Modifier and Type | Class and Description |
---|---|
(package private) static class |
RexSimplify.CaseBranch
Object to describe a Case branch
|
private static class |
RexSimplify.Comparison
Represents a simple Comparison.
|
private static class |
RexSimplify.IsPredicate
Represents an IS Predicate.
|
private static interface |
RexSimplify.Predicate
Marker interface for predicates (expressions that evaluate to BOOLEAN).
|
(package private) static class |
RexSimplify.SafeRexVisitor
Decides whether it is safe to flatten the given case part into AND/ORs
|
Modifier and Type | Field and Description |
---|---|
(package private) RexUnknownAs |
defaultUnknownAs
How to treat UNKNOWN values, if one of the deprecated
simplify methods without an unknownAs argument is called. |
private RexExecutor |
executor |
private boolean |
paranoid |
(package private) boolean |
predicateElimination |
private RelOptPredicateList |
predicates |
RexBuilder |
rexBuilder |
private Strong |
strong |
Modifier | Constructor and Description |
---|---|
|
RexSimplify(RexBuilder rexBuilder,
boolean unknownAsFalse,
RexExecutor executor)
Deprecated.
|
|
RexSimplify(RexBuilder rexBuilder,
RelOptPredicateList predicates,
boolean unknownAsFalse,
RexExecutor executor)
Deprecated.
|
|
RexSimplify(RexBuilder rexBuilder,
RelOptPredicateList predicates,
RexExecutor executor)
Creates a RexSimplify.
|
private |
RexSimplify(RexBuilder rexBuilder,
RelOptPredicateList predicates,
RexUnknownAs defaultUnknownAs,
boolean predicateElimination,
boolean paranoid,
RexExecutor executor)
Internal constructor.
|
Modifier and Type | Method and Description |
---|---|
private static boolean |
canRollUp(org.apache.calcite.avatica.util.TimeUnit outer,
org.apache.calcite.avatica.util.TimeUnit inner)
Method that returns whether we can rollup from inner time unit
to outer time unit.
|
private void |
ensureParanoidOff() |
private RexSimplify.CaseBranch |
generateBranch(boolean simplifyCond,
RexSimplify simplifier,
RexSimplify.CaseBranch branch)
If boolean is true, simplify cond in input branch and return new branch.
|
private static boolean |
isLowerBound(RexNode e) |
(package private) static boolean |
isSafeExpression(RexNode r)
Analyzes a given
RexNode and decides whenever it is safe to
unwind. |
private static boolean |
isUpperBound(RexNode e) |
private static <C extends java.lang.Comparable<C>> |
processRange(RexBuilder rexBuilder,
java.util.List<RexNode> terms,
java.util.Map<RexNode,Pair<com.google.common.collect.Range<C>,java.util.List<RexNode>>> rangeTerms,
RexNode term,
RexNode ref,
C v0,
SqlKind comparison) |
private static <C extends java.lang.Comparable<C>> |
range(SqlKind comparison,
C c) |
RexNode |
removeNullabilityCast(RexNode e)
Removes any casts that change nullability but not type.
|
private static <E> boolean |
replaceLast(java.util.List<E> list,
E oldVal,
E newVal)
Replaces the last occurrence of one specified value in a list with
another.
|
private <C extends java.lang.Comparable<C>> |
residue(RexNode ref,
com.google.common.collect.Range<C> r0,
java.util.List<RexNode> predicates,
java.lang.Class<C> clazz)
Weakens a term so that it checks only what is not implied by predicates.
|
private boolean |
sameTypeOrNarrowsNullability(RelDataType oldType,
RelDataType newType)
Return if the new type is the same and at most narrows the nullability.
|
RexNode |
simplify(RexNode e)
Simplifies a boolean expression.
|
(package private) RexNode |
simplify(RexNode e,
RexUnknownAs unknownAs)
Internal method to simplify an expression.
|
RexNode |
simplifyAnd(RexCall e)
Deprecated.
|
(package private) RexNode |
simplifyAnd(RexCall e,
RexUnknownAs unknownAs) |
(package private) RexNode |
simplifyAnd2(java.util.List<RexNode> terms,
java.util.List<RexNode> notTerms) |
(package private) RexNode |
simplifyAnd2ForUnknownAsFalse(java.util.List<RexNode> terms,
java.util.List<RexNode> notTerms)
As
simplifyAnd2(List, List) but we assume that if the expression
returns UNKNOWN it will be interpreted as FALSE. |
private <C extends java.lang.Comparable<C>> |
simplifyAnd2ForUnknownAsFalse(java.util.List<RexNode> terms,
java.util.List<RexNode> notTerms,
java.lang.Class<C> clazz) |
RexNode |
simplifyAnds(java.lang.Iterable<? extends RexNode> nodes)
Deprecated.
|
(package private) RexNode |
simplifyAnds(java.lang.Iterable<? extends RexNode> nodes,
RexUnknownAs unknownAs) |
private void |
simplifyAndTerms(java.util.List<RexNode> terms,
RexUnknownAs unknownAs) |
private static RexNode |
simplifyBooleanCase(RexBuilder rexBuilder,
java.util.List<RexSimplify.CaseBranch> inputBranches,
RexUnknownAs unknownAs,
RelDataType branchType) |
private static RexNode |
simplifyBooleanCaseGeneric(RexBuilder rexBuilder,
java.util.List<RexSimplify.CaseBranch> branches,
RelDataType outputType)
Generic boolean case simplification.
|
private RexNode |
simplifyCase(RexCall call,
RexUnknownAs unknownAs) |
private RexNode |
simplifyCast(RexCall e) |
private RexNode |
simplifyCeilFloor(RexCall e)
Tries to simplify CEIL/FLOOR function on top of CEIL/FLOOR.
|
private RexNode |
simplifyCoalesce(RexCall call) |
private RexNode |
simplifyComparison(RexCall e,
RexUnknownAs unknownAs) |
private <C extends java.lang.Comparable<C>> |
simplifyComparison(RexCall e,
RexUnknownAs unknownAs,
java.lang.Class<C> clazz) |
RexNode |
simplifyFilterPredicates(java.lang.Iterable<? extends RexNode> predicates)
Combines predicates AND, optimizes, and returns null if the result is
always false.
|
private RexNode |
simplifyGenericNode(RexCall e)
Runs simplification inside a non-specialized node.
|
private RexNode |
simplifyIs(RexCall call,
RexUnknownAs unknownAs) |
private RexNode |
simplifyIs2(SqlKind kind,
RexNode a,
RexUnknownAs unknownAs) |
private RexNode |
simplifyIsNotNull(RexNode a) |
private RexNode |
simplifyIsNull(RexNode a) |
private RexNode |
simplifyIsPredicate(SqlKind kind,
RexNode a) |
private void |
simplifyList(java.util.List<RexNode> terms,
RexUnknownAs unknownAs) |
private RexNode |
simplifyNot(RexCall call,
RexUnknownAs unknownAs) |
RexNode |
simplifyOr(RexCall call)
Deprecated.
|
private RexNode |
simplifyOr(RexCall call,
RexUnknownAs unknownAs) |
RexNode |
simplifyOrs(java.util.List<RexNode> terms)
Deprecated.
|
private RexNode |
simplifyOrs(java.util.List<RexNode> terms,
RexUnknownAs unknownAs)
Simplifies a list of terms and combines them into an OR.
|
private void |
simplifyOrTerms(java.util.List<RexNode> terms,
RexUnknownAs unknownAs) |
RexNode |
simplifyPreservingType(RexNode e)
Simplifies a boolean expression, always preserving its type and its
nullability.
|
RexNode |
simplifyPreservingType(RexNode e,
RexUnknownAs unknownAs,
boolean matchNullability) |
RexNode |
simplifyUnknownAs(RexNode e,
RexUnknownAs unknownAs)
As
simplify(RexNode) , but specifying how UNKNOWN values are to be
treated. |
RexNode |
simplifyUnknownAsFalse(RexNode e)
As
simplify(RexNode) , but for a boolean expression
for which a result of UNKNOWN will be treated as FALSE. |
private <C extends java.lang.Comparable<C>> |
simplifyUsingPredicates(RexNode e,
java.lang.Class<C> clazz) |
private void |
verify(RexNode before,
RexNode simplified,
RexUnknownAs unknownAs) |
RexSimplify |
withParanoid(boolean paranoid)
Returns a RexSimplify the same as this but which verifies that
the expression before and after simplification are equivalent.
|
private RexSimplify |
withPredicateElimination(boolean predicateElimination)
Returns a RexSimplify the same as this but with a specified
predicateElimination value. |
RexSimplify |
withPredicates(RelOptPredicateList predicates)
Returns a RexSimplify the same as this but with a specified
predicates value. |
RexSimplify |
withUnknownAsFalse(boolean unknownAsFalse)
Deprecated.
Use methods with a
RexUnknownAs argument, such as
simplify(RexNode, RexUnknownAs) . |
private final boolean paranoid
public final RexBuilder rexBuilder
private final RelOptPredicateList predicates
final RexUnknownAs defaultUnknownAs
simplify
methods without an unknownAs
argument is called.final boolean predicateElimination
private final RexExecutor executor
private final Strong strong
public RexSimplify(RexBuilder rexBuilder, RelOptPredicateList predicates, RexExecutor executor)
rexBuilder
- Rex builderpredicates
- Predicates known to hold on input fieldsexecutor
- Executor for constant reduction, not nullprivate RexSimplify(RexBuilder rexBuilder, RelOptPredicateList predicates, RexUnknownAs defaultUnknownAs, boolean predicateElimination, boolean paranoid, RexExecutor executor)
@Deprecated public RexSimplify(RexBuilder rexBuilder, boolean unknownAsFalse, RexExecutor executor)
@Deprecated public RexSimplify(RexBuilder rexBuilder, RelOptPredicateList predicates, boolean unknownAsFalse, RexExecutor executor)
@Deprecated public RexSimplify withUnknownAsFalse(boolean unknownAsFalse)
RexUnknownAs
argument, such as
simplify(RexNode, RexUnknownAs)
.defaultUnknownAs
value.public RexSimplify withPredicates(RelOptPredicateList predicates)
predicates
value.public RexSimplify withParanoid(boolean paranoid)
private RexSimplify withPredicateElimination(boolean predicateElimination)
predicateElimination
value.
This is introduced temporarily, until
[CALCITE-2401] is fixed
.
public RexNode simplifyPreservingType(RexNode e)
This is useful if you are simplifying expressions in a
Project
.
public RexNode simplifyPreservingType(RexNode e, RexUnknownAs unknownAs, boolean matchNullability)
public RexNode simplify(RexNode e)
In particular:
simplify(x = 1 AND y = 2 AND NOT x = 1)
returns y = 2
simplify(x = 1 AND FALSE)
returns FALSE
Handles UNKNOWN values using the policy specified when you created this
RexSimplify
. Unless you used a deprecated constructor, that policy
is RexUnknownAs.UNKNOWN
.
If the expression is a predicate in a WHERE clause, consider instead
using simplifyUnknownAsFalse(RexNode)
.
e
- Expression to simplifypublic final RexNode simplifyUnknownAsFalse(RexNode e)
simplify(RexNode)
, but for a boolean expression
for which a result of UNKNOWN will be treated as FALSE.
Use this form for expressions on a WHERE, ON, HAVING or FILTER(WHERE) clause.
This may allow certain additional simplifications. A result of UNKNOWN may yield FALSE, however it may still yield UNKNOWN. (If the simplified expression has type BOOLEAN NOT NULL, then of course it can only return FALSE.)
public RexNode simplifyUnknownAs(RexNode e, RexUnknownAs unknownAs)
simplify(RexNode)
, but specifying how UNKNOWN values are to be
treated.
If UNKNOWN is treated as FALSE, this may allow certain additional simplifications. A result of UNKNOWN may yield FALSE, however it may still yield UNKNOWN. (If the simplified expression has type BOOLEAN NOT NULL, then of course it can only return FALSE.)
RexNode simplify(RexNode e, RexUnknownAs unknownAs)
Unlike the public simplify(RexNode)
and simplifyUnknownAsFalse(RexNode)
methods,
never calls verify(RexNode, RexNode, RexUnknownAs)
.
Verify adds an overhead that is only acceptable for a top-level call.
private RexNode simplifyGenericNode(RexCall e)
private RexNode simplifyComparison(RexCall e, RexUnknownAs unknownAs)
private <C extends java.lang.Comparable<C>> RexNode simplifyComparison(RexCall e, RexUnknownAs unknownAs, java.lang.Class<C> clazz)
@Deprecated public RexNode simplifyAnds(java.lang.Iterable<? extends RexNode> nodes)
RexNode simplifyAnds(java.lang.Iterable<? extends RexNode> nodes, RexUnknownAs unknownAs)
private void simplifyList(java.util.List<RexNode> terms, RexUnknownAs unknownAs)
private void simplifyAndTerms(java.util.List<RexNode> terms, RexUnknownAs unknownAs)
private void simplifyOrTerms(java.util.List<RexNode> terms, RexUnknownAs unknownAs)
private RexNode simplifyNot(RexCall call, RexUnknownAs unknownAs)
private RexNode simplifyIs(RexCall call, RexUnknownAs unknownAs)
private RexNode simplifyIs2(SqlKind kind, RexNode a, RexUnknownAs unknownAs)
private RexNode simplifyCase(RexCall call, RexUnknownAs unknownAs)
private RexSimplify.CaseBranch generateBranch(boolean simplifyCond, RexSimplify simplifier, RexSimplify.CaseBranch branch)
private boolean sameTypeOrNarrowsNullability(RelDataType oldType, RelDataType newType)
static boolean isSafeExpression(RexNode r)
RexNode
and decides whenever it is safe to
unwind.
"Safe" means that it only contains a combination of known good operators.
Division is an unsafe operator; consider the following:
case when a > 0 then 1 / a else null end
private static RexNode simplifyBooleanCase(RexBuilder rexBuilder, java.util.List<RexSimplify.CaseBranch> inputBranches, RexUnknownAs unknownAs, RelDataType branchType)
private static RexNode simplifyBooleanCaseGeneric(RexBuilder rexBuilder, java.util.List<RexSimplify.CaseBranch> branches, RelDataType outputType)
Rewrites:
CASE WHEN p1 THEN x WHEN p2 THEN y ELSE z ENDto
(p1 and x) or (p2 and y and not(p1)) or (true and z and not(p1) and not(p2))
RexNode simplifyAnd(RexCall e, RexUnknownAs unknownAs)
RexNode simplifyAnd2ForUnknownAsFalse(java.util.List<RexNode> terms, java.util.List<RexNode> notTerms)
simplifyAnd2(List, List)
but we assume that if the expression
returns UNKNOWN it will be interpreted as FALSE.private <C extends java.lang.Comparable<C>> RexNode simplifyAnd2ForUnknownAsFalse(java.util.List<RexNode> terms, java.util.List<RexNode> notTerms, java.lang.Class<C> clazz)
private <C extends java.lang.Comparable<C>> RexNode simplifyUsingPredicates(RexNode e, java.lang.Class<C> clazz)
private <C extends java.lang.Comparable<C>> com.google.common.collect.Range<C> residue(RexNode ref, com.google.common.collect.Range<C> r0, java.util.List<RexNode> predicates, java.lang.Class<C> clazz)
The term is broken into "ref comparison constant", for example "$0 < 5".
Examples:
residue($0 < 10, [$0 < 5])
returns true
residue($0 < 10, [$0 < 20, $0 > 0])
returns $0 < 10
@Deprecated public RexNode simplifyOr(RexCall call)
private RexNode simplifyOr(RexCall call, RexUnknownAs unknownAs)
@Deprecated public RexNode simplifyOrs(java.util.List<RexNode> terms)
private void ensureParanoidOff()
private RexNode simplifyOrs(java.util.List<RexNode> terms, RexUnknownAs unknownAs)
private void verify(RexNode before, RexNode simplified, RexUnknownAs unknownAs)
private RexNode simplifyCeilFloor(RexCall e)
Examples:
floor(floor($0, flag(hour)), flag(day))
returns floor($0, flag(day))
ceil(ceil($0, flag(second)), flag(day))
returns ceil($0, flag(day))
floor(floor($0, flag(day)), flag(second))
does not change
private static boolean canRollUp(org.apache.calcite.avatica.util.TimeUnit outer, org.apache.calcite.avatica.util.TimeUnit inner)
public RexNode removeNullabilityCast(RexNode e)
For example, CAST(1 = 0 AS BOOLEAN)
becomes 1 = 0
.
private static <C extends java.lang.Comparable<C>> RexNode processRange(RexBuilder rexBuilder, java.util.List<RexNode> terms, java.util.Map<RexNode,Pair<com.google.common.collect.Range<C>,java.util.List<RexNode>>> rangeTerms, RexNode term, RexNode ref, C v0, SqlKind comparison)
private static <C extends java.lang.Comparable<C>> com.google.common.collect.Range<C> range(SqlKind comparison, C c)
private static boolean isUpperBound(RexNode e)
private static boolean isLowerBound(RexNode e)
public RexNode simplifyFilterPredicates(java.lang.Iterable<? extends RexNode> predicates)
The expression is simplified on the assumption that an UNKNOWN value is always treated as FALSE. Therefore the simplified expression may sometimes evaluate to FALSE where the original expression would evaluate to UNKNOWN.
predicates
- Filter condition predicatesprivate static <E> boolean replaceLast(java.util.List<E> list, E oldVal, E newVal)
Does not change the size of the list.
Returns whether the value was found.
Copyright © 2012–2019 The Apache Software Foundation. All rights reserved.