public EmptyMapConstructor(@TypeParameter("map(unknown,unknown)") Type mapType) { BlockBuilder mapBlockBuilder = mapType.createBlockBuilder(null, 1); mapBlockBuilder.beginBlockEntry(); mapBlockBuilder.closeEntry(); emptyMap = ((MapType) mapType).getObject(mapBlockBuilder.build(), 0); }
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(); } } }
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(); }
@Override public void writeSlice(BlockBuilder blockBuilder, Slice value, int offset, int length) { blockBuilder.writeBytes(value, offset, length).closeEntry(); } }
@Override public void writeSlice(BlockBuilder blockBuilder, Slice value, int offset, int length) { if (value == null) { blockBuilder.appendNull(); return; } blockBuilder.writeBytes(value, offset, length).closeEntry(); }
public void clear() { containsNullElement = false; blockPositionByHash.fill(EMPTY_SLOT); elementBlock = elementBlock.newBlockBuilderLike(null); // first position is always null elementBlock.appendNull(); }
private void assertFixedWithValues(Slice[] expectedValues) { BlockBuilder blockBuilder = createBlockBuilderWithValues(expectedValues); assertBlock(blockBuilder, () -> blockBuilder.newBlockBuilderLike(null), expectedValues); assertBlock(blockBuilder.build(), () -> blockBuilder.newBlockBuilderLike(null), expectedValues); }
@Test(expectedExceptions = IllegalStateException.class, expectedExceptionsMessageRegExp = "Expected current entry to be closed but was opened") public void testConcurrentWriting() { BlockBuilder blockBuilder = new ArrayBlockBuilder(BIGINT, null, EXPECTED_ENTRY_COUNT); BlockBuilder elementBlockWriter = blockBuilder.beginBlockEntry(); elementBlockWriter.writeLong(45).closeEntry(); blockBuilder.appendStructure(new FixedWidthBlockBuilder(8, 4).writeLong(123).closeEntry().build()); } }
private static Block createSingleValueBlock(Slice expectedValue) { BlockBuilder blockBuilder = new VariableWidthBlockBuilder(null, 1, expectedValue.length()); blockBuilder.writeBytes(expectedValue, 0, expectedValue.length()).closeEntry(); return blockBuilder.build(); }
public static Block createStringSequenceBlock(int start, int end) { BlockBuilder builder = VARCHAR.createBlockBuilder(null, 100); for (int i = start; i < end; i++) { VARCHAR.writeString(builder, String.valueOf(i)); } return builder.build(); }
static void write(Type type, NullableDoubleState state, BlockBuilder out) { if (state.isNull()) { out.appendNull(); } else { type.writeDouble(out, state.getDouble()); } } }
private static void writeValues(Slice[] expectedValues, BlockBuilder blockBuilder) { for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeLong(expectedValue.getLong(0)).closeEntry(); } } }
@Override public Block[] getSequenceBlocks(int start, int length) { BlockBuilder blockBuilder = UNKNOWN.createBlockBuilder(null, length); for (int i = 0; i < length; i++) { blockBuilder.appendNull(); } return new Block[] {blockBuilder.build()}; }
private static void writeValues(Slice[] expectedValues, BlockBuilder blockBuilder) { for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeShort(expectedValue.getShort(0)).closeEntry(); } } }
public static Block toRow(List<Type> parameterTypes, Object... values) { checkArgument(parameterTypes.size() == values.length, "parameterTypes.size(" + parameterTypes.size() + ") does not equal to values.length(" + values.length + ")"); RowType rowType = RowType.anonymous(parameterTypes); BlockBuilder blockBuilder = new RowBlockBuilder(parameterTypes, null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < values.length; i++) { appendToBlockBuilder(parameterTypes.get(i), values[i], singleRowBlockWriter); } blockBuilder.closeEntry(); return rowType.getObject(blockBuilder, 0); }
@Override public boolean isEmpty() { return values.getPositionCount() == 0; }
@Override public void writeLong(BlockBuilder blockBuilder, long value) { blockBuilder.writeLong(value).closeEntry(); } }
@Override public BlockBuilder beginBlockEntry() { BlockBuilder result; if (writeToValueNext) { result = valueBlockBuilder.beginBlockEntry(); } else { result = keyBlockBuilder.beginBlockEntry(); } return result; }
@Override public long getEstimatedSize() { long estimatedSize = INSTANCE_SIZE; if (blockBuilder != null) { estimatedSize += blockBuilder.getRetainedSizeInBytes(); } return estimatedSize; }
@Override public BlockBuilder writeBytes(Slice source, int sourceIndex, int length) { blockBuilder.writeBytes(source, sourceIndex, length); return this; }