How to use

FieldAccessPostAggregator

in

org.apache.druid.query.aggregation.post

@Test
public void testSketchSetPostAggregatorSerde() throws Exception
{
 assertPostAggregatorSerde(
   new OldSketchSetPostAggregator(
     "name",
     "INTERSECT",
     null,
     Lists.newArrayList(
       new FieldAccessPostAggregator("name1", "fieldName1"),
       new FieldAccessPostAggregator("name2", "fieldName2")
     )
   )
 );
}

 @Test
 public void testCompute()
 {
  final String aggName = "rows";
  FieldAccessPostAggregator fieldAccessPostAggregator;

  fieldAccessPostAggregator = new FieldAccessPostAggregator("To be, or not to be, that is the question:", "rows");
  CountAggregator agg = new CountAggregator();
  Map<String, Object> metricValues = new HashMap<String, Object>();
  metricValues.put(aggName, agg.get());
  Assert.assertEquals(new Long(0L), fieldAccessPostAggregator.compute(metricValues));

  agg.aggregate();
  agg.aggregate();
  agg.aggregate();
  metricValues.put(aggName, agg.get());
  Assert.assertEquals(new Long(3L), fieldAccessPostAggregator.compute(metricValues));
 }
}

@Test
public void testSketchEstimatePostAggregatorSerde() throws Exception
{
 assertPostAggregatorSerde(
   new OldSketchEstimatePostAggregator(
     "name",
     new FieldAccessPostAggregator("name", "fieldName")
   )
 );
}

@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 testSketchSetPostAggregatorSerde() throws Exception
{
 assertPostAggregatorSerde(
   new SketchSetPostAggregator(
     "name",
     "INTERSECT",
     null,
     Lists.newArrayList(
       new FieldAccessPostAggregator("name1", "fieldName1"),
       new FieldAccessPostAggregator("name2", "fieldName2")
     )
   )
 );
 
 assertPostAggregatorSerde(
   new SketchSetPostAggregator(
     "name",
     "INTERSECT",
     null,
     Lists.newArrayList(
       new FieldAccessPostAggregator("name1", "fieldName1"),
       new SketchConstantPostAggregator("name2", "AgMDAAAazJMCAAAAAACAPzz9j7pWTMdROWGf15uY1nI=")
     )
   )
 );
}

"quotient",
ImmutableList.of(
  new FieldAccessPostAggregator(null, sumName),
  new FieldAccessPostAggregator(null, countName)

@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 testSketchEstimatePostAggregatorSerde() throws Exception
{
 assertPostAggregatorSerde(
   new SketchEstimatePostAggregator(
     "name",
     new FieldAccessPostAggregator("name", "fieldName"),
     null
   )
 );
 assertPostAggregatorSerde(
   new SketchEstimatePostAggregator(
     "name",
     new FieldAccessPostAggregator("name", "fieldName"),
     2
   )
 );
 
 assertPostAggregatorSerde(
   new SketchEstimatePostAggregator(
     "name",
     new SketchConstantPostAggregator("name", "AgMDAAAazJMCAAAAAACAPzz9j7pWTMdROWGf15uY1nI="),
     null
   )
 );
}

PostAggregator agg2 = new FieldAccessPostAggregator("def", "def");
PostAggregator dependency2 = new FieldAccessPostAggregator("dep2", "dep2");
PostAggregator aggregator = new ArithmeticPostAggregator(
  "finalAgg",
  "+",
  Lists.newArrayList(
    new FieldAccessPostAggregator("dep1", "dep1"),
    new FieldAccessPostAggregator("dep2", "dep2")

PostAggregator agg2 = new FieldAccessPostAggregator("def", "def");
PostAggregator dependency2 = new FieldAccessPostAggregator("dep2", "dep2");
PostAggregator aggregator = new ArithmeticPostAggregator(
  "finalAgg",
  "+",
  Lists.newArrayList(
    new FieldAccessPostAggregator("dep1", "dep1"),
    new FieldAccessPostAggregator("dep2", "dep2")

@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)));
}

final FieldAccessPostAggregator rowsPostAgg = new FieldAccessPostAggregator("rows", "rows");
final FieldAccessPostAggregator indexPostAgg = new FieldAccessPostAggregator("index", "index");

@Test
public void testCompute()
{
 final String aggName = "rows";
 LongGreatestPostAggregator 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 LongGreatestPostAggregator("greatest", postAggregatorList);
 Assert.assertEquals(Long.valueOf(6), greatestPostAggregator.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));
}

"+",
Arrays.asList(
  new FieldAccessPostAggregator("idx", "idx"),
  new ConstantPostAggregator("const", 1)

"+",
Arrays.asList(
  new FieldAccessPostAggregator("idx", "idx"),
  new ConstantPostAggregator("const", 1)

  "roku", 2D
),
new FieldAccessPostAggregator(
  "rows", aggName