private static Block repeatNullValues(BlockBuilder blockBuilder, long count) { for (int i = 0; i < count; i++) { blockBuilder.appendNull(); } return blockBuilder.build(); }
private static Block getNullBlock(Type type, int positionCount) { Block nullValueBlock = type.createBlockBuilder(null, 1) .appendNull() .build(); return new RunLengthEncodedBlock(nullValueBlock, positionCount); }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writePositionTo(position, blockBuilder); } }
public ChannelSetBuilder(Type type, Optional<Integer> hashChannel, int expectedPositions, OperatorContext operatorContext) { List<Type> types = ImmutableList.of(type); this.hash = createGroupByHash(operatorContext.getSession(), types, HASH_CHANNELS, Optional.empty(), hashChannel, expectedPositions); this.operatorContext = operatorContext; this.nullBlockPage = new Page(type.createBlockBuilder(new BlockBuilderStatus(), 1, UNKNOWN.getFixedSize()).appendNull().build()); }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { blockBuilder.writeLong(block.getLong(position, 0)).closeEntry(); } }
private static Block createStringsBlock(List<String> values) { BlockBuilder builder = VARCHAR.createBlockBuilder(new BlockBuilderStatus(), values.size()); for (String value : values) { if (value == null) { builder.appendNull(); } else { VARCHAR.writeString(builder, value); } } return builder.build(); } }
@Override public Block apply(Block block) { BlockBuilder blockBuilder = DOUBLE.createBlockBuilder(null, block.getPositionCount()); for (int i = 0; i < block.getPositionCount(); i++) { if (block.isNull(i)) { blockBuilder.appendNull(); continue; } DOUBLE.writeDouble(blockBuilder, intBitsToFloat((int) REAL.getLong(block, i))); } return blockBuilder.build(); } }
@Override public Block apply(Block block) { BlockBuilder blockBuilder = toType.createBlockBuilder(null, block.getPositionCount()); for (int i = 0; i < block.getPositionCount(); i++) { if (block.isNull(i)) { blockBuilder.appendNull(); continue; } toType.writeLong(blockBuilder, fromType.getLong(block, i)); } return blockBuilder.build(); } }
@Test public void testMultipleValuesWithNull() { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 10); blockBuilder.appendNull(); BIGINT.writeLong(blockBuilder, 42); blockBuilder.appendNull(); BIGINT.writeLong(blockBuilder, 42); Block block = blockBuilder.build(); assertTrue(block.isNull(0)); assertEquals(BIGINT.getLong(block, 1), 42L); assertTrue(block.isNull(2)); assertEquals(BIGINT.getLong(block, 3), 42L); } }
private static Block longBlock(Integer... values) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, values.length); for (Integer value : values) { if (value == null) { blockBuilder.appendNull(); } else { blockBuilder.writeLong(value).closeEntry(); } } return blockBuilder.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(null, 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(); }
@Override public void start() { if (builder == null) { if (nullBuilder == null || (nullBuilder.getPositionCount() >= NULL_BUILDER_POSITIONS_THRESHOLD && nullBuilder.getSizeInBytes() >= NULL_BUILDER_SIZE_IN_BYTES_THRESHOLD)) { nullBuilder = arrayType.createBlockBuilder(new BlockBuilderStatus(), NULL_BUILDER_POSITIONS_THRESHOLD); } currentEntryBuilder = nullBuilder.beginBlockEntry(); } else { while (builder.getPositionCount() < fieldIndex) { builder.appendNull(); } currentEntryBuilder = builder.beginBlockEntry(); } elementConverter.beforeValue(currentEntryBuilder); }
public static void output(Type elementType, ArrayAggregationState state, BlockBuilder out) { if (state.isEmpty()) { out.appendNull(); } else { BlockBuilder entryBuilder = out.beginBlockEntry(); state.forEach((block, position) -> elementType.appendTo(block, position, entryBuilder)); out.closeEntry(); } } }
private BlockBuilder createBlockBuilderWithValues(long[][] expectedValues) { BlockBuilder blockBuilder = new ArrayBlockBuilder(BIGINT, new BlockBuilderStatus(), 100, 100); for (long[] expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { BlockBuilder elementBlockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), expectedValue.length); for (long v : expectedValue) { BIGINT.writeLong(elementBlockBuilder, v); } blockBuilder.writeObject(elementBlockBuilder).closeEntry(); } } return blockBuilder; }
private static Block serializeList(Type type, BlockBuilder builder, Object object) { List<?> list = (List) object; if (list == null) { requireNonNull(builder, "parent builder is null").appendNull(); return null; } List<Type> typeParameters = type.getTypeParameters(); checkArgument(typeParameters.size() == 1, "list must have exactly 1 type parameter"); Type elementType = typeParameters.get(0); BlockBuilder currentBuilder; if (builder != null) { currentBuilder = builder.beginBlockEntry(); } else { currentBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), list.size()); } for (Object element : list) { serializeObject(elementType, currentBuilder, element); } if (builder != null) { builder.closeEntry(); return null; } else { Block resultBlock = currentBuilder.build(); return resultBlock; } }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writeBytesTo(position, 0, block.getSliceLength(position), blockBuilder); blockBuilder.closeEntry(); } }
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 TestUnknownType() { super(UNKNOWN, void.class, UNKNOWN.createBlockBuilder(new BlockBuilderStatus(), 3) .appendNull() .appendNull() .appendNull() .build()); }
public TestUnknownType() { super(UNKNOWN, boolean.class, UNKNOWN.createBlockBuilder(null, 3) .appendNull() .appendNull() .appendNull() .build()); }
private static Block copyBlockViaWritePositionTo(Block block, Supplier<BlockBuilder> newBlockBuilder) { BlockBuilder blockBuilder = newBlockBuilder.get(); for (int i = 0; i < block.getPositionCount(); i++) { if (block.isNull(i)) { blockBuilder.appendNull(); } else { block.writePositionTo(i, blockBuilder); } } return blockBuilder.build(); }