@Override public Object compute(Map<String, Object> combinedAggregators) { Function fn = getCompiledScript(); final Object[] args = new Object[fieldNames.size()]; int i = 0; for (String field : fieldNames) { args[i++] = combinedAggregators.get(field); } return fn.apply(args); }
private static FinalizingFieldAccessPostAggregator buildDecorated( String name, String fieldName, Map<String, AggregatorFactory> aggregators ) { FinalizingFieldAccessPostAggregator ret = new FinalizingFieldAccessPostAggregator(name, fieldName); return ret.decorate(aggregators); } }
@Override public DoubleLeastPostAggregator decorate(Map<String, AggregatorFactory> aggregators) { return new DoubleLeastPostAggregator(name, Queries.decoratePostAggregators(fields, aggregators)); }
@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 testCompute() { final String aggName = "rows"; DoubleLeastPostAggregator leastPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); 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", aggName ) ); leastPostAggregator = new DoubleLeastPostAggregator("least", postAggregatorList); Assert.assertEquals(3.0, leastPostAggregator.compute(metricValues)); }
@Test public void testCompute() { final String aggName = "rows"; LongLeastPostAggregator leastPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); 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", aggName ) ); leastPostAggregator = new LongLeastPostAggregator("leastPostAggregator", postAggregatorList); Assert.assertEquals(Long.valueOf(3), leastPostAggregator.compute(metricValues)); }
@Test public void testCompute() { final String aggName = "rows"; DoubleGreatestPostAggregator greatestPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); 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", aggName ) ); greatestPostAggregator = new DoubleGreatestPostAggregator("greatest", postAggregatorList); Assert.assertEquals(6.0, greatestPostAggregator.compute(metricValues)); }
@Override public ArithmeticPostAggregator decorate(Map<String, AggregatorFactory> aggregators) { return new ArithmeticPostAggregator(name, fnName, Queries.decoratePostAggregators(fields, aggregators), ordering); }
public static ExpressionPostAggregator EXPRESSION_POST_AGG(final String name, final String expression) { return new ExpressionPostAggregator(name, expression, null, CalciteTests.createExprMacroTable()); }
@Test public void testComparator() { ConstantPostAggregator constantPostAggregator = new ConstantPostAggregator("thistestbasicallydoesnothing unhappyface", 1); Comparator comp = constantPostAggregator.getComparator(); Assert.assertEquals(0, comp.compare(0, constantPostAggregator.compute(null))); Assert.assertEquals(0, comp.compare(0, 1)); Assert.assertEquals(0, comp.compare(1, 0)); }
@Test public void testSketchEstimatePostAggregatorSerde() throws Exception { assertPostAggregatorSerde( new OldSketchEstimatePostAggregator( "name", new FieldAccessPostAggregator("name", "fieldName") ) ); }
@JsonCreator public ArithmeticPostAggregator( @JsonProperty("name") String name, @JsonProperty("fn") String fnName, @JsonProperty("fields") List<PostAggregator> fields, @JsonProperty("ordering") String ordering ) { Preconditions.checkArgument(fnName != null, "fn cannot not be null"); Preconditions.checkArgument(fields != null && fields.size() > 1, "Illegal number of fields[%s], must be > 1"); this.name = name; this.fnName = fnName; this.fields = fields; this.op = Ops.lookup(fnName); if (op == null) { throw new IAE("Unknown operation[%s], known operations[%s]", fnName, Ops.getFns()); } this.ordering = ordering; this.comparator = ordering == null ? DEFAULT_COMPARATOR : Ordering.valueOf(ordering); }
@Test public void testCompute() { ConstantPostAggregator constantPostAggregator; constantPostAggregator = new ConstantPostAggregator("shichi", 7); Assert.assertEquals(7, constantPostAggregator.compute(null)); constantPostAggregator = new ConstantPostAggregator("rei", 0.0); Assert.assertEquals(0.0, constantPostAggregator.compute(null)); constantPostAggregator = new ConstantPostAggregator("ichi", 1.0); Assert.assertNotSame(1, constantPostAggregator.compute(null)); }
@Override public DoubleGreatestPostAggregator decorate(Map<String, AggregatorFactory> aggregators) { return new DoubleGreatestPostAggregator(name, Queries.decoratePostAggregators(fields, aggregators)); }
@Override public LongLeastPostAggregator decorate(Map<String, AggregatorFactory> aggregators) { return new LongLeastPostAggregator(name, Queries.decoratePostAggregators(fields, aggregators)); }
@Override public LongGreatestPostAggregator decorate(Map<String, AggregatorFactory> aggregators) { return new LongGreatestPostAggregator(name, Queries.decoratePostAggregators(fields, aggregators)); }
@Test public void testSerde() throws Exception { DefaultObjectMapper mapper = new DefaultObjectMapper(); ConstantPostAggregator aggregator = new ConstantPostAggregator("aggregator", 2); ConstantPostAggregator aggregator1 = mapper.readValue( mapper.writeValueAsString(aggregator), ConstantPostAggregator.class ); Assert.assertEquals(aggregator, aggregator1); } }
@Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + fnName.hashCode(); result = 31 * result + fields.hashCode(); result = 31 * result + op.hashCode(); result = 31 * result + comparator.hashCode(); result = 31 * result + (ordering != null ? ordering.hashCode() : 0); return result; } }
@Override public byte[] getCacheKey() { final CacheKeyBuilder builder = new CacheKeyBuilder(PostAggregatorIds.ARITHMETIC) .appendString(fnName) .appendString(ordering); if (preserveFieldOrderInCacheKey(op)) { builder.appendCacheables(fields); } else { builder.appendCacheablesIgnoringOrder(fields); } return builder.build(); }
@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))); }