Refine search
@Override public void add(Block block, int position) { if (blockBuilder == null) { blockBuilder = type.createBlockBuilder(null, 16); } type.appendTo(block, position, blockBuilder); }
private static void appendTypedArray(Block array, Type type, TypedSet typedSet, BlockBuilder blockBuilder) { for (int i = 0; i < array.getPositionCount(); i++) { if (!typedSet.contains(array, i)) { typedSet.add(array, i); type.appendTo(array, i, blockBuilder); } } }
@UsedByGeneratedCode public static Block appendElement(Type elementType, Block block, boolean value) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } elementType.writeBoolean(blockBuilder, value); return blockBuilder.build(); }
@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(); }
@UsedByGeneratedCode public static Block zip(List<Type> types, Block... arrays) { int biggestCardinality = 0; for (Block array : arrays) { biggestCardinality = Math.max(biggestCardinality, array.getPositionCount()); } RowType rowType = RowType.anonymous(types); BlockBuilder outputBuilder = rowType.createBlockBuilder(null, biggestCardinality); for (int outputPosition = 0; outputPosition < biggestCardinality; outputPosition++) { BlockBuilder rowBuilder = outputBuilder.beginBlockEntry(); for (int fieldIndex = 0; fieldIndex < arrays.length; fieldIndex++) { if (arrays[fieldIndex].getPositionCount() <= outputPosition) { rowBuilder.appendNull(); } else { types.get(fieldIndex).appendTo(arrays[fieldIndex], outputPosition, rowBuilder); } } outputBuilder.closeEntry(); } return outputBuilder.build(); } }
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 (keyBlockBuilder.getSizeInBytes() < COMPACT_THRESHOLD_BYTES || keyBlockBuilder.getPositionCount() / positionCount < COMPACT_THRESHOLD_RATIO) { return; } BlockBuilder newHeapKeyBlockBuilder = keyType.createBlockBuilder(null, keyBlockBuilder.getPositionCount()); BlockBuilder newHeapValueBlockBuilder = valueType.createBlockBuilder(null, valueBlockBuilder.getPositionCount()); for (int i = 0; i < positionCount; i++) { keyType.appendTo(keyBlockBuilder, heapIndex[i], newHeapKeyBlockBuilder); valueType.appendTo(valueBlockBuilder, heapIndex[i], newHeapValueBlockBuilder); heapIndex[i] = i; } keyBlockBuilder = newHeapKeyBlockBuilder; valueBlockBuilder = newHeapValueBlockBuilder; } }
@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(); }
int firstMapIndex = lastMapIndex; for (int i = 0; i < maps.length; i++) { entries += maps[i].getPositionCount(); if (maps[i].getPositionCount() > 0) { lastMapIndex = i; firstMapIndex = min(firstMapIndex, i); for (int i = 0; i < map.getPositionCount(); i += 2) { typedSet.add(map, i); keyType.appendTo(map, i, blockBuilder); valueType.appendTo(map, i + 1, blockBuilder); if (!typedSet.contains(map, i)) { typedSet.add(map, i); keyType.appendTo(map, i, blockBuilder); valueType.appendTo(map, i + 1, blockBuilder); for (int i = 0; i < map.getPositionCount(); i += 2) { if (!typedSet.contains(map, i)) { keyType.appendTo(map, i, blockBuilder); valueType.appendTo(map, i + 1, blockBuilder);
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(); }
resultPositionCount += blocks[i].getPositionCount(); if (blocks[i].getPositionCount() > 0) { nonEmptyBlock = blocks[i]; return blocks[0]; if (resultPositionCount == nonEmptyBlock.getPositionCount()) { return nonEmptyBlock; Block block = blocks[blockIndex]; for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder);
@Override public void add(Block block, int position) { BlockBuilder blockBuilder = blockBuilders.get(getGroupId()); long startSize = 0; if (blockBuilder == null) { blockBuilder = type.createBlockBuilder(null, 4); blockBuilders.set(getGroupId(), blockBuilder); } else { startSize = blockBuilder.getRetainedSizeInBytes(); } type.appendTo(block, position, blockBuilder); size += blockBuilder.getRetainedSizeInBytes() - startSize; }
@UsedByGeneratedCode public static Block appendElement(Type elementType, Block block, Slice value) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } elementType.writeSlice(blockBuilder, value); return blockBuilder.build(); }
@Override public void serialize(BlockBuilder out) { if (values.getPositionCount() == 0) { out.appendNull(); } else { Block valuesBlock = values.build(); BlockBuilder blockBuilder = out.beginBlockEntry(); for (int i = 0; i < valuesBlock.getPositionCount(); i++) { type.appendTo(valuesBlock, i, blockBuilder); BIGINT.writeLong(blockBuilder, counts.get(i)); } out.closeEntry(); } }
valueBlocks[keyIndex] = valueType.createBlockBuilder(null, 0).build(); BlockBuilder valueBlockBuilder = valueType.createBlockBuilder(null, totalMapEntries); int[] keyIds = new int[totalMapEntries]; int keyIdsIndex = 0; if (inMapVectors[keyIndex] == null || inMapVectors[keyIndex][mapIndex]) { mapLength++; valueType.appendTo(valueBlocks[keyIndex], valueBlockPositions[keyIndex], valueBlockBuilder); keyIds[keyIdsIndex++] = keyIndex; valueBlockPositions[keyIndex]++;
@UsedByGeneratedCode public static Block appendElement(Type elementType, Block block, double value) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } elementType.writeDouble(blockBuilder, value); return blockBuilder.build(); }
@SqlType("array(E)") Block block) int arrayLength = block.getPositionCount(); if (positions.size() < arrayLength) { positions = Ints.asList(new int[arrayLength]); type.appendTo(block, positions.get(i), blockBuilder);
@Override public void add(Block key, Block value, int position) { BlockBuilder keyBlockBuilder = keyBlockBuilders.get(getGroupId()); BlockBuilder valueBlockBuilder = valueBlockBuilders.get(getGroupId()); if (keyBlockBuilder != null) { size -= keyBlockBuilder.getRetainedSizeInBytes(); size -= valueBlockBuilder.getRetainedSizeInBytes(); } else { keyBlockBuilder = keyType.createBlockBuilder(null, EXPECTED_ENTRIES, expectedValueSize(keyType, EXPECTED_ENTRY_SIZE)); valueBlockBuilder = valueType.createBlockBuilder(null, EXPECTED_ENTRIES, expectedValueSize(valueType, EXPECTED_ENTRY_SIZE)); keyBlockBuilders.set(getGroupId(), keyBlockBuilder); valueBlockBuilders.set(getGroupId(), valueBlockBuilder); } keyType.appendTo(key, position, keyBlockBuilder); valueType.appendTo(value, position, valueBlockBuilder); size += keyBlockBuilder.getRetainedSizeInBytes(); size += valueBlockBuilder.getRetainedSizeInBytes(); }
@UsedByGeneratedCode public static Block prependElement(Type elementType, long value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeLong(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); }
for (int i = 0; i < array.getPositionCount(); i++) { Object element = readNativeValue(type, array, i); if (array.getPositionCount() == positions.size()) { return array; type.appendTo(array, position, blockBuilder);