@Override public void writeSlice(BlockBuilder blockBuilder, Slice value, int offset, int length) { blockBuilder.writeBytes(value, offset, length).closeEntry(); } }
@Override public void writeSlice(BlockBuilder blockBuilder, Slice value, int offset, int length) { blockBuilder.writeBytes(value, offset, length).closeEntry(); } }
@Override public void writeLong(BlockBuilder blockBuilder, long value) { blockBuilder.writeLong(value).closeEntry(); } }
@Override public void serialize(TriStateBooleanState state, BlockBuilder out) { if (state.getByte() == NULL_VALUE) { out.appendNull(); } else { out.writeByte(state.getByte() == TRUE_VALUE ? 1 : 0).closeEntry(); } }
public void serialize(BlockBuilder out) { BlockBuilder mapBlockBuilder = out.beginBlockEntry(); for (int i = 0; i < keyBlockBuilder.getPositionCount(); i++) { keyType.appendTo(keyBlockBuilder, i, mapBlockBuilder); valueType.appendTo(valueBlockBuilder, i, mapBlockBuilder); } out.closeEntry(); }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { block.writeBytesTo(position, 0, getFixedSize(), blockBuilder); blockBuilder.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 serialize(ArrayAggregationState state, BlockBuilder out) { if (state.isEmpty()) { out.appendNull(); } else { BlockBuilder entryBuilder = out.beginBlockEntry(); state.forEach((block, position) -> elementType.appendTo(block, position, entryBuilder)); out.closeEntry(); } }
public static Block toRow(List<Type> parameterTypes, Object... values) { checkArgument(parameterTypes.size() == values.length, "parameterTypes.size(" + parameterTypes.size() + ") does not equal to values.length(" + values.length + ")"); RowType rowType = RowType.anonymous(parameterTypes); BlockBuilder blockBuilder = new RowBlockBuilder(parameterTypes, null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < values.length; i++) { appendToBlockBuilder(parameterTypes.get(i), values[i], singleRowBlockWriter); } blockBuilder.closeEntry(); return rowType.getObject(blockBuilder, 0); }
private void assertRowHashOperator(String inputString, List<Type> types, List<Object> elements) { checkArgument(types.size() == elements.size(), "types and elements must have the same size"); RowType rowType = RowType.anonymous(types); BlockBuilder blockBuilder = rowType.createBlockBuilder(null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < types.size(); i++) { appendToBlockBuilder(types.get(i), elements.get(i), singleRowBlockWriter); } blockBuilder.closeEntry(); assertOperator(HASH_CODE, inputString, BIGINT, rowType.hash(blockBuilder.build(), 0)); }
private static void writeValues(Slice[] expectedValues, BlockBuilder blockBuilder) { for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeLong(expectedValue.getLong(0)).closeEntry(); } } }
private static void writeValues(Slice[] expectedValues, BlockBuilder blockBuilder) { for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeShort(expectedValue.getShort(0)).closeEntry(); } } }
private static void writeValues(Slice[] expectedValues, BlockBuilder blockBuilder) { for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeBytes(expectedValue, 0, expectedValue.length()).closeEntry(); } } }
public static Block mapBlockOf(Type keyType, Type valueType, Map<?, ?> value) { MapType mapType = mapType(keyType, valueType); BlockBuilder mapArrayBuilder = mapType.createBlockBuilder(null, 1); BlockBuilder singleMapWriter = mapArrayBuilder.beginBlockEntry(); for (Map.Entry<?, ?> entry : value.entrySet()) { appendToBlockBuilder(keyType, entry.getKey(), singleMapWriter); appendToBlockBuilder(valueType, entry.getValue(), singleMapWriter); } mapArrayBuilder.closeEntry(); return mapType.getObject(mapArrayBuilder, 0); }
private static void writeValues(Slice[] expectedValues, BlockBuilder blockBuilder) { for (Slice expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { blockBuilder.writeByte(expectedValue.getByte(0)).closeEntry(); } } }
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()); } }
@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()); } }
@Override public void appendTo(Block block, int position, BlockBuilder blockBuilder) { if (block.isNull(position)) { blockBuilder.appendNull(); } else { blockBuilder.writeLong(block.getLong(position, 0)).closeEntry(); } }
@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); }
private static RunLengthEncodedBlock createRLEBlock(Iterable<Double> percentiles, int positionCount) { BlockBuilder rleBlockBuilder = new ArrayType(DOUBLE).createBlockBuilder(null, 1); BlockBuilder arrayBlockBuilder = rleBlockBuilder.beginBlockEntry(); for (double percentile : percentiles) { DOUBLE.writeDouble(arrayBlockBuilder, percentile); } rleBlockBuilder.closeEntry(); return new RunLengthEncodedBlock(rleBlockBuilder.build(), positionCount); } }