/**
* Combines the join filters from the left and right inputs (if they are MultiJoinRels) with the
* join filter in the joinrel into a single AND'd join filter, unless the inputs correspond to
* null generating inputs in an outer join
*
* @param joinRel join rel
* @param left left child of the joinrel
* @param right right child of the joinrel
* @return combined join filters AND'd together
*/
private RexNode combineJoinFilters(JoinRel joinRel, RelNode left, RelNode right) {
RexBuilder rexBuilder = joinRel.getCluster().getRexBuilder();
JoinRelType joinType = joinRel.getJoinType();
// first need to adjust the RexInputs of the right child, since
// those need to shift over to the right
RexNode rightFilter = null;
if (canCombine(right, joinType.generatesNullsOnRight())) {
MultiJoinRel multiJoin = (MultiJoinRel) right;
rightFilter = shiftRightFilter(joinRel, left, multiJoin, multiJoin.getJoinFilter());
}
// AND the join condition if this isn't a left or right outer join;
// in those cases, the outer join condition is already tracked
// separately
RexNode newFilter = null;
if ((joinType != JoinRelType.LEFT) && (joinType != JoinRelType.RIGHT)) {
newFilter = joinRel.getCondition();
}
if (canCombine(left, joinType.generatesNullsOnLeft())) {
RexNode leftFilter = ((MultiJoinRel) left).getJoinFilter();
newFilter = RelOptUtil.andJoinFilters(rexBuilder, newFilter, leftFilter);
}
newFilter = RelOptUtil.andJoinFilters(rexBuilder, newFilter, rightFilter);
return newFilter;
}
public void onMatch(RelOptRuleCall call) {
assert matches(call);
final JoinRel join = (JoinRel) call.rels[0];
final List<Integer> leftKeys = new ArrayList<Integer>();
final List<Integer> rightKeys = new ArrayList<Integer>();
RelNode right = join.getRight();
final RelNode left = join.getLeft();
RexNode remainingCondition =
RelOptUtil.splitJoinCondition(left, right, join.getCondition(), leftKeys, rightKeys);
assert leftKeys.size() == rightKeys.size();
final List<CorrelatorRel.Correlation> correlationList =
new ArrayList<CorrelatorRel.Correlation>();
if (leftKeys.size() > 0) {
final RelOptCluster cluster = join.getCluster();
final RexBuilder rexBuilder = cluster.getRexBuilder();
int k = 0;
RexNode condition = null;
for (Integer leftKey : leftKeys) {
Integer rightKey = rightKeys.get(k++);
final String dyn_inIdStr = cluster.getQuery().createCorrel();
final int dyn_inId = RelOptQuery.getCorrelOrdinal(dyn_inIdStr);
// Create correlation to say 'each row, set variable #id
// to the value of column #leftKey'.
correlationList.add(new CorrelatorRel.Correlation(dyn_inId, leftKey));
condition =
RelOptUtil.andJoinFilters(
rexBuilder,
condition,
rexBuilder.makeCall(
SqlStdOperatorTable.equalsOperator,
rexBuilder.makeInputRef(
right.getRowType().getFieldList().get(rightKey).getType(), rightKey),
rexBuilder.makeCorrel(
left.getRowType().getFieldList().get(leftKey).getType(), dyn_inIdStr)));
}
right = CalcRel.createFilter(right, condition);
}
RelNode newRel =
new CorrelatorRel(
join.getCluster(),
left,
right,
remainingCondition,
correlationList,
join.getJoinType());
call.transformTo(newRel);
}
/** Splits a condition into conjunctions that do or do not intersect with a given bit set. */
static void split(
RexNode condition, BitSet bitSet, List<RexNode> intersecting, List<RexNode> nonIntersecting) {
for (RexNode node : RelOptUtil.conjunctions(condition)) {
BitSet inputBitSet = RelOptUtil.InputFinder.bits(node);
if (bitSet.intersects(inputBitSet)) {
intersecting.add(node);
} else {
nonIntersecting.add(node);
}
}
}
/**
* Analyzes a rex predicate.
*
* @param rexPredicate predicate to be analyzed
* @return a list of SargBindings contained in the input rex predicate
*/
public List<SargBinding> analyzeAll(RexNode rexPredicate) {
sargBindingList = new ArrayList<SargBinding>();
sarg2RexMap = new HashMap<SargExpr, RexNode>();
nonSargFilterList = new ArrayList<RexNode>();
// Flatten out the RexNode tree into a list of terms that
// are AND'ed together
final List<RexNode> rexCFList = RelOptUtil.conjunctions(rexPredicate);
// In simple mode, each input ref can only be referenced once, so
// keep a list of them. We also only allow one non-point expression.
List<Integer> boundRefList = new ArrayList<Integer>();
boolean rangeFound = false;
for (RexNode rexPred : rexCFList) {
final SargBinding sargBinding = analyze(rexPred);
if (sargBinding != null) {
if (simpleMode) {
RexInputRef inputRef = sargBinding.getInputRef();
if (boundRefList.contains(inputRef.getIndex())) {
nonSargFilterList.add(rexPred);
continue;
} else {
boundRefList.add(inputRef.getIndex());
}
SargIntervalSequence sargSeq = sargBinding.getExpr().evaluate();
if (sargSeq.isRange()) {
if (rangeFound) {
nonSargFilterList.add(rexPred);
continue;
} else {
rangeFound = true;
}
}
}
sargBindingList.add(sargBinding);
sarg2RexMap.put(sargBinding.getExpr(), rexPred);
} else {
nonSargFilterList.add(rexPred);
}
}
// Reset the state variables used during analyze, just for sanity sake.
failed = false;
boundInputRef = null;
clearLeaf();
// Combine the AND terms back together.
recomposeConjunction();
return sargBindingList;
}
/**
* Creates new RelNodes replacing/removing the original project/row scan
*
* @param projectedScan new scan that is now projected
* @param origProject original projection
* @param needRename true if fields from the row scan need to be renamed
* @param newProject projection that contains the new projection expressions, in the case where
* the original projection cannot be removed because it projects expressions
* @return new RelNode
*/
public RelNode createNewRelNode(
RelNode projectedScan, ProjectRel origProject, boolean needRename, ProjectRel newProject) {
RelNode scanRel;
if (needRename) {
// Replace calling convention with FENNEL_EXEC_CONVENTION
RelTraitSet traits = RelOptUtil.clone(origProject.getTraits());
traits.setTrait(CallingConventionTraitDef.instance, FennelRel.FENNEL_EXEC_CONVENTION);
if (!traits.equals(projectedScan.getTraits())) {
RelNode mergedProjectedScan = convert(projectedScan, traits);
RelOptPlanner planner = projectedScan.getCluster().getPlanner();
// register projectedScan == mergedProjectedScan
// so mergedProjectedScan will have a set later on
projectedScan = planner.ensureRegistered(mergedProjectedScan, projectedScan);
}
scanRel =
new FennelRenameRel(
origProject.getCluster(),
projectedScan,
RelOptUtil.getFieldNames(origProject.getRowType()),
traits);
} else {
scanRel = projectedScan;
}
if (newProject == null) {
return scanRel;
} else {
// in the case where the projection had expressions, put the
// new, modified projection on top of the projected row scan
return (ProjectRel)
CalcRel.createProject(
scanRel,
newProject.getProjectExps(),
RelOptUtil.getFieldNames(newProject.getRowType()));
}
}
/**
* Combines the post-join filters from the left and right inputs (if they are MultiJoinRels) into
* a single AND'd filter.
*
* @param joinRel the original JoinRel
* @param left left child of the JoinRel
* @param right right child of the JoinRel
* @return combined post-join filters AND'd together
*/
private RexNode combinePostJoinFilters(JoinRel joinRel, RelNode left, RelNode right) {
RexNode rightPostJoinFilter = null;
if (right instanceof MultiJoinRel) {
rightPostJoinFilter =
shiftRightFilter(
joinRel, left, (MultiJoinRel) right, ((MultiJoinRel) right).getPostJoinFilter());
}
RexNode leftPostJoinFilter = null;
if (left instanceof MultiJoinRel) {
leftPostJoinFilter = ((MultiJoinRel) left).getPostJoinFilter();
}
if ((leftPostJoinFilter == null) && (rightPostJoinFilter == null)) {
return null;
} else {
return RelOptUtil.andJoinFilters(
joinRel.getCluster().getRexBuilder(), leftPostJoinFilter, rightPostJoinFilter);
}
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
final FilterRelBase filterRel = call.rel(0);
final ProjectRelBase projRel = call.rel(1);
// convert the filter to one that references the child of the project
RexNode newCondition = RelOptUtil.pushFilterPastProject(filterRel.getCondition(), projRel);
RelNode newFilterRel =
filterFactory == null
? filterRel.copy(filterRel.getTraitSet(), projRel.getChild(), newCondition)
: filterFactory.createFilter(projRel.getChild(), newCondition);
RelNode newProjRel =
projectFactory == null
? projRel.copy(
projRel.getTraitSet(), newFilterRel, projRel.getProjects(), projRel.getRowType())
: projectFactory.createProject(
newFilterRel, projRel.getProjects(), projRel.getRowType().getFieldNames());
call.transformTo(newProjRel);
}