public static ImmutableBitSet valueOf(int... values) { BitSet set = new BitSet(); for (int i : values) set.set(i); return new ImmutableBitSet(set); }
ByPassChecker(int aggregateBufferSizeLimit) { this.aggregateBufferSizeLimit = aggregateBufferSizeLimit; //init groupOffsetsInLastKey int p = 0; int idx = 0; this.groupOffsetsInLastKey = new int[groupBy.trueBitCount()]; for (int i = 0; i < dimensions.trueBitCount(); i++) { int c = dimensions.trueBitAt(i); int l = info.codeSystem.maxCodeLength(c); if (groupBy.get(c)) groupOffsetsInLastKey[idx++] = p; p += l; } }
public ImmutableBitSet set(int bitIndex) { return set(bitIndex, true); }
public ImmutableBitSet selectColumns(ImmutableBitSet selectedColBlocks) { ImmutableBitSet result = ImmutableBitSet.EMPTY; for (int i = 0; i < selectedColBlocks.trueBitCount(); i++) { result = result.or(colBlocks[selectedColBlocks.trueBitAt(i)]); } return result; }
public ImmutableBitSet or(ImmutableBitSet another) { BitSet mutable = mutable(); mutable.or(another.set); return new ImmutableBitSet(mutable); }
public int getMaxLength() { int ret = 0; for (int i = 0; i < colAll.trueBitCount(); i++) { ret += codeSystem.maxCodeLength(colAll.trueBitAt(i)); } return ret; }
private static ImmutableBitSet setOf(int... values) { return ImmutableBitSet.valueOf(values); } }
private void validateColumnBlocks() { colAll = new ImmutableBitSet(0, nColumns); colBlocks[1] = colAll.andNot(primaryKey); colBlocksAll = new ImmutableBitSet(0, colBlocks.length); if (colBlocks[i].intersects(colBlocks[j])) throw new IllegalStateException(); merge = merge.or(colBlocks[i]); if (!merge.equals(colAll)) throw new IllegalStateException(); if (!primaryKey.equals(colBlocks[0])) throw new IllegalStateException(); while (it.hasNext()) { ImmutableBitSet cb = it.next(); if (cb.isEmpty()) it.remove();
@Override public MeasureAggregator<?>[] newMetricsAggregators(ImmutableBitSet columns, String[] aggrFunctions) { assert columns.trueBitCount() == aggrFunctions.length; MeasureAggregator<?>[] result = new MeasureAggregator[aggrFunctions.length]; for (int i = 0; i < result.length; i++) { int col = columns.trueBitAt(i); result[i] = MeasureAggregator.create(aggrFunctions[i], info.getColumnType(col)); } // deal with holistic distinct count if (dependentMetricsMap != null) { for (Map.Entry<Integer, Integer> childEntry : dependentMetricsMap.entrySet()) { if (columns.get(childEntry.getKey())) { Integer parent = childEntry.getValue(); if (columns.get(parent) == false) throw new IllegalStateException(); int childIdx = columns.trueBitIndexOf(childEntry.getKey()); int parentIdx = columns.trueBitIndexOf(parent); result[childIdx].setDependentAggregator(result[parentIdx]); } } } return result; }
@Test public void testImmutableBitSet() { ImmutableBitSet x = new ImmutableBitSet(10, 100); ImmutableBitSet.serializer.serialize(x, buffer); buffer.flip(); ImmutableBitSet sx = ImmutableBitSet.serializer.deserialize(buffer); for (int i = 0; i < 10; i++) { Assert.assertFalse(sx.get(i)); } for (int i = 10; i < 100; i++) { Assert.assertTrue(sx.get(i)); } }
protected GTScanRange newScanRange(Collection<ColumnRange> andDimRanges) { GTRecord pkStart = new GTRecord(gtInfo); GTRecord pkEnd = new GTRecord(gtInfo); Map<Integer, Set<ByteArray>> fuzzyValues = Maps.newHashMap(); for (ColumnRange range : andDimRanges) { int col = range.column.getColumnDesc().getZeroBasedIndex(); if (!gtInfo.getPrimaryKey().get(col)) continue; pkStart.set(col, range.begin); pkEnd.set(col, range.end); if (range.valueSet != null && !range.valueSet.isEmpty()) { fuzzyValues.put(col, range.valueSet); } } List<GTRecord> fuzzyKeys = buildFuzzyKeys(fuzzyValues); return new GTScanRange(pkStart, pkEnd, fuzzyKeys); }
public ImmutableBitSet selectColumnBlocks(ImmutableBitSet columns) { if (columns == null) columns = colAll; BitSet result = new BitSet(); for (int i = 0; i < colBlocks.length; i++) { ImmutableBitSet cb = colBlocks[i]; if (cb.intersects(columns)) { result.set(i); } } return new ImmutableBitSet(result); }
/** * for each selected hbase column, it might contain values of multiple GT columns. * The mapping should be passed down to storage */ protected List<List<Integer>> getHBaseColumnsGTMapping(ImmutableBitSet selectedColBlocks) { List<List<Integer>> ret = Lists.newArrayList(); int colBlkIndex = 1; int metricOffset = fullGTInfo.getPrimaryKey().trueBitCount(); HBaseMappingDesc hbaseMapping = cubeSeg.getCubeDesc().getHbaseMapping(); for (HBaseColumnFamilyDesc familyDesc : hbaseMapping.getColumnFamily()) { for (HBaseColumnDesc hbaseColDesc : familyDesc.getColumns()) { if (selectedColBlocks.get(colBlkIndex)) { int[] metricIndexes = hbaseColDesc.getMeasureIndex(); Integer[] gtIndexes = new Integer[metricIndexes.length]; for (int i = 0; i < gtIndexes.length; i++) { gtIndexes[i] = metricIndexes[i] + metricOffset; } ret.add(Arrays.asList(gtIndexes)); } colBlkIndex++; } } Preconditions.checkState(selectedColBlocks.trueBitCount() == ret.size() + 1); return ret; }
/** decode and return the values of this record */ public Object[] getValues(ImmutableBitSet selectedCols, Object[] result) { assert selectedCols.cardinality() == result.length; for (int i = 0; i < selectedCols.trueBitCount(); i++) { result[i] = decodeValue(selectedCols.trueBitAt(i)); } return result; }
private void enqueueFromDump(int index) { if (dumpIterators.get(index) != null && dumpIterators.get(index).hasNext()) { Pair<byte[], byte[]> pair = dumpIterators.get(index).next(); minHeap.offer(new SimpleEntry(pair.getFirst(), index)); Object[] metricValues = new Object[metrics.trueBitCount()]; measureCodec.decode(ByteBuffer.wrap(pair.getSecond()), metricValues); dumpCurrentValues.set(index, metricValues); } }
@SuppressWarnings("unchecked") protected void aggregate(MeasureAggregator[] aggregators, GTRecord record) { for (int i = 0; i < aggregators.length; i++) { int c = metrics.trueBitAt(i); Object metric = codeSystem.decodeColumnValue(c, record.cols[c].asBuffer()); aggregators[i].aggregate(metric); } }
public int sizeOf(ImmutableBitSet selectedCols) { int size = 0; for (int i = 0; i < selectedCols.trueBitCount(); i++) { int c = selectedCols.trueBitAt(i); size += cols[c].length(); } return size; }
public void testAggregate5() throws IOException { testAggregate(ImmutableBitSet.valueOf(0, 1, 2, 3, 4)); }
@Override public MeasureAggregator<?>[] newMetricsAggregators(ImmutableBitSet columns, String[] aggrFunctions) { assert columns.trueBitCount() == aggrFunctions.length; MeasureAggregator<?>[] result = new MeasureAggregator[aggrFunctions.length]; for (int i = 0; i < result.length; i++) { int col = columns.trueBitAt(i); result[i] = MeasureAggregator.create(aggrFunctions[i], info.getColumnType(col)); } // deal with holistic distinct count if (dependentMetricsMap != null) { for (Map.Entry<Integer, Integer> childEntry : dependentMetricsMap.entrySet()) { if (columns.get(childEntry.getKey())) { Integer parent = childEntry.getValue(); if (columns.get(parent) == false) throw new IllegalStateException(); int childIdx = columns.trueBitIndexOf(childEntry.getKey()); int parentIdx = columns.trueBitIndexOf(parent); result[childIdx].setDependentAggregator(result[parentIdx]); } } } return result; }
public ImmutableBitSet set(int bitIndex, boolean value) { if (set.get(bitIndex) == value) { return this; } else { BitSet mutable = mutable(); mutable.set(bitIndex, value); return new ImmutableBitSet(mutable); } }