Java Range类代码示例

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testSingleValuedField() {
    SearchResponse rsp = client().prepareSearch("idx").addAggregation(
            AggregationBuilders.ipRange("my_range")
                .field("ip")
                .addUnboundedTo("192.168.1.0")
                .addRange("192.168.1.0", "192.168.1.10")
                .addUnboundedFrom("192.168.1.10")).get();
    assertSearchResponse(rsp);
    Range range = rsp.getAggregations().get("my_range");
    assertEquals(3, range.getBuckets().size());

    Range.Bucket bucket1 = range.getBuckets().get(0);
    assertNull(bucket1.getFrom());
    assertEquals("192.168.1.0", bucket1.getTo());
    assertEquals(0, bucket1.getDocCount());

    Range.Bucket bucket2 = range.getBuckets().get(1);
    assertEquals("192.168.1.0", bucket2.getFrom());
    assertEquals("192.168.1.10", bucket2.getTo());
    assertEquals(1, bucket2.getDocCount());

    Range.Bucket bucket3 = range.getBuckets().get(2);
    assertEquals("192.168.1.10", bucket3.getFrom());
    assertNull(bucket3.getTo());
    assertEquals(2, bucket3.getDocCount());
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testMultiValuedField() {
    SearchResponse rsp = client().prepareSearch("idx").addAggregation(
            AggregationBuilders.ipRange("my_range")
                .field("ips")
                .addUnboundedTo("192.168.1.0")
                .addRange("192.168.1.0", "192.168.1.10")
                .addUnboundedFrom("192.168.1.10")).get();
    assertSearchResponse(rsp);
    Range range = rsp.getAggregations().get("my_range");
    assertEquals(3, range.getBuckets().size());

    Range.Bucket bucket1 = range.getBuckets().get(0);
    assertNull(bucket1.getFrom());
    assertEquals("192.168.1.0", bucket1.getTo());
    assertEquals(1, bucket1.getDocCount());

    Range.Bucket bucket2 = range.getBuckets().get(1);
    assertEquals("192.168.1.0", bucket2.getFrom());
    assertEquals("192.168.1.10", bucket2.getTo());
    assertEquals(1, bucket2.getDocCount());

    Range.Bucket bucket3 = range.getBuckets().get(2);
    assertEquals("192.168.1.10", bucket3.getFrom());
    assertNull(bucket3.getTo());
    assertEquals(2, bucket3.getDocCount());
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testIpMask() {
    SearchResponse rsp = client().prepareSearch("idx").addAggregation(
            AggregationBuilders.ipRange("my_range")
                .field("ips")
                .addMaskRange("::/0")
                .addMaskRange("0.0.0.0/0")
                .addMaskRange("2001:db8::/64")).get();
    assertSearchResponse(rsp);
    Range range = rsp.getAggregations().get("my_range");
    assertEquals(3, range.getBuckets().size());

    Range.Bucket bucket1 = range.getBuckets().get(0);
    assertEquals("::/0", bucket1.getKey());
    assertEquals(3, bucket1.getDocCount());

    Range.Bucket bucket2 = range.getBuckets().get(1);
    assertEquals("0.0.0.0/0", bucket2.getKey());
    assertEquals(2, bucket2.getDocCount());

    Range.Bucket bucket3 = range.getBuckets().get(2);
    assertEquals("2001:db8::/64", bucket3.getKey());
    assertEquals(1, bucket3.getDocCount());
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testPartiallyUnmapped() {
    SearchResponse rsp = client().prepareSearch("idx", "idx_unmapped").addAggregation(
            AggregationBuilders.ipRange("my_range")
                .field("ip")
                .addUnboundedTo("192.168.1.0")
                .addRange("192.168.1.0", "192.168.1.10")
                .addUnboundedFrom("192.168.1.10")).get();
    assertSearchResponse(rsp);
    Range range = rsp.getAggregations().get("my_range");
    assertEquals(3, range.getBuckets().size());

    Range.Bucket bucket1 = range.getBuckets().get(0);
    assertNull(bucket1.getFrom());
    assertEquals("192.168.1.0", bucket1.getTo());
    assertEquals(0, bucket1.getDocCount());

    Range.Bucket bucket2 = range.getBuckets().get(1);
    assertEquals("192.168.1.0", bucket2.getFrom());
    assertEquals("192.168.1.10", bucket2.getTo());
    assertEquals(1, bucket2.getDocCount());

    Range.Bucket bucket3 = range.getBuckets().get(2);
    assertEquals("192.168.1.10", bucket3.getFrom());
    assertNull(bucket3.getTo());
    assertEquals(2, bucket3.getDocCount());
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testUnmapped() {
    SearchResponse rsp = client().prepareSearch("idx_unmapped").addAggregation(
            AggregationBuilders.ipRange("my_range")
                .field("ip")
                .addUnboundedTo("192.168.1.0")
                .addRange("192.168.1.0", "192.168.1.10")
                .addUnboundedFrom("192.168.1.10")).get();
    assertSearchResponse(rsp);
    Range range = rsp.getAggregations().get("my_range");
    assertEquals(3, range.getBuckets().size());

    Range.Bucket bucket1 = range.getBuckets().get(0);
    assertNull(bucket1.getFrom());
    assertEquals("192.168.1.0", bucket1.getTo());
    assertEquals(0, bucket1.getDocCount());

    Range.Bucket bucket2 = range.getBuckets().get(1);
    assertEquals("192.168.1.0", bucket2.getFrom());
    assertEquals("192.168.1.10", bucket2.getTo());
    assertEquals(0, bucket2.getDocCount());

    Range.Bucket bucket3 = range.getBuckets().get(2);
    assertEquals("192.168.1.10", bucket3.getFrom());
    assertNull(bucket3.getTo());
    assertEquals(0, bucket3.getDocCount());
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
@Override
public AggregationResults convertResult(ResultsConverter resultsConverter, Aggregation aggregation, Aggregations aggs) {
    AggregationResults result = null;

    String name = aggregation.getName();
    if (aggs.get(name) instanceof Range) {
        Range ranges = aggs.get(name);
        List<Bucket> buckets = new ArrayList<>();
        for (Range.Bucket bucket : ranges.getBuckets()) {
            String label = bucket.getFrom() + " TO " + bucket.getTo();
            String key = bucket.getKeyAsString();
            Bucket b = new Bucket(key, bucket.getDocCount(), label);
            buckets.add(b);
            for (Aggregation subAgg : aggregation.getAggs().values()) {
                AggregationResults subResults = resultsConverter.convertResults(subAgg, bucket.getAggregations());
                if (subResults != null) {
                    b.getAggs().put(subAgg.getName(), subResults);
                }
            }
        }
        result = new AggregationResults(name, buckets);
    }
    return result;
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
@Override
public AggregationResults convertResult(ResultsConverter resultsConverter, Aggregation aggregation, Aggregations aggs) {
    AggregationResults result = null;

    String name = aggregation.getName();
    if (aggs.get(name) instanceof Range) {
        Range ranges = (Range) aggs.get(name);
        List<Bucket> buckets = new ArrayList<>();
        for (Range.Bucket bucket : ranges.getBuckets()) {
            String label = bucket.getFrom() + " TO " + bucket.getTo();
            String key = bucket.getKey();
            Bucket b = new Bucket(key, bucket.getDocCount(), label);
            buckets.add(b);
            for (Aggregation subAgg : aggregation.getAggs().values()) {
                AggregationResults subResults = resultsConverter.convertResults(subAgg, bucket.getAggregations());
                if (subResults != null) {
                    b.getAggs().put(subAgg.getName(), subResults);
                }
            }
        }
        result = new AggregationResults(name, buckets);
    }
    return result;
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testDateRange() throws Exception {
    SearchResponse response = client().prepareSearch("idx")
            .setQuery(QueryBuilders.matchAllQuery())
            .addAggregation(dateRange("range").field("date").addRange("r1", "2014-01-01", "2014-01-10")
                    .subAggregation(dateHistogram("histo").field("date").dateHistogramInterval(DateHistogramInterval.DAY).minDocCount(0)))
            .execute().actionGet();

    assertSearchResponse(response);

    Range range = response.getAggregations().get("range");
    Histogram histo = range.getBuckets().get(0).getAggregations().get("histo");
    assertThat(histo.getBuckets().size(), equalTo(4));
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
@AwaitsFix(bugUrl="https://github.com/elastic/elasticsearch/issues/17700")
public void testIpRange() throws Exception {
    SearchResponse response = client().prepareSearch("idx")
            .setQuery(QueryBuilders.matchAllQuery())
            .addAggregation(ipRange("range").field("ip").addRange("r1", "10.0.0.1", "10.0.0.10")
                    .subAggregation(dateHistogram("histo").field("date").dateHistogramInterval(DateHistogramInterval.DAY).minDocCount(0)))
            .execute().actionGet();

    assertSearchResponse(response);

    Range range = response.getAggregations().get("range");
    Histogram histo = range.getBuckets().get(0).getAggregations().get("histo");
    assertThat(histo.getBuckets().size(), equalTo(4));
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testDateMath() throws Exception {
    Map<String, Object> params = new HashMap<>();
    params.put("fieldname", "date");
    DateRangeAggregationBuilder rangeBuilder = dateRange("range");
    if (randomBoolean()) {
        rangeBuilder.field("date");
    } else {
        rangeBuilder.script(new Script(ScriptType.INLINE, "native", DateScriptMocks.ExtractFieldScript.NAME, params));
    }
    SearchResponse response = client()
            .prepareSearch("idx")
            .addAggregation(
                    rangeBuilder.addUnboundedTo("a long time ago", "now-50y").addRange("recently", "now-50y", "now-1y")
                            .addUnboundedFrom("last year", "now-1y").timeZone(DateTimeZone.forID("EST"))).execute().actionGet();

    assertSearchResponse(response);

    Range range = response.getAggregations().get("range");
    assertThat(range, notNullValue());
    assertThat(range.getName(), equalTo("range"));
    assertThat(range.getBuckets().size(), equalTo(3));

    // TODO: use diamond once JI-9019884 is fixed
    List<Range.Bucket> buckets = new ArrayList<>(range.getBuckets());

    Range.Bucket bucket = buckets.get(0);
    assertThat((String) bucket.getKey(), equalTo("a long time ago"));
    assertThat(bucket.getKeyAsString(), equalTo("a long time ago"));
    assertThat(bucket.getDocCount(), equalTo(0L));

    bucket = buckets.get(1);
    assertThat((String) bucket.getKey(), equalTo("recently"));
    assertThat(bucket.getKeyAsString(), equalTo("recently"));
    assertThat(bucket.getDocCount(), equalTo((long) numDocs));

    bucket = buckets.get(2);
    assertThat((String) bucket.getKey(), equalTo("last year"));
    assertThat(bucket.getKeyAsString(), equalTo("last year"));
    assertThat(bucket.getDocCount(), equalTo(0L));
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testRangeAgg() {
    SearchResponse response = client().prepareSearch("old_index", "new_index")
            .addAggregation(AggregationBuilders.ipRange("ip_range").field("ip_field")
                    .addMaskRange("127.0.0.1/16")
                    .addMaskRange("::1/64")).get();
    assertNoFailures(response);
    assertEquals(3, response.getHits().getTotalHits());
    Range range = response.getAggregations().get("ip_range");
    assertEquals(2, range.getBuckets().size());
    assertEquals("::1/64", range.getBuckets().get(0).getKeyAsString());
    assertEquals(3, range.getBuckets().get(0).getDocCount());
    assertEquals("127.0.0.1/16", range.getBuckets().get(1).getKeyAsString());
    assertEquals(2, range.getBuckets().get(1).getDocCount());
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public ElasticsearchFacetFieldCollector(Aggregation facet) {
	if (facet instanceof Range) {
		initialize((Range)facet);
	}
	else {
		initialize((Terms)facet);
	}
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
protected void initialize(Range rangeFacet) {
	_facet = rangeFacet;

	for (Range.Bucket entry : rangeFacet.getBuckets()) {
		StringBundler sb = new StringBundler();

		sb.append("{");
		sb.append(entry.getFromAsString());
		sb.append("-");
		sb.append(entry.getToAsString());
		sb.append("}");

		_counts.put(sb.toString(), entry.getDocCount());
	}
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testSingleValueField() throws Exception {
    SearchResponse response = client().prepareSearch("idx")
            .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(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(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 - 4L));
}
 

import org.elasticsearch.search.aggregations.bucket.range.Range; //导入依赖的package包/类
public void testSingleValueFieldWithStringDates() throws Exception {
    SearchResponse response = client().prepareSearch("idx")
            .addAggregation(dateRange("range")
                    .field("date")
                    .addUnboundedTo("2012-02-15")
                    .addRange("2012-02-15", "2012-03-15")
                    .addUnboundedFrom("2012-03-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(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 - 4L));
}