/**
* 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);
}
}
/**
* Creates a relational expression which permutes the output fields of a relational expression
* according to a permutation.
*
* <p>Optimizations:
*
* <ul>
* <li>If the relational expression is a {@link CalcRel} or {@link ProjectRel} which is already
* acting as a permutation, combines the new permutation with the old;
* <li>If the permutation is the identity, returns the original relational expression.
* </ul>
*
* <p>If a permutation is combined with its inverse, these optimizations would combine to remove
* them both.
*
* @param rel Relational expression
* @param permutation Permutation to apply to fields
* @param fieldNames Field names; if null, or if a particular entry is null, the name of the
* permuted field is used
* @return relational expression which permutes its input fields
*/
public static RelNode permute(RelNode rel, Permutation permutation, List<String> fieldNames) {
if (permutation.isIdentity()) {
return rel;
}
if (rel instanceof CalcRel) {
CalcRel calcRel = (CalcRel) rel;
Permutation permutation1 = calcRel.getProgram().getPermutation();
if (permutation1 != null) {
Permutation permutation2 = permutation.product(permutation1);
return permute(rel, permutation2, null);
}
}
if (rel instanceof ProjectRel) {
Permutation permutation1 = ((ProjectRel) rel).getPermutation();
if (permutation1 != null) {
Permutation permutation2 = permutation.product(permutation1);
return permute(rel, permutation2, null);
}
}
final List<RelDataType> outputTypeList = new ArrayList<RelDataType>();
final List<String> outputNameList = new ArrayList<String>();
final List<RexNode> exprList = new ArrayList<RexNode>();
final List<RexLocalRef> projectRefList = new ArrayList<RexLocalRef>();
final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
for (int i = 0; i < permutation.getTargetCount(); i++) {
int target = permutation.getTarget(i);
final RelDataTypeField targetField = fields.get(target);
outputTypeList.add(targetField.getType());
outputNameList.add(
((fieldNames == null) || (fieldNames.size() <= i) || (fieldNames.get(i) == null))
? targetField.getName()
: fieldNames.get(i));
exprList.add(rel.getCluster().getRexBuilder().makeInputRef(fields.get(i).getType(), i));
final int source = permutation.getSource(i);
projectRefList.add(new RexLocalRef(source, fields.get(source).getType()));
}
final RexProgram program =
new RexProgram(
rel.getRowType(),
exprList,
projectRefList,
null,
rel.getCluster().getTypeFactory().createStructType(outputTypeList, outputNameList));
return new CalcRel(
rel.getCluster(),
rel.getTraitSet(),
rel,
program.getOutputRowType(),
program,
Collections.<RelCollation>emptyList());
}
/** Returns whether a {@link RexProgram} contains expressions which require decimal expansion. */
public static boolean requiresDecimalExpansion(RexProgram program, boolean recurse) {
final List<RexNode> exprList = program.getExprList();
for (RexNode expr : exprList) {
if (requiresDecimalExpansion(expr, recurse)) {
return true;
}
}
return false;
}
/**
* Creates a relational expression which filters according to a given condition, returning the
* same fields as its input.
*
* @param child Child relational expression
* @param condition Condition
* @return Relational expression
*/
public static RelNode createFilter(RelNode child, RexNode condition) {
if (DeprecateProjectAndFilter) {
final RelOptCluster cluster = child.getCluster();
RexProgramBuilder builder =
new RexProgramBuilder(child.getRowType(), cluster.getRexBuilder());
builder.addIdentity();
builder.addCondition(condition);
final RexProgram program = builder.getProgram();
return new CalcRel(
cluster,
child.getTraitSet(),
child,
program.getOutputRowType(),
program,
Collections.<RelCollation>emptyList());
} else {
return new FilterRel(child.getCluster(), child, condition);
}
}
/**
* Creates a relational expression which projects the output fields of a relational expression
* according to a partial mapping.
*
* <p>A partial mapping is weaker than a permutation: every target has one source, but a source
* may have 0, 1 or more than one targets. Usually the result will have fewer fields than the
* source, unless some source fields are projected multiple times.
*
* <p>This method could optimize the result as {@link #permute} does, but does not at present.
*
* @param rel Relational expression
* @param mapping Mapping from source fields to target fields. The mapping type must obey the
* constaints {@link MappingType#isMandatorySource()} and {@link
* MappingType#isSingleSource()}, as does {@link MappingType#InverseFunction}.
* @param fieldNames Field names; if null, or if a particular entry is null, the name of the
* permuted field is used
* @return relational expression which projects a subset of the input fields
*/
public static RelNode projectMapping(RelNode rel, Mapping mapping, List<String> fieldNames) {
assert mapping.getMappingType().isSingleSource();
assert mapping.getMappingType().isMandatorySource();
if (mapping.isIdentity()) {
return rel;
}
final List<RelDataType> outputTypeList = new ArrayList<RelDataType>();
final List<String> outputNameList = new ArrayList<String>();
final List<RexNode> exprList = new ArrayList<RexNode>();
final List<RexLocalRef> projectRefList = new ArrayList<RexLocalRef>();
final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
for (int i = 0; i < fields.size(); i++) {
final RelDataTypeField field = fields.get(i);
exprList.add(rel.getCluster().getRexBuilder().makeInputRef(field.getType(), i));
}
for (int i = 0; i < mapping.getTargetCount(); i++) {
int source = mapping.getSource(i);
final RelDataTypeField sourceField = fields.get(source);
outputTypeList.add(sourceField.getType());
outputNameList.add(
((fieldNames == null) || (fieldNames.size() <= i) || (fieldNames.get(i) == null))
? sourceField.getName()
: fieldNames.get(i));
projectRefList.add(new RexLocalRef(source, sourceField.getType()));
}
final RexProgram program =
new RexProgram(
rel.getRowType(),
exprList,
projectRefList,
null,
rel.getCluster().getTypeFactory().createStructType(outputTypeList, outputNameList));
return new CalcRel(
rel.getCluster(),
rel.getTraitSet(),
rel,
program.getOutputRowType(),
program,
Collections.<RelCollation>emptyList());
}
@Override
public CalcRelBase copy(
RelTraitSet traitSet, RelNode child, RexProgram program, List<RelCollation> collationList) {
return new CalcRel(
getCluster(), traitSet, child, program.getOutputRowType(), program, collationList);
}