@Override public void deserialize(Block block, int index, MinMaxNState state) { Block currentBlock = (Block) serializedType.getObject(block, index); int capacity = toIntExact(BIGINT.getLong(currentBlock, 0)); Block heapBlock = arrayType.getObject(currentBlock, 1); TypedHeap heap = new TypedHeap(blockComparator, elementType, capacity); heap.addAll(heapBlock); state.setTypedHeap(heap); } }
public static void output(ArrayType outputType, MinMaxNState state, BlockBuilder out) { TypedHeap heap = state.getTypedHeap(); if (heap == null || heap.isEmpty()) { out.appendNull(); return; } Type elementType = outputType.getElementType(); BlockBuilder reversedBlockBuilder = elementType.createBlockBuilder(null, heap.getCapacity()); long startSize = heap.getEstimatedSize(); heap.popAll(reversedBlockBuilder); state.addMemoryUsage(heap.getEstimatedSize() - startSize); BlockBuilder arrayBlockBuilder = out.beginBlockEntry(); for (int i = reversedBlockBuilder.getPositionCount() - 1; i >= 0; i--) { elementType.appendTo(reversedBlockBuilder, i, arrayBlockBuilder); } out.closeEntry(); } }
public static void input(BlockComparator comparator, Type type, MinMaxNState state, Block block, long n, int blockIndex) { TypedHeap heap = state.getTypedHeap(); if (heap == null) { if (n <= 0) { throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "second argument of max_n/min_n must be positive"); } checkCondition(n <= MAX_NUMBER_OF_VALUES, INVALID_FUNCTION_ARGUMENT, "second argument of max_n/min_n must be less than or equal to %s; found %s", MAX_NUMBER_OF_VALUES, n); heap = new TypedHeap(comparator, type, toIntExact(n)); state.setTypedHeap(heap); } long startSize = heap.getEstimatedSize(); heap.add(block, blockIndex); state.addMemoryUsage(heap.getEstimatedSize() - startSize); }
public static void combine(MinMaxNState state, MinMaxNState otherState) { TypedHeap otherHeap = otherState.getTypedHeap(); if (otherHeap == null) { return; } TypedHeap heap = state.getTypedHeap(); if (heap == null) { state.setTypedHeap(otherHeap); return; } long startSize = heap.getEstimatedSize(); heap.addAll(otherHeap); state.addMemoryUsage(heap.getEstimatedSize() - startSize); }
private static void test(IntStream inputStream, BlockComparator comparator, PrimitiveIterator.OfInt outputIterator) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, INPUT_SIZE); inputStream.forEach(x -> BIGINT.writeLong(blockBuilder, x)); TypedHeap heap = new TypedHeap(comparator, BIGINT, OUTPUT_SIZE); heap.addAll(blockBuilder); BlockBuilder resultBlockBuilder = BIGINT.createBlockBuilder(null, OUTPUT_SIZE); heap.popAll(resultBlockBuilder); Block resultBlock = resultBlockBuilder.build(); assertEquals(resultBlock.getPositionCount(), OUTPUT_SIZE); for (int i = 0; i < OUTPUT_SIZE; i++) { assertEquals(BIGINT.getLong(resultBlock, i), outputIterator.nextInt()); } } }
public void add(Block block, int position) { checkArgument(!block.isNull(position)); if (positionCount == capacity) { if (comparator.compareTo(heapBlockBuilder, heapIndex[0], block, position) >= 0) { return; // and new element is not larger than heap top: do not add } heapIndex[0] = heapBlockBuilder.getPositionCount(); type.appendTo(block, position, heapBlockBuilder); siftDown(); } else { heapIndex[positionCount] = heapBlockBuilder.getPositionCount(); positionCount++; type.appendTo(block, position, heapBlockBuilder); siftUp(); } compactIfNecessary(); }
@Override public void serialize(MinMaxNState state, BlockBuilder out) { TypedHeap heap = state.getTypedHeap(); if (heap == null) { out.appendNull(); return; } BlockBuilder blockBuilder = out.beginBlockEntry(); BIGINT.writeLong(blockBuilder, heap.getCapacity()); BlockBuilder elements = blockBuilder.beginBlockEntry(); heap.writeAll(elements); blockBuilder.closeEntry(); out.closeEntry(); }
public void addAll(TypedHeap other) { for (int i = 0; i < other.positionCount; i++) { add(other.heapBlockBuilder, other.heapIndex[i]); } }
@Override public long getEstimatedSize() { long estimatedSize = INSTANCE_SIZE; if (typedHeap != null) { estimatedSize += typedHeap.getEstimatedSize(); } return estimatedSize; }
public void popAll(BlockBuilder resultBlockBuilder) { while (positionCount > 0) { pop(resultBlockBuilder); } }
public void pop(BlockBuilder resultBlockBuilder) { type.appendTo(heapBlockBuilder, heapIndex[0], resultBlockBuilder); remove(); }
private void test(IntStream inputStream, BlockComparator comparator, PrimitiveIterator.OfInt outputIterator) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), INPUT_SIZE); inputStream.forEach(x -> BIGINT.writeLong(blockBuilder, x)); TypedHeap heap = new TypedHeap(comparator, BIGINT, OUTPUT_SIZE); heap.addAll(blockBuilder); BlockBuilder resultBlockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), OUTPUT_SIZE); heap.popAll(resultBlockBuilder); Block resultBlock = resultBlockBuilder.build(); assertEquals(resultBlock.getPositionCount(), OUTPUT_SIZE); for (int i = 0; i < OUTPUT_SIZE; i++) { assertEquals(BIGINT.getLong(resultBlock, i), outputIterator.nextInt()); } } }
public static void combine(MinMaxNState state, MinMaxNState otherState) { TypedHeap otherHeap = otherState.getTypedHeap(); if (otherHeap == null) { return; } TypedHeap heap = state.getTypedHeap(); if (heap == null) { state.setTypedHeap(otherHeap); return; } long startSize = heap.getEstimatedSize(); heap.addAll(otherHeap); state.addMemoryUsage(heap.getEstimatedSize() - startSize); }
public void add(Block block, int position) { checkArgument(!block.isNull(position)); if (positionCount == capacity) { if (comparator.compareTo(heapBlockBuilder, heapIndex[0], block, position) >= 0) { return; // and new element is not larger than heap top: do not add } heapIndex[0] = heapBlockBuilder.getPositionCount(); type.appendTo(block, position, heapBlockBuilder); siftDown(); } else { heapIndex[positionCount] = heapBlockBuilder.getPositionCount(); positionCount++; type.appendTo(block, position, heapBlockBuilder); siftUp(); } compactIfNecessary(); }
@Override public void serialize(MinMaxNState state, BlockBuilder out) { TypedHeap heap = state.getTypedHeap(); if (heap == null) { out.appendNull(); return; } BlockBuilder blockBuilder = out.beginBlockEntry(); BIGINT.writeLong(blockBuilder, heap.getCapacity()); BlockBuilder elements = blockBuilder.beginBlockEntry(); heap.writeAll(elements); blockBuilder.closeEntry(); out.closeEntry(); }
public void addAll(Block block) { for (int i = 0; i < block.getPositionCount(); i++) { add(block, i); } }
@Override public void setTypedHeap(TypedHeap value) { TypedHeap previous = getTypedHeap(); if (previous != null) { size -= previous.getEstimatedSize(); } heaps.set(getGroupId(), value); size += value.getEstimatedSize(); }
public void popAll(BlockBuilder resultBlockBuilder) { while (positionCount > 0) { pop(resultBlockBuilder); } }
public void pop(BlockBuilder resultBlockBuilder) { type.appendTo(heapBlockBuilder, heapIndex[0], resultBlockBuilder); remove(); }
public static void output(ArrayType outputType, MinMaxNState state, BlockBuilder out) { TypedHeap heap = state.getTypedHeap(); if (heap == null || heap.isEmpty()) { out.appendNull(); return; } Type elementType = outputType.getElementType(); BlockBuilder reversedBlockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), heap.getCapacity()); long startSize = heap.getEstimatedSize(); heap.popAll(reversedBlockBuilder); state.addMemoryUsage(heap.getEstimatedSize() - startSize); BlockBuilder arrayBlockBuilder = out.beginBlockEntry(); for (int i = reversedBlockBuilder.getPositionCount() - 1; i >= 0; i--) { elementType.appendTo(reversedBlockBuilder, i, arrayBlockBuilder); } out.closeEntry(); } }