public static Block getKeys(Type keyType, Block block) { BlockBuilder blockBuilder = keyType.createBlockBuilder(new BlockBuilderStatus(), block.getPositionCount() / 2); for (int i = 0; i < block.getPositionCount(); i += 2) { keyType.appendTo(block, i, blockBuilder); } 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); } }
public Block serialize() { Block keys = keyBlockBuilder.build(); Block values = valueBlockBuilder.build(); BlockBuilder blockBuilder = new InterleavedBlockBuilder(ImmutableList.of(keyType, valueType), new BlockBuilderStatus(), keys.getPositionCount() * 2); for (int i = 0; i < keys.getPositionCount(); i++) { keyType.appendTo(keys, i, blockBuilder); valueType.appendTo(values, i, blockBuilder); } return blockBuilder.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 testMapBlock() { MapHolder holder = new MapHolder(); holder.map = new TreeMap<>(); holder.map.put("twelve", new InnerStruct(13, 14L)); holder.map.put("fifteen", new InnerStruct(16, 17L)); com.facebook.presto.spi.type.Type rowType = new RowType(ImmutableList.of(BIGINT, BIGINT), Optional.empty()); com.facebook.presto.spi.type.Type mapOfVarcharRowType = new RowType(ImmutableList.of(new MapType(VARCHAR, rowType)), Optional.empty()); Block actual = toBinaryBlock(mapOfVarcharRowType, holder, getInspector(MapHolder.class)); BlockBuilder blockBuilder = new InterleavedBlockBuilder(ImmutableList.of(VARCHAR, rowType), new BlockBuilderStatus(), 1024); VARCHAR.writeString(blockBuilder, "fifteen"); rowType.writeObject(blockBuilder, rowBlockOf(ImmutableList.of(BIGINT, BIGINT), 16, 17L)); VARCHAR.writeString(blockBuilder, "twelve"); rowType.writeObject(blockBuilder, rowBlockOf(ImmutableList.of(BIGINT, BIGINT), 13, 14L)); Block expected = rowBlockOf(ImmutableList.of(new MapType(VARCHAR, rowType)), blockBuilder); assertBlockEquals(actual, expected); }
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()}; }
@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 createSingleValueBlock(Slice expectedValue) { BlockBuilder blockBuilder = new VariableWidthBlockBuilder(new BlockBuilderStatus(), 1, expectedValue.length()); blockBuilder.writeBytes(expectedValue, 0, expectedValue.length()).closeEntry(); return blockBuilder.build(); } }
assertEquals(block.compareTo(position, offset, 3, expectedBlock, 0, offset, 3), 0); BlockBuilder blockBuilder = VARBINARY.createBlockBuilder(new BlockBuilderStatus(), 1); block.writeBytesTo(position, offset, 3, blockBuilder); blockBuilder.closeEntry(); Block segment = blockBuilder.build(); Block actual = block.getObject(position, Block.class); long[] expected = (long[]) expectedValue; assertEquals(actual.getPositionCount(), expected.length); for (int i = 0; i < expected.length; i++) { assertEquals(BIGINT.getLong(actual, i), expected[i]); Block actual = block.getObject(position, Block.class); Slice[] expected = (Slice[]) expectedValue; assertEquals(actual.getPositionCount(), expected.length); for (int i = 0; i < expected.length; i++) { assertEquals(VARCHAR.getSlice(actual, i), expected[i]); Block actual = block.getObject(position, Block.class); long[][] expected = (long[][]) expectedValue; assertEquals(actual.getPositionCount(), expected.length); for (int i = 0; i < expected.length; i++) { assertPositionValue(actual, i, expected[i]);
@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 = rowType.createBlockBuilder(new BlockBuilderStatus(), NULL_BUILDER_POSITIONS_THRESHOLD); } currentEntryBuilder = nullBuilder.beginBlockEntry(); } else { while (builder.getPositionCount() < fieldIndex) { builder.appendNull(); } currentEntryBuilder = builder.beginBlockEntry(); } for (BlockConverter converter : converters) { converter.beforeValue(currentEntryBuilder); } }
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; }
@Test public void testRoundTrip() { BlockBuilder expectedBlockBuilder = VARCHAR.createBlockBuilder(new BlockBuilderStatus(), 5); VARCHAR.writeString(expectedBlockBuilder, "alice"); VARCHAR.writeString(expectedBlockBuilder, "bob"); VARCHAR.writeString(expectedBlockBuilder, "charlie"); VARCHAR.writeString(expectedBlockBuilder, "dave"); Block expectedBlock = expectedBlockBuilder.build(); Page expectedPage = new Page(expectedBlock, expectedBlock, expectedBlock); DynamicSliceOutput sliceOutput = new DynamicSliceOutput(1024); writePages(blockEncodingManager, sliceOutput, expectedPage, expectedPage, expectedPage); List<Type> types = ImmutableList.<Type>of(VARCHAR, VARCHAR, VARCHAR); Iterator<Page> pageIterator = readPages(blockEncodingManager, sliceOutput.slice().getInput()); assertPageEquals(types, pageIterator.next(), expectedPage); assertPageEquals(types, pageIterator.next(), expectedPage); assertPageEquals(types, pageIterator.next(), expectedPage); assertFalse(pageIterator.hasNext()); }
public static Block getValues(Type valueType, Block block) { BlockBuilder blockBuilder = valueType.createBlockBuilder(new BlockBuilderStatus(), block.getPositionCount() / 2); for (int i = 0; i < block.getPositionCount(); i += 2) { valueType.appendTo(block, i + 1, blockBuilder); } return blockBuilder.build(); } }
public TestUnknownType() { super(UNKNOWN, void.class, UNKNOWN.createBlockBuilder(new BlockBuilderStatus(), 3) .appendNull() .appendNull() .appendNull() .build()); }
public static Block createLongsBlock(int... values) { BlockBuilder builder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 100); for (int value : values) { BIGINT.writeLong(builder, (long) value); } return builder.build(); }
public static Block arrayBlockOf(Type elementType, Object... values) { BlockBuilder blockBuilder = elementType.createBlockBuilder(new BlockBuilderStatus(), values.length); for (Object value : values) { appendToBlockBuilder(elementType, value, 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(); }
private static RunLengthEncodedBlock createRLEBlock(Iterable<Double> percentiles, int positionCount) { BlockBuilder rleBlockBuilder = new ArrayType(DOUBLE).createBlockBuilder(new BlockBuilderStatus(), 1); BlockBuilder arrayBlockBuilder = rleBlockBuilder.beginBlockEntry(); for (double percentile : percentiles) { DOUBLE.writeDouble(arrayBlockBuilder, percentile); } rleBlockBuilder.closeEntry(); return new RunLengthEncodedBlock(rleBlockBuilder.build(), positionCount); } }
private static BlockBuilder createBlockBuilderWithValues(Slice[] expectedValues) { VariableWidthBlockBuilder blockBuilder = new VariableWidthBlockBuilder(new BlockBuilderStatus(), expectedValues.length, 32); for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeBytes(expectedValue, 0, expectedValue.length()).closeEntry(); } } return blockBuilder; } }