/**
* 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());
}
public void onMatch(RelOptRuleCall call) {
assert matches(call);
final JoinRel join = (JoinRel) call.rels[0];
final List<Integer> leftKeys = new ArrayList<Integer>();
final List<Integer> rightKeys = new ArrayList<Integer>();
RelNode right = join.getRight();
final RelNode left = join.getLeft();
RexNode remainingCondition =
RelOptUtil.splitJoinCondition(left, right, join.getCondition(), leftKeys, rightKeys);
assert leftKeys.size() == rightKeys.size();
final List<CorrelatorRel.Correlation> correlationList =
new ArrayList<CorrelatorRel.Correlation>();
if (leftKeys.size() > 0) {
final RelOptCluster cluster = join.getCluster();
final RexBuilder rexBuilder = cluster.getRexBuilder();
int k = 0;
RexNode condition = null;
for (Integer leftKey : leftKeys) {
Integer rightKey = rightKeys.get(k++);
final String dyn_inIdStr = cluster.getQuery().createCorrel();
final int dyn_inId = RelOptQuery.getCorrelOrdinal(dyn_inIdStr);
// Create correlation to say 'each row, set variable #id
// to the value of column #leftKey'.
correlationList.add(new CorrelatorRel.Correlation(dyn_inId, leftKey));
condition =
RelOptUtil.andJoinFilters(
rexBuilder,
condition,
rexBuilder.makeCall(
SqlStdOperatorTable.equalsOperator,
rexBuilder.makeInputRef(
right.getRowType().getFieldList().get(rightKey).getType(), rightKey),
rexBuilder.makeCorrel(
left.getRowType().getFieldList().get(leftKey).getType(), dyn_inIdStr)));
}
right = CalcRel.createFilter(right, condition);
}
RelNode newRel =
new CorrelatorRel(
join.getCluster(),
left,
right,
remainingCondition,
correlationList,
join.getJoinType());
call.transformTo(newRel);
}
/** 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 TableFunctionRel}. */
public TrimResult trimFields(
TableFunctionRel tabFun, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final RelDataType rowType = tabFun.getRowType();
final int fieldCount = rowType.getFieldCount();
List<RelNode> newInputs = new ArrayList<RelNode>();
for (RelNode input : tabFun.getInputs()) {
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 = trimChildRestore(tabFun, input, inputFieldsUsed, inputExtraFields);
assert trimResult.right.isIdentity();
newInputs.add(trimResult.left);
}
TableFunctionRel newTabFun = tabFun;
if (!tabFun.getInputs().equals(newInputs)) {
newTabFun = tabFun.copy(tabFun.getTraitSet(), newInputs);
}
assert newTabFun.getClass() == tabFun.getClass();
// Always project all fields.
Mapping mapping = Mappings.createIdentity(fieldCount);
return new TrimResult(newTabFun, mapping);
}
private void bindDeferred(JavaFrame frame, final RelNode rel) {
final StatementList statementList = getStatementList();
if (frame.bind == null) {
// this relational expression has not bound itself, so we presume
// that we can call its implementSelf() method
if (!(rel instanceof JavaSelfRel)) {
throw Util.newInternal(
"In order to bind-deferred, a "
+ "relational expression must implement JavaSelfRel: "
+ rel);
}
final JavaSelfRel selfRel = (JavaSelfRel) rel;
LazyBind lazyBind =
new LazyBind(
newVariable(),
statementList,
getTypeFactory(),
rel.getRowType(),
new VariableInitializerThunk() {
public VariableInitializer getInitializer() {
return selfRel.implementSelf(JavaRelImplementor.this);
}
});
bind(rel, lazyBind);
} else if ((frame.bind instanceof LazyBind)
&& (((LazyBind) frame.bind).statementList != statementList)) {
// Frame is already bound, but to a variable declared in a different
// scope. Re-bind it.
final LazyBind lazyBind = (LazyBind) frame.bind;
lazyBind.statementList = statementList;
lazyBind.bound = false;
}
}
/**
* Trims unused fields from a relational expression.
*
* <p>We presume that all fields of the relational expression are wanted by its consumer, so only
* trim fields that are not used within the tree.
*
* @param root Root node of relational expression
* @return Trimmed relational expression
*/
public RelNode trim(RelNode root) {
final int fieldCount = root.getRowType().getFieldCount();
final BitSet fieldsUsed = Util.bitSetBetween(0, fieldCount);
final Set<RelDataTypeField> extraFields = Collections.emptySet();
final TrimResult trimResult = dispatchTrimFields(root, fieldsUsed, extraFields);
if (!trimResult.right.isIdentity()) {
throw new IllegalArgumentException();
}
return trimResult.left;
}
/**
* Trims the fields of an input relational expression.
*
* @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 trimChild(
RelNode rel, RelNode input, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
Util.discard(rel);
if (input.getClass().getName().endsWith("MedMdrClassExtentRel")) {
// MedMdrJoinRule cannot handle Join of Project of
// MedMdrClassExtentRel, only naked MedMdrClassExtentRel.
// So, disable trimming.
fieldsUsed = Util.bitSetBetween(0, input.getRowType().getFieldCount());
}
return dispatchTrimFields(input, fieldsUsed, extraFields);
}
/**
* 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());
}
/**
* Returns the index of the first field in <code>rel</code> which comes from its <code>ordinal
* </code>th input.
*
* <p>For example, if rel joins T0(A,B,C) to T1(D,E), then countFields(0,rel) yields 0, and
* countFields(1,rel) yields 3.
*/
private int computeFieldOffset(RelNode rel, int ordinal) {
if (ordinal == 0) {
// short-circuit for the common case
return 0;
}
int fieldOffset = 0;
final List<RelNode> inputs = rel.getInputs();
for (int i = 0; i < ordinal; i++) {
RelNode input = inputs.get(i);
fieldOffset += input.getRowType().getFieldList().size();
}
return fieldOffset;
}
/**
* Invokes {@link #trimFields}, or the appropriate method for the type of the rel parameter, using
* multi-method dispatch.
*
* @param rel Relational expression
* @param fieldsUsed Bitmap of fields needed by the consumer
* @return New relational expression and its field mapping
*/
protected final TrimResult dispatchTrimFields(
RelNode rel, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final TrimResult trimResult = trimFieldsDispatcher.invoke(rel, fieldsUsed, extraFields);
final RelNode newRel = trimResult.left;
final Mapping mapping = trimResult.right;
final int fieldCount = rel.getRowType().getFieldCount();
assert mapping.getSourceCount() == fieldCount
: "source: " + mapping.getSourceCount() + " != " + fieldCount;
final int newFieldCount = newRel.getRowType().getFieldCount();
assert mapping.getTargetCount() + extraFields.size() == newFieldCount
: "target: "
+ mapping.getTargetCount()
+ " + "
+ extraFields.size()
+ " != "
+ newFieldCount;
if (Bug.TodoFixed) assert newFieldCount > 0 : "rel has no fields after trim: " + rel;
if (newRel.equals(rel)) {
return new TrimResult(rel, mapping);
}
return trimResult;
}
/**
* Returns a relational expression which has the same fields as the underlying expression, but the
* fields have different names.
*
* @param rel Relational expression
* @param fieldNames Field names
* @return Renamed relational expression
*/
public static RelNode createRename(RelNode rel, List<String> fieldNames) {
final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
assert fieldNames.size() == fields.size();
final List<Pair<RexNode, String>> refs =
new AbstractList<Pair<RexNode, String>>() {
public int size() {
return fields.size();
}
public Pair<RexNode, String> get(int index) {
return RexInputRef.of2(index, fields);
}
};
return createProject(rel, refs, true);
}
/**
* Declares a variable, and binds it lazily, so it only gets initialized if it is actually used.
*
* @return the Variable so declared
*/
public Variable bind(
RelNode rel, StatementList statementList, final VariableInitializer initializer) {
VariableInitializerThunk thunk =
new VariableInitializerThunk() {
public VariableInitializer getInitializer() {
return initializer;
}
};
Variable variable = newVariable();
LazyBind bind =
new LazyBind(variable, statementList, getTypeFactory(), rel.getRowType(), thunk);
bind(rel, bind);
return bind.getVariable();
}
/**
* 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);
}
}
/**
* 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()));
}
/** 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);
}
/**
* Visit method, per {@link org.eigenbase.util.ReflectiveVisitor}.
*
* <p>This method is invoked reflectively, so there may not be any apparent calls to it. The class
* (or derived classes) may contain overloads of this method with more specific types for the
* {@code rel} parameter.
*
* <p>Returns a pair: the relational expression created, and the mapping between the original
* fields and the fields of the newly created relational expression.
*
* @param rel Relational expression
* @param fieldsUsed Fields needed by the consumer
* @return relational expression and mapping
*/
public TrimResult trimFields(RelNode rel, BitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
// We don't know how to trim this kind of relational expression, so give
// it back intact.
Util.discard(fieldsUsed);
return new TrimResult(rel, Mappings.createIdentity(rel.getRowType().getFieldCount()));
}
/** 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);
}