Beispiel #1
0
  @Test
  public void withStatsSubAggregator() throws Exception {
    SearchResponse response =
        client()
            .prepareSearch("idx")
            .setQuery(QueryBuilders.termQuery("tag", "tag1"))
            .addAggregation(global("global").subAggregation(stats("value_stats").field("value")))
            .execute()
            .actionGet();

    assertSearchResponse(response);

    Global global = response.getAggregations().get("global");
    assertThat(global, notNullValue());
    assertThat(global.getName(), equalTo("global"));
    assertThat(global.getDocCount(), equalTo((long) numDocs));
    assertThat(global.getAggregations().asList().isEmpty(), is(false));

    Stats stats = global.getAggregations().get("value_stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("value_stats"));
    long sum = 0;
    for (int i = 0; i < numDocs; ++i) {
      sum += i + 1;
    }
    assertThat(stats.getAvg(), equalTo((double) sum / numDocs));
    assertThat(stats.getMin(), equalTo(1.0));
    assertThat(stats.getMax(), equalTo((double) numDocs));
    assertThat(stats.getCount(), equalTo((long) numDocs));
    assertThat(stats.getSum(), equalTo((double) sum));
  }
Beispiel #2
0
  @Override
  public void testScriptSingleValuedWithParams() throws Exception {
    Map<String, Object> params = new HashMap<>();
    params.put("inc", 1);

    Script script =
        new Script(
            "doc['value'].value + inc",
            ScriptType.INLINE,
            AggregationTestScriptsPlugin.NAME,
            params);

    SearchResponse searchResponse =
        client()
            .prepareSearch("idx")
            .setQuery(matchAllQuery())
            .addAggregation(stats("stats").script(script))
            .get();

    assertShardExecutionState(searchResponse, 0);

    assertHitCount(searchResponse, 10);

    Stats stats = searchResponse.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(stats.getAvg(), equalTo((double) (2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11) / 10));
    assertThat(stats.getMin(), equalTo(2.0));
    assertThat(stats.getMax(), equalTo(11.0));
    assertThat(stats.getSum(), equalTo((double) 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11));
    assertThat(stats.getCount(), equalTo(10L));
  }
Beispiel #3
0
  @Override
  public void testEmptyAggregation() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("empty_bucket_idx")
            .setQuery(matchAllQuery())
            .addAggregation(
                histogram("histo")
                    .field("value")
                    .interval(1L)
                    .minDocCount(0)
                    .subAggregation(stats("stats").field("value")))
            .execute()
            .actionGet();

    assertShardExecutionState(searchResponse, 0);

    assertThat(searchResponse.getHits().getTotalHits(), equalTo(2L));
    Histogram histo = searchResponse.getAggregations().get("histo");
    assertThat(histo, notNullValue());
    Histogram.Bucket bucket = histo.getBuckets().get(1);
    assertThat(bucket, notNullValue());

    Stats stats = bucket.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(stats.getCount(), equalTo(0L));
    assertThat(stats.getSum(), equalTo(0.0));
    assertThat(stats.getMin(), equalTo(Double.POSITIVE_INFINITY));
    assertThat(stats.getMax(), equalTo(Double.NEGATIVE_INFINITY));
    assertThat(Double.isNaN(stats.getAvg()), is(true));
  }
Beispiel #4
0
  public void testSingleValuedField_WithFormatter() throws Exception {

    SearchResponse searchResponse =
        client()
            .prepareSearch("idx")
            .setQuery(matchAllQuery())
            .addAggregation(stats("stats").format("0000.0").field("value"))
            .execute()
            .actionGet();

    assertHitCount(searchResponse, 10);

    Stats stats = searchResponse.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(stats.getAvg(), equalTo((double) (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10) / 10));
    assertThat(stats.getAvgAsString(), equalTo("0005.5"));
    assertThat(stats.getMin(), equalTo(1.0));
    assertThat(stats.getMinAsString(), equalTo("0001.0"));
    assertThat(stats.getMax(), equalTo(10.0));
    assertThat(stats.getMaxAsString(), equalTo("0010.0"));
    assertThat(stats.getSum(), equalTo((double) 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10));
    assertThat(stats.getSumAsString(), equalTo("0055.0"));
    assertThat(stats.getCount(), equalTo(10L));
    assertThat(stats.getCountAsString(), equalTo("0010.0"));
  }
Beispiel #5
0
  @Override
  public void testScriptSingleValued() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("idx")
            .setQuery(matchAllQuery())
            .addAggregation(
                stats("stats")
                    .script(
                        new Script(
                            "doc['value'].value",
                            ScriptType.INLINE,
                            AggregationTestScriptsPlugin.NAME,
                            emptyMap())))
            .get();

    assertShardExecutionState(searchResponse, 0);

    assertHitCount(searchResponse, 10);

    Stats stats = searchResponse.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(stats.getAvg(), equalTo((double) (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10) / 10));
    assertThat(stats.getMin(), equalTo(1.0));
    assertThat(stats.getMax(), equalTo(10.0));
    assertThat(stats.getSum(), equalTo((double) 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10));
    assertThat(stats.getCount(), equalTo(10L));
  }
 public void testStats() {
   SearchResponse response =
       client().prepareSearch("idx").addAggregation(stats("stats").field("long").missing(5)).get();
   assertSearchResponse(response);
   Stats stats = response.getAggregations().get("stats");
   assertEquals(2, stats.getCount());
   assertEquals(4, stats.getAvg(), 0);
 }
 @Test
 public void statsTest() throws IOException, SqlParseException, SQLFeatureNotSupportedException {
   Aggregations result = query(String.format("SELECT STATS(age) FROM %s/account", TEST_INDEX));
   Stats stats = result.get("STATS(age)");
   Assert.assertEquals(1000, stats.getCount());
   assertThat(stats.getSum(), equalTo(30171.0));
   assertThat(stats.getMin(), equalTo(20.0));
   assertThat(stats.getMax(), equalTo(40.0));
   assertThat(stats.getAvg(), equalTo(30.171));
 }
Beispiel #8
0
 public void testPartiallyUnmapped() {
   Stats s1 =
       client()
           .prepareSearch("idx")
           .addAggregation(stats("stats").field("value"))
           .get()
           .getAggregations()
           .get("stats");
   Stats s2 =
       client()
           .prepareSearch("idx", "idx_unmapped")
           .addAggregation(stats("stats").field("value"))
           .get()
           .getAggregations()
           .get("stats");
   assertEquals(s1.getAvg(), s2.getAvg(), 1e-10);
   assertEquals(s1.getCount(), s2.getCount());
   assertEquals(s1.getMin(), s2.getMin(), 0d);
   assertEquals(s1.getMax(), s2.getMax(), 0d);
 }
Beispiel #9
0
  @Override
  public void testMultiValuedField() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("idx")
            .setQuery(matchAllQuery())
            .addAggregation(stats("stats").field("values"))
            .execute()
            .actionGet();

    assertShardExecutionState(searchResponse, 0);

    assertHitCount(searchResponse, 10);

    Stats stats = searchResponse.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(
        stats.getAvg(),
        equalTo(
            (double)
                    (2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11
                        + 12)
                / 20));
    assertThat(stats.getMin(), equalTo(2.0));
    assertThat(stats.getMax(), equalTo(12.0));
    assertThat(
        stats.getSum(),
        equalTo(
            (double) 2
                + 3
                + 4
                + 5
                + 6
                + 7
                + 8
                + 9
                + 10
                + 11
                + 3
                + 4
                + 5
                + 6
                + 7
                + 8
                + 9
                + 10
                + 11
                + 12));
    assertThat(stats.getCount(), equalTo(20L));
  }
Beispiel #10
0
  @Override
  public void testSingleValuedFieldGetProperty() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("idx")
            .setQuery(matchAllQuery())
            .addAggregation(global("global").subAggregation(stats("stats").field("value")))
            .execute()
            .actionGet();

    assertHitCount(searchResponse, 10);

    Global global = searchResponse.getAggregations().get("global");
    assertThat(global, notNullValue());
    assertThat(global.getName(), equalTo("global"));
    assertThat(global.getDocCount(), equalTo(10L));
    assertThat(global.getAggregations(), notNullValue());
    assertThat(global.getAggregations().asMap().size(), equalTo(1));

    Stats stats = global.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    Stats statsFromProperty = (Stats) global.getProperty("stats");
    assertThat(statsFromProperty, notNullValue());
    assertThat(statsFromProperty, sameInstance(stats));
    double expectedAvgValue = (double) (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10) / 10;
    assertThat(stats.getAvg(), equalTo(expectedAvgValue));
    assertThat((double) global.getProperty("stats.avg"), equalTo(expectedAvgValue));
    double expectedMinValue = 1.0;
    assertThat(stats.getMin(), equalTo(expectedMinValue));
    assertThat((double) global.getProperty("stats.min"), equalTo(expectedMinValue));
    double expectedMaxValue = 10.0;
    assertThat(stats.getMax(), equalTo(expectedMaxValue));
    assertThat((double) global.getProperty("stats.max"), equalTo(expectedMaxValue));
    double expectedSumValue = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;
    assertThat(stats.getSum(), equalTo(expectedSumValue));
    assertThat((double) global.getProperty("stats.sum"), equalTo(expectedSumValue));
    long expectedCountValue = 10;
    assertThat(stats.getCount(), equalTo(expectedCountValue));
    assertThat((double) global.getProperty("stats.count"), equalTo((double) expectedCountValue));
  }
Beispiel #11
0
  public void testSimple() throws Exception {
    SearchResponse response =
        client()
            .prepareSearch("idx")
            .addAggregation(
                nested("nested", "nested")
                    .subAggregation(stats("nested_value_stats").field("nested.value")))
            .execute()
            .actionGet();

    assertSearchResponse(response);

    double min = Double.POSITIVE_INFINITY;
    double max = Double.NEGATIVE_INFINITY;
    long sum = 0;
    long count = 0;
    for (int i = 0; i < numParents; ++i) {
      for (int j = 0; j < numChildren[i]; ++j) {
        final long value = i + 1 + j;
        min = Math.min(min, value);
        max = Math.max(max, value);
        sum += value;
        ++count;
      }
    }

    Nested nested = response.getAggregations().get("nested");
    assertThat(nested, notNullValue());
    assertThat(nested.getName(), equalTo("nested"));
    assertThat(nested.getDocCount(), equalTo(count));
    assertThat(nested.getAggregations().asList().isEmpty(), is(false));

    Stats stats = nested.getAggregations().get("nested_value_stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getMin(), equalTo(min));
    assertThat(stats.getMax(), equalTo(max));
    assertThat(stats.getCount(), equalTo(count));
    assertThat(stats.getSum(), equalTo((double) sum));
    assertThat(stats.getAvg(), equalTo((double) sum / count));
  }
Beispiel #12
0
  @Override
  public void testOrderByEmptyAggregation() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("idx")
            .setQuery(matchAllQuery())
            .addAggregation(
                terms("terms")
                    .field("value")
                    .order(Order.compound(Order.aggregation("filter>stats.avg", true)))
                    .subAggregation(
                        filter("filter", termQuery("value", 100))
                            .subAggregation(stats("stats").field("value"))))
            .get();

    assertHitCount(searchResponse, 10);

    Terms terms = searchResponse.getAggregations().get("terms");
    assertThat(terms, notNullValue());
    List<Terms.Bucket> buckets = terms.getBuckets();
    assertThat(buckets, notNullValue());
    assertThat(buckets.size(), equalTo(10));

    for (int i = 0; i < 10; i++) {
      Terms.Bucket bucket = buckets.get(i);
      assertThat(bucket, notNullValue());
      assertThat(bucket.getKeyAsNumber(), equalTo((long) i + 1));
      assertThat(bucket.getDocCount(), equalTo(1L));
      Filter filter = bucket.getAggregations().get("filter");
      assertThat(filter, notNullValue());
      assertThat(filter.getDocCount(), equalTo(0L));
      Stats stats = filter.getAggregations().get("stats");
      assertThat(stats, notNullValue());
      assertThat(stats.getMin(), equalTo(Double.POSITIVE_INFINITY));
      assertThat(stats.getMax(), equalTo(Double.NEGATIVE_INFINITY));
      assertThat(stats.getAvg(), equalTo(Double.NaN));
      assertThat(stats.getSum(), equalTo(0.0));
      assertThat(stats.getCount(), equalTo(0L));
    }
  }
Beispiel #13
0
  @Override
  public void testUnmapped() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("idx_unmapped")
            .setQuery(matchAllQuery())
            .addAggregation(stats("stats").field("value"))
            .execute()
            .actionGet();

    assertShardExecutionState(searchResponse, 0);

    assertThat(searchResponse.getHits().getTotalHits(), equalTo(0L));

    Stats stats = searchResponse.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(stats.getAvg(), equalTo(Double.NaN));
    assertThat(stats.getMin(), equalTo(Double.POSITIVE_INFINITY));
    assertThat(stats.getMax(), equalTo(Double.NEGATIVE_INFINITY));
    assertThat(stats.getSum(), equalTo(0.0));
    assertThat(stats.getCount(), equalTo(0L));
  }
Beispiel #14
0
  @Override
  public void testSingleValuedFieldPartiallyUnmapped() throws Exception {
    SearchResponse searchResponse =
        client()
            .prepareSearch("idx", "idx_unmapped")
            .setQuery(matchAllQuery())
            .addAggregation(stats("stats").field("value"))
            .execute()
            .actionGet();

    assertShardExecutionState(searchResponse, 0);

    assertHitCount(searchResponse, 10);

    Stats stats = searchResponse.getAggregations().get("stats");
    assertThat(stats, notNullValue());
    assertThat(stats.getName(), equalTo("stats"));
    assertThat(stats.getAvg(), equalTo((double) (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10) / 10));
    assertThat(stats.getMin(), equalTo(1.0));
    assertThat(stats.getMax(), equalTo(10.0));
    assertThat(stats.getSum(), equalTo((double) 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10));
    assertThat(stats.getCount(), equalTo(10L));
  }