@Override public void add(Block block, int position) { if (blockBuilder == null) { blockBuilder = type.createBlockBuilder(null, 16); } type.appendTo(block, position, blockBuilder); }
private static Block getNullBlock(Type type, int positionCount) { Block nullValueBlock = type.createBlockBuilder(null, 1) .appendNull() .build(); return new RunLengthEncodedBlock(nullValueBlock, positionCount); }
@UsedByGeneratedCode public static Block appendElement(Type elementType, Block block, Object value) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } elementType.writeObject(blockBuilder, value); return blockBuilder.build(); }
public static boolean equals(Type rowType, Block leftRow, Block rightRow) { // TODO: Fix this. It feels very inefficient and unnecessary to wrap and unwrap with Block BlockBuilder leftBlockBuilder = rowType.createBlockBuilder(new BlockBuilderStatus(), 1); BlockBuilder rightBlockBuilder = rowType.createBlockBuilder(new BlockBuilderStatus(), 1); rowType.writeObject(leftBlockBuilder, leftRow); rowType.writeObject(rightBlockBuilder, rightRow); return rowType.equalTo(leftBlockBuilder.build(), 0, rightBlockBuilder.build(), 0); } }
@UsedByGeneratedCode public static long hash(Type rowType, Block block) { BlockBuilder blockBuilder = rowType.createBlockBuilder(null, 1); blockBuilder.appendStructure(block); return rowType.hash(blockBuilder.build(), 0); } }
private static Block serializeStruct(Type type, BlockBuilder builder, Object object) { if (object == null) { requireNonNull(builder, "parent builder is null").appendNull(); return null; if (builder == null) { builderSynthesized = true; builder = type.createBlockBuilder(new BlockBuilderStatus(), 1);
@TypeParameter("E") @SqlType("array(E)") public static Block union( @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) { int leftArrayCount = leftArray.getPositionCount(); int rightArrayCount = rightArray.getPositionCount(); TypedSet typedSet = new TypedSet(type, leftArrayCount + rightArrayCount, "array_union"); BlockBuilder distinctElementBlockBuilder = type.createBlockBuilder(null, leftArrayCount + rightArrayCount); appendTypedArray(leftArray, type, typedSet, distinctElementBlockBuilder); appendTypedArray(rightArray, type, typedSet, distinctElementBlockBuilder); return distinctElementBlockBuilder.build(); }
public static void output(ArrayType outputType, MinMaxByNState state, BlockBuilder out) { TypedKeyValueHeap heap = state.getTypedKeyValueHeap(); if (heap == null || heap.isEmpty()) { out.appendNull(); return; } Type elementType = outputType.getElementType(); BlockBuilder arrayBlockBuilder = out.beginBlockEntry(); BlockBuilder reversedBlockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), heap.getCapacity()); long startSize = heap.getEstimatedSize(); heap.popAll(reversedBlockBuilder); state.addMemoryUsage(heap.getEstimatedSize() - startSize); for (int i = reversedBlockBuilder.getPositionCount() - 1; i >= 0; i--) { elementType.appendTo(reversedBlockBuilder, i, arrayBlockBuilder); } out.closeEntry(); }
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(); } }
@Override public void deserialize(Block block, int index, ArrayAggregationState state) { Block stateBlock = (Block) arrayType.getObject(block, index); int positionCount = stateBlock.getPositionCount(); BlockBuilder blockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), positionCount); for (int i = 0; i < positionCount; i++) { stateBlock.writePositionTo(i, blockBuilder); blockBuilder.closeEntry(); } state.setBlockBuilder(blockBuilder); } }
@UsedByGeneratedCode public static Block prependElement(Type elementType, Slice value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeSlice(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); }
public Block readBlock(int columnIndex) throws IOException { checkArgument(readColumns.containsKey(columnIndex), "Column %s is not being read", columnIndex); checkState(currentChunkRowCount > 0, "No more data"); if (columnIndex >= columns.length) { Type type = readColumns.get(columnIndex); Block nullBlock = type.createBlockBuilder(null, 1, 0).appendNull().build(); return new RunLengthEncodedBlock(nullBlock, currentChunkRowCount); } return columns[columnIndex].readBlock(rowGroupPosition, currentChunkRowCount); }
public static long hash(Type rowType, Block block) { BlockBuilder blockBuilder = rowType.createBlockBuilder(new BlockBuilderStatus(), 1); blockBuilder.writeObject(block).closeEntry(); return rowType.hash(blockBuilder.build(), 0); } }
public static Block arrayBlockOf(Type elementType, Object... values) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, values.length); for (Object value : values) { appendToBlockBuilder(elementType, value, blockBuilder); } return blockBuilder.build(); }
private static Block serializeMap(Type type, BlockBuilder builder, Object object) { Map<?, ?> map = (Map) object; if (map == null) { requireNonNull(builder, "parent builder is null").appendNull(); return null; } List<Type> typeParameters = type.getTypeParameters(); checkArgument(typeParameters.size() == 2, "map must have exactly 2 type parameter"); Type keyType = typeParameters.get(0); Type valueType = typeParameters.get(1); boolean builderSynthesized = false; if (builder == null) { builderSynthesized = true; builder = type.createBlockBuilder(new BlockBuilderStatus(), 1); } BlockBuilder currentBuilder = builder.beginBlockEntry(); for (Map.Entry<?, ?> entry : map.entrySet()) { // Hive skips map entries with null keys if (entry.getKey() != null) { serializeObject(keyType, currentBuilder, entry.getKey()); serializeObject(valueType, currentBuilder, entry.getValue()); } } builder.closeEntry(); if (builderSynthesized) { return (Block) type.getObject(builder, 0); } else { return null; } }
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(); } }
private void compactIfNecessary() { // Byte size check is needed. Otherwise, if size * 3 is small, BlockBuilder can be reallocate too often. // Position count is needed. Otherwise, for large elements, heap will be compacted every time. // Size instead of retained size is needed because default allocation size can be huge for some block builders. And the first check will become useless in such case. if (heapBlockBuilder.getSizeInBytes() < COMPACT_THRESHOLD_BYTES || heapBlockBuilder.getPositionCount() / positionCount < COMPACT_THRESHOLD_RATIO) { return; } BlockBuilder newHeapBlockBuilder = type.createBlockBuilder(null, heapBlockBuilder.getPositionCount()); for (int i = 0; i < positionCount; i++) { type.appendTo(heapBlockBuilder, heapIndex[i], newHeapBlockBuilder); heapIndex[i] = i; } heapBlockBuilder = newHeapBlockBuilder; } }
@UsedByGeneratedCode public static Block appendElement(Type elementType, Block block, long value) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } elementType.writeLong(blockBuilder, value); return blockBuilder.build(); }
public static Block createTypedLongsBlock(Type type, Iterable<Long> values) { BlockBuilder builder = type.createBlockBuilder(null, 100); for (Long value : values) { if (value == null) { builder.appendNull(); } else { type.writeLong(builder, value); } } return builder.build(); }
public static Block arrayBlockOf(Type elementType, Object... values) { BlockBuilder blockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), values.length); for (Object value : values) { appendToBlockBuilder(elementType, value, blockBuilder); } return blockBuilder.build(); }