public static Block createDoublesBlock(Double... values) { requireNonNull(values, "varargs 'values' is null"); return createDoublesBlock(Arrays.asList(values)); }
@Test public void testDivisionByZero() { testAggregation(null, createDoublesBlock(2.0, 2.0, 2.0, 2.0, 2.0), createDoublesBlock(1.0, 4.0, 9.0, 16.0, 25.0)); testAggregation(null, createDoublesBlock(1.0, 4.0, 9.0, 16.0, 25.0), createDoublesBlock(2.0, 2.0, 2.0, 2.0, 2.0)); }
private void testCustomAggregation(Double[] values, int n) { PriorityQueue<Double> heap = new PriorityQueue<>(n, (x, y) -> -Double.compare(x, y)); Arrays.stream(values).filter(x -> x != null).forEach(heap::add); Double[] expected = new Double[heap.size()]; for (int i = heap.size() - 1; i >= 0; i--) { expected[i] = heap.remove(); } testAggregation(Arrays.asList(expected), createDoublesBlock(values), createLongRepeatBlock(n, values.length)); } }
private void testNonTrivialAggregation(Double[] y, Double[] x) { SimpleRegression regression = new SimpleRegression(); for (int i = 0; i < x.length; i++) { regression.addData(x[i], y[i]); } double expected = regression.getSlope(); checkArgument(Double.isFinite(expected) && expected != 0.0, "Expected result is trivial"); testAggregation(expected, createDoublesBlock(y), createDoublesBlock(x)); } }
@Test public void testMaxNull() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("max_by", AGGREGATE, parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, null, createDoublesBlock(1.0, null), createDoublesBlock(1.0, 2.0)); assertAggregation( function, 10.0, createDoublesBlock(8.0, 9.0, 10.0, 11.0), createDoublesBlock(-2.0, null, -1.0, null)); }
@Test public void testMinDoubleDouble() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("min_by", AGGREGATE, parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, null, createDoublesBlock(null, null), createDoublesBlock(null, null)); assertAggregation( function, 3.0, createDoublesBlock(3.0, 2.0, 5.0, 3.0), createDoublesBlock(1.0, 1.5, 2.0, 4.0)); }
@Test public void testMaxDoubleDouble() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("max_by", AGGREGATE, parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, null, createDoublesBlock(null, null), createDoublesBlock(null, null)); assertAggregation( function, 2.0, createDoublesBlock(3.0, 2.0, null), createDoublesBlock(1.0, 1.5, null)); }
private void testNonTrivialAggregation(Double[] y, Double[] x) { SimpleRegression regression = new SimpleRegression(); for (int i = 0; i < x.length; i++) { regression.addData(x[i], y[i]); } double expected = regression.getIntercept(); checkArgument(Double.isFinite(expected) && expected != 0., "Expected result is trivial"); testAggregation(expected, createDoublesBlock(y), createDoublesBlock(x)); } }
private void testNonTrivialAggregation(double[] y, double[] x) { PearsonsCorrelation corr = new PearsonsCorrelation(); double expected = corr.correlation(x, y); checkArgument(Double.isFinite(expected) && expected != 0.0 && expected != 1.0, "Expected result is trivial"); testAggregation(expected, createDoublesBlock(box(y)), createDoublesBlock(box(x))); }
@Test public void testMaxDoubleLongArray() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("max_by", AGGREGATE, parseTypeSignature("array(bigint)"), parseTypeSignature("array(bigint)"), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, null, createArrayBigintBlock(asList(asList(3L, 4L), null, asList(2L, 2L))), createDoublesBlock(1.0, 2.0, null)); assertAggregation( function, asList(2L, 2L), createArrayBigintBlock(asList(asList(3L, 4L), null, asList(2L, 2L))), createDoublesBlock(0.0, 1.0, 2.0)); }
@Test public void testContains() { Block valuesBlock = BlockAssertions.createDoubleSequenceBlock(0, 10); Block hashBlock = TypeUtils.getHashBlock(ImmutableList.of(DOUBLE), valuesBlock); GroupByHash groupByHash = createGroupByHash(TEST_SESSION, ImmutableList.of(DOUBLE), new int[] {0}, Optional.of(1), 100, JOIN_COMPILER); groupByHash.getGroupIds(new Page(valuesBlock, hashBlock)).process(); Block testBlock = BlockAssertions.createDoublesBlock((double) 3); Block testHashBlock = TypeUtils.getHashBlock(ImmutableList.of(DOUBLE), testBlock); assertTrue(groupByHash.contains(0, new Page(testBlock, testHashBlock), CONTAINS_CHANNELS)); testBlock = BlockAssertions.createDoublesBlock(11.0); testHashBlock = TypeUtils.getHashBlock(ImmutableList.of(DOUBLE), testBlock); assertFalse(groupByHash.contains(0, new Page(testBlock, testHashBlock), CONTAINS_CHANNELS)); }
@Test public void testMinDoubleLongArray() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("min_by", AGGREGATE, parseTypeSignature("array(bigint)"), parseTypeSignature("array(bigint)"), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, asList(3L, 4L), createArrayBigintBlock(asList(asList(3L, 4L), null, asList(2L, 2L))), createDoublesBlock(1.0, 2.0, 3.0)); assertAggregation( function, null, createArrayBigintBlock(asList(null, null, asList(2L, 2L))), createDoublesBlock(0.0, 1.0, 2.0)); }
@Test public void testContainsMultipleColumns() { Block valuesBlock = BlockAssertions.createDoubleSequenceBlock(0, 10); Block stringValuesBlock = BlockAssertions.createStringSequenceBlock(0, 10); Block hashBlock = TypeUtils.getHashBlock(ImmutableList.of(DOUBLE, VARCHAR), valuesBlock, stringValuesBlock); int[] hashChannels = {0, 1}; GroupByHash groupByHash = createGroupByHash(TEST_SESSION, ImmutableList.of(DOUBLE, VARCHAR), hashChannels, Optional.of(2), 100, JOIN_COMPILER); groupByHash.getGroupIds(new Page(valuesBlock, stringValuesBlock, hashBlock)).process(); Block testValuesBlock = BlockAssertions.createDoublesBlock((double) 3); Block testStringValuesBlock = BlockAssertions.createStringsBlock("3"); Block testHashBlock = TypeUtils.getHashBlock(ImmutableList.of(DOUBLE, VARCHAR), testValuesBlock, testStringValuesBlock); assertTrue(groupByHash.contains(0, new Page(testValuesBlock, testStringValuesBlock, testHashBlock), hashChannels)); }
private void testInvalidAggregation(Double[] x, int n) { try { testAggregation(new long[] {}, createDoublesBlock(x), createLongRepeatBlock(n, x.length)); } catch (PrestoException e) { assertEquals(e.getErrorCode().getName(), INVALID_FUNCTION_ARGUMENT.name()); } }
@Test public void testNullDouble() { InternalAggregationFunction doubleAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("arbitrary", AGGREGATE, parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( doubleAgg, null, createDoublesBlock(null, null)); }
@Test public void testValidDouble() { InternalAggregationFunction doubleAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("arbitrary", AGGREGATE, parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( doubleAgg, 2.0, createDoublesBlock(null, 2.0)); }
@Test public void testMaxDoubleVarchar() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("max_by", AGGREGATE, parseTypeSignature(StandardTypes.VARCHAR), parseTypeSignature(StandardTypes.VARCHAR), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, "a", createStringsBlock("z", "a", null), createDoublesBlock(1.0, 2.0, null)); assertAggregation( function, "hi", createStringsBlock("zz", "hi", null, "a"), createDoublesBlock(0.0, 1.0, null, -1.0)); }
@Test public void testMinDoubleVarchar() { InternalAggregationFunction function = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("min_by", AGGREGATE, parseTypeSignature(StandardTypes.VARCHAR), parseTypeSignature(StandardTypes.VARCHAR), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( function, "z", createStringsBlock("z", "a", "x", "b"), createDoublesBlock(1.0, 2.0, 2.0, 3.0)); assertAggregation( function, "a", createStringsBlock("zz", "hi", "bb", "a"), createDoublesBlock(0.0, 1.0, 2.0, -1.0)); }
@Test public void testDouble() { InternalAggregationFunction doubleAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("checksum", AGGREGATE, parseTypeSignature(VARBINARY), parseTypeSignature(DOUBLE))); Block block = createDoublesBlock(null, 2.0, null, 3.0, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN); assertAggregation(doubleAgg, expectedChecksum(DoubleType.DOUBLE, block), block); }
@Test public void testMinUnknown() { InternalAggregationFunction unknownKey = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("min_by", AGGREGATE, parseTypeSignature(UnknownType.NAME), parseTypeSignature(UnknownType.NAME), parseTypeSignature(StandardTypes.DOUBLE))); assertAggregation( unknownKey, null, createBooleansBlock(null, null), createDoublesBlock(1.0, 2.0)); InternalAggregationFunction unknownValue = METADATA.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("min_by", AGGREGATE, parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(StandardTypes.DOUBLE), parseTypeSignature(UnknownType.NAME))); assertAggregation( unknownKey, null, createDoublesBlock(1.0, 2.0), createBooleansBlock(null, null)); }