public Double getDistinctRowCount(Aggregate rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
// determine which predicates can be applied on the child of the
// aggregate
List<RexNode> notPushable = new ArrayList<RexNode>();
List<RexNode> pushable = new ArrayList<RexNode>();
RelOptUtil.splitFilters(rel.getGroupSet(), predicate, pushable, notPushable);
final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
RexNode childPreds = RexUtil.composeConjunction(rexBuilder, pushable, true);
// set the bits as they correspond to the child input
ImmutableBitSet.Builder childKey = ImmutableBitSet.builder();
RelMdUtil.setAggChildKeys(groupKey, rel, childKey);
Double distinctRowCount =
RelMetadataQuery.getDistinctRowCount(rel.getInput(), childKey.build(), childPreds);
if (distinctRowCount == null) {
return null;
} else if (notPushable.isEmpty()) {
return distinctRowCount;
} else {
RexNode preds = RexUtil.composeConjunction(rexBuilder, notPushable, true);
return distinctRowCount * RelMdUtil.guessSelectivity(preds);
}
}
/**
* Infers predicates for an Aggregate.
*
* <p>Pulls up predicates that only contains references to columns in the GroupSet. For e.g.
*
* <pre>
* childPullUpExprs : { a > 7, b + c < 10, a + e = 9}
* groupSet : { a, b}
* pulledUpExprs : { a > 7}
* </pre>
*/
public RelOptPredicateList getPredicates(Aggregate agg) {
RelNode child = agg.getInput();
RelOptPredicateList childInfo = RelMetadataQuery.getPulledUpPredicates(child);
List<RexNode> aggPullUpPredicates = new ArrayList<RexNode>();
ImmutableBitSet groupKeys = agg.getGroupSet();
Mapping m =
Mappings.create(
MappingType.PARTIAL_FUNCTION,
child.getRowType().getFieldCount(),
agg.getRowType().getFieldCount());
int i = 0;
for (int j : groupKeys) {
m.set(j, i++);
}
for (RexNode r : childInfo.pulledUpPredicates) {
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r);
if (groupKeys.contains(rCols)) {
r = r.accept(new RexPermuteInputsShuttle(m, child));
aggPullUpPredicates.add(r);
}
}
return RelOptPredicateList.of(aggPullUpPredicates);
}
public Double getDistinctRowCount(Project rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
ImmutableBitSet.Builder baseCols = ImmutableBitSet.builder();
ImmutableBitSet.Builder projCols = ImmutableBitSet.builder();
List<RexNode> projExprs = rel.getProjects();
RelMdUtil.splitCols(projExprs, groupKey, baseCols, projCols);
List<RexNode> notPushable = new ArrayList<RexNode>();
List<RexNode> pushable = new ArrayList<RexNode>();
RelOptUtil.splitFilters(
ImmutableBitSet.range(rel.getRowType().getFieldCount()), predicate, pushable, notPushable);
final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
// get the distinct row count of the child input, passing in the
// columns and filters that only reference the child; convert the
// filter to reference the children projection expressions
RexNode childPred = RexUtil.composeConjunction(rexBuilder, pushable, true);
RexNode modifiedPred;
if (childPred == null) {
modifiedPred = null;
} else {
modifiedPred = RelOptUtil.pushPastProject(childPred, rel);
}
Double distinctRowCount =
RelMetadataQuery.getDistinctRowCount(rel.getInput(), baseCols.build(), modifiedPred);
if (distinctRowCount == null) {
return null;
} else if (!notPushable.isEmpty()) {
RexNode preds = RexUtil.composeConjunction(rexBuilder, notPushable, true);
distinctRowCount *= RelMdUtil.guessSelectivity(preds);
}
// No further computation required if the projection expressions
// are all column references
if (projCols.cardinality() == 0) {
return distinctRowCount;
}
// multiply by the cardinality of the non-child projection expressions
for (int bit : projCols.build()) {
Double subRowCount = RelMdUtil.cardOfProjExpr(rel, projExprs.get(bit));
if (subRowCount == null) {
return null;
}
distinctRowCount *= subRowCount;
}
return RelMdUtil.numDistinctVals(distinctRowCount, RelMetadataQuery.getRowCount(rel));
}
public static List<Integer> translateBitSetToProjIndx(ImmutableBitSet projBitSet) {
List<Integer> projIndxLst = new ArrayList<Integer>();
for (int i = 0; i < projBitSet.length(); i++) {
if (projBitSet.get(i)) {
projIndxLst.add(i);
}
}
return projIndxLst;
}
ExprsItr(ImmutableBitSet fields) {
nextMapping = null;
columns = new int[fields.cardinality()];
columnSets = new BitSet[fields.cardinality()];
iterationIdx = new int[fields.cardinality()];
for (int j = 0, i = fields.nextSetBit(0); i >= 0; i = fields.nextSetBit(i + 1), j++) {
columns[j] = i;
columnSets[j] = equivalence.get(i);
iterationIdx[j] = 0;
}
firstCall = true;
}
/**
* Computes the rollup of bit sets.
*
* <p>For example, <code>rollup({0}, {1})</code> returns <code>({0, 1}, {0}, {})</code>.
*
* <p>Bit sets are not necessarily singletons: <code>rollup({0, 2}, {3, 5})</code> returns <code>
* ({0, 2, 3, 5}, {0, 2}, {})</code>.
*/
@VisibleForTesting
public static ImmutableList<ImmutableBitSet> rollup(List<ImmutableBitSet> bitSets) {
Set<ImmutableBitSet> builder = Sets.newLinkedHashSet();
for (; ; ) {
final ImmutableBitSet union = ImmutableBitSet.union(bitSets);
builder.add(union);
if (union.isEmpty()) {
break;
}
bitSets = bitSets.subList(0, bitSets.size() - 1);
}
return ImmutableList.copyOf(builder);
}
/**
* Infers predicates for a project.
*
* <ol>
* <li>create a mapping from input to projection. Map only positions that directly reference an
* input column.
* <li>Expressions that only contain above columns are retained in the Project's pullExpressions
* list.
* <li>For e.g. expression 'a + e = 9' below will not be pulled up because 'e' is not in the
* projection list.
* <pre>
* childPullUpExprs: {a > 7, b + c < 10, a + e = 9}
* projectionExprs: {a, b, c, e / 2}
* projectionPullupExprs: {a > 7, b + c < 10}
* </pre>
* </ol>
*/
public RelOptPredicateList getPredicates(Project project) {
RelNode child = project.getInput();
final RexBuilder rexBuilder = project.getCluster().getRexBuilder();
RelOptPredicateList childInfo = RelMetadataQuery.getPulledUpPredicates(child);
List<RexNode> projectPullUpPredicates = new ArrayList<RexNode>();
ImmutableBitSet.Builder columnsMappedBuilder = ImmutableBitSet.builder();
Mapping m =
Mappings.create(
MappingType.PARTIAL_FUNCTION,
child.getRowType().getFieldCount(),
project.getRowType().getFieldCount());
for (Ord<RexNode> o : Ord.zip(project.getProjects())) {
if (o.e instanceof RexInputRef) {
int sIdx = ((RexInputRef) o.e).getIndex();
m.set(sIdx, o.i);
columnsMappedBuilder.set(sIdx);
}
}
// Go over childPullUpPredicates. If a predicate only contains columns in
// 'columnsMapped' construct a new predicate based on mapping.
final ImmutableBitSet columnsMapped = columnsMappedBuilder.build();
for (RexNode r : childInfo.pulledUpPredicates) {
ImmutableBitSet rCols = RelOptUtil.InputFinder.bits(r);
if (columnsMapped.contains(rCols)) {
r = r.accept(new RexPermuteInputsShuttle(m, child));
projectPullUpPredicates.add(r);
}
}
// Project can also generate constants. We need to include them.
for (Ord<RexNode> expr : Ord.zip(project.getProjects())) {
if (RexLiteral.isNullLiteral(expr.e)) {
projectPullUpPredicates.add(
rexBuilder.makeCall(
SqlStdOperatorTable.IS_NULL, rexBuilder.makeInputRef(project, expr.i)));
} else if (RexUtil.isConstant(expr.e)) {
final List<RexNode> args =
ImmutableList.of(rexBuilder.makeInputRef(project, expr.i), expr.e);
final SqlOperator op =
args.get(0).getType().isNullable() || args.get(1).getType().isNullable()
? SqlStdOperatorTable.IS_NOT_DISTINCT_FROM
: SqlStdOperatorTable.EQUALS;
projectPullUpPredicates.add(rexBuilder.makeCall(op, args));
}
}
return RelOptPredicateList.of(projectPullUpPredicates);
}
/**
* Computes the cube of bit sets.
*
* <p>For example, <code>rollup({0}, {1})</code> returns <code>({0, 1}, {0}, {})</code>.
*
* <p>Bit sets are not necessarily singletons: <code>rollup({0, 2}, {3, 5})</code> returns <code>
* ({0, 2, 3, 5}, {0, 2}, {})</code>.
*/
@VisibleForTesting
public static ImmutableList<ImmutableBitSet> cube(List<ImmutableBitSet> bitSets) {
// Given the bit sets [{1}, {2, 3}, {5}],
// form the lists [[{1}, {}], [{2, 3}, {}], [{5}, {}]].
final Set<List<ImmutableBitSet>> builder = Sets.newLinkedHashSet();
for (ImmutableBitSet bitSet : bitSets) {
builder.add(Arrays.asList(bitSet, ImmutableBitSet.of()));
}
Set<ImmutableBitSet> flattenedBitSets = Sets.newLinkedHashSet();
for (List<ImmutableBitSet> o : Linq4j.product(builder)) {
flattenedBitSets.add(ImmutableBitSet.union(o));
}
return ImmutableList.copyOf(flattenedBitSets);
}
public Double getDistinctRowCount(Join rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
return RelMdUtil.getJoinDistinctRowCount(rel, rel.getJoinType(), groupKey, predicate, false);
}
public Double getDistinctRowCount(Values rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
Double selectivity = RelMdUtil.guessSelectivity(predicate);
// assume half the rows are duplicates
Double nRows = rel.getRows() / 2;
return RelMdUtil.numDistinctVals(nRows, nRows * selectivity);
}
public Double getDistinctRowCount(Filter rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
// REVIEW zfong 4/18/06 - In the Broadbase code, duplicates are not
// removed from the two filter lists. However, the code below is
// doing so.
RexNode unionPreds =
RelMdUtil.unionPreds(rel.getCluster().getRexBuilder(), predicate, rel.getCondition());
return RelMetadataQuery.getDistinctRowCount(rel.getInput(), groupKey, unionPreds);
}
public Double getDistinctRowCount(SemiJoin rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
// create a RexNode representing the selectivity of the
// semijoin filter and pass it to getDistinctRowCount
RexNode newPred = RelMdUtil.makeSemiJoinSelectivityRexNode(rel);
if (predicate != null) {
RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
newPred = rexBuilder.makeCall(SqlStdOperatorTable.AND, newPred, predicate);
}
return RelMetadataQuery.getDistinctRowCount(rel.getLeft(), groupKey, newPred);
}
// Catch-all rule when none of the others apply.
public Double getDistinctRowCount(RelNode rel, ImmutableBitSet groupKey, RexNode predicate) {
if (predicate == null || predicate.isAlwaysTrue()) {
if (groupKey.isEmpty()) {
return 1D;
}
}
// REVIEW zfong 4/19/06 - Broadbase code does not take into
// consideration selectivity of predicates passed in. Also, they
// assume the rows are unique even if the table is not
boolean uniq = RelMdUtil.areColumnsDefinitelyUnique(rel, groupKey);
if (uniq) {
return NumberUtil.multiply(
RelMetadataQuery.getRowCount(rel), RelMetadataQuery.getSelectivity(rel, predicate));
}
return null;
}
public ImmutableBitSet getSortedInputs() throws CalciteSemanticException {
ImmutableBitSet.Builder sortedInputsBuilder = ImmutableBitSet.builder();
JoinPredicateInfo joinPredInfo =
HiveCalciteUtil.JoinPredicateInfo.constructJoinPredicateInfo(this);
List<ImmutableIntList> joinKeysInChildren = new ArrayList<ImmutableIntList>();
joinKeysInChildren.add(
ImmutableIntList.copyOf(joinPredInfo.getProjsFromLeftPartOfJoinKeysInChildSchema()));
joinKeysInChildren.add(
ImmutableIntList.copyOf(joinPredInfo.getProjsFromRightPartOfJoinKeysInChildSchema()));
for (int i = 0; i < this.getInputs().size(); i++) {
boolean correctOrderFound =
RelCollations.contains(
RelMetadataQuery.instance().collations(this.getInputs().get(i)),
joinKeysInChildren.get(i));
if (correctOrderFound) {
sortedInputsBuilder.set(i);
}
}
return sortedInputsBuilder.build();
}
private void infer(
RexNode predicates,
Set<String> allExprsDigests,
List<RexNode> inferedPredicates,
boolean includeEqualityInference,
ImmutableBitSet inferringFields) {
for (RexNode r : RelOptUtil.conjunctions(predicates)) {
if (!includeEqualityInference && equalityPredicates.contains(r.toString())) {
continue;
}
for (Mapping m : mappings(r)) {
RexNode tr =
r.accept(new RexPermuteInputsShuttle(m, joinRel.getInput(0), joinRel.getInput(1)));
if (inferringFields.contains(RelOptUtil.InputFinder.bits(tr))
&& !allExprsDigests.contains(tr.toString())
&& !isAlwaysTrue(tr)) {
inferedPredicates.add(tr);
allExprsDigests.add(tr.toString());
}
}
}
}
/** Analyzes a GROUPING SETS item in a GROUP BY clause. */
private static void convertGroupSet(
SqlValidatorScope scope,
List<SqlNode> groupExprs,
Map<Integer, Integer> groupExprProjection,
ImmutableList.Builder<ImmutableBitSet> builder,
SqlNode groupExpr) {
switch (groupExpr.getKind()) {
case GROUPING_SETS:
final SqlCall call = (SqlCall) groupExpr;
for (SqlNode node : call.getOperandList()) {
convertGroupSet(scope, groupExprs, groupExprProjection, builder, node);
}
return;
case ROW:
final List<ImmutableBitSet> bitSets =
analyzeGroupTuple(
scope, groupExprs, groupExprProjection, ((SqlCall) groupExpr).getOperandList());
builder.add(ImmutableBitSet.union(bitSets));
return;
default:
builder.add(analyzeGroupExpr(scope, groupExprs, groupExprProjection, groupExpr));
return;
}
}
/**
* The PullUp Strategy is sound but not complete.
*
* <ol>
* <li>We only pullUp inferred predicates for now. Pulling up existing predicates causes an
* explosion of duplicates. The existing predicates are pushed back down as new
* predicates. Once we have rules to eliminate duplicate Filter conditions, we should
* pullUp all predicates.
* <li>For Left Outer: we infer new predicates from the left and set them as applicable on the
* Right side. No predicates are pulledUp.
* <li>Right Outer Joins are handled in an analogous manner.
* <li>For Full Outer Joins no predicates are pulledUp or inferred.
* </ol>
*/
public RelOptPredicateList inferPredicates(boolean includeEqualityInference) {
List<RexNode> inferredPredicates = new ArrayList<RexNode>();
Set<String> allExprsDigests = new HashSet<String>(this.allExprsDigests);
final JoinRelType joinType = joinRel.getJoinType();
switch (joinType) {
case INNER:
case LEFT:
infer(
leftChildPredicates,
allExprsDigests,
inferredPredicates,
includeEqualityInference,
joinType == JoinRelType.LEFT ? rightFieldsBitSet : allFieldsBitSet);
break;
}
switch (joinType) {
case INNER:
case RIGHT:
infer(
rightChildPredicates,
allExprsDigests,
inferredPredicates,
includeEqualityInference,
joinType == JoinRelType.RIGHT ? leftFieldsBitSet : allFieldsBitSet);
break;
}
Mappings.TargetMapping rightMapping =
Mappings.createShiftMapping(
nSysFields + nFieldsLeft + nFieldsRight, 0, nSysFields + nFieldsLeft, nFieldsRight);
final RexPermuteInputsShuttle rightPermute =
new RexPermuteInputsShuttle(rightMapping, joinRel);
Mappings.TargetMapping leftMapping =
Mappings.createShiftMapping(nSysFields + nFieldsLeft, 0, nSysFields, nFieldsLeft);
final RexPermuteInputsShuttle leftPermute = new RexPermuteInputsShuttle(leftMapping, joinRel);
List<RexNode> leftInferredPredicates = new ArrayList<RexNode>();
List<RexNode> rightInferredPredicates = new ArrayList<RexNode>();
for (RexNode iP : inferredPredicates) {
ImmutableBitSet iPBitSet = RelOptUtil.InputFinder.bits(iP);
if (leftFieldsBitSet.contains(iPBitSet)) {
leftInferredPredicates.add(iP.accept(leftPermute));
} else if (rightFieldsBitSet.contains(iPBitSet)) {
rightInferredPredicates.add(iP.accept(rightPermute));
}
}
switch (joinType) {
case INNER:
Iterable<RexNode> pulledUpPredicates;
if (isSemiJoin) {
pulledUpPredicates =
Iterables.concat(
RelOptUtil.conjunctions(leftChildPredicates), leftInferredPredicates);
} else {
pulledUpPredicates =
Iterables.concat(
RelOptUtil.conjunctions(leftChildPredicates),
RelOptUtil.conjunctions(rightChildPredicates),
RelOptUtil.conjunctions(joinRel.getCondition()),
inferredPredicates);
}
return RelOptPredicateList.of(
pulledUpPredicates, leftInferredPredicates, rightInferredPredicates);
case LEFT:
return RelOptPredicateList.of(
RelOptUtil.conjunctions(leftChildPredicates),
leftInferredPredicates,
rightInferredPredicates);
case RIGHT:
return RelOptPredicateList.of(
RelOptUtil.conjunctions(rightChildPredicates), inferredPredicates, EMPTY_LIST);
default:
assert inferredPredicates.size() == 0;
return RelOptPredicateList.EMPTY;
}
}
private JoinConditionBasedPredicateInference(
Join joinRel, boolean isSemiJoin, RexNode lPreds, RexNode rPreds) {
super();
this.joinRel = joinRel;
this.isSemiJoin = isSemiJoin;
nFieldsLeft = joinRel.getLeft().getRowType().getFieldList().size();
nFieldsRight = joinRel.getRight().getRowType().getFieldList().size();
nSysFields = joinRel.getSystemFieldList().size();
leftFieldsBitSet = ImmutableBitSet.range(nSysFields, nSysFields + nFieldsLeft);
rightFieldsBitSet =
ImmutableBitSet.range(nSysFields + nFieldsLeft, nSysFields + nFieldsLeft + nFieldsRight);
allFieldsBitSet = ImmutableBitSet.range(0, nSysFields + nFieldsLeft + nFieldsRight);
exprFields = Maps.newHashMap();
allExprsDigests = new HashSet<String>();
if (lPreds == null) {
leftChildPredicates = null;
} else {
Mappings.TargetMapping leftMapping =
Mappings.createShiftMapping(nSysFields + nFieldsLeft, nSysFields, 0, nFieldsLeft);
leftChildPredicates =
lPreds.accept(new RexPermuteInputsShuttle(leftMapping, joinRel.getInput(0)));
for (RexNode r : RelOptUtil.conjunctions(leftChildPredicates)) {
exprFields.put(r.toString(), RelOptUtil.InputFinder.bits(r));
allExprsDigests.add(r.toString());
}
}
if (rPreds == null) {
rightChildPredicates = null;
} else {
Mappings.TargetMapping rightMapping =
Mappings.createShiftMapping(
nSysFields + nFieldsLeft + nFieldsRight, nSysFields + nFieldsLeft, 0, nFieldsRight);
rightChildPredicates =
rPreds.accept(new RexPermuteInputsShuttle(rightMapping, joinRel.getInput(1)));
for (RexNode r : RelOptUtil.conjunctions(rightChildPredicates)) {
exprFields.put(r.toString(), RelOptUtil.InputFinder.bits(r));
allExprsDigests.add(r.toString());
}
}
equivalence = Maps.newTreeMap();
equalityPredicates = new HashSet<String>();
for (int i = 0; i < nSysFields + nFieldsLeft + nFieldsRight; i++) {
equivalence.put(i, BitSets.of(i));
}
// Only process equivalences found in the join conditions. Processing
// Equivalences from the left or right side infer predicates that are
// already present in the Tree below the join.
RexBuilder rexBuilder = joinRel.getCluster().getRexBuilder();
List<RexNode> exprs =
RelOptUtil.conjunctions(compose(rexBuilder, ImmutableList.of(joinRel.getCondition())));
final EquivalenceFinder eF = new EquivalenceFinder();
new ArrayList<Void>(
Lists.transform(
exprs,
new Function<RexNode, Void>() {
public Void apply(RexNode input) {
return input.accept(eF);
}
}));
equivalence = BitSets.closure(equivalence);
}
/** Analyzes a component of a tuple in a GROUPING SETS clause. */
private static ImmutableBitSet analyzeGroupExpr(
SqlValidatorScope scope,
List<SqlNode> groupExprs,
Map<Integer, Integer> groupExprProjection,
SqlNode groupExpr) {
final SqlNode expandedGroupExpr = scope.getValidator().expand(groupExpr, scope);
switch (expandedGroupExpr.getKind()) {
case ROW:
return ImmutableBitSet.union(
analyzeGroupTuple(
scope,
groupExprs,
groupExprProjection,
((SqlCall) expandedGroupExpr).getOperandList()));
case OTHER:
if (expandedGroupExpr instanceof SqlNodeList
&& ((SqlNodeList) expandedGroupExpr).size() == 0) {
return ImmutableBitSet.of();
}
}
final int ref = lookupGroupExpr(groupExprs, groupExpr);
if (expandedGroupExpr instanceof SqlIdentifier) {
// SQL 2003 does not allow expressions of column references
SqlIdentifier expr = (SqlIdentifier) expandedGroupExpr;
// column references should be fully qualified.
assert expr.names.size() == 2;
String originalRelName = expr.names.get(0);
String originalFieldName = expr.names.get(1);
final SqlValidatorScope.ResolvedImpl resolved = new SqlValidatorScope.ResolvedImpl();
scope.resolve(ImmutableList.of(originalRelName), false, resolved);
assert resolved.count() == 1;
final SqlValidatorScope.Resolve resolve = resolved.only();
final SqlValidatorNamespace foundNs = resolve.namespace;
final int childNamespaceIndex = resolve.path.steps().get(0).i;
int namespaceOffset = 0;
if (childNamespaceIndex > 0) {
// If not the first child, need to figure out the width of
// output types from all the preceding namespaces
final SqlValidatorScope ancestorScope = resolve.scope;
assert ancestorScope instanceof ListScope;
List<SqlValidatorNamespace> children = ((ListScope) ancestorScope).getChildren();
for (int j = 0; j < childNamespaceIndex; j++) {
namespaceOffset += children.get(j).getRowType().getFieldCount();
}
}
RelDataTypeField field =
scope.getValidator().getCatalogReader().field(foundNs.getRowType(), originalFieldName);
int origPos = namespaceOffset + field.getIndex();
groupExprProjection.put(origPos, ref);
}
return ImmutableBitSet.of(ref);
}
private static void splitJoinCondition(
List<RelDataTypeField> sysFieldList,
List<RelNode> inputs,
RexNode condition,
List<List<RexNode>> joinKeys,
List<Integer> filterNulls,
List<SqlOperator> rangeOp,
List<RexNode> nonEquiList)
throws CalciteSemanticException {
final int sysFieldCount = sysFieldList.size();
final RelOptCluster cluster = inputs.get(0).getCluster();
final RexBuilder rexBuilder = cluster.getRexBuilder();
if (condition instanceof RexCall) {
RexCall call = (RexCall) condition;
if (call.getOperator() == SqlStdOperatorTable.AND) {
for (RexNode operand : call.getOperands()) {
splitJoinCondition(
sysFieldList, inputs, operand, joinKeys, filterNulls, rangeOp, nonEquiList);
}
return;
}
RexNode leftKey = null;
RexNode rightKey = null;
int leftInput = 0;
int rightInput = 0;
List<RelDataTypeField> leftFields = null;
List<RelDataTypeField> rightFields = null;
boolean reverse = false;
SqlKind kind = call.getKind();
// Only consider range operators if we haven't already seen one
if ((kind == SqlKind.EQUALS)
|| (filterNulls != null && kind == SqlKind.IS_NOT_DISTINCT_FROM)
|| (rangeOp != null
&& rangeOp.isEmpty()
&& (kind == SqlKind.GREATER_THAN
|| kind == SqlKind.GREATER_THAN_OR_EQUAL
|| kind == SqlKind.LESS_THAN
|| kind == SqlKind.LESS_THAN_OR_EQUAL))) {
final List<RexNode> operands = call.getOperands();
RexNode op0 = operands.get(0);
RexNode op1 = operands.get(1);
final ImmutableBitSet projRefs0 = InputFinder.bits(op0);
final ImmutableBitSet projRefs1 = InputFinder.bits(op1);
final ImmutableBitSet[] inputsRange = new ImmutableBitSet[inputs.size()];
int totalFieldCount = 0;
for (int i = 0; i < inputs.size(); i++) {
final int firstField = totalFieldCount + sysFieldCount;
totalFieldCount = firstField + inputs.get(i).getRowType().getFieldCount();
inputsRange[i] = ImmutableBitSet.range(firstField, totalFieldCount);
}
boolean foundBothInputs = false;
for (int i = 0; i < inputs.size() && !foundBothInputs; i++) {
if (projRefs0.intersects(inputsRange[i])
&& projRefs0.union(inputsRange[i]).equals(inputsRange[i])) {
if (leftKey == null) {
leftKey = op0;
leftInput = i;
leftFields = inputs.get(leftInput).getRowType().getFieldList();
} else {
rightKey = op0;
rightInput = i;
rightFields = inputs.get(rightInput).getRowType().getFieldList();
reverse = true;
foundBothInputs = true;
}
} else if (projRefs1.intersects(inputsRange[i])
&& projRefs1.union(inputsRange[i]).equals(inputsRange[i])) {
if (leftKey == null) {
leftKey = op1;
leftInput = i;
leftFields = inputs.get(leftInput).getRowType().getFieldList();
} else {
rightKey = op1;
rightInput = i;
rightFields = inputs.get(rightInput).getRowType().getFieldList();
foundBothInputs = true;
}
}
}
if ((leftKey != null) && (rightKey != null)) {
// adjustment array
int[] adjustments = new int[totalFieldCount];
for (int i = 0; i < inputs.size(); i++) {
final int adjustment = inputsRange[i].nextSetBit(0);
for (int j = adjustment; j < inputsRange[i].length(); j++) {
adjustments[j] = -adjustment;
}
}
// replace right Key input ref
rightKey =
rightKey.accept(
new RelOptUtil.RexInputConverter(
rexBuilder, rightFields, rightFields, adjustments));
// left key only needs to be adjusted if there are system
// fields, but do it for uniformity
leftKey =
leftKey.accept(
new RelOptUtil.RexInputConverter(
rexBuilder, leftFields, leftFields, adjustments));
RelDataType leftKeyType = leftKey.getType();
RelDataType rightKeyType = rightKey.getType();
if (leftKeyType != rightKeyType) {
// perform casting using Hive rules
TypeInfo rType = TypeConverter.convert(rightKeyType);
TypeInfo lType = TypeConverter.convert(leftKeyType);
TypeInfo tgtType = FunctionRegistry.getCommonClassForComparison(lType, rType);
if (tgtType == null) {
throw new CalciteSemanticException(
"Cannot find common type for join keys "
+ leftKey
+ " (type "
+ leftKeyType
+ ") and "
+ rightKey
+ " (type "
+ rightKeyType
+ ")");
}
RelDataType targetKeyType = TypeConverter.convert(tgtType, rexBuilder.getTypeFactory());
if (leftKeyType != targetKeyType
&& TypeInfoUtils.isConversionRequiredForComparison(tgtType, lType)) {
leftKey = rexBuilder.makeCast(targetKeyType, leftKey);
}
if (rightKeyType != targetKeyType
&& TypeInfoUtils.isConversionRequiredForComparison(tgtType, rType)) {
rightKey = rexBuilder.makeCast(targetKeyType, rightKey);
}
}
}
}
if ((leftKey != null) && (rightKey != null)) {
// found suitable join keys
// add them to key list, ensuring that if there is a
// non-equi join predicate, it appears at the end of the
// key list; also mark the null filtering property
addJoinKey(joinKeys.get(leftInput), leftKey, (rangeOp != null) && !rangeOp.isEmpty());
addJoinKey(joinKeys.get(rightInput), rightKey, (rangeOp != null) && !rangeOp.isEmpty());
if (filterNulls != null && kind == SqlKind.EQUALS) {
// nulls are considered not matching for equality comparison
// add the position of the most recently inserted key
filterNulls.add(joinKeys.get(leftInput).size() - 1);
}
if (rangeOp != null && kind != SqlKind.EQUALS && kind != SqlKind.IS_DISTINCT_FROM) {
if (reverse) {
kind = reverse(kind);
}
rangeOp.add(op(kind, call.getOperator()));
}
return;
} // else fall through and add this condition as nonEqui condition
}
// The operator is not of RexCall type
// So we fail. Fall through.
// Add this condition to the list of non-equi-join conditions.
nonEquiList.add(condition);
}
/**
* Variant of {@link #trimFields(RelNode, ImmutableBitSet, Set)} for {@link
* org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveMultiJoin}.
*/
public TrimResult trimFields(
HiveMultiJoin join, ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields) {
final int fieldCount = join.getRowType().getFieldCount();
final RexNode conditionExpr = join.getCondition();
// Add in fields used in the condition.
final Set<RelDataTypeField> combinedInputExtraFields =
new LinkedHashSet<RelDataTypeField>(extraFields);
RelOptUtil.InputFinder inputFinder = new RelOptUtil.InputFinder(combinedInputExtraFields);
inputFinder.inputBitSet.addAll(fieldsUsed);
conditionExpr.accept(inputFinder);
final ImmutableBitSet fieldsUsedPlus = inputFinder.inputBitSet.build();
int inputStartPos = 0;
int changeCount = 0;
int newFieldCount = 0;
List<RelNode> newInputs = new ArrayList<RelNode>();
List<Mapping> inputMappings = new ArrayList<Mapping>();
for (RelNode input : join.getInputs()) {
final RelDataType inputRowType = input.getRowType();
final int inputFieldCount = inputRowType.getFieldCount();
// Compute required mapping.
ImmutableBitSet.Builder inputFieldsUsed = ImmutableBitSet.builder();
for (int bit : fieldsUsedPlus) {
if (bit >= inputStartPos && bit < inputStartPos + inputFieldCount) {
inputFieldsUsed.set(bit - inputStartPos);
}
}
Set<RelDataTypeField> inputExtraFields = Collections.<RelDataTypeField>emptySet();
TrimResult trimResult = trimChild(join, input, inputFieldsUsed.build(), 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.
inputStartPos += inputFieldCount;
newFieldCount += inputMapping.getTargetCount();
}
Mapping mapping = Mappings.create(MappingType.INVERSE_SURJECTION, fieldCount, newFieldCount);
int offset = 0;
int newOffset = 0;
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();
}
if (changeCount == 0 && mapping.isIdentity()) {
return new TrimResult(join, Mappings.createIdentity(fieldCount));
}
// Build new join.
final RexVisitor<RexNode> shuttle =
new RexPermuteInputsShuttle(mapping, newInputs.toArray(new RelNode[newInputs.size()]));
RexNode newConditionExpr = conditionExpr.accept(shuttle);
final RelDataType newRowType =
RelOptUtil.permute(join.getCluster().getTypeFactory(), join.getRowType(), mapping);
final RelNode newJoin =
new HiveMultiJoin(
join.getCluster(),
newInputs,
newConditionExpr,
newRowType,
join.getJoinInputs(),
join.getJoinTypes(),
join.getJoinFilters());
return new TrimResult(newJoin, mapping);
}
// We create the join predicate info object. The object contains the join condition,
// split accordingly. If the join condition is not part of the equi-join predicate,
// the returned object will be typed as SQLKind.OTHER.
private static JoinLeafPredicateInfo constructJoinLeafPredicateInfo(
List<RelNode> inputs, List<RelDataTypeField> systemFieldList, RexNode pe)
throws CalciteSemanticException {
JoinLeafPredicateInfo jlpi = null;
List<Integer> filterNulls = new ArrayList<Integer>();
List<List<RexNode>> joinExprs = new ArrayList<List<RexNode>>();
for (int i = 0; i < inputs.size(); i++) {
joinExprs.add(new ArrayList<RexNode>());
}
// 1. Split leaf join predicate to expressions from left, right
RexNode otherConditions =
HiveRelOptUtil.splitHiveJoinCondition(
systemFieldList, inputs, pe, joinExprs, filterNulls, null);
if (otherConditions.isAlwaysTrue()) {
// 2. Collect child projection indexes used
List<Set<Integer>> projsJoinKeysInChildSchema = new ArrayList<Set<Integer>>();
for (int i = 0; i < inputs.size(); i++) {
ImmutableSet.Builder<Integer> projsFromInputJoinKeysInChildSchema =
ImmutableSet.builder();
InputReferencedVisitor irvLeft = new InputReferencedVisitor();
irvLeft.apply(joinExprs.get(i));
projsFromInputJoinKeysInChildSchema.addAll(irvLeft.inputPosReferenced);
projsJoinKeysInChildSchema.add(projsFromInputJoinKeysInChildSchema.build());
}
// 3. Translate projection indexes to join schema, by adding offset.
List<Set<Integer>> projsJoinKeysInJoinSchema = new ArrayList<Set<Integer>>();
// The offset of the first input does not need to change.
projsJoinKeysInJoinSchema.add(projsJoinKeysInChildSchema.get(0));
for (int i = 1; i < inputs.size(); i++) {
int offSet = inputs.get(i - 1).getRowType().getFieldCount();
ImmutableSet.Builder<Integer> projsFromInputJoinKeysInJoinSchema = ImmutableSet.builder();
for (Integer indx : projsJoinKeysInChildSchema.get(i)) {
projsFromInputJoinKeysInJoinSchema.add(indx + offSet);
}
projsJoinKeysInJoinSchema.add(projsFromInputJoinKeysInJoinSchema.build());
}
// 4. Construct JoinLeafPredicateInfo
jlpi =
new JoinLeafPredicateInfo(
pe.getKind(), joinExprs, projsJoinKeysInChildSchema, projsJoinKeysInJoinSchema);
} else {
// 2. Construct JoinLeafPredicateInfo
ImmutableBitSet refCols = InputFinder.bits(pe);
int count = 0;
for (int i = 0; i < inputs.size(); i++) {
final int length = inputs.get(i).getRowType().getFieldCount();
ImmutableBitSet inputRange = ImmutableBitSet.range(count, count + length);
if (inputRange.contains(refCols)) {
joinExprs.get(i).add(pe);
}
count += length;
}
jlpi =
new JoinLeafPredicateInfo(
SqlKind.OTHER,
joinExprs,
new ArrayList<Set<Integer>>(),
new ArrayList<Set<Integer>>());
}
return jlpi;
}
