@Override public Block[] getSequenceBlocks(int start, int length) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, length); for (int i = start; i < start + length; i++) { BIGINT.writeLong(blockBuilder, i); } return new Block[] {blockBuilder.build()}; }
@SqlType("array(bigint)") public static Block bigintUnion(@SqlType("array(bigint)") Block leftArray, @SqlType("array(bigint)") Block rightArray) { int leftArrayCount = leftArray.getPositionCount(); int rightArrayCount = rightArray.getPositionCount(); LongSet set = new LongOpenHashSet(leftArrayCount + rightArrayCount); BlockBuilder distinctElementBlockBuilder = BIGINT.createBlockBuilder(null, leftArrayCount + rightArrayCount); AtomicBoolean containsNull = new AtomicBoolean(false); appendBigintArray(leftArray, containsNull, set, distinctElementBlockBuilder); appendBigintArray(rightArray, containsNull, set, distinctElementBlockBuilder); return distinctElementBlockBuilder.build(); }
private static BlockBuilder writeValues(long[][] expectedValues, BlockBuilder blockBuilder) { for (long[] expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { BlockBuilder elementBlockBuilder = BIGINT.createBlockBuilder(null, expectedValue.length); for (long v : expectedValue) { BIGINT.writeLong(elementBlockBuilder, v); } blockBuilder.appendStructure(elementBlockBuilder); } } return blockBuilder; }
@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()}; }
@Test public void testPrimitiveByteSerialization() { StateCompiler compiler = new StateCompiler(); AccumulatorStateFactory<ByteState> factory = compiler.generateStateFactory(ByteState.class); AccumulatorStateSerializer<ByteState> serializer = compiler.generateStateSerializer(ByteState.class); ByteState state = factory.createSingleState(); ByteState deserializedState = factory.createSingleState(); state.setByte((byte) 3); BlockBuilder builder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 1); serializer.serialize(state, builder); Block block = builder.build(); serializer.deserialize(block, 0, deserializedState); assertEquals(deserializedState.getByte(), state.getByte()); }
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; }
public BlockBuilder createBlockBuilder() { return BIGINT.createBlockBuilder(new BlockBuilderStatus(), nextBatchSize); }
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(); }
@Override public Block[] getSequenceBlocks(int start, int length) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, length); for (int i = start; i < start + length; i++) { BIGINT.writeLong(blockBuilder, i); } return new Block[] {blockBuilder.build()}; }
private Page buildPage() { BlockBuilder col1 = BIGINT.createBlockBuilder(null, 1); col1.writeLong(42).closeEntry(); return new Page(col1.build()); }
@Test public void testPrimitiveLongSerialization() { StateCompiler compiler = new StateCompiler(); AccumulatorStateFactory<LongState> factory = compiler.generateStateFactory(LongState.class); AccumulatorStateSerializer<LongState> serializer = compiler.generateStateSerializer(LongState.class); LongState state = factory.createSingleState(); LongState deserializedState = factory.createSingleState(); state.setLong(2); BlockBuilder builder = BIGINT.createBlockBuilder(new BlockBuilderStatus(), 1); serializer.serialize(state, builder); Block block = builder.build(); assertEquals(BIGINT.getLong(block, 0), state.getLong()); serializer.deserialize(block, 0, deserializedState); assertEquals(deserializedState.getLong(), state.getLong()); }
BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, NUM_ROUNDS * (NUM_RANDOM_VALUES_IN_ROUND + NUM_EXISTING_VALUES_IN_ROUND)); HashTable hashTable = new HashTable(BIGINT, blockBuilder); Set<Long> valueSet = new HashSet<>(); for (int j = 0; j < NUM_RANDOM_VALUES_IN_ROUND; j++) { long value = rand.nextLong(); BIGINT.writeLong(blockBuilder, value); if (valueSet.contains(value)) { assertTrue(hashTable.contains(blockBuilder.getPositionCount() - 1)); BIGINT.writeLong(blockBuilder, value); assertTrue(hashTable.contains(blockBuilder.getPositionCount() - 1)); assertFalse(hashTable.addIfAbsent(blockBuilder.getPositionCount() - 1));
public BlockBuilder createBlockBuilder() { return BIGINT.createBlockBuilder(new BlockBuilderStatus(), nextBatchSize); }
@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 Block[] getSequenceBlocks(int start, int length) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, length); for (int i = start; i < start + length; i++) { BIGINT.writeLong(blockBuilder, i); } return new Block[] {blockBuilder.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(); }
@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()); }
@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 Block[] getSequenceBlocks(int start, int length) { BlockBuilder blockBuilder = BIGINT.createBlockBuilder(null, length); for (int i = start; i < start + length; i++) { BIGINT.writeLong(blockBuilder, i); } return new Block[] {blockBuilder.build()}; }
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()); } }