/**
* 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;
}
/**
* Combines the outer join conditions and join types from the left and right join inputs. If the
* join itself is either a left or right outer join, then the join condition corresponding to the
* join is also set in the position corresponding to the null-generating input into the join. The
* join type is also set.
*
* @param joinRel join rel
* @param combinedInputs the combined inputs to the join
* @param left left child of the joinrel
* @param right right child of the joinrel
* @param combinedConds the array containing the combined join conditions
* @param joinTypes the array containing the combined join types
* @return combined join filters AND'd together
*/
private RexNode[] combineOuterJoins(
JoinRel joinRel,
RelNode[] combinedInputs,
RelNode left,
RelNode right,
RexNode[] combinedConds,
JoinRelType[] joinTypes) {
JoinRelType joinType = joinRel.getJoinType();
int nCombinedInputs = combinedInputs.length;
boolean leftCombined = canCombine(left, joinType.generatesNullsOnLeft());
boolean rightCombined = canCombine(right, joinType.generatesNullsOnRight());
if (joinType == JoinRelType.LEFT) {
if (leftCombined) {
copyOuterJoinInfo((MultiJoinRel) left, combinedConds, joinTypes, 0, 0, null, null);
} else {
joinTypes[0] = JoinRelType.INNER;
}
combinedConds[nCombinedInputs - 1] = joinRel.getCondition();
joinTypes[nCombinedInputs - 1] = joinType;
} else if (joinType == JoinRelType.RIGHT) {
if (rightCombined) {
copyOuterJoinInfo(
(MultiJoinRel) right,
combinedConds,
joinTypes,
1,
left.getRowType().getFieldCount(),
right.getRowType().getFields(),
joinRel.getRowType().getFields());
} else {
joinTypes[nCombinedInputs - 1] = JoinRelType.INNER;
}
combinedConds[0] = joinRel.getCondition();
joinTypes[0] = joinType;
} else {
int nInputsLeft;
if (leftCombined) {
nInputsLeft = left.getInputs().length;
copyOuterJoinInfo((MultiJoinRel) left, combinedConds, joinTypes, 0, 0, null, null);
} else {
nInputsLeft = 1;
joinTypes[0] = JoinRelType.INNER;
}
if (rightCombined) {
copyOuterJoinInfo(
(MultiJoinRel) right,
combinedConds,
joinTypes,
nInputsLeft,
left.getRowType().getFieldCount(),
right.getRowType().getFields(),
joinRel.getRowType().getFields());
} else {
joinTypes[nInputsLeft] = JoinRelType.INNER;
}
}
return combinedConds;
}
/**
* Combines the inputs into a JoinRel into an array of inputs.
*
* @param join original join
* @param left left input into join
* @param right right input into join
* @param projFieldsList returns a list of the new combined projection fields
* @param joinFieldRefCountsList returns a list of the new combined join field reference counts
* @return combined left and right inputs in an array
*/
private RelNode[] combineInputs(
JoinRel join,
RelNode left,
RelNode right,
List<BitSet> projFieldsList,
List<int[]> joinFieldRefCountsList) {
// leave the null generating sides of an outer join intact; don't
// pull up those children inputs into the array we're constructing
int nInputs;
int nInputsOnLeft;
MultiJoinRel leftMultiJoin = null;
JoinRelType joinType = join.getJoinType();
boolean combineLeft = canCombine(left, joinType.generatesNullsOnLeft());
if (combineLeft) {
leftMultiJoin = (MultiJoinRel) left;
nInputs = left.getInputs().length;
nInputsOnLeft = nInputs;
} else {
nInputs = 1;
nInputsOnLeft = 1;
}
MultiJoinRel rightMultiJoin = null;
boolean combineRight = canCombine(right, joinType.generatesNullsOnRight());
if (combineRight) {
rightMultiJoin = (MultiJoinRel) right;
nInputs += right.getInputs().length;
} else {
nInputs += 1;
}
RelNode[] newInputs = new RelNode[nInputs];
int i = 0;
if (combineLeft) {
for (; i < left.getInputs().length; i++) {
newInputs[i] = leftMultiJoin.getInput(i);
projFieldsList.add(((MultiJoinRel) left).getProjFields()[i]);
joinFieldRefCountsList.add(((MultiJoinRel) left).getJoinFieldRefCountsMap().get(i));
}
} else {
newInputs[0] = left;
i = 1;
projFieldsList.add(null);
joinFieldRefCountsList.add(new int[left.getRowType().getFieldCount()]);
}
if (combineRight) {
for (; i < nInputs; i++) {
newInputs[i] = rightMultiJoin.getInput(i - nInputsOnLeft);
projFieldsList.add(((MultiJoinRel) right).getProjFields()[i - nInputsOnLeft]);
joinFieldRefCountsList.add(
((MultiJoinRel) right).getJoinFieldRefCountsMap().get(i - nInputsOnLeft));
}
} else {
newInputs[i] = right;
projFieldsList.add(null);
joinFieldRefCountsList.add(new int[right.getRowType().getFieldCount()]);
}
return newInputs;
}