/** Computes the closure of a set of columns according to a given list of * constraints. Each 'x = y' constraint causes bit y to be set if bit x is * set, and vice versa. */ private static ImmutableBitSet keyColumns(ImmutableBitSet aggregateColumns, ImmutableList<RexNode> predicates) { SortedMap<Integer, BitSet> equivalence = new TreeMap<>(); for (RexNode predicate : predicates) { populateEquivalences(equivalence, predicate); } ImmutableBitSet keyColumns = aggregateColumns; for (Integer aggregateColumn : aggregateColumns) { final BitSet bitSet = equivalence.get(aggregateColumn); if (bitSet != null) { keyColumns = keyColumns.union(bitSet); } } return keyColumns; }
/** Computes the closure of a set of columns according to a given list of * constraints. Each 'x = y' constraint causes bit y to be set if bit x is * set, and vice versa. */ private static ImmutableBitSet keyColumns(ImmutableBitSet aggregateColumns, ImmutableList<RexNode> predicates) { SortedMap<Integer, BitSet> equivalence = new TreeMap<>(); for (RexNode pred : predicates) { populateEquivalences(equivalence, pred); } ImmutableBitSet keyColumns = aggregateColumns; for (Integer aggregateColumn : aggregateColumns) { final BitSet bitSet = equivalence.get(aggregateColumn); if (bitSet != null) { keyColumns = keyColumns.union(bitSet); } } return keyColumns; }
private boolean filterRefersToBothSidesOfJoin(RexNode filter, Join j) { boolean refersToBothSides = false; int joinNoOfProjects = j.getRowType().getFieldCount(); ImmutableBitSet filterProjs = ImmutableBitSet.FROM_BIT_SET.apply(new BitSet(joinNoOfProjects)); ImmutableBitSet allLeftProjs = filterProjs.union(ImmutableBitSet.range(0, j.getInput(0) .getRowType().getFieldCount())); ImmutableBitSet allRightProjs = filterProjs.union(ImmutableBitSet.range(j.getInput(0) .getRowType().getFieldCount(), joinNoOfProjects)); filterProjs = filterProjs.union(InputFinder.bits(filter)); if (allLeftProjs.intersects(filterProjs) && allRightProjs.intersects(filterProjs)) refersToBothSides = true; return refersToBothSides; } }
private boolean filterRefersToBothSidesOfJoin(RexNode filter, Join j) { boolean refersToBothSides = false; int joinNoOfProjects = j.getRowType().getFieldCount(); ImmutableBitSet filterProjs = ImmutableBitSet.FROM_BIT_SET.apply(new BitSet(joinNoOfProjects)); ImmutableBitSet allLeftProjs = filterProjs.union(ImmutableBitSet.range(0, j.getInput(0) .getRowType().getFieldCount())); ImmutableBitSet allRightProjs = filterProjs.union(ImmutableBitSet.range(j.getInput(0) .getRowType().getFieldCount(), joinNoOfProjects)); filterProjs = filterProjs.union(InputFinder.bits(filter)); if (allLeftProjs.intersects(filterProjs) && allRightProjs.intersects(filterProjs)) refersToBothSides = true; return refersToBothSides; } }
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; && projRefs1.union(inputsRange[i]).equals(inputsRange[i])) { if (leftKey == null) { leftKey = op1;
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; && projRefs1.union(inputsRange[i]).equals(inputsRange[i])) { if (leftKey == null) { leftKey = op1;
for (ImmutableBitSet colMaskRight : rightSet) { for (ImmutableBitSet colMaskLeft : leftSet) { retSet.add(colMaskLeft.union(colMaskRight));
keyColumns.contains(joinColumns); final ImmutableBitSet belowAggregateColumns = aggregateColumns.union(joinColumns);
keyColumns.contains(joinColumns); final ImmutableBitSet belowAggregateColumns = aggregateColumns.union(joinColumns);
fieldsUsed.union(updatedGroupFields);
/** Returns a bit set the same as this but with a given bit set. */ public ImmutableBitSet set(int i) { return union(ImmutableBitSet.of(i)); }
/** Returns a bit set the same as this but with a given bit set. */ public ImmutableBitSet set(int i) { return union(ImmutableBitSet.of(i)); }
/** Computes the closure of a set of columns according to a given list of * constraints. Each 'x = y' constraint causes bit y to be set if bit x is * set, and vice versa. */ private static ImmutableBitSet keyColumns(ImmutableBitSet aggregateColumns, ImmutableList<RexNode> predicates) { SortedMap<Integer, BitSet> equivalence = new TreeMap<>(); for (RexNode predicate : predicates) { populateEquivalences(equivalence, predicate); } ImmutableBitSet keyColumns = aggregateColumns; for (Integer aggregateColumn : aggregateColumns) { final BitSet bitSet = equivalence.get(aggregateColumn); if (bitSet != null) { keyColumns = keyColumns.union(bitSet); } } return keyColumns; }
/** Computes the closure of a set of columns according to a given list of * constraints. Each 'x = y' constraint causes bit y to be set if bit x is * set, and vice versa. */ private static ImmutableBitSet keyColumns(ImmutableBitSet aggregateColumns, ImmutableList<RexNode> predicates) { SortedMap<Integer, BitSet> equivalence = new TreeMap<>(); for (RexNode predicate : predicates) { populateEquivalences(equivalence, predicate); } ImmutableBitSet keyColumns = aggregateColumns; for (Integer aggregateColumn : aggregateColumns) { final BitSet bitSet = equivalence.get(aggregateColumn); if (bitSet != null) { keyColumns = keyColumns.union(bitSet); } } return keyColumns; }
private ImmutableBitSet computeClosure(int pos) { ImmutableBitSet o = closure.get(pos); if (o != null) { return o; } final ImmutableBitSet b = equivalence.get(pos); o = b; int i = b.nextSetBit(pos + 1); for (; i >= 0; i = b.nextSetBit(i + 1)) { o = o.union(computeClosure(i)); } closure.put(pos, o); i = o.nextSetBit(pos + 1); for (; i >= 0; i = b.nextSetBit(i + 1)) { closure.put(i, o); } return o; } }
private ImmutableBitSet computeClosure(int pos) { ImmutableBitSet o = closure.get(pos); if (o != null) { return o; } final ImmutableBitSet b = equivalence.get(pos); o = b; int i = b.nextSetBit(pos + 1); for (; i >= 0; i = b.nextSetBit(i + 1)) { o = o.union(computeClosure(i)); } closure.put(pos, o); i = o.nextSetBit(pos + 1); for (; i >= 0; i = b.nextSetBit(i + 1)) { closure.put(i, o); } return o; } }
private boolean filterRefersToBothSidesOfJoin(RexNode filter, Join j) { boolean refersToBothSides = false; int joinNoOfProjects = j.getRowType().getFieldCount(); ImmutableBitSet filterProjs = ImmutableBitSet.FROM_BIT_SET.apply(new BitSet(joinNoOfProjects)); ImmutableBitSet allLeftProjs = filterProjs.union(ImmutableBitSet.range(0, j.getInput(0) .getRowType().getFieldCount())); ImmutableBitSet allRightProjs = filterProjs.union(ImmutableBitSet.range(j.getInput(0) .getRowType().getFieldCount(), joinNoOfProjects)); filterProjs = filterProjs.union(InputFinder.bits(filter)); if (allLeftProjs.intersects(filterProjs) && allRightProjs.intersects(filterProjs)) refersToBothSides = true; return refersToBothSides; } }
public AggregateNode(Compiler compiler, Aggregate rel) { super(compiler, rel); this.dataContext = compiler.getDataContext(); ImmutableBitSet union = ImmutableBitSet.of(); if (rel.getGroupSets() != null) { for (ImmutableBitSet group : rel.getGroupSets()) { union = union.union(group); groups.add(new Grouping(group)); } } this.unionGroups = union; this.outputRowLength = unionGroups.cardinality() + (rel.indicator ? unionGroups.cardinality() : 0) + rel.getAggCallList().size(); ImmutableList.Builder<AccumulatorFactory> builder = ImmutableList.builder(); for (AggregateCall aggregateCall : rel.getAggCallList()) { builder.add(getAccumulator(aggregateCall, false)); } accumulatorFactories = builder.build(); }
public Double getDistinctRowCount(Aggregate rel, RelMetadataQuery mq, ImmutableBitSet groupKey, RexNode predicate) { if (predicate == null || predicate.isAlwaysTrue()) { if (groupKey.isEmpty()) { return 1D; } } final ImmutableBitSet allGroupSet = rel.getGroupSet().union(groupKey); return getDistinctRowCountFromEstimateRowCount(rel.getInput(), mq, allGroupSet, predicate); }
/** * Tests the method * {@link org.apache.calcite.util.ImmutableBitSet#union(ImmutableBitSet)}. */ @Test public void testUnion() { assertThat(ImmutableBitSet.of(1).union(ImmutableBitSet.of(3)).toString(), equalTo("{1, 3}")); assertThat(ImmutableBitSet.of(1).union(ImmutableBitSet.of(3, 100)) .toString(), equalTo("{1, 3, 100}")); ImmutableBitSet x = ImmutableBitSet.of(1) .rebuild() .addAll(ImmutableBitSet.of(2)) .addAll(ImmutableBitSet.of()) .addAll(ImmutableBitSet.of(3)) .build(); assertThat(x.toString(), equalTo("{1, 2, 3}")); }