@Test public void testEmpty() { InternalAggregationFunction bigIntAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("array_agg", AGGREGATE, parseTypeSignature("array(bigint)"), parseTypeSignature(StandardTypes.BIGINT))); assertAggregation( bigIntAgg, null, createLongsBlock(new Long[] {})); }
@Test public void averageOfNullIsNull() { assertAggregation(avgFunction, null, createBlockOfReals(null, null)); }
@Test public void testLargerHistograms() { MapType mapType = mapType(VARCHAR, BIGINT); InternalAggregationFunction aggregationFunction = getAggregation(mapType.getTypeSignature(), parseTypeSignature(StandardTypes.VARCHAR)); assertAggregation( aggregationFunction, ImmutableMap.of("a", 25L, "b", 10L, "c", 12L, "d", 1L, "e", 2L), createStringsBlock("a", "b", "c", "d", "e", "e", "c", "a", "a", "a", "b", "a", "a", "a", "a", "b", "a", "a", "a", "a", "b", "a", "a", "a", "a", "b", "a", "a", "a", "a", "b", "a", "c", "c", "b", "a", "c", "c", "b", "a", "c", "c", "b", "a", "c", "c", "b", "a", "c", "c")); }
@Test public void testBigInt() { InternalAggregationFunction bigIntAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("array_agg", AGGREGATE, parseTypeSignature("array(bigint)"), parseTypeSignature(StandardTypes.BIGINT))); assertAggregation( bigIntAgg, Arrays.asList(2L, 1L, 2L), createLongsBlock(new Long[] {2L, 1L, 2L})); }
@Test public void averageOfSingleValueEqualsThatValue() { assertAggregation(avgFunction, 1.23f, createBlockOfReals(1.23f)); }
@Test public void testSharedGroupBy() { MapType mapType = mapType(VARCHAR, BIGINT); InternalAggregationFunction aggregationFunction = getAggregation(mapType.getTypeSignature(), parseTypeSignature(StandardTypes.VARCHAR)); assertAggregation( aggregationFunction, ImmutableMap.of("a", 1L, "b", 1L, "c", 1L), createStringsBlock("a", "b", "c")); mapType = mapType(BIGINT, BIGINT); aggregationFunction = getAggregation(mapType.getTypeSignature(), parseTypeSignature(StandardTypes.BIGINT)); assertAggregation( aggregationFunction, ImmutableMap.of(100L, 1L, 200L, 1L, 300L, 1L), createLongsBlock(100L, 200L, 300L)); mapType = mapType(DOUBLE, BIGINT); aggregationFunction = getAggregation(mapType.getTypeSignature(), parseTypeSignature(StandardTypes.DOUBLE)); assertAggregation( aggregationFunction, ImmutableMap.of(0.1, 1L, 0.3, 1L, 0.2, 1L), createDoublesBlock(0.1, 0.3, 0.2)); mapType = mapType(BOOLEAN, BIGINT); aggregationFunction = getAggregation(mapType.getTypeSignature(), parseTypeSignature(StandardTypes.BOOLEAN)); assertAggregation( aggregationFunction, ImmutableMap.of(true, 1L, false, 1L), createBooleansBlock(true, false)); }
@Test public void testEmpty() { InternalAggregationFunction booleanAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("checksum", AGGREGATE, parseTypeSignature(VARBINARY), parseTypeSignature(BOOLEAN))); assertAggregation(booleanAgg, null, createBooleansBlock()); }
@Test public void averageOfTwoMaxFloatsEqualsMaxFloat() { assertAggregation(avgFunction, Float.MAX_VALUE, createBlockOfReals(Float.MAX_VALUE, Float.MAX_VALUE)); }
@Test public void testValidBoolean() { InternalAggregationFunction booleanAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("arbitrary", AGGREGATE, parseTypeSignature(StandardTypes.BOOLEAN), parseTypeSignature(StandardTypes.BOOLEAN))); assertAggregation( booleanAgg, true, createBooleansBlock(true, true)); }
@Test public void testArrayHistograms() { ArrayType arrayType = new ArrayType(VARCHAR); MapType mapType = mapType(arrayType, BIGINT); InternalAggregationFunction aggregationFunction = getAggregation(mapType.getTypeSignature(), arrayType.getTypeSignature()); assertAggregation( aggregationFunction, ImmutableMap.of(ImmutableList.of("a", "b", "c"), 1L, ImmutableList.of("d", "e", "f"), 1L, ImmutableList.of("c", "b", "a"), 1L), createStringArraysBlock(ImmutableList.of(ImmutableList.of("a", "b", "c"), ImmutableList.of("d", "e", "f"), ImmutableList.of("c", "b", "a")))); }
@Test public void testValidLong() { InternalAggregationFunction longAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("arbitrary", AGGREGATE, parseTypeSignature(StandardTypes.BIGINT), parseTypeSignature(StandardTypes.BIGINT))); assertAggregation( longAgg, 1L, createLongsBlock(1L, null)); }
@Test @Override public void testMultiplePositions() { assertAggregation(getFunction(), QDIGEST_EQUALITY, "test multiple positions", new Page(getSequenceBlocks(0, 5)), getExpectedValue(0, 5)); }
@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 testMapHistograms() { MapType innerMapType = mapType(VARCHAR, VARCHAR); MapType mapType = mapType(innerMapType, BIGINT); InternalAggregationFunction aggregationFunction = getAggregation(mapType.getTypeSignature(), innerMapType.getTypeSignature()); BlockBuilder builder = innerMapType.createBlockBuilder(null, 3); innerMapType.writeObject(builder, mapBlockOf(VARCHAR, VARCHAR, ImmutableMap.of("a", "b"))); innerMapType.writeObject(builder, mapBlockOf(VARCHAR, VARCHAR, ImmutableMap.of("c", "d"))); innerMapType.writeObject(builder, mapBlockOf(VARCHAR, VARCHAR, ImmutableMap.of("e", "f"))); assertAggregation( aggregationFunction, ImmutableMap.of(ImmutableMap.of("a", "b"), 1L, ImmutableMap.of("c", "d"), 1L, ImmutableMap.of("e", "f"), 1L), builder.build()); }
@Test public void testValidInt() { InternalAggregationFunction arrayAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("arbitrary", AGGREGATE, parseTypeSignature("integer"), parseTypeSignature("integer"))); assertAggregation( arrayAgg, 3, createIntsBlock(3, 3, null)); } }
@Test public void testRowHistograms() { RowType innerRowType = RowType.from(ImmutableList.of( RowType.field("f1", BIGINT), RowType.field("f2", DOUBLE))); MapType mapType = mapType(innerRowType, BIGINT); InternalAggregationFunction aggregationFunction = getAggregation(mapType.getTypeSignature(), innerRowType.getTypeSignature()); BlockBuilder builder = innerRowType.createBlockBuilder(null, 3); innerRowType.writeObject(builder, toRow(ImmutableList.of(BIGINT, DOUBLE), 1L, 1.0)); innerRowType.writeObject(builder, toRow(ImmutableList.of(BIGINT, DOUBLE), 2L, 2.0)); innerRowType.writeObject(builder, toRow(ImmutableList.of(BIGINT, DOUBLE), 3L, 3.0)); assertAggregation( aggregationFunction, ImmutableMap.of(ImmutableList.of(1L, 1.0), 1L, ImmutableList.of(2L, 2.0), 1L, ImmutableList.of(3L, 3.0), 1L), builder.build()); }
@Test public void testNullOnly() { InternalAggregationFunction bigIntAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("array_agg", AGGREGATE, parseTypeSignature("array(bigint)"), parseTypeSignature(StandardTypes.BIGINT))); assertAggregation( bigIntAgg, Arrays.asList(null, null, null), createLongsBlock(new Long[] {null, null, null})); }
@Test @Override public void testMixedNullAndNonNullPositions() { assertAggregation(getFunction(), QDIGEST_EQUALITY, "test mixed null and nonnull position", new Page(createAlternatingNullsBlock(getFunction().getParameterTypes(), getSequenceBlocks(0, 10))), getExpectedValueIncludingNulls(0, 10, 20)); } }
@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 testNullString() { InternalAggregationFunction stringAgg = metadata.getFunctionRegistry().getAggregateFunctionImplementation( new Signature("arbitrary", AGGREGATE, parseTypeSignature(StandardTypes.VARCHAR), parseTypeSignature(StandardTypes.VARCHAR))); assertAggregation( stringAgg, null, createStringsBlock(null, null)); }