Refine search
@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(); }
@Override public final void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { blockBuilder.writeLong(block.getLong(position, 0)).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); }
@Override public void writeSlice(BlockBuilder blockBuilder, Slice value, int offset, int length) { blockBuilder.writeBytes(value, offset, length).closeEntry(); }
@Override public long getSizeInBytes() { return keyBlockBuilder.getSizeInBytes() + valueBlockBuilder.getSizeInBytes() + (Integer.BYTES + Byte.BYTES) * (long) positionCount + Integer.BYTES * HASH_MULTIPLIER * (long) keyBlockBuilder.getPositionCount(); }
@Override public void writeDouble(BlockBuilder blockBuilder, double value) { blockBuilder.writeLong(doubleToLongBits(value)).closeEntry(); }
@Test public void testBigintSerializedSize() { BlockBuilder builder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 5); // empty page Page page = new Page(builder.build()); int pageSize = serializedSize(ImmutableList.of(BIGINT), page); assertEquals(pageSize, 35); // page overhead // page with one value BIGINT.writeLong(builder, 123); page = new Page(builder.build()); int firstValueSize = serializedSize(ImmutableList.of(BIGINT), page) - pageSize; assertEquals(firstValueSize, 9); // value size + value overhead // page with two values BIGINT.writeLong(builder, 456); page = new Page(builder.build()); int secondValueSize = serializedSize(ImmutableList.of(BIGINT), page) - (pageSize + firstValueSize); assertEquals(secondValueSize, 8); // value size (value overhead is shared with previous value) }
@Test public void testMultipleValuesWithNull() { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, 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 void test(IntStream inputStream, BlockComparator comparator, PrimitiveIterator.OfInt outputIterator) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), INPUT_SIZE); inputStream.forEach(x -> BIGINT.writeLong(blockBuilder, x)); TypedHeap heap = new TypedHeap(comparator, BIGINT, OUTPUT_SIZE); heap.addAll(blockBuilder); BlockBuilder resultBlockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), OUTPUT_SIZE); heap.popAll(resultBlockBuilder); Block resultBlock = resultBlockBuilder.build(); assertEquals(resultBlock.getPositionCount(), OUTPUT_SIZE); for (int i = 0; i < OUTPUT_SIZE; i++) { assertEquals(BIGINT.getLong(resultBlock, i), outputIterator.nextInt()); } } }
@Test public void testEstimatedDataSizeForStats() { Map<String, Long>[] expectedValues = alternatingNullValues(createTestMap(9, 3, 4, 0, 8, 0, 6, 5)); BlockBuilder blockBuilder = createBlockBuilderWithValues(expectedValues); Block block = blockBuilder.build(); assertEquals(block.getPositionCount(), expectedValues.length); for (int i = 0; i < block.getPositionCount(); i++) { int expectedSize = getExpectedEstimatedDataSize(expectedValues[i]); assertEquals(blockBuilder.getEstimatedDataSizeForStats(i), expectedSize); assertEquals(block.getEstimatedDataSizeForStats(i), expectedSize); } }
@Test public void testGeometryGetObjectValue() { BlockBuilder builder = GEOMETRY.createBlockBuilder(null, 1); GEOMETRY.writeSlice(builder, GeoFunctions.stPoint(1.2, 3.4)); Block block = builder.build(); assertEquals("POINT (1.2 3.4)", GEOMETRY.getObjectValue(null, block, 0)); }
@Test public void testCopyRegion() { Slice[] expectedValues = createExpectedValues(100); Block block = createBlockBuilderWithValues(expectedValues).build(); Block actual = block.copyRegion(10, 10); Block expected = createBlockBuilderWithValues(copyOfRange(expectedValues, 10, 20)).build(); assertEquals(actual.getPositionCount(), expected.getPositionCount()); assertEquals(actual.getSizeInBytes(), expected.getSizeInBytes()); }
@Test public void testHashCode() { Slice data = Slices.wrappedBuffer(ALL_BYTES); Block block = VARBINARY.createBlockBuilder(null, 1, ALL_BYTES.length) .writeBytes(data, 0, data.length()) .closeEntry() .build(); assertEquals(VarbinaryOperators.hashCode(data), VARBINARY.hash(block, 0)); }
@Test public void testRetainedSizeInBytes() { int expectedEntries = 1000; BlockBuilder arrayBlockBuilder = new ArrayBlockBuilder(BIGINT, null, expectedEntries); long initialRetainedSize = arrayBlockBuilder.getRetainedSizeInBytes(); for (int i = 0; i < expectedEntries; i++) { BlockBuilder arrayElementBuilder = arrayBlockBuilder.beginBlockEntry(); BIGINT.writeLong(arrayElementBuilder, i); arrayBlockBuilder.closeEntry(); } assertTrue(arrayBlockBuilder.getRetainedSizeInBytes() >= (expectedEntries * Long.BYTES + ClassLayout.parseClass(LongArrayBlockBuilder.class).instanceSize() + initialRetainedSize)); }
@Test public void testStackRepresentation() throws Exception { Block actualBlock = arrayBlockOf(new ArrayType(BIGINT), arrayBlockOf(BIGINT, 1L, 2L), arrayBlockOf(BIGINT, 3L)); DynamicSliceOutput actualSliceOutput = new DynamicSliceOutput(100); writeBlock(actualSliceOutput, actualBlock); Block expectedBlock = new ArrayType(BIGINT) .createBlockBuilder(new BlockBuilderStatus(), 3) .writeObject(BIGINT.createBlockBuilder(new BlockBuilderStatus(), 2).writeLong(1).closeEntry().writeLong(2).closeEntry().build()) .closeEntry() .writeObject(BIGINT.createBlockBuilder(new BlockBuilderStatus(), 1).writeLong(3).closeEntry().build()) .closeEntry() .build(); DynamicSliceOutput expectedSliceOutput = new DynamicSliceOutput(100); writeBlock(expectedSliceOutput, expectedBlock); assertEquals(actualSliceOutput.slice(), expectedSliceOutput.slice()); }
@Test public void testMapHistograms() throws Exception { MapType innerMapType = new MapType(VARCHAR, VARCHAR); MapType mapType = new MapType(innerMapType, BIGINT); InternalAggregationFunction aggregationFunction = metadata.getFunctionRegistry().getAggregateFunctionImplementation(new Signature(NAME, AGGREGATE, mapType.getTypeSignature().toString(), innerMapType.getTypeSignature().toString())); BlockBuilder builder = innerMapType.createBlockBuilder(new BlockBuilderStatus(), 3); innerMapType.writeObject(builder, mapBlockOf(VARCHAR, VARCHAR, ImmutableMap.of("a", "b"))); innerMapType.writeObject(builder, mapBlockOf(VARCHAR, VARCHAR, ImmutableMap.of("c", "d"))); innerMapType.writeObject(builder, mapBlockOf(VARCHAR, VARCHAR, ImmutableMap.of("e", "f"))); assertAggregation( aggregationFunction, 1.0, ImmutableMap.of(ImmutableMap.of("a", "b"), 1L, ImmutableMap.of("c", "d"), 1L, ImmutableMap.of("e", "f"), 1L), builder.build()); }
@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()); } }
@Test public void testArrayBlock() { BlockBuilder arrayBlockBuilder = new ArrayBlockBuilder(BIGINT, null, EXPECTED_ENTRIES); for (int i = 0; i < EXPECTED_ENTRIES; i++) { BlockBuilder arrayElementBuilder = arrayBlockBuilder.beginBlockEntry(); writeNativeValue(BIGINT, arrayElementBuilder, castIntegerToObject(i, BIGINT)); arrayBlockBuilder.closeEntry(); } checkRetainedSize(arrayBlockBuilder.build(), false); }
@Test public void testCopyPositions() { Slice[] expectedValues = alternatingNullValues(createTestValue(17)); BlockBuilder blockBuilder = createBlockBuilderWithValues(expectedValues); assertBlockFilteredPositions(expectedValues, blockBuilder.build(), () -> blockBuilder.newBlockBuilderLike(null), 0, 2, 4, 6, 7, 9, 10, 16); }