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);
}
/**
* Generates a cast from one row type to another
*
* @param rexBuilder RexBuilder to use for constructing casts
* @param lhsRowType target row type
* @param rhsRowType source row type; fields must be 1-to-1 with lhsRowType, in same order
* @return cast expressions
*/
public static RexNode[] generateCastExpressions(
RexBuilder rexBuilder, RelDataType lhsRowType, RelDataType rhsRowType) {
int n = rhsRowType.getFieldCount();
assert n == lhsRowType.getFieldCount()
: "field count: lhs [" + lhsRowType + "] rhs [" + rhsRowType + "]";
RexNode[] rhsExps = new RexNode[n];
for (int i = 0; i < n; ++i) {
rhsExps[i] = rexBuilder.makeInputRef(rhsRowType.getFields()[i].getType(), i);
}
return generateCastExpressions(rexBuilder, lhsRowType, rhsExps);
}
/**
* Creates an OR expression from a list of RexNodes
*
* @param rexList list of RexNodes
* @return OR'd expression
*/
public static RexNode orRexNodeList(RexBuilder rexBuilder, List<RexNode> rexList) {
if (rexList.isEmpty()) {
return null;
}
RexNode orExpr = rexList.get(rexList.size() - 1);
for (int i = rexList.size() - 2; i >= 0; i--) {
orExpr = rexBuilder.makeCall(SqlStdOperatorTable.orOperator, rexList.get(i), orExpr);
}
return orExpr;
}
/**
* Creates an AND expression from a list of RexNodes
*
* @param rexList list of RexNodes
* @return AND'd expression
*/
public static RexNode andRexNodeList(RexBuilder rexBuilder, List<RexNode> rexList) {
if (rexList.isEmpty()) {
return null;
}
// create a right-deep tree to allow short-circuiting during
// expression evaluation
RexNode andExpr = rexList.get(rexList.size() - 1);
for (int i = rexList.size() - 2; i >= 0; i--) {
andExpr = rexBuilder.makeCall(SqlStdOperatorTable.andOperator, rexList.get(i), andExpr);
}
return andExpr;
}
/**
* Generates a cast for a row type.
*
* @param rexBuilder RexBuilder to use for constructing casts
* @param lhsRowType target row type
* @param rhsExps expressions to be cast
* @return cast expressions
*/
public static RexNode[] generateCastExpressions(
RexBuilder rexBuilder, RelDataType lhsRowType, RexNode[] rhsExps) {
RelDataTypeField[] lhsFields = lhsRowType.getFields();
final int fieldCount = lhsFields.length;
RexNode[] castExps = new RexNode[fieldCount];
assert fieldCount == rhsExps.length;
for (int i = 0; i < fieldCount; ++i) {
RelDataTypeField lhsField = lhsFields[i];
RelDataType lhsType = lhsField.getType();
RelDataType rhsType = rhsExps[i].getType();
if (lhsType.equals(rhsType)) {
castExps[i] = rhsExps[i];
} else {
castExps[i] = rexBuilder.makeCast(lhsType, rhsExps[i]);
}
}
return castExps;
}
// override RexShuttle
public RexNode visitCall(final RexCall call) {
int i = reducibleExps.indexOf(call);
if (i == -1) {
return super.visitCall(call);
}
RexNode replacement = reducedValues.get(i);
if (addCasts.get(i) && (replacement.getType() != call.getType())) {
// Handle change from nullable to NOT NULL by claiming
// that the result is still nullable, even though
// we know it isn't.
//
// Also, we cannot reduce CAST('abc' AS VARCHAR(4)) to 'abc'.
// If we make 'abc' of type VARCHAR(4), we may later encounter
// the same expression in a ProjectRel's digest where it has
// type VARCHAR(3), and that's wrong.
replacement = rexBuilder.makeCast(call.getType(), replacement);
}
return replacement;
}