private static Block repeatNullValues(BlockBuilder blockBuilder, long count) { for (int i = 0; i < count; i++) { blockBuilder.appendNull(); } return blockBuilder.build(); }
@Override public GroupByIdBlock getResult() { checkState(lastPosition == block.getPositionCount(), "process has not yet finished"); checkState(!finished, "result has produced"); finished = true; return new GroupByIdBlock(nextGroupId, blockBuilder.build()); } }
private static Block getNullBlock(Type type, int positionCount) { Block nullValueBlock = type.createBlockBuilder(null, 1) .appendNull() .build(); return new RunLengthEncodedBlock(nullValueBlock, positionCount); }
public static Block createLongsBlock(Iterable<Long> values) { BlockBuilder builder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 100); for (Long value : values) { if (value == null) { builder.appendNull(); } else { BIGINT.writeLong(builder, value); } } return builder.build(); }
@Test public void testVarcharSerializedSize() { BlockBuilder builder = VARCHAR.createBlockBuilder(new BlockBuilderStatus(), 5); // empty page Page page = new Page(builder.build()); int pageSize = serializedSize(ImmutableList.of(VARCHAR), page); assertEquals(pageSize, 34); // page overhead // page with one value VARCHAR.writeString(builder, "alice"); page = new Page(builder.build()); int firstValueSize = serializedSize(ImmutableList.of(VARCHAR), page) - pageSize; assertEquals(firstValueSize, 4 + 5 + 1); // length + "alice" + null // page with two values VARCHAR.writeString(builder, "bob"); page = new Page(builder.build()); int secondValueSize = serializedSize(ImmutableList.of(VARCHAR), page) - (pageSize + firstValueSize); assertEquals(secondValueSize, 4 + 3); // length + "bob" (null shared with first entry) }
@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()); }
@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(); } }
@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(); }
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[] getSequenceBlocks(int start, int length) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), length); for (int i = start; i < start + length; i++) { BIGINT.writeLong(blockBuilder, i); } return new Block[] {blockBuilder.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(); }
public Block serialize() { Block valuesBlock = values.build(); BlockBuilder blockBuilder = new InterleavedBlockBuilder(ImmutableList.of(type, BIGINT), new BlockBuilderStatus(), valuesBlock.getPositionCount() * 2); for (int i = 0; i < valuesBlock.getPositionCount(); i++) { type.appendTo(valuesBlock, i, blockBuilder); BIGINT.writeLong(blockBuilder, counts.get(i)); } return blockBuilder.build(); }
public static Block createTestBlock(Type arrayType) { BlockBuilder blockBuilder = arrayType.createBlockBuilder(null, 4); arrayType.writeObject(blockBuilder, arrayBlockOf(SMALLINT, 1, 2)); arrayType.writeObject(blockBuilder, arrayBlockOf(SMALLINT, 1, 2, 3)); arrayType.writeObject(blockBuilder, arrayBlockOf(SMALLINT, 1, 2, 3)); arrayType.writeObject(blockBuilder, arrayBlockOf(SMALLINT, 100, 200, 300)); return blockBuilder.build(); }
public static boolean equals(Type rowType, Block leftRow, Block rightRow) { // TODO: Fix this. It feels very inefficient and unnecessary to wrap and unwrap with Block BlockBuilder leftBlockBuilder = rowType.createBlockBuilder(new BlockBuilderStatus(), 1); BlockBuilder rightBlockBuilder = rowType.createBlockBuilder(new BlockBuilderStatus(), 1); rowType.writeObject(leftBlockBuilder, leftRow); rowType.writeObject(rightBlockBuilder, rightRow); return rowType.equalTo(leftBlockBuilder.build(), 0, rightBlockBuilder.build(), 0); } }
@Override protected Object getGreaterValue(Object value) { Block block = (Block) value; BlockBuilder blockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { BIGINT.appendTo(block, i, blockBuilder); } BIGINT.writeLong(blockBuilder, 1L); return blockBuilder.build(); } }
@Test public void testRowHistograms() throws Exception { RowType innerRowType = new RowType(ImmutableList.of(BIGINT, DOUBLE), Optional.of(ImmutableList.of("f1", "f2"))); MapType mapType = new MapType(innerRowType, BIGINT); InternalAggregationFunction aggregationFunction = metadata.getFunctionRegistry().getAggregateFunctionImplementation(new Signature(NAME, AGGREGATE, mapType.getTypeSignature().toString(), innerRowType.getTypeSignature().toString())); BlockBuilder builder = innerRowType.createBlockBuilder(new BlockBuilderStatus(), 3); innerRowType.writeObject(builder, testRowBigintBigint(1L, 1.0)); innerRowType.writeObject(builder, testRowBigintBigint(2L, 2.0)); innerRowType.writeObject(builder, testRowBigintBigint(3L, 3.0)); assertAggregation( aggregationFunction, 1.0, ImmutableMap.of(ImmutableList.of(1L, 1.0), 1L, ImmutableList.of(2L, 2.0), 1L, ImmutableList.of(3L, 3.0), 1L), builder.build()); }
@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); } }
@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.writeSlice(blockBuilder, utf8Slice(String.valueOf(fromType.getLong(block, i)))); } return blockBuilder.build(); } }