org.apache.calcite.rex

Class RexSimplify

java.lang.Object

org.apache.calcite.rex.RexSimplify

public class RexSimplify
extends Object

Context required to simplify a row-expression.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	RexSimplify.Comparison Comparison between a RexInputRef or RexFieldAccess and a literal.

Field Summary

Fields

Modifier and Type	Field and Description
private RexExecutor	executor
private RelOptPredicateList	predicates
RexBuilder	rexBuilder
(package private) boolean	unknownAsFalse

Constructor Summary

Constructors

Constructor and Description
RexSimplify(RexBuilder rexBuilder, boolean unknownAsFalse, RexExecutor executor) Deprecated.
RexSimplify(RexBuilder rexBuilder, RelOptPredicateList predicates, boolean unknownAsFalse, RexExecutor executor) Creates a RexSimplify.

Method Summary

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 static List<Pair<RexNode,RexNode>>	casePairs(RexBuilder rexBuilder, List<RexNode> operands) Given "CASE WHEN p1 THEN v1 ...
private static boolean	isLowerBound(RexNode e)
private static boolean	isUpperBound(RexNode e)
private static <C extends Comparable<C>> RexNode	processRange(RexBuilder rexBuilder, List<RexNode> terms, Map<String,Pair<com.google.common.collect.Range<C>,List<RexNode>>> rangeTerms, RexNode term, RexNode ref, C v0, SqlKind comparison)
private static <C extends Comparable<C>> com.google.common.collect.Range<C>	range(SqlKind comparison, C c)
RexNode	removeNullabilityCast(RexNode e) Removes any casts that change nullability but not type.
private <C extends Comparable<C>> com.google.common.collect.Range<C>	residue(RexNode ref, com.google.common.collect.Range<C> r0, List<RexNode> predicates, Class<C> clazz) Weakens a term so that it checks only what is not implied by predicates.
RexNode	simplify(RexNode e) Simplifies a boolean expression.
RexNode	simplifyAnd(RexCall e)
(package private) RexNode	simplifyAnd2(List<RexNode> terms, List<RexNode> notTerms)
(package private) RexNode	simplifyAnd2ForUnknownAsFalse(List<RexNode> terms, 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 Comparable<C>> RexNode	simplifyAnd2ForUnknownAsFalse(List<RexNode> terms, List<RexNode> notTerms, Class<C> clazz)
RexNode	simplifyAnds(Iterable<? extends RexNode> nodes) Simplifies a conjunction of boolean expressions.
private RexNode	simplifyCase(RexCall call)
private RexNode	simplifyCast(RexCall e)
private RexNode	simplifyCeilFloor(RexCall e) Tries to simplify CEIL/FLOOR function on top of CEIL/FLOOR.
private RexNode	simplifyComparison(RexCall e)
private <C extends Comparable<C>> RexNode	simplifyComparison(RexCall e, Class<C> clazz)
private RexNode	simplifyIs(RexCall call)
private RexNode	simplifyIs2(SqlKind kind, RexNode a)
private RexNode	simplifyIsNotNull(RexNode a)
private void	simplifyList(List<RexNode> terms)
private RexNode	simplifyNot(RexCall call)
RexNode	simplifyOr(RexCall call) Simplifies OR(x, x) into x, and similar.
RexNode	simplifyOrs(List<RexNode> terms) Simplifies a list of terms and combines them into an OR.
RexNode	simplifyPreservingType(RexNode e) Simplifies a boolean expression, always preserving its type and its nullability.
private <C extends Comparable<C>> RexNode	simplifyUsingPredicates(RexNode e, Class<C> clazz)
RexSimplify	withPredicates(RelOptPredicateList predicates) Returns a RexSimplify the same as this but with a specified predicates value.
RexSimplify	withUnknownAsFalse(boolean unknownAsFalse) Returns a RexSimplify the same as this but with a specified unknownAsFalse value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

rexBuilder

public final RexBuilder rexBuilder

predicates

private final RelOptPredicateList predicates

unknownAsFalse

final boolean unknownAsFalse

executor

private final RexExecutor executor

Constructor Detail

RexSimplify

public RexSimplify(RexBuilder rexBuilder,
                   RelOptPredicateList predicates,
                   boolean unknownAsFalse,
                   RexExecutor executor)

Creates a RexSimplify.

Parameters:

rexBuilder - Rex builder

predicates - Predicates known to hold on input fields

unknownAsFalse - Whether to convert UNKNOWN values to FALSE

executor - Executor for constant reduction, not null

RexSimplify

@Deprecated
public RexSimplify(RexBuilder rexBuilder,
                               boolean unknownAsFalse,
                               RexExecutor executor)

Deprecated.

Method Detail

withUnknownAsFalse

public RexSimplify withUnknownAsFalse(boolean unknownAsFalse)

Returns a RexSimplify the same as this but with a specified unknownAsFalse value.

withPredicates

public RexSimplify withPredicates(RelOptPredicateList predicates)

Returns a RexSimplify the same as this but with a specified predicates value.

simplifyPreservingType

public RexNode simplifyPreservingType(RexNode e)

Simplifies a boolean expression, always preserving its type and its nullability.

This is useful if you are simplifying expressions in a Project.

simplify

public RexNode simplify(RexNode e)

Simplifies a boolean expression.

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:

e - Expression to simplify

simplifyComparison

private RexNode simplifyComparison(RexCall e)

simplifyComparison

private <C extends Comparable<C>> RexNode simplifyComparison(RexCall e,
                                                             Class<C> clazz)

simplifyAnds

public RexNode simplifyAnds(Iterable<? extends RexNode> nodes)

Simplifies a conjunction of boolean expressions.

simplifyList

private void simplifyList(List<RexNode> terms)

simplifyNot

private RexNode simplifyNot(RexCall call)

simplifyIs

private RexNode simplifyIs(RexCall call)

simplifyIs2

private RexNode simplifyIs2(SqlKind kind,
                            RexNode a)

simplifyIsNotNull

private RexNode simplifyIsNotNull(RexNode a)

simplifyCase

private RexNode simplifyCase(RexCall call)

casePairs

private static List<Pair<RexNode,RexNode>> casePairs(RexBuilder rexBuilder,
                                                     List<RexNode> operands)

Given "CASE WHEN p1 THEN v1 ... ELSE e END" returns [(p1, v1), ..., (true, e)].

simplifyAnd

public RexNode simplifyAnd(RexCall e)

simplifyAnd2

RexNode simplifyAnd2(List<RexNode> terms,
                     List<RexNode> notTerms)

simplifyAnd2ForUnknownAsFalse

RexNode simplifyAnd2ForUnknownAsFalse(List<RexNode> terms,
                                      List<RexNode> notTerms)

As simplifyAnd2(List, List) but we assume that if the expression returns UNKNOWN it will be interpreted as FALSE.

simplifyAnd2ForUnknownAsFalse

private <C extends Comparable<C>> RexNode simplifyAnd2ForUnknownAsFalse(List<RexNode> terms,
                                                                        List<RexNode> notTerms,
                                                                        Class<C> clazz)

simplifyUsingPredicates

private <C extends Comparable<C>> RexNode simplifyUsingPredicates(RexNode e,
                                                                  Class<C> clazz)

residue

private <C extends Comparable<C>> com.google.common.collect.Range<C> residue(RexNode ref,
                                                                             com.google.common.collect.Range<C> r0,
                                                                             List<RexNode> predicates,
                                                                             Class<C> clazz)

Weakens a term so that it checks only what is not implied by predicates.

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

simplifyOr

public RexNode simplifyOr(RexCall call)

Simplifies OR(x, x) into x, and similar.

simplifyOrs

public RexNode simplifyOrs(List<RexNode> terms)

Simplifies a list of terms and combines them into an OR. Modifies the list in place.

simplifyCast

private RexNode simplifyCast(RexCall e)

simplifyCeilFloor

private RexNode simplifyCeilFloor(RexCall e)

Tries to simplify CEIL/FLOOR function on top of CEIL/FLOOR.

Examples:

• ceil(floor($0, flag(hour)), flag(day)) returns ceil($0, flag(day))
• floor(floor($0, flag(second)), flag(day)) returns floor($0, flag(day))
• floor(ceil($0, flag(day)), flag(second)) does not change

canRollUp

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.

removeNullabilityCast

public RexNode removeNullabilityCast(RexNode e)

Removes any casts that change nullability but not type.

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

processRange

private static <C extends Comparable<C>> RexNode processRange(RexBuilder rexBuilder,
                                                              List<RexNode> terms,
                                                              Map<String,Pair<com.google.common.collect.Range<C>,List<RexNode>>> rangeTerms,
                                                              RexNode term,
                                                              RexNode ref,
                                                              C v0,
                                                              SqlKind comparison)

range

private static <C extends Comparable<C>> com.google.common.collect.Range<C> range(SqlKind comparison,
                                                                                  C c)

isUpperBound

private static boolean isUpperBound(RexNode e)

isLowerBound

private static boolean isLowerBound(RexNode e)