/**
* Infers predicates for an Aggregate.
*
* <p>Pulls up predicates that only contains references to columns in the GroupSet. For e.g.
*
* <pre>
* childPullUpExprs : { a > 7, b + c < 10, a + e = 9}
* groupSet : { a, b}
* pulledUpExprs : { a > 7}
* </pre>
*/
public RelOptPredicateList getPredicates(Aggregate agg) {
RelNode child = agg.getInput();
RelOptPredicateList childInfo = RelMetadataQuery.getPulledUpPredicates(child);
List<RexNode> aggPullUpPredicates = new ArrayList<RexNode>();
ImmutableBitSet groupKeys = agg.getGroupSet();
Mapping m =
Mappings.create(
MappingType.PARTIAL_FUNCTION,
child.getRowType().getFieldCount(),
agg.getRowType().getFieldCount());
int i = 0;
for (int j : groupKeys) {
m.set(j, i++);
}
for (RexNode r : childInfo.pulledUpPredicates) {
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r);
if (groupKeys.contains(rCols)) {
r = r.accept(new RexPermuteInputsShuttle(m, child));
aggPullUpPredicates.add(r);
}
}
return RelOptPredicateList.of(aggPullUpPredicates);
}
/** Add the Filter condition to the pulledPredicates list from the input. */
public RelOptPredicateList getPredicates(Filter filter, RelMetadataQuery mq) {
final RelNode input = filter.getInput();
final RelOptPredicateList inputInfo = mq.getPulledUpPredicates(input);
return Util.first(inputInfo, RelOptPredicateList.EMPTY)
.union(RelOptPredicateList.of(RelOptUtil.conjunctions(filter.getCondition())));
}
/** Add the Filter condition to the pulledPredicates list from the child. */
public RelOptPredicateList getPredicates(Filter filter) {
RelNode child = filter.getInput();
RelOptPredicateList childInfo = RelMetadataQuery.getPulledUpPredicates(child);
return RelOptPredicateList.of(
Iterables.concat(
childInfo.pulledUpPredicates, RelOptUtil.conjunctions(filter.getCondition())));
}
/**
* Infers predicates for a project.
*
* <ol>
* <li>create a mapping from input to projection. Map only positions that directly reference an
* input column.
* <li>Expressions that only contain above columns are retained in the Project's pullExpressions
* list.
* <li>For e.g. expression 'a + e = 9' below will not be pulled up because 'e' is not in the
* projection list.
* <pre>
* childPullUpExprs: {a > 7, b + c < 10, a + e = 9}
* projectionExprs: {a, b, c, e / 2}
* projectionPullupExprs: {a > 7, b + c < 10}
* </pre>
* </ol>
*/
public RelOptPredicateList getPredicates(Project project) {
RelNode child = project.getInput();
final RexBuilder rexBuilder = project.getCluster().getRexBuilder();
RelOptPredicateList childInfo = RelMetadataQuery.getPulledUpPredicates(child);
List<RexNode> projectPullUpPredicates = new ArrayList<RexNode>();
ImmutableBitSet.Builder columnsMappedBuilder = ImmutableBitSet.builder();
Mapping m =
Mappings.create(
MappingType.PARTIAL_FUNCTION,
child.getRowType().getFieldCount(),
project.getRowType().getFieldCount());
for (Ord<RexNode> o : Ord.zip(project.getProjects())) {
if (o.e instanceof RexInputRef) {
int sIdx = ((RexInputRef) o.e).getIndex();
m.set(sIdx, o.i);
columnsMappedBuilder.set(sIdx);
}
}
// Go over childPullUpPredicates. If a predicate only contains columns in
// 'columnsMapped' construct a new predicate based on mapping.
final ImmutableBitSet columnsMapped = columnsMappedBuilder.build();
for (RexNode r : childInfo.pulledUpPredicates) {
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r);
if (columnsMapped.contains(rCols)) {
r = r.accept(new RexPermuteInputsShuttle(m, child));
projectPullUpPredicates.add(r);
}
}
// Project can also generate constants. We need to include them.
for (Ord<RexNode> expr : Ord.zip(project.getProjects())) {
if (RexLiteral.isNullLiteral(expr.e)) {
projectPullUpPredicates.add(
rexBuilder.makeCall(
SqlStdOperatorTable.IS_NULL, rexBuilder.makeInputRef(project, expr.i)));
} else if (RexUtil.isConstant(expr.e)) {
final List<RexNode> args =
ImmutableList.of(rexBuilder.makeInputRef(project, expr.i), expr.e);
final SqlOperator op =
args.get(0).getType().isNullable() || args.get(1).getType().isNullable()
? SqlStdOperatorTable.IS_NOT_DISTINCT_FROM
: SqlStdOperatorTable.EQUALS;
projectPullUpPredicates.add(rexBuilder.makeCall(op, args));
}
}
return RelOptPredicateList.of(projectPullUpPredicates);
}
/**
* Infers predicates for a Union.
*
* <p>The pulled up expression is a disjunction of its children's predicates.
*/
public RelOptPredicateList getPredicates(Union union) {
RexBuilder rB = union.getCluster().getRexBuilder();
List<RexNode> orList = Lists.newArrayList();
for (RelNode input : union.getInputs()) {
RelOptPredicateList info = RelMetadataQuery.getPulledUpPredicates(input);
if (info.pulledUpPredicates.isEmpty()) {
return RelOptPredicateList.EMPTY;
}
RelOptUtil.decomposeDisjunction(
RexUtil.composeConjunction(rB, info.pulledUpPredicates, false), orList);
}
if (orList.isEmpty()) {
return RelOptPredicateList.EMPTY;
}
return RelOptPredicateList.of(
RelOptUtil.conjunctions(RexUtil.composeDisjunction(rB, orList, false)));
}
/**
* The PullUp Strategy is sound but not complete.
*
* <ol>
* <li>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.
* <li>For Left Outer: we infer new predicates from the left and set them as applicable on the
* Right side. No predicates are pulledUp.
* <li>Right Outer Joins are handled in an analogous manner.
* <li>For Full Outer Joins no predicates are pulledUp or inferred.
* </ol>
*/
public RelOptPredicateList inferPredicates(boolean includeEqualityInference) {
List<RexNode> inferredPredicates = new ArrayList<RexNode>();
Set<String> allExprsDigests = new HashSet<String>(this.allExprsDigests);
final JoinRelType joinType = joinRel.getJoinType();
switch (joinType) {
case INNER:
case LEFT:
infer(
leftChildPredicates,
allExprsDigests,
inferredPredicates,
includeEqualityInference,
joinType == JoinRelType.LEFT ? rightFieldsBitSet : allFieldsBitSet);
break;
}
switch (joinType) {
case INNER:
case RIGHT:
infer(
rightChildPredicates,
allExprsDigests,
inferredPredicates,
includeEqualityInference,
joinType == JoinRelType.RIGHT ? leftFieldsBitSet : allFieldsBitSet);
break;
}
Mappings.TargetMapping rightMapping =
Mappings.createShiftMapping(
nSysFields + nFieldsLeft + nFieldsRight, 0, nSysFields + nFieldsLeft, nFieldsRight);
final RexPermuteInputsShuttle rightPermute =
new RexPermuteInputsShuttle(rightMapping, joinRel);
Mappings.TargetMapping leftMapping =
Mappings.createShiftMapping(nSysFields + nFieldsLeft, 0, nSysFields, nFieldsLeft);
final RexPermuteInputsShuttle leftPermute = new RexPermuteInputsShuttle(leftMapping, joinRel);
List<RexNode> leftInferredPredicates = new ArrayList<RexNode>();
List<RexNode> rightInferredPredicates = new ArrayList<RexNode>();
for (RexNode iP : inferredPredicates) {
ImmutableBitSet iPBitSet = RelOptUtil.InputFinder.bits(iP);
if (leftFieldsBitSet.contains(iPBitSet)) {
leftInferredPredicates.add(iP.accept(leftPermute));
} else if (rightFieldsBitSet.contains(iPBitSet)) {
rightInferredPredicates.add(iP.accept(rightPermute));
}
}
switch (joinType) {
case INNER:
Iterable<RexNode> pulledUpPredicates;
if (isSemiJoin) {
pulledUpPredicates =
Iterables.concat(
RelOptUtil.conjunctions(leftChildPredicates), leftInferredPredicates);
} else {
pulledUpPredicates =
Iterables.concat(
RelOptUtil.conjunctions(leftChildPredicates),
RelOptUtil.conjunctions(rightChildPredicates),
RelOptUtil.conjunctions(joinRel.getCondition()),
inferredPredicates);
}
return RelOptPredicateList.of(
pulledUpPredicates, leftInferredPredicates, rightInferredPredicates);
case LEFT:
return RelOptPredicateList.of(
RelOptUtil.conjunctions(leftChildPredicates),
leftInferredPredicates,
rightInferredPredicates);
case RIGHT:
return RelOptPredicateList.of(
RelOptUtil.conjunctions(rightChildPredicates), inferredPredicates, EMPTY_LIST);
default:
assert inferredPredicates.size() == 0;
return RelOptPredicateList.EMPTY;
}
}