Examples with Bucket org.elasticsearch.search.aggregations.bucket.range.Range.Bucket used on opensource projects

Example 1 with Bucket

use of org.elasticsearch.search.aggregations.bucket.range.Range.Bucket in project elasticsearch by elastic.

the class EquivalenceIT method testRandomRanges.

// Make sure that unordered, reversed, disjoint and/or overlapping ranges are supported
// Duel with filters
public void testRandomRanges() throws Exception {
    final int numDocs = scaledRandomIntBetween(500, 5000);
    final double[][] docs = new double[numDocs][];
    for (int i = 0; i < numDocs; ++i) {
        final int numValues = randomInt(5);
        docs[i] = new double[numValues];
        for (int j = 0; j < numValues; ++j) {
            docs[i][j] = randomDouble() * 100;
        }
    }
    prepareCreate("idx").addMapping("type", jsonBuilder().startObject().startObject("type").startObject("properties").startObject("values").field("type", "double").endObject().endObject().endObject().endObject()).execute().actionGet();
    for (int i = 0; i < docs.length; ++i) {
        XContentBuilder source = jsonBuilder().startObject().startArray("values");
        for (int j = 0; j < docs[i].length; ++j) {
            source = source.value(docs[i][j]);
        }
        source = source.endArray().endObject();
        client().prepareIndex("idx", "type").setSource(source).execute().actionGet();
    }
    assertNoFailures(client().admin().indices().prepareRefresh("idx").setIndicesOptions(IndicesOptions.lenientExpandOpen()).get());
    final int numRanges = randomIntBetween(1, 20);
    final double[][] ranges = new double[numRanges][];
    for (int i = 0; i < ranges.length; ++i) {
        switch(randomInt(2)) {
            case 0:
                ranges[i] = new double[] { Double.NEGATIVE_INFINITY, randomInt(100) };
                break;
            case 1:
                ranges[i] = new double[] { randomInt(100), Double.POSITIVE_INFINITY };
                break;
            case 2:
                ranges[i] = new double[] { randomInt(100), randomInt(100) };
                break;
            default:
                throw new AssertionError();
        }
    }
    RangeAggregationBuilder query = range("range").field("values");
    for (int i = 0; i < ranges.length; ++i) {
        String key = Integer.toString(i);
        if (ranges[i][0] == Double.NEGATIVE_INFINITY) {
            query.addUnboundedTo(key, ranges[i][1]);
        } else if (ranges[i][1] == Double.POSITIVE_INFINITY) {
            query.addUnboundedFrom(key, ranges[i][0]);
        } else {
            query.addRange(key, ranges[i][0], ranges[i][1]);
        }
    }
    SearchRequestBuilder reqBuilder = client().prepareSearch("idx").addAggregation(query);
    for (int i = 0; i < ranges.length; ++i) {
        RangeQueryBuilder filter = QueryBuilders.rangeQuery("values");
        if (ranges[i][0] != Double.NEGATIVE_INFINITY) {
            filter = filter.from(ranges[i][0]);
        }
        if (ranges[i][1] != Double.POSITIVE_INFINITY) {
            filter = filter.to(ranges[i][1]);
        }
        reqBuilder = reqBuilder.addAggregation(filter("filter" + i, filter));
    }
    SearchResponse resp = reqBuilder.execute().actionGet();
    Range range = resp.getAggregations().get("range");
    List<? extends Bucket> buckets = range.getBuckets();
    HashMap<String, Bucket> bucketMap = new HashMap<>(buckets.size());
    for (Bucket bucket : buckets) {
        bucketMap.put(bucket.getKeyAsString(), bucket);
    }
    for (int i = 0; i < ranges.length; ++i) {
        long count = 0;
        for (double[] values : docs) {
            for (double value : values) {
                if (value >= ranges[i][0] && value < ranges[i][1]) {
                    ++count;
                    break;
                }
            }
        }
        final Range.Bucket bucket = bucketMap.get(Integer.toString(i));
        assertEquals(bucket.getKeyAsString(), Integer.toString(i), bucket.getKeyAsString());
        assertEquals(bucket.getKeyAsString(), count, bucket.getDocCount());
        final Filter filter = resp.getAggregations().get("filter" + i);
        assertThat(filter.getDocCount(), equalTo(count));
    }
}

Example 2 with Bucket

use of org.elasticsearch.search.aggregations.bucket.range.Range.Bucket in project elasticsearch by elastic.

the class GeoDistanceIT method testWithSubAggregation.

public void testWithSubAggregation() throws Exception {
    SearchResponse response = client().prepareSearch("idx").addAggregation(geoDistance("amsterdam_rings", new GeoPoint(52.3760, 4.894)).field("location").unit(DistanceUnit.KILOMETERS).addUnboundedTo(500).addRange(500, 1000).addUnboundedFrom(1000).subAggregation(terms("cities").field("city").collectMode(randomFrom(SubAggCollectionMode.values())))).execute().actionGet();
    assertSearchResponse(response);
    Range geoDist = response.getAggregations().get("amsterdam_rings");
    assertThat(geoDist, notNullValue());
    assertThat(geoDist.getName(), equalTo("amsterdam_rings"));
    List<? extends Bucket> buckets = geoDist.getBuckets();
    assertThat(geoDist.getBuckets().size(), equalTo(3));
    assertThat(geoDist.getProperty("_bucket_count"), equalTo(3));
    Object[] propertiesKeys = (Object[]) geoDist.getProperty("_key");
    Object[] propertiesDocCounts = (Object[]) geoDist.getProperty("_count");
    Object[] propertiesCities = (Object[]) geoDist.getProperty("cities");
    Range.Bucket bucket = buckets.get(0);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("*-500.0"));
    assertThat(((Number) bucket.getFrom()).doubleValue(), equalTo(0.0));
    assertThat(((Number) bucket.getTo()).doubleValue(), equalTo(500.0));
    assertThat(bucket.getFromAsString(), equalTo("0.0"));
    assertThat(bucket.getToAsString(), equalTo("500.0"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    assertThat(bucket.getAggregations().asList().isEmpty(), is(false));
    Terms cities = bucket.getAggregations().get("cities");
    assertThat(cities, Matchers.notNullValue());
    Set<String> names = new HashSet<>();
    for (Terms.Bucket city : cities.getBuckets()) {
        names.add(city.getKeyAsString());
    }
    assertThat(names.contains("utrecht") && names.contains("haarlem"), is(true));
    assertThat((String) propertiesKeys[0], equalTo("*-500.0"));
    assertThat((long) propertiesDocCounts[0], equalTo(2L));
    assertThat((Terms) propertiesCities[0], sameInstance(cities));
    bucket = buckets.get(1);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("500.0-1000.0"));
    assertThat(((Number) bucket.getFrom()).doubleValue(), equalTo(500.0));
    assertThat(((Number) bucket.getTo()).doubleValue(), equalTo(1000.0));
    assertThat(bucket.getFromAsString(), equalTo("500.0"));
    assertThat(bucket.getToAsString(), equalTo("1000.0"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    assertThat(bucket.getAggregations().asList().isEmpty(), is(false));
    cities = bucket.getAggregations().get("cities");
    assertThat(cities, Matchers.notNullValue());
    names = new HashSet<>();
    for (Terms.Bucket city : cities.getBuckets()) {
        names.add(city.getKeyAsString());
    }
    assertThat(names.contains("berlin") && names.contains("prague"), is(true));
    assertThat((String) propertiesKeys[1], equalTo("500.0-1000.0"));
    assertThat((long) propertiesDocCounts[1], equalTo(2L));
    assertThat((Terms) propertiesCities[1], sameInstance(cities));
    bucket = buckets.get(2);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("1000.0-*"));
    assertThat(((Number) bucket.getFrom()).doubleValue(), equalTo(1000.0));
    assertThat(((Number) bucket.getTo()).doubleValue(), equalTo(Double.POSITIVE_INFINITY));
    assertThat(bucket.getFromAsString(), equalTo("1000.0"));
    assertThat(bucket.getToAsString(), nullValue());
    assertThat(bucket.getDocCount(), equalTo(1L));
    assertThat(bucket.getAggregations().asList().isEmpty(), is(false));
    cities = bucket.getAggregations().get("cities");
    assertThat(cities, Matchers.notNullValue());
    names = new HashSet<>();
    for (Terms.Bucket city : cities.getBuckets()) {
        names.add(city.getKeyAsString());
    }
    assertThat(names.contains("tel-aviv"), is(true));
    assertThat((String) propertiesKeys[2], equalTo("1000.0-*"));
    assertThat((long) propertiesDocCounts[2], equalTo(1L));
    assertThat((Terms) propertiesCities[2], sameInstance(cities));
}

Example 3 with Bucket

use of org.elasticsearch.search.aggregations.bucket.range.Range.Bucket in project elasticsearch by elastic.

the class DateRangeIT method testMultiValuedFieldWithValueScript.

/*
        Feb 2,  Mar 3,      1
        Mar 2,  Apr 3,      2
        Mar 15, Apr 16,     3
        Apr 2,  May 3,      4
        Apr 15, May 16      5
        Apr 23, May 24      6
     */
public void testMultiValuedFieldWithValueScript() throws Exception {
    Map<String, Object> params = new HashMap<>();
    params.put("fieldname", "dates");
    SearchResponse response = client().prepareSearch("idx").addAggregation(dateRange("range").field("dates").script(new Script(ScriptType.INLINE, "native", DateScriptMocks.PlusOneMonthScript.NAME, params)).addUnboundedTo(date(2, 15)).addRange(date(2, 15), date(3, 15)).addUnboundedFrom(date(3, 15))).execute().actionGet();
    assertSearchResponse(response);
    Range range = response.getAggregations().get("range");
    assertThat(range, notNullValue());
    assertThat(range.getName(), equalTo("range"));
    List<? extends Bucket> buckets = range.getBuckets();
    assertThat(buckets.size(), equalTo(3));
    Range.Bucket bucket = buckets.get(0);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("*-2012-02-15T00:00:00.000Z"));
    assertThat(((DateTime) bucket.getFrom()), nullValue());
    assertThat(((DateTime) bucket.getTo()), equalTo(date(2, 15)));
    assertThat(bucket.getFromAsString(), nullValue());
    assertThat(bucket.getToAsString(), equalTo("2012-02-15T00:00:00.000Z"));
    assertThat(bucket.getDocCount(), equalTo(1L));
    bucket = buckets.get(1);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("2012-02-15T00:00:00.000Z-2012-03-15T00:00:00.000Z"));
    assertThat(((DateTime) bucket.getFrom()), equalTo(date(2, 15)));
    assertThat(((DateTime) bucket.getTo()), equalTo(date(3, 15)));
    assertThat(bucket.getFromAsString(), equalTo("2012-02-15T00:00:00.000Z"));
    assertThat(bucket.getToAsString(), equalTo("2012-03-15T00:00:00.000Z"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    bucket = buckets.get(2);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("2012-03-15T00:00:00.000Z-*"));
    assertThat(((DateTime) bucket.getFrom()), equalTo(date(3, 15)));
    assertThat(((DateTime) bucket.getTo()), nullValue());
    assertThat(bucket.getFromAsString(), equalTo("2012-03-15T00:00:00.000Z"));
    assertThat(bucket.getToAsString(), nullValue());
    assertThat(bucket.getDocCount(), equalTo(numDocs - 1L));
}

Example 4 with Bucket

use of org.elasticsearch.search.aggregations.bucket.range.Range.Bucket in project elasticsearch by elastic.

the class DateRangeIT method testUnmapped.

public void testUnmapped() throws Exception {
    client().admin().cluster().prepareHealth("idx_unmapped").setWaitForYellowStatus().execute().actionGet();
    SearchResponse response = client().prepareSearch("idx_unmapped").addAggregation(dateRange("range").field("date").addUnboundedTo(date(2, 15)).addRange(date(2, 15), date(3, 15)).addUnboundedFrom(date(3, 15))).execute().actionGet();
    assertSearchResponse(response);
    Range range = response.getAggregations().get("range");
    assertThat(range, notNullValue());
    assertThat(range.getName(), equalTo("range"));
    List<? extends Bucket> buckets = range.getBuckets();
    assertThat(buckets.size(), equalTo(3));
    Range.Bucket bucket = buckets.get(0);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("*-2012-02-15T00:00:00.000Z"));
    assertThat(((DateTime) bucket.getFrom()), nullValue());
    assertThat(((DateTime) bucket.getTo()), equalTo(date(2, 15)));
    assertThat(bucket.getFromAsString(), nullValue());
    assertThat(bucket.getToAsString(), equalTo("2012-02-15T00:00:00.000Z"));
    assertThat(bucket.getDocCount(), equalTo(0L));
    bucket = buckets.get(1);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("2012-02-15T00:00:00.000Z-2012-03-15T00:00:00.000Z"));
    assertThat(((DateTime) bucket.getFrom()), equalTo(date(2, 15)));
    assertThat(((DateTime) bucket.getTo()), equalTo(date(3, 15)));
    assertThat(bucket.getFromAsString(), equalTo("2012-02-15T00:00:00.000Z"));
    assertThat(bucket.getToAsString(), equalTo("2012-03-15T00:00:00.000Z"));
    assertThat(bucket.getDocCount(), equalTo(0L));
    bucket = buckets.get(2);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("2012-03-15T00:00:00.000Z-*"));
    assertThat(((DateTime) bucket.getFrom()), equalTo(date(3, 15)));
    assertThat(((DateTime) bucket.getTo()), nullValue());
    assertThat(bucket.getFromAsString(), equalTo("2012-03-15T00:00:00.000Z"));
    assertThat(bucket.getToAsString(), nullValue());
    assertThat(bucket.getDocCount(), equalTo(0L));
}

Example 5 with Bucket

use of org.elasticsearch.search.aggregations.bucket.range.Range.Bucket in project elasticsearch by elastic.

the class DateRangeIT method testScriptMultiValued.

/*
        Jan 2,  Feb 3,      1
        Feb 2,  Mar 3,      2
        Feb 15, Mar 16,     3
        Mar 2,  Apr 3,      4
        Mar 15, Apr 16      5
        Mar 23, Apr 24      6
     */
public void testScriptMultiValued() throws Exception {
    Map<String, Object> params = new HashMap<>();
    params.put("fieldname", "dates");
    SearchResponse response = client().prepareSearch("idx").addAggregation(dateRange("range").script(new Script(ScriptType.INLINE, "native", DateScriptMocks.ExtractFieldScript.NAME, params)).addUnboundedTo(date(2, 15)).addRange(date(2, 15), date(3, 15)).addUnboundedFrom(date(3, 15))).execute().actionGet();
    assertSearchResponse(response);
    Range range = response.getAggregations().get("range");
    assertThat(range, notNullValue());
    assertThat(range.getName(), equalTo("range"));
    List<? extends Bucket> buckets = range.getBuckets();
    assertThat(buckets.size(), equalTo(3));
    Range.Bucket bucket = buckets.get(0);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("*-2012-02-15T00:00:00.000Z"));
    assertThat(((DateTime) bucket.getFrom()), nullValue());
    assertThat(((DateTime) bucket.getTo()), equalTo(date(2, 15)));
    assertThat(bucket.getFromAsString(), nullValue());
    assertThat(bucket.getToAsString(), equalTo("2012-02-15T00:00:00.000Z"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    bucket = buckets.get(1);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("2012-02-15T00:00:00.000Z-2012-03-15T00:00:00.000Z"));
    assertThat(((DateTime) bucket.getFrom()), equalTo(date(2, 15)));
    assertThat(((DateTime) bucket.getTo()), equalTo(date(3, 15)));
    assertThat(bucket.getFromAsString(), equalTo("2012-02-15T00:00:00.000Z"));
    assertThat(bucket.getToAsString(), equalTo("2012-03-15T00:00:00.000Z"));
    assertThat(bucket.getDocCount(), equalTo(3L));
    bucket = buckets.get(2);
    assertThat(bucket, notNullValue());
    assertThat((String) bucket.getKey(), equalTo("2012-03-15T00:00:00.000Z-*"));
    assertThat(((DateTime) bucket.getFrom()), equalTo(date(3, 15)));
    assertThat(((DateTime) bucket.getTo()), nullValue());
    assertThat(bucket.getFromAsString(), equalTo("2012-03-15T00:00:00.000Z"));
    assertThat(bucket.getToAsString(), nullValue());
    assertThat(bucket.getDocCount(), equalTo(numDocs - 2L));
}