// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
CalcRel calcRel = (CalcRel) call.rels[0];
RexProgram program = calcRel.getProgram();
// check the projection
List<Integer> projOrdinals = new ArrayList<Integer>();
RelDataType outputRowType = isProjectSimple(calcRel, projOrdinals);
if (outputRowType == null) {
return;
}
RexLocalRef condition = program.getCondition();
CompOperatorEnum compOp = CompOperatorEnum.COMP_NOOP;
Integer[] filterOrdinals = {};
List<RexLiteral> filterLiterals = new ArrayList<RexLiteral>();
// check the condition
if (condition != null) {
RexNode filterExprs = program.expandLocalRef(condition);
List<Integer> filterList = new ArrayList<Integer>();
List<CompOperatorEnum> op = new ArrayList<CompOperatorEnum>();
if (!isConditionSimple(calcRel, filterExprs, filterList, filterLiterals, op)) {
return;
}
compOp = op.get(0);
filterOrdinals = filterList.toArray(new Integer[filterList.size()]);
}
RelNode fennelInput =
mergeTraitsAndConvert(
calcRel.getTraits(), FennelRel.FENNEL_EXEC_CONVENTION, calcRel.getChild());
if (fennelInput == null) {
return;
}
Integer[] projection = projOrdinals.toArray(new Integer[projOrdinals.size()]);
FennelReshapeRel reshapeRel =
new FennelReshapeRel(
calcRel.getCluster(),
fennelInput,
projection,
outputRowType,
compOp,
filterOrdinals,
filterLiterals,
new FennelRelParamId[] {},
new Integer[] {},
null);
call.transformTo(reshapeRel);
}
/**
* Determines if a filter condition is a simple one and returns the parameters corresponding to
* the simple filters.
*
* @param calcRel original CalcRel
* @param filterExprs filter expression being analyzed
* @param filterList returns the list of filter ordinals in the simple expression
* @param literals returns the list of literals to be used in the simple comparisons
* @param op returns the operator to be used in the simple comparison
* @return true if the filter condition is simple
*/
private boolean isConditionSimple(
CalcRel calcRel,
RexNode filterExprs,
List<Integer> filterList,
List<RexLiteral> literals,
List<CompOperatorEnum> op) {
SargFactory sargFactory = new SargFactory(calcRel.getCluster().getRexBuilder());
SargRexAnalyzer rexAnalyzer = sargFactory.newRexAnalyzer(true);
List<SargBinding> sargBindingList = rexAnalyzer.analyzeAll(filterExprs);
// Currently, it's all or nothing. So, if there are filters rejected
// by the analyzer, we can't process a subset using the reshape
// exec stream
if (rexAnalyzer.getNonSargFilterRexNode() != null) {
return false;
}
List<RexInputRef> filterCols = new ArrayList<RexInputRef>();
List<RexNode> filterOperands = new ArrayList<RexNode>();
if (FennelRelUtil.extractSimplePredicates(sargBindingList, filterCols, filterOperands, op)) {
for (RexInputRef filterCol : filterCols) {
filterList.add(filterCol.getIndex());
}
for (RexNode operand : filterOperands) {
literals.add((RexLiteral) operand);
}
return true;
} else {
return false;
}
}
/**
* Determines if a projection is simple.
*
* @param calcRel CalcRel containing the projection
* @param projOrdinals if the projection is simple, returns the ordinals of the projection inputs
* @return rowtype corresponding to the projection, provided it is simple; otherwise null is
* returned
*/
private RelDataType isProjectSimple(CalcRel calcRel, List<Integer> projOrdinals) {
// Loop through projection expressions. If we find a non-simple
// projection expression, simply return.
RexProgram program = calcRel.getProgram();
List<RexLocalRef> projList = program.getProjectList();
int nProjExprs = projList.size();
RelDataType[] types = new RelDataType[nProjExprs];
String[] fieldNames = new String[nProjExprs];
RelDataTypeField[] projFields = calcRel.getRowType().getFields();
for (int i = 0; i < nProjExprs; i++) {
RexNode projExpr = program.expandLocalRef(projList.get(i));
if (projExpr instanceof RexInputRef) {
projOrdinals.add(((RexInputRef) projExpr).getIndex());
types[i] = projExpr.getType();
fieldNames[i] = projFields[i].getName();
continue;
} else if (!(projExpr instanceof RexCall)) {
return null;
}
RexCall rexCall = (RexCall) projExpr;
if (rexCall.getOperator() != SqlStdOperatorTable.castFunc) {
return null;
}
RexNode castOperand = rexCall.getOperands()[0];
if (!(castOperand instanceof RexInputRef)) {
return null;
}
RelDataType castType = projExpr.getType();
RelDataType origType = castOperand.getType();
if (isCastSimple(origType, castType)) {
projOrdinals.add(((RexInputRef) castOperand).getIndex());
types[i] = castType;
fieldNames[i] = projFields[i].getName();
} else {
return null;
}
}
// return the rowtype corresponding to the output of the projection
return calcRel.getCluster().getTypeFactory().createStructType(types, fieldNames);
}