Refine search
public BlockBuilderStatus createBlockBuilderStatus() { return new BlockBuilderStatus(this); }
private void entryAdded(boolean isNull) { if (valueIsNull.length <= positionCount) { growCapacity(); } offsets[positionCount + 1] = values.getPositionCount(); valueIsNull[positionCount] = isNull; hasNullValue |= isNull; positionCount++; if (blockBuilderStatus != null) { blockBuilderStatus.addBytes(Integer.BYTES + Byte.BYTES); } }
/** * Computes the size of an instance of this class assuming that all reference fields are non-null */ private static int deepInstanceSize(Class<?> clazz) { if (clazz.isArray()) { throw new IllegalArgumentException(format("Cannot determine size of %s because it contains an array", clazz.getSimpleName())); } if (clazz.isInterface()) { throw new IllegalArgumentException(format("%s is an interface", clazz.getSimpleName())); } if (Modifier.isAbstract(clazz.getModifiers())) { throw new IllegalArgumentException(format("%s is abstract", clazz.getSimpleName())); } if (!clazz.getSuperclass().equals(Object.class)) { throw new IllegalArgumentException(format("Cannot determine size of a subclass. %s extends from %s", clazz.getSimpleName(), clazz.getSuperclass().getSimpleName())); } int size = ClassLayout.parseClass(clazz).instanceSize(); for (Field field : clazz.getDeclaredFields()) { if (!field.getType().isPrimitive()) { size += deepInstanceSize(field.getType()); } } return size; } }
@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) }
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 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 testMultipleValuesWithNull() { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 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); } }
@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 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()); }
@Test public void testAllPositionsNull() throws Exception { // if there are no parameters skip this test List<Type> parameterTypes = getFunction().getParameterTypes(); if (parameterTypes.isEmpty()) { return; } Block[] blocks = new Block[parameterTypes.size()]; for (int i = 0; i < parameterTypes.size(); i++) { Block nullValueBlock = parameterTypes.get(0).createBlockBuilder(new BlockBuilderStatus(), 1) .appendNull() .build(); blocks[i] = new RunLengthEncodedBlock(nullValueBlock, 10); } testAggregation(getExpectedValueIncludingNulls(0, 0, 10), blocks); }
@Test public void testListBlock() { List<InnerStruct> array = new ArrayList<>(2); array.add(new InnerStruct(8, 9L)); array.add(new InnerStruct(10, 11L)); ListHolder listHolder = new ListHolder(); listHolder.array = array; com.facebook.presto.spi.type.Type rowType = new RowType(ImmutableList.of(BIGINT, BIGINT), Optional.empty()); com.facebook.presto.spi.type.Type arrayOfRowType = new RowType(ImmutableList.of(new ArrayType(rowType)), Optional.empty()); Block actual = toBinaryBlock(arrayOfRowType, listHolder, getInspector(ListHolder.class)); BlockBuilder blockBuilder = rowType.createBlockBuilder(new BlockBuilderStatus(), 1024); rowType.writeObject(blockBuilder, rowBlockOf(ImmutableList.of(BIGINT, BIGINT), 8, 9L)); rowType.writeObject(blockBuilder, rowBlockOf(ImmutableList.of(BIGINT, BIGINT), 10, 11L)); Block expected = rowBlockOf(ImmutableList.of(new ArrayType(rowType)), blockBuilder.build()); assertBlockEquals(actual, expected); }
@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 void assertProjection( String expression, @Nullable Object expectedValue, Map<Symbol, Integer> symbolToInputMappings, Map<Symbol, Type> symbolTypes, int position, Block... blocks) { InterpretedProjectionFunction projectionFunction = new InterpretedProjectionFunction( createExpression(expression, METADATA, symbolTypes), symbolTypes, symbolToInputMappings, METADATA, SQL_PARSER, TEST_SESSION ); // create output Type type = projectionFunction.getType(); BlockBuilder builder = type.createBlockBuilder(new BlockBuilderStatus(), 1); // project projectionFunction.project(position, blocks, builder); // extract single value Object actualValue = BlockAssertions.getOnlyValue(type, builder.build()); assertEquals(actualValue, expectedValue); }
BlockBuilder builder = getType().createBlockBuilder(new BlockBuilderStatus(), list.size()); for (Number sample : list) { if (getType().equals(BIGINT)) { BIGINT.writeLong(builder, sample.longValue()); Page page = new Page(builder.build()); page = OperatorAssertion.appendSampleWeight(ImmutableList.of(page), WEIGHT).get(0); Accumulator accumulator = getFunction().bind(ImmutableList.of(0), Optional.empty(), Optional.of(page.getChannelCount() - 1), getConfidence()).createAccumulator(); int lowerBound = binomial.inverseCumulativeProbability(0.01); int upperBound = binomial.inverseCumulativeProbability(0.99); assertTrue(lowerBound < inRange && inRange < upperBound, String.format("%d out of %d passed. Expected [%d, %d]", inRange, numberOfRuns, lowerBound, upperBound));
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(); } }
@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()}; }
protected void assertPositionEquals(Block block, int position, Object expectedStackValue, Object expectedObjectValue) { int hash = 0; if (type.isComparable()) { hash = hashPosition(type, block, position); } assertPositionValue(block, position, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getSingleValueBlock(position), 0, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getRegion(position, 1), 0, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getRegion(0, position + 1), position, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getRegion(position, block.getPositionCount() - position), 0, expectedStackValue, hash, expectedObjectValue); BlockBuilder blockBuilder = type.createBlockBuilder(new BlockBuilderStatus(), 1); type.appendTo(block, position, blockBuilder); assertPositionValue(blockBuilder.build(), 0, expectedStackValue, hash, expectedObjectValue); }
@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); } }
@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(); } }
public static Block getIntermediateBlock(Accumulator accumulator) { BlockBuilder blockBuilder = accumulator.getIntermediateType().createBlockBuilder(new BlockBuilderStatus(), 1000); accumulator.evaluateIntermediate(blockBuilder); return blockBuilder.build(); }