RelNode newChildFilter = filterFactory.createFilter(filter.getInput(), newChildFilterCondition); RelNode newTopFilter = filterFactory.createFilter(newChildFilter, topFilterCondition);
final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY; bb.setRoot(factory.createFilter(bb.root, havingExpr), false);
RelNode newFilter = filterFactory.createFilter(filterChild, newCondition); RelNode newTopFilter = filterFactory.createFilter(newFilter, condition);
return factory.createFilter(rel, condition);
ret = factory.createFilter(ret, conditionExp);
ret = factory.createFilter(ret, conditionExp);
return factory.createFilter(rel, condition);
final RelNode filter = factory.createFilter(bb.root, convertedWhere2); final RelNode r; final CorrelationUse p = getCorrelationUse(bb, filter);
final RelNode filter = factory.createFilter(bb.root, convertedWhere2); final RelNode r; final CorrelationUse p = getCorrelationUse(bb, filter);
final RelNode filter = factory.createFilter(bb.root, convertedWhere); final RelNode r; final CorrelationUse p = getCorrelationUse(bb, filter);
final RelNode filter = factory.createFilter(bb.root, convertedWhere); final RelNode r; final CorrelationUse p = getCorrelationUse(bb, filter);
protected RelNode createJoin( Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType) { assert joinCond != null; final CorrelationUse p = getCorrelationUse(bb, rightRel); if (p != null) { LogicalCorrelate corr = LogicalCorrelate.create(leftRel, p.r, p.id, p.requiredColumns, SemiJoinType.of(joinType)); if (!joinCond.isAlwaysTrue()) { final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY; return factory.createFilter(corr, joinCond); } return corr; } // OVERRIDE POINT if (containOnlyCast(joinCond)) { joinCond = convertCastCondition(joinCond); } final Join originalJoin = (Join) RelFactories.DEFAULT_JOIN_FACTORY.createJoin(leftRel, rightRel, joinCond, ImmutableSet.<CorrelationId>of(), joinType, false); return RelOptUtil.pushDownJoinConditions(originalJoin); }
@Override public void onMatch(RelOptRuleCall call) { Join join = call.rel(0); RelOptPredicateList preds = RelMetadataQuery.getPulledUpPredicates(join); RexBuilder rB = join.getCluster().getRexBuilder(); RelNode lChild = call.rel(1); RelNode rChild = call.rel(2); List<RexNode> leftPreds = getValidPreds(preds.leftInferredPredicates, lChild.getRowType().getFieldList()); List<RexNode> rightPreds = getValidPreds(preds.rightInferredPredicates, rChild.getRowType().getFieldList()); if (leftPreds.isEmpty() && rightPreds.isEmpty()) { return; } if (leftPreds.size() > 0) { RelNode curr = lChild; lChild = filterFactory.createFilter(lChild, RexUtil.composeConjunction(rB, leftPreds, false)); call.getPlanner().onCopy(curr, lChild); } if (rightPreds.size() > 0) { RelNode curr = rChild; rChild = filterFactory.createFilter(rChild, RexUtil.composeConjunction(rB, rightPreds, false)); call.getPlanner().onCopy(curr, rChild); } RelNode newRel = join.copy(join.getTraitSet(), join.getCondition(), lChild, rChild, join.getJoinType(), join.isSemiJoinDone()); call.getPlanner().onCopy(join, newRel); call.transformTo(newRel); }
(Filter) filterFactory.createFilter( bottomFilter.getInput(), RexUtil.flatten(rexBuilder, newCondition));
protected RelNode createJoin( Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType) { assert joinCond != null; final CorrelationUse p = getCorrelationUse(bb, rightRel); if (p != null) { LogicalCorrelate corr = LogicalCorrelate.create(leftRel, p.r, p.id, p.requiredColumns, SemiJoinType.of(joinType)); if (!joinCond.isAlwaysTrue()) { final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY; return factory.createFilter(corr, joinCond); } return corr; } final Join originalJoin = (Join) RelFactories.DEFAULT_JOIN_FACTORY.createJoin(leftRel, rightRel, joinCond, ImmutableSet.<CorrelationId>of(), joinType, false); return RelOptUtil.pushDownJoinConditions(originalJoin); }
protected RelNode createJoin( Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType) { assert joinCond != null; final CorrelationUse p = getCorrelationUse(bb, rightRel); if (p != null) { LogicalCorrelate corr = LogicalCorrelate.create(leftRel, p.r, p.id, p.requiredColumns, SemiJoinType.of(joinType)); if (!joinCond.isAlwaysTrue()) { final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY; return factory.createFilter(corr, joinCond); } return corr; } final Join originalJoin = (Join) RelFactories.DEFAULT_JOIN_FACTORY.createJoin(leftRel, rightRel, joinCond, ImmutableSet.of(), joinType, false); return RelOptUtil.pushDownJoinConditions(originalJoin, relBuilder); }
protected RelNode createJoin( Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType) { assert joinCond != null; final CorrelationUse p = getCorrelationUse(bb, rightRel); if (p != null) { LogicalCorrelate corr = LogicalCorrelate.create(leftRel, p.r, p.id, p.requiredColumns, SemiJoinType.of(joinType)); if (!joinCond.isAlwaysTrue()) { final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY; return factory.createFilter(corr, joinCond); } return corr; } final Join originalJoin = (Join) RelFactories.DEFAULT_JOIN_FACTORY.createJoin(leftRel, rightRel, joinCond, ImmutableSet.of(), joinType, false); return RelOptUtil.pushDownJoinConditions(originalJoin, relBuilder); }
/** Creates a {@link Filter} of a list of * predicates. * * <p>The predicates are combined using AND, * and optimized in a similar way to the {@link #and} method. * If the result is TRUE no filter is created. */ public RelBuilder filter(Iterable<? extends RexNode> predicates) { final RexNode simplifiedPredicates = simplifier.simplifyFilterPredicates(predicates); if (simplifiedPredicates == null) { return empty(); } if (!simplifiedPredicates.isAlwaysTrue()) { final Frame frame = stack.pop(); final RelNode filter = filterFactory.createFilter(frame.rel, simplifiedPredicates); stack.push(new Frame(filter, frame.fields)); } return this; }
/** Creates a {@link Filter} of a list of * predicates. * * <p>The predicates are combined using AND, * and optimized in a similar way to the {@link #and} method. * If the result is TRUE no filter is created. */ public RelBuilder filter(Iterable<? extends RexNode> predicates) { final RexNode simplifiedPredicates = simplifier.simplifyFilterPredicates(predicates); if (simplifiedPredicates == null) { return empty(); } if (!simplifiedPredicates.isAlwaysTrue()) { final Frame frame = stack.pop(); final RelNode filter = filterFactory.createFilter(frame.rel, simplifiedPredicates); stack.push(new Frame(filter, frame.fields)); } return this; }
public void onMatch(RelOptRuleCall call) { SemiJoin semiJoin = call.rel(0); LogicalFilter filter = call.rel(1); RelNode newSemiJoin = SemiJoin.create(filter.getInput(), semiJoin.getRight(), semiJoin.getCondition(), semiJoin.getLeftKeys(), semiJoin.getRightKeys()); final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY; RelNode newFilter = factory.createFilter(newSemiJoin, filter.getCondition()); call.transformTo(newFilter); } }