@Override public void writeSlice(BlockBuilder blockBuilder, Slice value, int offset, int length) { if (value == null) { blockBuilder.appendNull(); return; } blockBuilder.writeBytes(value, offset, length).closeEntry(); }
@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 EmptyMapConstructor(@TypeParameter("map(unknown,unknown)") Type mapType) { BlockBuilder mapBlockBuilder = mapType.createBlockBuilder(null, 1); mapBlockBuilder.beginBlockEntry(); mapBlockBuilder.closeEntry(); emptyMap = ((MapType) mapType).getObject(mapBlockBuilder.build(), 0); }
private static Block serializeList(BlockBuilder blockBuilder, Object value, Type type, String columnName) { if (value == null) { requireNonNull(blockBuilder, "parent blockBuilder is null").appendNull(); return blockBuilder.build(); } List<?> list = (List) value; List<Type> typeParameters = type.getTypeParameters(); Type elementType = typeParameters.get(0); BlockBuilder currentBlockBuilder; if (blockBuilder != null) { currentBlockBuilder = blockBuilder.beginBlockEntry(); } else { currentBlockBuilder = elementType.createBlockBuilder(null, list.size()); } for (Object element : list) { serializeObject(currentBlockBuilder, element, elementType, columnName); } if (blockBuilder != null) { blockBuilder.closeEntry(); return null; } return currentBlockBuilder.build(); }
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 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(); }
private Page buildPage() { BlockBuilder col1 = BIGINT.createBlockBuilder(null, 1); BlockBuilder col2 = DOUBLE.createBlockBuilder(null, 1); BlockBuilder col3 = VARBINARY.createBlockBuilder(null, 1); col1.writeLong(42).closeEntry(); col2.writeLong(doubleToLongBits(43.0)).closeEntry(); col3.writeLong(doubleToLongBits(43.0)).writeLong(1).closeEntry(); return new Page(col1.build(), col2.build(), col3.build()); } }
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(); }
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; }
@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); } }
private static Block serializeList(Type type, BlockBuilder builder, Object object, ListObjectInspector inspector) { List<?> list = inspector.getList(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); ObjectInspector elementInspector = inspector.getListElementObjectInspector(); BlockBuilder currentBuilder; if (builder != null) { currentBuilder = builder.beginBlockEntry(); } else { currentBuilder = elementType.createBlockBuilder(null, list.size()); } for (Object element : list) { serializeObject(elementType, currentBuilder, element, elementInspector); } if (builder != null) { builder.closeEntry(); return null; } else { Block resultBlock = currentBuilder.build(); return resultBlock; } }
private void assertRowHashOperator(String inputString, List<Type> types, List<Object> elements) { checkArgument(types.size() == elements.size(), "types and elements must have the same size"); RowType rowType = RowType.anonymous(types); BlockBuilder blockBuilder = rowType.createBlockBuilder(null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < types.size(); i++) { appendToBlockBuilder(types.get(i), elements.get(i), singleRowBlockWriter); } blockBuilder.closeEntry(); assertOperator(HASH_CODE, inputString, BIGINT, rowType.hash(blockBuilder.build(), 0)); }
@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(); } }
@Override public void serialize(MultimapAggregationState state, BlockBuilder out) { if (state.isEmpty()) { out.appendNull(); return; } BlockBuilder entryBuilder = out.beginBlockEntry(); state.forEach((keyBlock, valueBlock, position) -> { BlockBuilder rowBlockBuilder = entryBuilder.beginBlockEntry(); valueType.appendTo(valueBlock, position, rowBlockBuilder); keyType.appendTo(keyBlock, position, rowBlockBuilder); entryBuilder.closeEntry(); }); out.closeEntry(); }
private static Block createSingleValueBlock(Slice expectedValue) { BlockBuilder blockBuilder = new VariableWidthBlockBuilder(new BlockBuilderStatus(), 1, expectedValue.length()); blockBuilder.writeBytes(expectedValue, 0, expectedValue.length()).closeEntry(); return blockBuilder.build(); } }
public static Block rowBlockOf(List<Type> parameterTypes, Object... values) { RowType rowType = RowType.anonymous(parameterTypes); BlockBuilder blockBuilder = rowType.createBlockBuilder(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); }
private Page buildPage() { BlockBuilder col1 = BIGINT.createBlockBuilder(null, 1); col1.writeLong(42).closeEntry(); return new Page(col1.build()); }
private static InterleavedBlockBuilder createBlockBuilderWithValues(Slice[] expectedValues, List<Type> types) { InterleavedBlockBuilder blockBuilder = new InterleavedBlockBuilder(types, new BlockBuilderStatus(), expectedValues.length); for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeBytes(expectedValue, 0, expectedValue.length()).closeEntry(); } } return blockBuilder; }
private static Block serializeStruct(Type type, BlockBuilder builder, Object object) { if (object == null) { requireNonNull(builder, "builder is null"); builder.appendNull(); return builder.build(); } if (builder == null) { builder = type.createBlockBuilder(null, 1); } BlockBuilder currentBuilder = builder.beginBlockEntry(); List<Type> typeParameters = type.getTypeParameters(); for (int i = 0; i < typeParameters.size(); i++) { Optional<String> fieldName = type.getTypeSignature().getParameters().get(i).getNamedTypeSignature().getName(); String name = ""; if (fieldName.isPresent()) { name = fieldName.get().toLowerCase(ENGLISH); } Object value = ((Map) object).get(name); serializeObject(typeParameters.get(i), currentBuilder, value); } builder.closeEntry(); return (Block) type.getObject(builder, 0); }
@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()); } }