/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link TableModificationRel}. */
public TrimResult trimFields(
TableModificationRel modifier, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
// Ignore what consumer wants. We always project all columns.
Util.discard(fieldsUsed);
final RelDataType rowType = modifier.getRowType();
final int fieldCount = rowType.getFieldCount();
RelNode input = modifier.getChild();
// We want all fields from the child.
final int inputFieldCount = input.getRowType().getFieldCount();
BitSet inputFieldsUsed = Util.bitSetBetween(0, inputFieldCount);
// Create input with trimmed columns.
final Set<RelDataTypeField> inputExtraFields = Collections.emptySet();
TrimResult trimResult = trimChild(modifier, input, inputFieldsUsed, inputExtraFields);
RelNode newInput = trimResult.left;
final Mapping inputMapping = trimResult.right;
if (!inputMapping.isIdentity()) {
// We asked for all fields. Can't believe that the child decided
// to permute them!
throw Util.newInternal("Expected identity mapping, got " + inputMapping);
}
TableModificationRel newModifier = modifier;
if (newInput != input) {
newModifier = modifier.copy(modifier.getTraitSet(), Collections.singletonList(newInput));
}
assert newModifier.getClass() == modifier.getClass();
// Always project all fields.
Mapping mapping = Mappings.createIdentity(fieldCount);
return new TrimResult(newModifier, mapping);
}
/** 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);
}
/**
* Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link SetOpRel} (including UNION and
* UNION ALL).
*/
public TrimResult trimFields(
SetOpRel setOp, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = setOp.getRowType();
final int fieldCount = rowType.getFieldCount();
int changeCount = 0;
// Fennel abhors an empty row type, so pretend that the parent rel
// wants the last field. (The last field is the least likely to be a
// system field.)
if (fieldsUsed.isEmpty()) {
fieldsUsed.set(rowType.getFieldCount() - 1);
}
// Compute the desired field mapping. Give the consumer the fields they
// want, in the order that they appear in the bitset.
final Mapping mapping = createMapping(fieldsUsed, fieldCount);
// Create input with trimmed columns.
final List<RelNode> newInputs = new ArrayList<RelNode>();
for (RelNode input : setOp.getInputs()) {
TrimResult trimResult = trimChild(setOp, input, fieldsUsed, extraFields);
RelNode newInput = trimResult.left;
final Mapping inputMapping = trimResult.right;
// We want "mapping", the input gave us "inputMapping", compute
// "remaining" mapping.
// | | |
// |---------------- mapping ---------->|
// |-- inputMapping -->| |
// | |-- remaining -->|
//
// For instance, suppose we have columns [a, b, c, d],
// the consumer asked for mapping = [b, d],
// and the transformed input has columns inputMapping = [d, a, b].
// remaining will permute [b, d] to [d, a, b].
Mapping remaining = Mappings.divide(mapping, inputMapping);
// Create a projection; does nothing if remaining is identity.
newInput = CalcRel.projectMapping(newInput, remaining, null);
if (input != newInput) {
++changeCount;
}
newInputs.add(newInput);
}
// If the input is unchanged, and we need to project all columns,
// there's to do.
if (changeCount == 0 && mapping.isIdentity()) {
return new TrimResult(setOp, mapping);
}
RelNode newSetOp = setOp.copy(setOp.getTraitSet(), newInputs);
return new TrimResult(newSetOp, mapping);
}
/**
* 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());
}
/** Variant of {@link #trimFields(RelNode, BitSet, Set)} for {@link JoinRel}. */
public TrimResult trimFields(JoinRel join, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = join.getRowType();
final int fieldCount = rowType.getFieldCount();
final RexNode conditionExpr = join.getCondition();
final int systemFieldCount = join.getSystemFieldList().size();
// Add in fields used in the condition.
BitSet fieldsUsedPlus = (BitSet) fieldsUsed.clone();
final Set<RelDataTypeField> combinedInputExtraFields =
new LinkedHashSet<RelDataTypeField>(extraFields);
RelOptUtil.InputFinder inputFinder =
new RelOptUtil.InputFinder(fieldsUsedPlus, combinedInputExtraFields);
conditionExpr.accept(inputFinder);
// If no system fields are used, we can remove them.
int systemFieldUsedCount = 0;
for (int i = 0; i < systemFieldCount; ++i) {
if (fieldsUsed.get(i)) {
++systemFieldUsedCount;
}
}
final int newSystemFieldCount;
if (systemFieldUsedCount == 0) {
newSystemFieldCount = 0;
} else {
newSystemFieldCount = systemFieldCount;
}
int offset = systemFieldCount;
int changeCount = 0;
int newFieldCount = newSystemFieldCount;
List<RelNode> newInputs = new ArrayList<RelNode>(2);
List<Mapping> inputMappings = new ArrayList<Mapping>();
List<Integer> inputExtraFieldCounts = new ArrayList<Integer>();
for (RelNode input : join.getInputs()) {
final RelDataType inputRowType = input.getRowType();
final int inputFieldCount = inputRowType.getFieldCount();
// Compute required mapping.
BitSet inputFieldsUsed = new BitSet(inputFieldCount);
for (int bit : Util.toIter(fieldsUsedPlus)) {
if (bit >= offset && bit < offset + inputFieldCount) {
inputFieldsUsed.set(bit - offset);
}
}
// If there are system fields, we automatically use the
// corresponding field in each input.
if (newSystemFieldCount > 0) {
// calling with newSystemFieldCount == 0 should be safe but hits
// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6222207
inputFieldsUsed.set(0, newSystemFieldCount);
}
// FIXME: We ought to collect extra fields for each input
// individually. For now, we assume that just one input has
// on-demand fields.
Set<RelDataTypeField> inputExtraFields =
input.getRowType().getField("_extra") == null
? Collections.<RelDataTypeField>emptySet()
: combinedInputExtraFields;
inputExtraFieldCounts.add(inputExtraFields.size());
TrimResult trimResult = trimChild(join, input, inputFieldsUsed, inputExtraFields);
newInputs.add(trimResult.left);
if (trimResult.left != input) {
++changeCount;
}
final Mapping inputMapping = trimResult.right;
inputMappings.add(inputMapping);
// Move offset to point to start of next input.
offset += inputFieldCount;
newFieldCount += inputMapping.getTargetCount() + inputExtraFields.size();
}
Mapping mapping = Mappings.create(MappingType.InverseSurjection, fieldCount, newFieldCount);
for (int i = 0; i < newSystemFieldCount; ++i) {
mapping.set(i, i);
}
offset = systemFieldCount;
int newOffset = newSystemFieldCount;
for (int i = 0; i < inputMappings.size(); i++) {
Mapping inputMapping = inputMappings.get(i);
for (IntPair pair : inputMapping) {
mapping.set(pair.source + offset, pair.target + newOffset);
}
offset += inputMapping.getSourceCount();
newOffset += inputMapping.getTargetCount() + inputExtraFieldCounts.get(i);
}
if (changeCount == 0 && mapping.isIdentity()) {
return new TrimResult(join, Mappings.createIdentity(fieldCount));
}
// Build new join.
final RexVisitor<RexNode> shuttle =
new RexPermuteInputsShuttle(mapping, newInputs.get(0), newInputs.get(1));
RexNode newConditionExpr = conditionExpr.accept(shuttle);
final JoinRel newJoin =
join.copy(join.getTraitSet(), newConditionExpr, newInputs.get(0), newInputs.get(1));
return new TrimResult(newJoin, mapping);
}
public boolean isIdentity() {
return parent.isIdentity();
}