@Override public ArithmeticPostAggregator decorate(Map<String, AggregatorFactory> aggregators) { return new ArithmeticPostAggregator(name, fnName, Queries.decoratePostAggregators(fields, aggregators), ordering); }
@Test public void testComputedInArithmeticPostAggregator() { String aggName = "billy"; AggregatorFactory aggFactory = EasyMock.createMock(AggregatorFactory.class); EasyMock.expect(aggFactory.getComparator()).andReturn(Comparators.naturalNullsFirst()).once(); EasyMock.expect(aggFactory.finalizeComputation("test")).andReturn(3L).once(); EasyMock.replay(aggFactory); FinalizingFieldAccessPostAggregator postAgg = buildDecorated( "final_billy", aggName, ImmutableMap.of(aggName, aggFactory) ); Map<String, Object> metricValues = new HashMap<>(); metricValues.put(aggName, "test"); List<PostAggregator> postAggsList = Lists.newArrayList( new ConstantPostAggregator("roku", 6), postAgg); ArithmeticPostAggregator arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggsList); Assert.assertEquals(new Double(9.0f), arithmeticPostAggregator.compute(metricValues)); EasyMock.verify(); }
new ArithmeticPostAggregator( "divideStuff", "/", Arrays.asList( new ArithmeticPostAggregator( "addStuff", "+", new ArithmeticPostAggregator( "subtractStuff", "-", new ArithmeticPostAggregator( "addStuff", "+",
new ArithmeticPostAggregator( "divideStuff", "/", Arrays.asList( new ArithmeticPostAggregator( "addStuff", "+", new ArithmeticPostAggregator( "subtractStuff", "-", new ArithmeticPostAggregator( "addStuff", "+",
for (int i = 0; i < postAggCount; i++) { postAggregators.add( new ArithmeticPostAggregator( "addrowsindexconstant" + i, "+",
@Test public void testNullPostAggregatorNames() { AggregatorFactory agg1 = new DoubleSumAggregatorFactory("agg1", "value"); AggregatorFactory agg2 = new DoubleSumAggregatorFactory("agg2", "count"); PostAggregator postAgg1 = new ArithmeticPostAggregator( null, "*", Lists.newArrayList(new FieldAccessPostAggregator(null, "agg1"), new FieldAccessPostAggregator(null, "agg2")) ); PostAggregator postAgg2 = new ArithmeticPostAggregator( "postAgg", "/", Lists.newArrayList(new FieldAccessPostAggregator(null, "agg1"), new FieldAccessPostAggregator(null, "agg2")) ); Assert.assertEquals( new Pair<>(Lists.newArrayList(agg1, agg2), Collections.singletonList(postAgg2)), AggregatorUtil.condensedAggregators( Lists.newArrayList(agg1, agg2), Lists.newArrayList(postAgg1, postAgg2), "postAgg" ) ); }
@Test public void testCasing() { AggregatorFactory agg1 = new DoubleSumAggregatorFactory("Agg1", "value"); AggregatorFactory agg2 = new DoubleSumAggregatorFactory("Agg2", "count"); PostAggregator postAgg1 = new ArithmeticPostAggregator( null, "*", Lists.newArrayList(new FieldAccessPostAggregator(null, "Agg1"), new FieldAccessPostAggregator(null, "Agg2")) ); PostAggregator postAgg2 = new ArithmeticPostAggregator( "postAgg", "/", Lists.newArrayList(new FieldAccessPostAggregator(null, "Agg1"), new FieldAccessPostAggregator(null, "Agg2")) ); Assert.assertEquals( new Pair<>(Lists.newArrayList(agg1, agg2), Collections.singletonList(postAgg2)), AggregatorUtil.condensedAggregators( Lists.newArrayList(agg1, agg2), Lists.newArrayList(postAgg1, postAgg2), "postAgg" ) ); }
@Test public void testNumericFirstOrdering() { ArithmeticPostAggregator agg = new ArithmeticPostAggregator( null, "quotient", ImmutableList.of( new ConstantPostAggregator("zero", 0), new ConstantPostAggregator("zero", 0) ), "numericFirst" ); final Comparator numericFirst = agg.getComparator(); Assert.assertTrue(numericFirst.compare(Double.NaN, 0.0) < 0); Assert.assertTrue(numericFirst.compare(Double.POSITIVE_INFINITY, 0.0) < 0); Assert.assertTrue(numericFirst.compare(Double.NEGATIVE_INFINITY, 0.0) < 0); Assert.assertTrue(numericFirst.compare(0.0, Double.NaN) > 0); Assert.assertTrue(numericFirst.compare(0.0, Double.POSITIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(0.0, Double.NEGATIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY) < 0); Assert.assertTrue(numericFirst.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.NaN, Double.POSITIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.NaN, Double.NEGATIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.POSITIVE_INFINITY, Double.NaN) < 0); Assert.assertTrue(numericFirst.compare(Double.NEGATIVE_INFINITY, Double.NaN) < 0); } }
@Test public void testQuotient() { ArithmeticPostAggregator agg = new ArithmeticPostAggregator( null, "quotient", ImmutableList.of( new FieldAccessPostAggregator("numerator", "value"), new ConstantPostAggregator("zero", 0) ), "numericFirst" ); Assert.assertEquals(Double.NaN, agg.compute(ImmutableMap.of("value", 0))); Assert.assertEquals(Double.NaN, agg.compute(ImmutableMap.of("value", Double.NaN))); Assert.assertEquals(Double.POSITIVE_INFINITY, agg.compute(ImmutableMap.of("value", 1))); Assert.assertEquals(Double.NEGATIVE_INFINITY, agg.compute(ImmutableMap.of("value", -1))); }
@Test public void testDiv() { ArithmeticPostAggregator agg = new ArithmeticPostAggregator( null, "/", ImmutableList.of( new FieldAccessPostAggregator("numerator", "value"), new ConstantPostAggregator("denomiator", 0) ) ); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", 0))); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", Double.NaN))); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", 1))); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", -1))); }
@Test public void testVerifyAggregations() { List<AggregatorFactory> aggFactories = Arrays.asList( new CountAggregatorFactory("count"), new DoubleSumAggregatorFactory("idx", "index"), new DoubleSumAggregatorFactory("rev", "revenue") ); List<PostAggregator> postAggs = Collections.singletonList( new ArithmeticPostAggregator( "addStuff", "+", Arrays.asList( new FieldAccessPostAggregator("idx", "idx"), new FieldAccessPostAggregator("count", "count") ) ) ); boolean exceptionOccured = false; try { Queries.prepareAggregations(ImmutableList.of(), aggFactories, postAggs); } catch (IllegalArgumentException e) { exceptionOccured = true; } Assert.assertFalse(exceptionOccured); }
@Test public void testVerifyAggregationsMissingVal() { List<AggregatorFactory> aggFactories = Arrays.asList( new CountAggregatorFactory("count"), new DoubleSumAggregatorFactory("idx", "index"), new DoubleSumAggregatorFactory("rev", "revenue") ); List<PostAggregator> postAggs = Collections.singletonList( new ArithmeticPostAggregator( "addStuff", "+", Arrays.asList( new FieldAccessPostAggregator("idx", "idx2"), new FieldAccessPostAggregator("count", "count") ) ) ); boolean exceptionOccured = false; try { Queries.prepareAggregations(ImmutableList.of(), aggFactories, postAggs); } catch (IllegalArgumentException e) { exceptionOccured = true; } Assert.assertTrue(exceptionOccured); }
@Test public void testPruneDependentPostAgg() PostAggregator agg1 = new ArithmeticPostAggregator( "abc", "+", Lists.newArrayList( new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("2", 2L) PostAggregator dependency1 = new ArithmeticPostAggregator( "dep1", "+", Lists.newArrayList( new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("4", 4L) PostAggregator agg2 = new FieldAccessPostAggregator("def", "def"); PostAggregator dependency2 = new FieldAccessPostAggregator("dep2", "dep2"); PostAggregator aggregator = new ArithmeticPostAggregator( "finalAgg", "+",
@Test public void testOutOfOrderPruneDependentPostAgg() PostAggregator agg1 = new ArithmeticPostAggregator( "abc", "+", Lists.newArrayList( new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("2", 2L) PostAggregator dependency1 = new ArithmeticPostAggregator( "dep1", "+", Lists.newArrayList( new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("4", 4L) PostAggregator agg2 = new FieldAccessPostAggregator("def", "def"); PostAggregator dependency2 = new FieldAccessPostAggregator("dep2", "dep2"); PostAggregator aggregator = new ArithmeticPostAggregator( "finalAgg", "+",
@Test public void testComparator() { final String aggName = "rows"; ArithmeticPostAggregator arithmeticPostAggregator; CountAggregator agg = new CountAggregator(); Map<String, Object> metricValues = new HashMap<String, Object>(); metricValues.put(aggName, agg.get()); List<PostAggregator> postAggregatorList = Lists.newArrayList( new ConstantPostAggregator( "roku", 6D ), new FieldAccessPostAggregator( "rows", "rows" ) ); arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggregatorList); Comparator comp = arithmeticPostAggregator.getComparator(); Object before = arithmeticPostAggregator.compute(metricValues); agg.aggregate(); agg.aggregate(); agg.aggregate(); metricValues.put(aggName, agg.get()); Object after = arithmeticPostAggregator.compute(metricValues); Assert.assertEquals(-1, comp.compare(before, after)); Assert.assertEquals(0, comp.compare(before, before)); Assert.assertEquals(0, comp.compare(after, after)); Assert.assertEquals(1, comp.compare(after, before)); }
arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggregatorList); expressionPostAggregator = new ExpressionPostAggregator("add", "roku + rows", null, TestExprMacroTable.INSTANCE); Assert.assertEquals(9.0, arithmeticPostAggregator.compute(metricValues)); Assert.assertEquals(9.0, expressionPostAggregator.compute(metricValues)); arithmeticPostAggregator = new ArithmeticPostAggregator("subtract", "-", postAggregatorList); expressionPostAggregator = new ExpressionPostAggregator("add", "roku - rows", null, TestExprMacroTable.INSTANCE); Assert.assertEquals(3.0, arithmeticPostAggregator.compute(metricValues)); Assert.assertEquals(3.0, expressionPostAggregator.compute(metricValues)); arithmeticPostAggregator = new ArithmeticPostAggregator("multiply", "*", postAggregatorList); expressionPostAggregator = new ExpressionPostAggregator("add", "roku * rows", null, TestExprMacroTable.INSTANCE); Assert.assertEquals(18.0, arithmeticPostAggregator.compute(metricValues)); Assert.assertEquals(18.0, expressionPostAggregator.compute(metricValues)); arithmeticPostAggregator = new ArithmeticPostAggregator("divide", "/", postAggregatorList); expressionPostAggregator = new ExpressionPostAggregator("add", "roku / rows", null, TestExprMacroTable.INSTANCE); Assert.assertEquals(2.0, arithmeticPostAggregator.compute(metricValues));
.postAggregators( ImmutableList.of( new ArithmeticPostAggregator( "a0", "quotient",
new ArithmeticPostAggregator( "a2", "quotient",
.setPostAggregatorSpecs( Collections.singletonList( new ArithmeticPostAggregator( "post_agg", "+",
.setPostAggregatorSpecs( ImmutableList.of( new ArithmeticPostAggregator( "_a2", "quotient",