@Override Object extractValue(Block block, int position) { return DOUBLE.getDouble(block, position); }
@Override public void writeJsonValue(JsonGenerator jsonGenerator, Block block, int position, ConnectorSession session) throws IOException { if (block.isNull(position)) { jsonGenerator.writeNull(); } else { double value = DOUBLE.getDouble(block, position); jsonGenerator.writeNumber(value); } } }
@Override public void setField(Block block, int position) { value.set(DoubleType.DOUBLE.getDouble(block, position)); rowInspector.setStructFieldData(row, field, value); } }
@Override public void deserialize(Block block, int index, NullableDoubleState state) { state.setNull(false); state.setDouble(DOUBLE.getDouble(block, index)); } }
public static FeatureVector toFeatures(Block map) { Map<Integer, Double> features = new HashMap<>(); if (map != null) { for (int position = 0; position < map.getPositionCount(); position += 2) { features.put((int) BIGINT.getLong(map, position), DOUBLE.getDouble(map, position + 1)); } } return new FeatureVector(features); } }
private double getRadius(int joinPosition) { long joinAddress = addresses.getLong(joinPosition); int blockIndex = decodeSliceIndex(joinAddress); int blockPosition = decodePosition(joinAddress); return DOUBLE.getDouble(channels.get(radiusChannel).get(blockIndex), blockPosition); }
private static void initializePercentilesArray(@AggregationState DigestAndPercentileArrayState state, Block percentilesArrayBlock) { if (state.getPercentiles() == null) { ImmutableList.Builder<Double> percentilesListBuilder = ImmutableList.builder(); for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) { checkCondition(!percentilesArrayBlock.isNull(i), INVALID_FUNCTION_ARGUMENT, "Percentile cannot be null"); double percentile = DOUBLE.getDouble(percentilesArrayBlock, i); checkCondition(0 <= percentile && percentile <= 1, INVALID_FUNCTION_ARGUMENT, "Percentile must be between 0 and 1"); percentilesListBuilder.add(percentile); } state.setPercentiles(percentilesListBuilder.build()); } }
private static double mapDotProduct(Block leftMap, Block rightMap) { TypedSet rightMapKeys = new TypedSet(VARCHAR, rightMap.getPositionCount(), "cosine_similarity"); for (int i = 0; i < rightMap.getPositionCount(); i += 2) { rightMapKeys.add(rightMap, i); } double result = 0.0; for (int i = 0; i < leftMap.getPositionCount(); i += 2) { int position = rightMapKeys.positionOf(leftMap, i); if (position != -1) { result += DOUBLE.getDouble(leftMap, i + 1) * DOUBLE.getDouble(rightMap, 2 * position + 1); } } return result; }
@SqlType(StandardTypes.BOOLEAN) public static boolean isDistinctFrom( @BlockPosition @SqlType(value = StandardTypes.DOUBLE, nativeContainerType = double.class) Block leftBlock, @BlockIndex int leftPosition, @BlockPosition @SqlType(value = StandardTypes.DOUBLE, nativeContainerType = double.class) Block rightBlock, @BlockIndex int rightPosition) { if (leftBlock.isNull(leftPosition) != rightBlock.isNull(rightPosition)) { return true; } if (leftBlock.isNull(leftPosition)) { return false; } double left = DOUBLE.getDouble(leftBlock, leftPosition); double right = DOUBLE.getDouble(rightBlock, rightPosition); if (Double.isNaN(left) && Double.isNaN(right)) { return false; } return notEqual(left, right); } }
private static boolean filter(Page page, int position) { Block discountBlock = page.getBlock(0); Block shipDateBlock = page.getBlock(1); Block quantityBlock = page.getBlock(2); return !shipDateBlock.isNull(position) && DATE.getLong(shipDateBlock, position) >= MIN_SHIP_DATE && !shipDateBlock.isNull(position) && DATE.getLong(shipDateBlock, position) < MAX_SHIP_DATE && !discountBlock.isNull(position) && DOUBLE.getDouble(discountBlock, position) >= 0.05 && !discountBlock.isNull(position) && DOUBLE.getDouble(discountBlock, position) <= 0.07 && !quantityBlock.isNull(position) && BIGINT.getLong(quantityBlock, position) < 24; } }
double radius = radiusChannel.map(channel -> DOUBLE.getDouble(channels.get(channel).get(blockIndex), blockPosition)).orElse(0.0); if (radius < 0) { continue;
@Description("The bucket number of a value given an array of bins") @ScalarFunction("width_bucket") @SqlType(StandardTypes.BIGINT) public static long widthBucket(@SqlType(StandardTypes.DOUBLE) double operand, @SqlType("array(double)") Block bins) { int numberOfBins = bins.getPositionCount(); checkCondition(numberOfBins > 0, INVALID_FUNCTION_ARGUMENT, "Bins cannot be an empty array"); checkCondition(!isNaN(operand), INVALID_FUNCTION_ARGUMENT, "Operand cannot be NaN"); int lower = 0; int upper = numberOfBins; int index; double bin; while (lower < upper) { if (DOUBLE.getDouble(bins, lower) > DOUBLE.getDouble(bins, upper - 1)) { throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Bin values are not sorted in ascending order"); } index = (lower + upper) / 2; bin = DOUBLE.getDouble(bins, index); if (!isFinite(bin)) { throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Bin value must be finite, got " + bin); } if (operand < bin) { upper = index; } else { lower = index + 1; } } return lower; }
private static boolean filter(int position, Block discountBlock, Block shipDateBlock, Block quantityBlock) { return !shipDateBlock.isNull(position) && VARCHAR.getSlice(shipDateBlock, position).compareTo(MIN_SHIP_DATE) >= 0 && !shipDateBlock.isNull(position) && VARCHAR.getSlice(shipDateBlock, position).compareTo(MAX_SHIP_DATE) < 0 && !discountBlock.isNull(position) && DOUBLE.getDouble(discountBlock, position) >= 0.05 && !discountBlock.isNull(position) && DOUBLE.getDouble(discountBlock, position) <= 0.07 && !quantityBlock.isNull(position) && DOUBLE.getDouble(quantityBlock, position) < 24; } }
private static void project(int position, PageBuilder pageBuilder, Block extendedPriceBlock, Block discountBlock) { pageBuilder.declarePosition(); if (discountBlock.isNull(position) || extendedPriceBlock.isNull(position)) { pageBuilder.getBlockBuilder(0).appendNull(); } else { DOUBLE.writeDouble(pageBuilder.getBlockBuilder(0), DOUBLE.getDouble(extendedPriceBlock, position) * DOUBLE.getDouble(discountBlock, position)); } }
public static PrestoThriftBlock fromBlock(Block block) { int positions = block.getPositionCount(); if (positions == 0) { return booleanData(new PrestoThriftBoolean(null, null)); } boolean[] nulls = null; double[] doubles = null; for (int position = 0; position < positions; position++) { if (block.isNull(position)) { if (nulls == null) { nulls = new boolean[positions]; } nulls[position] = true; } else { if (doubles == null) { doubles = new double[positions]; } doubles[position] = DOUBLE.getDouble(block, position); } } return doubleData(new PrestoThriftDouble(nulls, doubles)); }
@SqlType(StandardTypes.DOUBLE) @SqlNullable public static Double getDouble(@BlockPosition @SqlType(value = StandardTypes.DOUBLE, nativeContainerType = double.class) Block block, @BlockIndex int position) { hitBlockPositionDouble.set(true); return DOUBLE.getDouble(block, position); } }
@ScalarFunction("values_at_quantiles") @Description("For each input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType("array(real)") public static Block valuesAtQuantilesReal(@SqlType("qdigest(real)") Slice input, @SqlType("array(double)") Block percentilesArrayBlock) { QuantileDigest digest = new QuantileDigest(input); BlockBuilder output = REAL.createBlockBuilder(null, percentilesArrayBlock.getPositionCount()); for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) { REAL.writeLong(output, floatToRawIntBits(sortableIntToFloat((int) digest.getQuantile(DOUBLE.getDouble(percentilesArrayBlock, i))))); } return output.build(); }
@ScalarFunction("values_at_quantiles") @Description("For each input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType("array(bigint)") public static Block valuesAtQuantilesBigint(@SqlType("qdigest(bigint)") Slice input, @SqlType("array(double)") Block percentilesArrayBlock) { QuantileDigest digest = new QuantileDigest(input); BlockBuilder output = BIGINT.createBlockBuilder(null, percentilesArrayBlock.getPositionCount()); for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) { BIGINT.writeLong(output, digest.getQuantile(DOUBLE.getDouble(percentilesArrayBlock, i))); } return output.build(); }
@ScalarFunction("values_at_quantiles") @Description("For each input q between [0, 1], find the value whose rank in the sorted sequence of the n values represented by the qdigest is qn.") @SqlType("array(double)") public static Block valuesAtQuantilesDouble(@SqlType("qdigest(double)") Slice input, @SqlType("array(double)") Block percentilesArrayBlock) { QuantileDigest digest = new QuantileDigest(input); BlockBuilder output = DOUBLE.createBlockBuilder(null, percentilesArrayBlock.getPositionCount()); for (int i = 0; i < percentilesArrayBlock.getPositionCount(); i++) { DOUBLE.writeDouble(output, sortableLongToDouble(digest.getQuantile(DOUBLE.getDouble(percentilesArrayBlock, i)))); } return output.build(); }