@Override public void decodeValueInto(BlockBuilder builder, Slice slice, int offset, int length) { long longBits = slice.getLong(offset); // the file format uses big endian double value = Double.longBitsToDouble(Long.reverseBytes(longBits)); type.writeDouble(builder, value); } }
public void nextVector(Type type, int items, BlockBuilder builder) throws IOException { for (int i = 0; i < items; i++) { type.writeDouble(builder, next()); } } }
@Override void writeFirstField(BlockBuilder out, DoubleAndBlockPositionValueState state) { firstType.writeDouble(out, state.getFirst()); } }
@Override public void decodeValueInto(int depth, BlockBuilder builder, Slice slice, int offset, int length) throws RcFileCorruptionException { type.writeDouble(builder, parseDouble(slice, offset, length)); }
public static void providedBlockDouble(Type type, BlockBuilder output, double value) { hitProvidedBlockBuilderDouble.incrementAndGet(); type.writeDouble(output, value); }
static void write(Type type, NullableDoubleState state, BlockBuilder out) { if (state.isNull()) { out.appendNull(); } else { type.writeDouble(out, state.getDouble()); } } }
public static void providedBlockDouble(Type type, BlockBuilder output, Double value) { hitProvidedBlockBuilderDouble.incrementAndGet(); if (value == null) { output.appendNull(); } else { type.writeDouble(output, value); } }
private static Block serializePrimitive(Type type, BlockBuilder builder, Object object) { requireNonNull(builder, "builder is null"); if (object == null) { builder.appendNull(); return builder.build(); } if (type.equals(BOOLEAN)) { type.writeBoolean(builder, (Boolean) object); } else if (type.equals(BIGINT)) { type.writeLong(builder, (Long) object); } else if (type.equals(DOUBLE)) { type.writeDouble(builder, (Double) object); } else if (type.equals(INTEGER)) { type.writeLong(builder, (Integer) object); } else if (type.equals(VARCHAR) || type.equals(VARBINARY)) { type.writeSlice(builder, utf8Slice(object.toString())); } else { throw new IllegalArgumentException("Unknown primitive type: " + type.getDisplayName()); } return builder.build(); } }
@Override protected void readValue(BlockBuilder blockBuilder, Type type) { if (definitionLevel == columnDescriptor.getMaxDefinitionLevel()) { type.writeDouble(blockBuilder, valuesReader.readDouble()); } else if (isValueNull()) { blockBuilder.appendNull(); } }
@Override public Block decodeColumn(ColumnData columnData) { int size = columnData.rowCount(); BlockBuilder builder = type.createBlockBuilder(null, size); Slice slice = columnData.getSlice(); for (int i = 0; i < size; i++) { int length = columnData.getLength(i); if (length != 0) { checkState(length == SIZE_OF_DOUBLE, "Double should be 8 bytes"); long longBits = slice.getLong(columnData.getOffset(i)); // the file format uses big endian type.writeDouble(builder, Double.longBitsToDouble(Long.reverseBytes(longBits))); } else { builder.appendNull(); } } return builder.build(); }
private static void serializeGeneric(BlockBuilder blockBuilder, Object value, Type type, String columnName) { requireNonNull(blockBuilder, "parent blockBuilder is null"); if (value == null) { blockBuilder.appendNull(); return; } switch (type.getTypeSignature().getBase()) { case BOOLEAN: type.writeBoolean(blockBuilder, (Boolean) value); break; case BIGINT: type.writeLong(blockBuilder, (Long) value); break; case DOUBLE: type.writeDouble(blockBuilder, (Double) value); break; case VARCHAR: case VARBINARY: type.writeSlice(blockBuilder, getSlice(value, type, columnName)); break; default: throw new PrestoException(DECODER_CONVERSION_NOT_SUPPORTED, format("cannot decode object of '%s' as '%s' for column '%s'", value.getClass(), type, columnName)); } }
@UsedByGeneratedCode public static Block appendElement(Type elementType, Block block, double value) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } elementType.writeDouble(blockBuilder, value); return blockBuilder.build(); }
@UsedByGeneratedCode public static Block prependElement(Type elementType, double value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeDouble(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); } }
private static Block createChannel(int arraySize, Type elementType) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, arraySize); for (int i = 0; i < arraySize; i++) { if (elementType.getJavaType() == long.class) { elementType.writeLong(blockBuilder, (long) i); } else if (elementType.getJavaType() == double.class) { elementType.writeDouble(blockBuilder, ThreadLocalRandom.current().nextDouble()); } else if (elementType.getJavaType() == boolean.class) { elementType.writeBoolean(blockBuilder, ThreadLocalRandom.current().nextBoolean()); } else if (elementType.equals(VARCHAR)) { // make sure the size of a varchar is rather small; otherwise the aggregated slice may overflow elementType.writeSlice(blockBuilder, Slices.utf8Slice(Long.toString(ThreadLocalRandom.current().nextLong() % 100))); } else { throw new UnsupportedOperationException(); } } return blockBuilder.build(); }
@TypeParameter("T") @SqlType("array(T)") public static Block repeat( @TypeParameter("T") Type type, @SqlNullable @SqlType("T") Double element, @SqlType(StandardTypes.INTEGER) long count) { BlockBuilder blockBuilder = createBlockBuilder(type, count); if (element == null) { return repeatNullValues(blockBuilder, count); } for (int i = 0; i < count; i++) { type.writeDouble(blockBuilder, element); } return blockBuilder.build(); }
private static Block createChannel(int positionCount, int arraySize, Type elementType) { ArrayType arrayType = new ArrayType(elementType); BlockBuilder blockBuilder = arrayType.createBlockBuilder(null, positionCount); for (int position = 0; position < positionCount; position++) { BlockBuilder entryBuilder = blockBuilder.beginBlockEntry(); for (int i = 0; i < arraySize; i++) { if (elementType.getJavaType() == long.class) { elementType.writeLong(entryBuilder, ThreadLocalRandom.current().nextLong() % arraySize); } else if (elementType.getJavaType() == double.class) { elementType.writeDouble(entryBuilder, ThreadLocalRandom.current().nextDouble() % arraySize); } else if (elementType.getJavaType() == boolean.class) { elementType.writeBoolean(entryBuilder, ThreadLocalRandom.current().nextBoolean()); } else if (elementType.equals(VARCHAR)) { // make sure the size of a varchar is rather small; otherwise the aggregated slice may overflow elementType.writeSlice(entryBuilder, Slices.utf8Slice(Long.toString(ThreadLocalRandom.current().nextLong() % arraySize))); } else { throw new UnsupportedOperationException(); } } blockBuilder.closeEntry(); } return blockBuilder.build(); }
@Override public Block decodeColumn(ColumnData columnData) throws RcFileCorruptionException { int size = columnData.rowCount(); BlockBuilder builder = type.createBlockBuilder(null, size); Slice slice = columnData.getSlice(); for (int i = 0; i < size; i++) { int offset = columnData.getOffset(i); int length = columnData.getLength(i); if (length == 0 || nullSequence.equals(0, nullSequence.length(), slice, offset, length)) { builder.appendNull(); } else { type.writeDouble(builder, parseDouble(slice, offset, length)); } } return builder.build(); }
private static Block createChannel(int positionCount, int arraySize, ArrayType arrayType) { BlockBuilder blockBuilder = arrayType.createBlockBuilder(null, positionCount); for (int position = 0; position < positionCount; position++) { BlockBuilder entryBuilder = blockBuilder.beginBlockEntry(); for (int i = 0; i < arraySize; i++) { if (arrayType.getElementType().getJavaType() == long.class) { arrayType.getElementType().writeLong(entryBuilder, ThreadLocalRandom.current().nextLong()); } else if (arrayType.getElementType().getJavaType() == double.class) { arrayType.getElementType().writeDouble(entryBuilder, ThreadLocalRandom.current().nextDouble()); } else if (arrayType.getElementType().getJavaType() == boolean.class) { arrayType.getElementType().writeBoolean(entryBuilder, ThreadLocalRandom.current().nextBoolean()); } else if (arrayType.getElementType().equals(VARCHAR)) { arrayType.getElementType().writeSlice(entryBuilder, Slices.utf8Slice("test_string")); } else { throw new UnsupportedOperationException(); } } blockBuilder.closeEntry(); } return blockBuilder.build(); }
private static Block createBlock(Type type, Object value) { BlockBuilder blockBuilder = type.createBlockBuilder(null, 1); Class<?> javaType = type.getJavaType(); if (value == null) { blockBuilder.appendNull(); } else if (javaType == boolean.class) { type.writeBoolean(blockBuilder, (Boolean) value); } else if (javaType == long.class) { type.writeLong(blockBuilder, (Long) value); } else if (javaType == double.class) { type.writeDouble(blockBuilder, (Double) value); } else if (javaType == Slice.class) { Slice slice = (Slice) value; type.writeSlice(blockBuilder, slice, 0, slice.length()); } else { type.writeObject(blockBuilder, value); } return blockBuilder.build(); }
private Block toBlock(Object value) { BlockBuilder blockBuilder = type.createBlockBuilder(null, 1); Class<?> javaType = type.getJavaType(); if (value == null) { blockBuilder.appendNull(); } else if (javaType == boolean.class) { type.writeBoolean(blockBuilder, (Boolean) value); } else if (javaType == long.class) { type.writeLong(blockBuilder, (Long) value); } else if (javaType == double.class) { type.writeDouble(blockBuilder, (Double) value); } else if (javaType == Slice.class) { Slice slice = (Slice) value; type.writeSlice(blockBuilder, slice, 0, slice.length()); } else { type.writeObject(blockBuilder, value); } return blockBuilder.build(); }