org.apache.calcite.rel.metadata

Class RelMdPredicates.JoinConditionBasedPredicateInference

java.lang.Object

org.apache.calcite.rel.metadata.RelMdPredicates.JoinConditionBasedPredicateInference

Enclosing class:

RelMdPredicates

static class RelMdPredicates.JoinConditionBasedPredicateInference
extends Object

Utility to infer predicates from one side of the join that apply on the other side.

Contract is:

• initialize with a Join and optional predicates applicable on its left and right subtrees.
• you can then ask it for equivalentPredicate(s) given a predicate.

So for:

1. 'R1(x) join R2(y) on x = y' a call for equivalentPredicates on 'x > 7' will return ' [y > 7]'
2. 'R1(x) join R2(y) on x = y join R3(z) on y = z' a call for equivalentPredicates on the second join 'x > 7' will return

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
(package private) class	RelMdPredicates.JoinConditionBasedPredicateInference.EquivalenceFinder Find expressions of the form 'col_x = col_y'.
(package private) class	RelMdPredicates.JoinConditionBasedPredicateInference.ExprsItr Given an expression returns all the possible substitutions.

Field Summary

Fields

Modifier and Type	Field and Description
(package private) Set<String>	allExprsDigests
(package private) ImmutableBitSet	allFieldsBitSet
(package private) Set<String>	equalityPredicates
(package private) SortedMap<Integer,BitSet>	equivalence
(package private) Map<String,ImmutableBitSet>	exprFields
(package private) boolean	isSemiJoin
(package private) Join	joinRel
(package private) RexNode	leftChildPredicates
(package private) ImmutableBitSet	leftFieldsBitSet
(package private) int	nFieldsLeft
(package private) int	nFieldsRight
(package private) int	nSysFields
(package private) RexNode	rightChildPredicates
(package private) ImmutableBitSet	rightFieldsBitSet

Constructor Summary

Constructors

Modifier	Constructor and Description
private	JoinConditionBasedPredicateInference(Join joinRel, boolean isSemiJoin, RexNode lPreds, RexNode rPreds)
(package private)	JoinConditionBasedPredicateInference(Join joinRel, RexNode lPreds, RexNode rPreds)

Method Summary

Modifier and Type	Method and Description
(package private) RexNode	compose(RexBuilder rexBuilder, Iterable<RexNode> exprs)
private void	equivalent(int p1, int p2)
private void	infer(RexNode predicates, Set<String> allExprsDigests, List<RexNode> inferedPredicates, boolean includeEqualityInference, ImmutableBitSet inferringFields)
RelOptPredicateList	inferPredicates(boolean includeEqualityInference) The PullUp Strategy is sound but not complete.
private boolean	isAlwaysTrue(RexNode predicate)
RexNode	left()
(package private) Iterable<Mapping>	mappings(RexNode predicate)
private int	pos(RexNode expr)
RexNode	right()

Methods inherited from class java.lang.Object

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

Field Detail

joinRel

final Join joinRel

isSemiJoin

final boolean isSemiJoin

nSysFields

final int nSysFields

nFieldsLeft

final int nFieldsLeft

nFieldsRight

final int nFieldsRight

leftFieldsBitSet

final ImmutableBitSet leftFieldsBitSet

rightFieldsBitSet

final ImmutableBitSet rightFieldsBitSet

allFieldsBitSet

final ImmutableBitSet allFieldsBitSet

equivalence

SortedMap<Integer,BitSet> equivalence

exprFields

final Map<String,ImmutableBitSet> exprFields

allExprsDigests

final Set<String> allExprsDigests

equalityPredicates

final Set<String> equalityPredicates

leftChildPredicates

final RexNode leftChildPredicates

rightChildPredicates

final RexNode rightChildPredicates

Constructor Detail

JoinConditionBasedPredicateInference

JoinConditionBasedPredicateInference(Join joinRel,
                                     RexNode lPreds,
                                     RexNode rPreds)

JoinConditionBasedPredicateInference

private JoinConditionBasedPredicateInference(Join joinRel,
                                             boolean isSemiJoin,
                                             RexNode lPreds,
                                             RexNode rPreds)

Method Detail

inferPredicates

public RelOptPredicateList inferPredicates(boolean includeEqualityInference)

The PullUp Strategy is sound but not complete.

1. We only pullUp inferred predicates for now. Pulling up existing predicates causes an explosion of duplicates. The existing predicates are pushed back down as new predicates. Once we have rules to eliminate duplicate Filter conditions, we should pullUp all predicates.
2. For Left Outer: we infer new predicates from the left and set them as applicable on the Right side. No predicates are pulledUp.
3. Right Outer Joins are handled in an analogous manner.
4. For Full Outer Joins no predicates are pulledUp or inferred.

left

public RexNode left()

right

public RexNode right()

infer

private void infer(RexNode predicates,
                   Set<String> allExprsDigests,
                   List<RexNode> inferedPredicates,
                   boolean includeEqualityInference,
                   ImmutableBitSet inferringFields)

mappings

Iterable<Mapping> mappings(RexNode predicate)

equivalent

private void equivalent(int p1,
                        int p2)

compose

RexNode compose(RexBuilder rexBuilder,
                Iterable<RexNode> exprs)

pos

private int pos(RexNode expr)

isAlwaysTrue

private boolean isAlwaysTrue(RexNode predicate)