public void onMatch(RelOptRuleCall call) {
CalcRel calc = (CalcRel) call.getRels()[0];
RexProgram program = calc.getProgram();
final List<RexNode> exprList = program.getExprList();
// Form a list of expressions with sub-expressions fully
// expanded.
final List<RexNode> expandedExprList = new ArrayList<RexNode>(exprList.size());
final RexShuttle shuttle =
new RexShuttle() {
public RexNode visitLocalRef(RexLocalRef localRef) {
return expandedExprList.get(localRef.getIndex());
}
};
for (RexNode expr : exprList) {
expandedExprList.add(expr.accept(shuttle));
}
if (reduceExpressions(calc, expandedExprList)) {
final RexProgramBuilder builder =
new RexProgramBuilder(
calc.getChild().getRowType(), calc.getCluster().getRexBuilder());
List<RexLocalRef> list = new ArrayList<RexLocalRef>();
for (RexNode expr : expandedExprList) {
list.add(builder.registerInput(expr));
}
if (program.getCondition() != null) {
final int conditionIndex = program.getCondition().getIndex();
final RexNode newConditionExp = expandedExprList.get(conditionIndex);
if (newConditionExp.isAlwaysTrue()) {
// condition is always TRUE - drop it
} else if ((newConditionExp instanceof RexLiteral)
|| RexUtil.isNullLiteral(newConditionExp, true)) {
// condition is always NULL or FALSE - replace calc
// with empty
call.transformTo(new EmptyRel(calc.getCluster(), calc.getRowType()));
return;
} else {
builder.addCondition(list.get(conditionIndex));
}
}
int k = 0;
for (RexLocalRef projectExpr : program.getProjectList()) {
final int index = projectExpr.getIndex();
builder.addProject(
list.get(index).getIndex(),
program.getOutputRowType().getFieldList().get(k++).getName());
}
call.transformTo(
new CalcRel(
calc.getCluster(),
calc.getTraits(),
calc.getChild(),
calc.getRowType(),
builder.getProgram(),
calc.getCollationList()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(calc, 0.0);
}
}
/**
* Converts an array of {@link RexNode} to an array of {@link Integer}. Every node must be a
* {@link RexLocalRef}.
*/
public static Integer[] toOrdinalArray(RexNode[] rexNodes) {
Integer[] orderKeys = new Integer[rexNodes.length];
for (int i = 0; i < orderKeys.length; i++) {
RexLocalRef inputRef = (RexLocalRef) rexNodes[i];
orderKeys[i] = inputRef.getIndex();
}
return orderKeys;
}
/**
* Burrows into a synthetic record and returns the underlying relation which provides the field
* called <code>fieldName</code>.
*/
public JavaRel implementFieldAccess(JavaRelImplementor implementor, String fieldName) {
if (!isBoxed()) {
return implementor.implementFieldAccess((JavaRel) getChild(), fieldName);
}
RelDataType type = getRowType();
int field = type.getFieldOrdinal(fieldName);
RexLocalRef ref = program.getProjectList().get(field);
final int index = ref.getIndex();
return implementor.findRel((JavaRel) this, program.getExprList().get(index));
}
public Void visitLocalRef(RexLocalRef inputRef) {
super.visitLocalRef(inputRef);
if (inputRef.getIndex() >= limit) {
throw new IllegalForwardRefException();
}
return null;
}