/**
* Creates a relational expression which projects an array of expressions, and optionally
* optimizes.
*
* <p>The result may not be a {@link ProjectRel}. If the projection is trivial, <code>child</code>
* is returned directly; and future versions may return other formulations of expressions, such as
* {@link CalcRel}.
*
* @param child input relational expression
* @param exprs list of expressions for the input columns
* @param fieldNames aliases of the expressions, or null to generate
* @param optimize Whether to return <code>child</code> unchanged if the projections are trivial.
*/
public static RelNode createProject(
RelNode child, List<RexNode> exprs, List<String> fieldNames, boolean optimize) {
final RelOptCluster cluster = child.getCluster();
final RexProgram program =
RexProgram.create(child.getRowType(), exprs, null, fieldNames, cluster.getRexBuilder());
final List<RelCollation> collationList = program.getCollations(child.getCollationList());
if (DeprecateProjectAndFilter) {
return new CalcRel(
cluster, child.getTraitSet(), child, program.getOutputRowType(), program, collationList);
} else {
final RelDataType rowType =
RexUtil.createStructType(cluster.getTypeFactory(), exprs, fieldNames);
if (optimize && RemoveTrivialProjectRule.isIdentity(exprs, rowType, child.getRowType())) {
return child;
}
return new ProjectRel(
cluster,
cluster.traitSetOf(
collationList.isEmpty() ? RelCollationImpl.EMPTY : collationList.get(0)),
child,
exprs,
rowType,
ProjectRelBase.Flags.Boxed);
}
}
/**
* Creates a relational expression which projects an array of expressions, and optionally
* optimizes.
*
* <p>The result may not be a {@link ProjectRel}. If the projection is trivial, <code>child</code>
* is returned directly; and future versions may return other formulations of expressions, such as
* {@link CalcRel}.
*
* @param child input relational expression
* @param exprs list of expressions for the input columns
* @param fieldNames aliases of the expressions, or null to generate
* @param optimize Whether to return <code>child</code> unchanged if the projections are trivial.
*/
public static RelNode createProject(
RelNode child, List<RexNode> exprs, List<String> fieldNames, boolean optimize) {
final RelOptCluster cluster = child.getCluster();
final RexProgram program =
RexProgram.create(child.getRowType(), exprs, null, fieldNames, cluster.getRexBuilder());
final List<RelCollation> collationList = program.getCollations(child.getCollationList());
if (DEPRECATE_PROJECT_AND_FILTER) {
return new CalcRel(
cluster, child.getTraitSet(), child, program.getOutputRowType(), program, collationList);
} else {
final RelDataType rowType =
RexUtil.createStructType(
cluster.getTypeFactory(),
exprs,
fieldNames == null
? null
: SqlValidatorUtil.uniquify(fieldNames, SqlValidatorUtil.F_SUGGESTER));
if (optimize && RemoveTrivialProjectRule.isIdentity(exprs, rowType, child.getRowType())) {
return child;
}
return new ProjectRel(
cluster,
cluster.traitSetOf(
collationList.isEmpty() ? RelCollationImpl.EMPTY : collationList.get(0)),
child,
exprs,
rowType,
ProjectRelBase.Flags.BOXED);
}
}
/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link SortRel}. */
public TrimResult trimFields(SortRel sort, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = sort.getRowType();
final int fieldCount = rowType.getFieldCount();
final RelCollation collation = sort.getCollation();
final RelNode input = sort.getChild();
// We use the fields used by the consumer, plus any fields used as sort
// keys.
BitSet inputFieldsUsed = (BitSet) fieldsUsed.clone();
for (RelFieldCollation field : collation.getFieldCollations()) {
inputFieldsUsed.set(field.getFieldIndex());
}
// Create input with trimmed columns.
final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
TrimResult trimResult = trimChild(sort, input, inputFieldsUsed, inputExtraFields);
RelNode newInput = trimResult.left;
final Mapping inputMapping = trimResult.right;
// If the input is unchanged, and we need to project all columns,
// there's nothing we can do.
if (newInput == input && inputMapping.isIdentity() && fieldsUsed.cardinality() == fieldCount) {
return new TrimResult(sort, Mappings.createIdentity(fieldCount));
}
final SortRel newSort =
sort.copy(sort.getTraitSet(), newInput, RexUtil.apply(inputMapping, collation));
assert newSort.getClass() == sort.getClass();
// The result has the same mapping as the input gave us. Sometimes we
// return fields that the consumer didn't ask for, because the filter
// needs them for its condition.
return new TrimResult(newSort, inputMapping);
}
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);
}
}
/**
* Creates a ProjectRel with no sort keys.
*
* @param cluster Cluster this relational expression belongs to
* @param child input relational expression
* @param exps set of expressions for the input columns
* @param fieldNames aliases of the expressions
* @param flags values as in {@link ProjectRelBase.Flags}
*/
public ProjectRel(
RelOptCluster cluster, RelNode child, RexNode[] exps, String[] fieldNames, int flags) {
this(
cluster,
child,
exps,
RexUtil.createStructType(cluster.getTypeFactory(), exps, fieldNames),
flags,
Collections.<RelCollation>emptyList());
}
public ProjectRel clone() {
ProjectRel clone =
new ProjectRel(
getCluster(),
getChild().clone(),
RexUtil.clone(exps),
rowType,
getFlags(),
Collections.<RelCollation>emptyList());
clone.inheritTraitsFrom(this);
return clone;
}
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);
}
/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link ProjectRel}. */
public TrimResult trimFields(
ProjectRel project, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = project.getRowType();
final int fieldCount = rowType.getFieldCount();
final RelNode input = project.getChild();
final RelDataType inputRowType = input.getRowType();
// Which fields are required from the input?
BitSet inputFieldsUsed = new BitSet(inputRowType.getFieldCount());
final Set<RelDataTypeField> inputExtraFields = new LinkedHashSet<RelDataTypeField>(extraFields);
RelOptUtil.InputFinder inputFinder =
new RelOptUtil.InputFinder(inputFieldsUsed, inputExtraFields);
for (Ord<RexNode> ord : Ord.zip(project.getProjects())) {
if (fieldsUsed.get(ord.i)) {
ord.e.accept(inputFinder);
}
}
// Create input with trimmed columns.
TrimResult trimResult = trimChild(project, input, inputFieldsUsed, inputExtraFields);
RelNode newInput = trimResult.left;
final Mapping inputMapping = trimResult.right;
// If the input is unchanged, and we need to project all columns,
// there's nothing we can do.
if (newInput == input && fieldsUsed.cardinality() == fieldCount) {
return new TrimResult(project, Mappings.createIdentity(fieldCount));
}
// Some parts of the system can't handle rows with zero fields, so
// pretend that one field is used.
if (fieldsUsed.cardinality() == 0) {
final Mapping mapping = Mappings.create(MappingType.InverseSurjection, fieldCount, 1);
final RexLiteral expr =
project.getCluster().getRexBuilder().makeExactLiteral(BigDecimal.ZERO);
RelDataType newRowType =
project
.getCluster()
.getTypeFactory()
.createStructType(
Collections.singletonList(expr.getType()), Collections.singletonList("DUMMY"));
ProjectRel newProject =
new ProjectRel(
project.getCluster(),
project.getCluster().traitSetOf(RelCollationImpl.EMPTY),
newInput,
Collections.<RexNode>singletonList(expr),
newRowType,
project.getFlags());
return new TrimResult(newProject, mapping);
}
// Build new project expressions, and populate the mapping.
List<RexNode> newProjectExprList = new ArrayList<RexNode>();
final RexVisitor<RexNode> shuttle = new RexPermuteInputsShuttle(inputMapping, newInput);
final Mapping mapping =
Mappings.create(MappingType.InverseSurjection, fieldCount, fieldsUsed.cardinality());
for (Ord<RexNode> ord : Ord.zip(project.getProjects())) {
if (fieldsUsed.get(ord.i)) {
mapping.set(ord.i, newProjectExprList.size());
RexNode newProjectExpr = ord.e.accept(shuttle);
newProjectExprList.add(newProjectExpr);
}
}
final RelDataType newRowType =
project
.getCluster()
.getTypeFactory()
.createStructType(Mappings.apply3(mapping, rowType.getFieldList()));
final List<RelCollation> newCollations =
RexUtil.apply(inputMapping, project.getCollationList());
final RelNode newProject;
if (RemoveTrivialProjectRule.isIdentity(
newProjectExprList, newRowType, newInput.getRowType())) {
// The new project would be the identity. It is equivalent to return
// its child.
newProject = newInput;
} else {
newProject =
new ProjectRel(
project.getCluster(),
project
.getCluster()
.traitSetOf(
newCollations.isEmpty() ? RelCollationImpl.EMPTY : newCollations.get(0)),
newInput,
newProjectExprList,
newRowType,
project.getFlags());
assert newProject.getClass() == project.getClass();
}
return new TrimResult(newProject, mapping);
}