@Override public boolean isEmpty() { return values.getPositionCount() == 0; }
@Override public boolean isEmpty() { return keyBlockBuilder.getPositionCount() == 0; }
@Override public int getEntryCount() { return keyBlockBuilder.getPositionCount(); }
@Override public void forEach(MultimapAggregationStateConsumer consumer) { for (int i = 0; i < keyBlockBuilder.getPositionCount(); i++) { consumer.accept(keyBlockBuilder, valueBlockBuilder, i); } }
@Override public void forEach(ArrayAggregationStateConsumer consumer) { if (blockBuilder == null) { return; } for (int i = 0; i < blockBuilder.getPositionCount(); i++) { consumer.accept(blockBuilder, i); } }
@Override public SingleMapBlockWriter beginBlockEntry() { if (currentEntryOpened) { throw new IllegalStateException("Expected current entry to be closed but was opened"); } currentEntryOpened = true; return new SingleMapBlockWriter(keyBlockBuilder.getPositionCount() * 2, keyBlockBuilder, valueBlockBuilder); }
@Override public boolean isEmpty() { if (blockBuilder == null) { return true; } verify(blockBuilder.getPositionCount() != 0); return false; }
@Override public SingleRowBlockWriter beginBlockEntry() { if (currentEntryOpened) { throw new IllegalStateException("Expected current entry to be closed but was opened"); } currentEntryOpened = true; return new SingleRowBlockWriter(fieldBlockBuilders[0].getPositionCount(), fieldBlockBuilders); }
private void addNewGroup(int hashPosition, int position, Block block, long count) { hashPositions.set(hashPosition, values.getPositionCount()); counts.set(values.getPositionCount(), count); type.appendTo(block, position, values); // increase capacity, if necessary if (values.getPositionCount() >= maxFill) { rehash(); } }
private void addKey(Block key, int position) { checkArgument(position >= 0, "position is negative"); keyType.appendTo(key, position, keyBlockBuilder); int hashPosition = getHashPositionOfKey(key, position); if (keyPositionByHash[hashPosition] == EMPTY_SLOT) { keyPositionByHash[hashPosition] = keyBlockBuilder.getPositionCount() - 1; if (keyBlockBuilder.getPositionCount() >= maxFill) { rehash(); } } }
@Override public void readAllValues(HistogramValueReader reader) { for (int i = 0; i < values.getPositionCount(); i++) { long count = counts.get(i); if (count > 0) { reader.read(values, i, count); } } }
@Override public int getEntryCount() { return keyBlockBuilders.get(getGroupId()).getPositionCount(); } }
@Override public long getSizeInBytes() { return keyBlockBuilder.getSizeInBytes() + valueBlockBuilder.getSizeInBytes() + (Integer.BYTES + Byte.BYTES) * (long) positionCount + Integer.BYTES * HASH_MULTIPLIER * (long) keyBlockBuilder.getPositionCount(); }
@Override public boolean isEmpty() { BlockBuilder blockBuilder = blockBuilders.get(getGroupId()); verify(blockBuilder.getPositionCount() != 0); return false; } }
@Override public void forEach(ArrayAggregationStateConsumer consumer) { BlockBuilder blockBuilder = blockBuilders.get(getGroupId()); if (blockBuilder == null) { return; } for (int i = 0; i < blockBuilder.getPositionCount(); i++) { consumer.accept(blockBuilder, i); } }
public void serialize(BlockBuilder out) { BlockBuilder mapBlockBuilder = out.beginBlockEntry(); for (int i = 0; i < keyBlockBuilder.getPositionCount(); i++) { keyType.appendTo(keyBlockBuilder, i, mapBlockBuilder); valueType.appendTo(valueBlockBuilder, i, mapBlockBuilder); } out.closeEntry(); }
private Block computeResultBlock(Type type, Block block, int arrayLength) { if (pageBuilder.isFull()) { pageBuilder.reset(); } BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(0); for (int i = 0; i < arrayLength; ++i) { type.appendTo(block, positions.get(i), blockBuilder); } pageBuilder.declarePositions(arrayLength); return blockBuilder.getRegion(blockBuilder.getPositionCount() - arrayLength, arrayLength); }
@Override public void forEach(MultimapAggregationStateConsumer consumer) { BlockBuilder keyBlockBuilder = keyBlockBuilders.get(getGroupId()); BlockBuilder valueBlockBuilder = valueBlockBuilders.get(getGroupId()); if (keyBlockBuilder == null) { return; } for (int i = 0; i < keyBlockBuilder.getPositionCount(); i++) { consumer.accept(keyBlockBuilder, valueBlockBuilder, i); } }
private void rehash(int size) { int newHashSize = arraySize(size + 1, FILL_RATIO); hashMask = newHashSize - 1; maxFill = calculateMaxFill(newHashSize); blockPositionByHash.ensureCapacity(newHashSize); blockPositionByHash.fill(EMPTY_SLOT); // the first element of elementBlock is always null for (int blockPosition = 1; blockPosition < elementBlock.getPositionCount(); blockPosition++) { blockPositionByHash.set(getHashPositionOfElement(elementBlock, blockPosition), blockPosition); } }
private void testIsFull(PageBuilderStatus pageBuilderStatus) { BlockBuilder blockBuilder = new VariableWidthBlockBuilder(pageBuilderStatus.createBlockBuilderStatus(), 32, 1024); assertTrue(pageBuilderStatus.isEmpty()); while (!pageBuilderStatus.isFull()) { VARCHAR.writeSlice(blockBuilder, Slices.allocate(VARCHAR_VALUE_SIZE)); } assertEquals(blockBuilder.getPositionCount(), EXPECTED_ENTRY_COUNT); assertEquals(pageBuilderStatus.isFull(), true); } }