org.apache.calcite.plan

Class SubstitutionVisitor

java.lang.Object

org.apache.calcite.plan.SubstitutionVisitor

public class SubstitutionVisitor
extends Object

Substitutes part of a tree of relational expressions with another tree.

The call new SubstitutionVisitor(target, query).go(replacement)) will return query with every occurrence of target replaced by replacement.

The following example shows how SubstitutionVisitor can be used for materialized view recognition.

• query = SELECT a, c FROM t WHERE x = 5 AND b = 4
• target = SELECT a, b, c FROM t WHERE x = 5
• replacement = SELECT * FROM mv
• result = SELECT a, c FROM mv WHERE b = 4

Note that result uses the materialized view table mv and a simplified condition b = 4.

Uses a bottom-up matching algorithm. Nodes do not need to be identical. At each level, returns the residue.

The inputs must only include the core relational operators: LogicalTableScan, LogicalFilter, LogicalProject, LogicalJoin, LogicalUnion, LogicalAggregate.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SubstitutionVisitor.FilterOnProjectRule Rule that converts a LogicalFilter on top of a LogicalProject into a trivial filter (on a boolean column).

Field Summary

Fields

Modifier and Type	Field and Description
protected org.apache.calcite.plan.SubstitutionVisitor.MutableRel[]	slots Workspace while rule is being matched.

Constructor Summary

Constructors

Constructor and Description
SubstitutionVisitor(RelNode target_, RelNode query_)

Method Summary

Methods

Modifier and Type	Method and Description
static SqlAggFunction	getRollup(SqlAggFunction aggregation)
RelNode	go(RelNode replacement_)
RelNode	go0(RelNode replacement_)
static boolean	mayBeSatisfiable(RexNode e) Returns whether a boolean expression ever returns true.
static com.google.common.base.Function<RexNode,RexNode>	not(RexBuilder rexBuilder) Returns a function that applies NOT to its argument.
static org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate	permute(org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate aggregate, org.apache.calcite.plan.SubstitutionVisitor.MutableRel input, Mapping mapping)
static RexNode	simplify(RexBuilder rexBuilder, RexNode e) Simplifies a boolean expression.
static RexNode	splitFilter(RexBuilder rexBuilder, RexNode condition, RexNode target) Maps a condition onto a target.
static org.apache.calcite.plan.SubstitutionVisitor.MutableRel	unifyAggregates(org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate query, org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate target)

Methods inherited from class java.lang.Object

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

Field Detail

slots

protected final org.apache.calcite.plan.SubstitutionVisitor.MutableRel[] slots

Workspace while rule is being matched. Careful, re-entrant! Assumes no rule needs more than 2 slots.

Constructor Detail

SubstitutionVisitor

public SubstitutionVisitor(RelNode target_,
                   RelNode query_)

Method Detail

splitFilter

public static RexNode splitFilter(RexBuilder rexBuilder,
                  RexNode condition,
                  RexNode target)

Maps a condition onto a target.

If condition is stronger than target, returns the residue. If it is equal to target, returns the expression that evaluates to the constant true. If it is weaker than target, returns null.

The terms satisfy the relation

     condition = target AND residue
 

and residue must be as weak as possible.

Example #1: condition stronger than target

• condition: x = 1 AND y = 2
• target: x = 1
• residue: y = 2

Note that residue x > 0 AND y = 2 would also satisfy the relation condition = target AND residue but is stronger than necessary, so we prefer y = 2.

Example #2: target weaker than condition (valid, but not currently implemented)

• condition: x = 1
• target: x = 1 OR z = 3
• residue: NOT (z = 3)

Example #3: condition and target are equivalent

• condition: x = 1 AND y = 2
• target: y = 2 AND x = 1
• residue: TRUE

Example #4: condition weaker than target

• condition: x = 1
• target: x = 1 AND y = 2
• residue: null (i.e. no match)

There are many other possible examples. It amounts to solving whether condition AND NOT target can ever evaluate to true, and therefore is a form of the NP-complete Satisfiability problem.

not

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

Returns a function that applies NOT to its argument.

mayBeSatisfiable

public static boolean mayBeSatisfiable(RexNode e)

Returns whether a boolean expression ever returns true.

This method may give false positives. For instance, it will say that x = 5 AND x > 10 is satisfiable, because at present it cannot prove that it is not.

simplify

public static RexNode simplify(RexBuilder rexBuilder,
               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

go0

public RelNode go0(RelNode replacement_)

go

public RelNode go(RelNode replacement_)

permute

public static org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate permute(org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate aggregate,
                                                                   org.apache.calcite.plan.SubstitutionVisitor.MutableRel input,
                                                                   Mapping mapping)

unifyAggregates

public static org.apache.calcite.plan.SubstitutionVisitor.MutableRel unifyAggregates(org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate query,
                                                                     org.apache.calcite.plan.SubstitutionVisitor.MutableAggregate target)

getRollup

public static SqlAggFunction getRollup(SqlAggFunction aggregation)