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);
}
}
private void reduceNotNullableFilter(
RelOptRuleCall call, FilterRel filter, RexCall rexCall, boolean reverse) {
// If the expression is a IS [NOT] NULL on a non-nullable
// column, then we can either remove the filter or replace
// it with an EmptyRel.
SqlOperator op = rexCall.getOperator();
boolean alwaysTrue;
if (op == SqlStdOperatorTable.isNullOperator
|| op == SqlStdOperatorTable.isUnknownOperator) {
alwaysTrue = false;
} else if (op == SqlStdOperatorTable.isNotNullOperator) {
alwaysTrue = true;
} else {
return;
}
if (reverse) {
alwaysTrue = !alwaysTrue;
}
RexNode operand = rexCall.getOperands()[0];
if (operand instanceof RexInputRef) {
RexInputRef inputRef = (RexInputRef) operand;
if (!inputRef.getType().isNullable()) {
if (alwaysTrue) {
call.transformTo(filter.getChild());
} else {
call.transformTo(new EmptyRel(filter.getCluster(), filter.getRowType()));
}
}
}
}
public void onMatch(RelOptRuleCall call) {
FilterRel filter = (FilterRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(filter.getChildExps()));
RexNode newConditionExp;
boolean reduced;
if (reduceExpressions(filter, expList)) {
assert (expList.size() == 1);
newConditionExp = expList.get(0);
reduced = true;
} else {
// No reduction, but let's still test the original
// predicate to see if it was already a constant,
// in which case we don't need any runtime decision
// about filtering.
newConditionExp = filter.getChildExps()[0];
reduced = false;
}
if (newConditionExp.isAlwaysTrue()) {
call.transformTo(filter.getChild());
} else if ((newConditionExp instanceof RexLiteral)
|| RexUtil.isNullLiteral(newConditionExp, true)) {
call.transformTo(new EmptyRel(filter.getCluster(), filter.getRowType()));
} else if (reduced) {
call.transformTo(CalcRel.createFilter(filter.getChild(), expList.get(0)));
} else {
if (newConditionExp instanceof RexCall) {
RexCall rexCall = (RexCall) newConditionExp;
boolean reverse = (rexCall.getOperator() == SqlStdOperatorTable.notOperator);
if (reverse) {
rexCall = (RexCall) rexCall.getOperands()[0];
}
reduceNotNullableFilter(call, filter, rexCall, reverse);
}
return;
}
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(filter, 0.0);
}
public void onMatch(RelOptRuleCall call) {
JoinRel join = (JoinRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(join.getChildExps()));
if (reduceExpressions(join, expList)) {
call.transformTo(
new JoinRel(
join.getCluster(),
join.getLeft(),
join.getRight(),
expList.get(0),
join.getJoinType(),
join.getVariablesStopped()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(join, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
ProjectRel project = (ProjectRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(project.getChildExps()));
if (reduceExpressions(project, expList)) {
call.transformTo(
new ProjectRel(
project.getCluster(),
project.getChild(),
expList.toArray(new RexNode[expList.size()]),
project.getRowType(),
ProjectRel.Flags.Boxed,
Collections.<RelCollation>emptyList()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(project, 0.0);
}
}