public static RelNode createProject(final RelNode child, final List<Integer> posList) {
return CalcRel.createProject(
child,
new AbstractList<RexNode>() {
public int size() {
return posList.size();
}
public RexNode get(int index) {
final int pos = posList.get(index);
return child
.getCluster()
.getRexBuilder()
.makeInputRef(child.getRowType().getFieldList().get(pos).getType(), pos);
}
},
null);
}
/**
* Trims a child relational expression, then adds back a dummy project to restore the fields that
* were removed.
*
* <p>Sounds pointless? It causes unused fields to be removed further down the tree (towards the
* leaves), but it ensure that the consuming relational expression continues to see the same
* fields.
*
* @param rel Relational expression
* @param input Input relational expression, whose fields to trim
* @param fieldsUsed Bitmap of fields needed by the consumer
* @return New relational expression and its field mapping
*/
protected TrimResult trimChildRestore(
RelNode rel, RelNode input, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
TrimResult trimResult = trimChild(rel, input, fieldsUsed, extraFields);
if (trimResult.right.isIdentity()) {
return trimResult;
}
final RelDataType rowType = input.getRowType();
List<RelDataTypeField> fieldList = rowType.getFieldList();
final List<RexNode> exprList = new ArrayList<RexNode>();
final List<String> nameList = rowType.getFieldNames();
RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
assert trimResult.right.getSourceCount() == fieldList.size();
for (int i = 0; i < fieldList.size(); i++) {
int source = trimResult.right.getTargetOpt(i);
RelDataTypeField field = fieldList.get(i);
exprList.add(
source < 0
? rexBuilder.makeZeroLiteral(field.getType())
: rexBuilder.makeInputRef(field.getType(), source));
}
RelNode project = CalcRel.createProject(trimResult.left, exprList, nameList);
return new TrimResult(project, Mappings.createIdentity(fieldList.size()));
}
/**
* Creates new RelNodes replacing/removing the original project/row scan
*
* @param projectedScan new scan that is now projected
* @param origProject original projection
* @param needRename true if fields from the row scan need to be renamed
* @param newProject projection that contains the new projection expressions, in the case where
* the original projection cannot be removed because it projects expressions
* @return new RelNode
*/
public RelNode createNewRelNode(
RelNode projectedScan, ProjectRel origProject, boolean needRename, ProjectRel newProject) {
RelNode scanRel;
if (needRename) {
// Replace calling convention with FENNEL_EXEC_CONVENTION
RelTraitSet traits = RelOptUtil.clone(origProject.getTraits());
traits.setTrait(CallingConventionTraitDef.instance, FennelRel.FENNEL_EXEC_CONVENTION);
if (!traits.equals(projectedScan.getTraits())) {
RelNode mergedProjectedScan = convert(projectedScan, traits);
RelOptPlanner planner = projectedScan.getCluster().getPlanner();
// register projectedScan == mergedProjectedScan
// so mergedProjectedScan will have a set later on
projectedScan = planner.ensureRegistered(mergedProjectedScan, projectedScan);
}
scanRel =
new FennelRenameRel(
origProject.getCluster(),
projectedScan,
RelOptUtil.getFieldNames(origProject.getRowType()),
traits);
} else {
scanRel = projectedScan;
}
if (newProject == null) {
return scanRel;
} else {
// in the case where the projection had expressions, put the
// new, modified projection on top of the projected row scan
return (ProjectRel)
CalcRel.createProject(
scanRel,
newProject.getProjectExps(),
RelOptUtil.getFieldNames(newProject.getRowType()));
}
}
protected void executeImpl() throws Exception {
RelNode oneRowRel = new OneRowRel(getPreparingStmt().getRelOptCluster());
RelNode projectRel = CalcRel.createProject(oneRowRel, exprs, null);
executePlan(projectRel, exprs, false, true);
}
