Examples with Nested org.elasticsearch.search.aggregations.bucket.nested.Nested used on opensource projects

Example 16 with Nested

use of org.elasticsearch.search.aggregations.bucket.nested.Nested in project elasticsearch by elastic.

the class NestedIT method testParentFilterResolvedCorrectly.

// Test based on: https://github.com/elastic/elasticsearch/issues/9280
public void testParentFilterResolvedCorrectly() throws Exception {
    XContentBuilder mapping = jsonBuilder().startObject().startObject("provider").startObject("properties").startObject("comments").field("type", "nested").startObject("properties").startObject("cid").field("type", "long").endObject().startObject("identifier").field("type", "keyword").endObject().startObject("tags").field("type", "nested").startObject("properties").startObject("tid").field("type", "long").endObject().startObject("name").field("type", "keyword").endObject().endObject().endObject().endObject().endObject().startObject("dates").field("type", "object").startObject("properties").startObject("day").field("type", "date").field("format", "dateOptionalTime").endObject().startObject("month").field("type", "object").startObject("properties").startObject("end").field("type", "date").field("format", "dateOptionalTime").endObject().startObject("start").field("type", "date").field("format", "dateOptionalTime").endObject().startObject("label").field("type", "keyword").endObject().endObject().endObject().endObject().endObject().endObject().endObject().endObject();
    assertAcked(prepareCreate("idx2").setSettings(Settings.builder().put(SETTING_NUMBER_OF_SHARDS, 1).put(SETTING_NUMBER_OF_REPLICAS, 0)).addMapping("provider", mapping));
    ensureGreen("idx2");
    List<IndexRequestBuilder> indexRequests = new ArrayList<>(2);
    indexRequests.add(client().prepareIndex("idx2", "provider", "1").setSource("{\"dates\": {\"month\": {\"label\": \"2014-11\", \"end\": \"2014-11-30\", \"start\": \"2014-11-01\"}, \"day\": \"2014-11-30\"}, \"comments\": [{\"cid\": 3,\"identifier\": \"29111\"}, {\"cid\": 4,\"tags\": [{\"tid\" :44,\"name\": \"Roles\"}], \"identifier\": \"29101\"}]}", XContentType.JSON));
    indexRequests.add(client().prepareIndex("idx2", "provider", "2").setSource("{\"dates\": {\"month\": {\"label\": \"2014-12\", \"end\": \"2014-12-31\", \"start\": \"2014-12-01\"}, \"day\": \"2014-12-03\"}, \"comments\": [{\"cid\": 1, \"identifier\": \"29111\"}, {\"cid\": 2,\"tags\": [{\"tid\" : 22, \"name\": \"DataChannels\"}], \"identifier\": \"29101\"}]}", XContentType.JSON));
    indexRandom(true, indexRequests);
    SearchResponse response = client().prepareSearch("idx2").setTypes("provider").addAggregation(terms("startDate").field("dates.month.start").subAggregation(terms("endDate").field("dates.month.end").subAggregation(terms("period").field("dates.month.label").subAggregation(nested("ctxt_idfier_nested", "comments").subAggregation(filter("comment_filter", termQuery("comments.identifier", "29111")).subAggregation(nested("nested_tags", "comments.tags").subAggregation(terms("tag").field("comments.tags.name")))))))).get();
    assertNoFailures(response);
    assertHitCount(response, 2);
    Terms startDate = response.getAggregations().get("startDate");
    assertThat(startDate.getBuckets().size(), equalTo(2));
    Terms.Bucket bucket = startDate.getBucketByKey("2014-11-01T00:00:00.000Z");
    assertThat(bucket.getDocCount(), equalTo(1L));
    Terms endDate = bucket.getAggregations().get("endDate");
    bucket = endDate.getBucketByKey("2014-11-30T00:00:00.000Z");
    assertThat(bucket.getDocCount(), equalTo(1L));
    Terms period = bucket.getAggregations().get("period");
    bucket = period.getBucketByKey("2014-11");
    assertThat(bucket.getDocCount(), equalTo(1L));
    Nested comments = bucket.getAggregations().get("ctxt_idfier_nested");
    assertThat(comments.getDocCount(), equalTo(2L));
    Filter filter = comments.getAggregations().get("comment_filter");
    assertThat(filter.getDocCount(), equalTo(1L));
    Nested nestedTags = filter.getAggregations().get("nested_tags");
    // This must be 0
    assertThat(nestedTags.getDocCount(), equalTo(0L));
    Terms tags = nestedTags.getAggregations().get("tag");
    // and this must be empty
    assertThat(tags.getBuckets().size(), equalTo(0));
    bucket = startDate.getBucketByKey("2014-12-01T00:00:00.000Z");
    assertThat(bucket.getDocCount(), equalTo(1L));
    endDate = bucket.getAggregations().get("endDate");
    bucket = endDate.getBucketByKey("2014-12-31T00:00:00.000Z");
    assertThat(bucket.getDocCount(), equalTo(1L));
    period = bucket.getAggregations().get("period");
    bucket = period.getBucketByKey("2014-12");
    assertThat(bucket.getDocCount(), equalTo(1L));
    comments = bucket.getAggregations().get("ctxt_idfier_nested");
    assertThat(comments.getDocCount(), equalTo(2L));
    filter = comments.getAggregations().get("comment_filter");
    assertThat(filter.getDocCount(), equalTo(1L));
    nestedTags = filter.getAggregations().get("nested_tags");
    // This must be 0
    assertThat(nestedTags.getDocCount(), equalTo(0L));
    tags = nestedTags.getAggregations().get("tag");
    // and this must be empty
    assertThat(tags.getBuckets().size(), equalTo(0));
}

Example 17 with Nested

use of org.elasticsearch.search.aggregations.bucket.nested.Nested in project elasticsearch by elastic.

the class ReverseNestedIT method testSimpleReverseNestedToRoot.

public void testSimpleReverseNestedToRoot() throws Exception {
    SearchResponse response = client().prepareSearch("idx").setTypes("type1").addAggregation(nested("nested1", "nested1").subAggregation(terms("field2").field("nested1.field2").subAggregation(reverseNested("nested1_to_field1").subAggregation(terms("field1").field("field1").collectMode(randomFrom(SubAggCollectionMode.values())))))).get();
    assertSearchResponse(response);
    Nested nested = response.getAggregations().get("nested1");
    assertThat(nested, notNullValue());
    assertThat(nested.getName(), equalTo("nested1"));
    assertThat(nested.getDocCount(), equalTo(25L));
    assertThat(nested.getAggregations().asList().isEmpty(), is(false));
    Terms usernames = nested.getAggregations().get("field2");
    assertThat(usernames, notNullValue());
    assertThat(usernames.getBuckets().size(), equalTo(9));
    List<Terms.Bucket> usernameBuckets = new ArrayList<>(usernames.getBuckets());
    // nested.field2: 1
    Terms.Bucket bucket = usernameBuckets.get(0);
    assertThat(bucket.getKeyAsString(), equalTo("1"));
    assertThat(bucket.getDocCount(), equalTo(6L));
    ReverseNested reverseNested = bucket.getAggregations().get("nested1_to_field1");
    assertThat(reverseNested.getProperty("_count"), equalTo(5L));
    Terms tags = reverseNested.getAggregations().get("field1");
    assertThat(reverseNested.getProperty("field1"), sameInstance(tags));
    List<Terms.Bucket> tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(6));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(4L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("a"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(3L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("e"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(4).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(4).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(5).getKeyAsString(), equalTo("x"));
    assertThat(tagsBuckets.get(5).getDocCount(), equalTo(1L));
    // nested.field2: 4
    bucket = usernameBuckets.get(1);
    assertThat(bucket.getKeyAsString(), equalTo("4"));
    assertThat(bucket.getDocCount(), equalTo(4L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(5));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("a"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(3L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(4).getKeyAsString(), equalTo("e"));
    assertThat(tagsBuckets.get(4).getDocCount(), equalTo(1L));
    // nested.field2: 7
    bucket = usernameBuckets.get(2);
    assertThat(bucket.getKeyAsString(), equalTo("7"));
    assertThat(bucket.getDocCount(), equalTo(3L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(5));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("e"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("a"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(4).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(4).getDocCount(), equalTo(1L));
    // nested.field2: 2
    bucket = usernameBuckets.get(3);
    assertThat(bucket.getKeyAsString(), equalTo("2"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(3));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("a"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(1L));
    // nested.field2: 3
    bucket = usernameBuckets.get(4);
    assertThat(bucket.getKeyAsString(), equalTo("3"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(3));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("a"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(1L));
    // nested.field2: 5
    bucket = usernameBuckets.get(5);
    assertThat(bucket.getKeyAsString(), equalTo("5"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(4));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("z"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
    // nested.field2: 6
    bucket = usernameBuckets.get(6);
    assertThat(bucket.getKeyAsString(), equalTo("6"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(4));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("b"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("y"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
    // nested.field2: 8
    bucket = usernameBuckets.get(7);
    assertThat(bucket.getKeyAsString(), equalTo("8"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(4));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(2L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("e"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("x"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
    // nested.field2: 9
    bucket = usernameBuckets.get(8);
    assertThat(bucket.getKeyAsString(), equalTo("9"));
    assertThat(bucket.getDocCount(), equalTo(2L));
    reverseNested = bucket.getAggregations().get("nested1_to_field1");
    tags = reverseNested.getAggregations().get("field1");
    tagsBuckets = new ArrayList<>(tags.getBuckets());
    assertThat(tagsBuckets.size(), equalTo(4));
    assertThat(tagsBuckets.get(0).getKeyAsString(), equalTo("c"));
    assertThat(tagsBuckets.get(0).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(1).getKeyAsString(), equalTo("d"));
    assertThat(tagsBuckets.get(1).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(2).getKeyAsString(), equalTo("e"));
    assertThat(tagsBuckets.get(2).getDocCount(), equalTo(1L));
    assertThat(tagsBuckets.get(3).getKeyAsString(), equalTo("z"));
    assertThat(tagsBuckets.get(3).getDocCount(), equalTo(1L));
}

Example 18 with Nested

use of org.elasticsearch.search.aggregations.bucket.nested.Nested in project elasticsearch by elastic.

the class ReverseNestedIT method testNonExistingNestedField.

public void testNonExistingNestedField() throws Exception {
    SearchResponse searchResponse = client().prepareSearch("idx").setQuery(matchAllQuery()).addAggregation(nested("nested2", "nested1.nested2").subAggregation(reverseNested("incorrect").path("nested3"))).get();
    Nested nested = searchResponse.getAggregations().get("nested2");
    assertThat(nested, notNullValue());
    assertThat(nested.getName(), equalTo("nested2"));
    ReverseNested reverseNested = nested.getAggregations().get("incorrect");
    assertThat(reverseNested.getDocCount(), is(0L));
    // Test that parsing the reverse_nested agg doesn't fail, because the parent nested agg is unmapped:
    searchResponse = client().prepareSearch("idx").setQuery(matchAllQuery()).addAggregation(nested("incorrect1", "incorrect1").subAggregation(reverseNested("incorrect2").path("incorrect2"))).get();
    nested = searchResponse.getAggregations().get("incorrect1");
    assertThat(nested, notNullValue());
    assertThat(nested.getName(), equalTo("incorrect1"));
    assertThat(nested.getDocCount(), is(0L));
}

Example 19 with Nested

use of org.elasticsearch.search.aggregations.bucket.nested.Nested in project elasticsearch by elastic.

the class ReverseNestedIT method testSameParentDocHavingMultipleBuckets.

public void testSameParentDocHavingMultipleBuckets() throws Exception {
    XContentBuilder mapping = jsonBuilder().startObject().startObject("product").field("dynamic", "strict").startObject("properties").startObject("id").field("type", "long").endObject().startObject("category").field("type", "nested").startObject("properties").startObject("name").field("type", "keyword").endObject().endObject().endObject().startObject("sku").field("type", "nested").startObject("properties").startObject("sku_type").field("type", "keyword").endObject().startObject("colors").field("type", "nested").startObject("properties").startObject("name").field("type", "keyword").endObject().endObject().endObject().endObject().endObject().endObject().endObject().endObject();
    assertAcked(prepareCreate("idx3").setSettings(Settings.builder().put(SETTING_NUMBER_OF_SHARDS, 1).put(SETTING_NUMBER_OF_REPLICAS, 0)).addMapping("product", mapping));
    client().prepareIndex("idx3", "product", "1").setRefreshPolicy(IMMEDIATE).setSource(jsonBuilder().startObject().startArray("sku").startObject().field("sku_type", "bar1").startArray("colors").startObject().field("name", "red").endObject().startObject().field("name", "green").endObject().startObject().field("name", "yellow").endObject().endArray().endObject().startObject().field("sku_type", "bar1").startArray("colors").startObject().field("name", "red").endObject().startObject().field("name", "blue").endObject().startObject().field("name", "white").endObject().endArray().endObject().startObject().field("sku_type", "bar1").startArray("colors").startObject().field("name", "black").endObject().startObject().field("name", "blue").endObject().endArray().endObject().startObject().field("sku_type", "bar2").startArray("colors").startObject().field("name", "orange").endObject().endArray().endObject().startObject().field("sku_type", "bar2").startArray("colors").startObject().field("name", "pink").endObject().endArray().endObject().endArray().startArray("category").startObject().field("name", "abc").endObject().startObject().field("name", "klm").endObject().startObject().field("name", "xyz").endObject().endArray().endObject()).get();
    SearchResponse response = client().prepareSearch("idx3").addAggregation(nested("nested_0", "category").subAggregation(terms("group_by_category").field("category.name").subAggregation(reverseNested("to_root").subAggregation(nested("nested_1", "sku").subAggregation(filter("filter_by_sku", termQuery("sku.sku_type", "bar1")).subAggregation(count("sku_count").field("sku.sku_type"))))))).get();
    assertNoFailures(response);
    assertHitCount(response, 1);
    Nested nested0 = response.getAggregations().get("nested_0");
    assertThat(nested0.getDocCount(), equalTo(3L));
    Terms terms = nested0.getAggregations().get("group_by_category");
    assertThat(terms.getBuckets().size(), equalTo(3));
    for (String bucketName : new String[] { "abc", "klm", "xyz" }) {
        logger.info("Checking results for bucket {}", bucketName);
        Terms.Bucket bucket = terms.getBucketByKey(bucketName);
        assertThat(bucket.getDocCount(), equalTo(1L));
        ReverseNested toRoot = bucket.getAggregations().get("to_root");
        assertThat(toRoot.getDocCount(), equalTo(1L));
        Nested nested1 = toRoot.getAggregations().get("nested_1");
        assertThat(nested1.getDocCount(), equalTo(5L));
        Filter filterByBar = nested1.getAggregations().get("filter_by_sku");
        assertThat(filterByBar.getDocCount(), equalTo(3L));
        ValueCount barCount = filterByBar.getAggregations().get("sku_count");
        assertThat(barCount.getValue(), equalTo(3L));
    }
    response = client().prepareSearch("idx3").addAggregation(nested("nested_0", "category").subAggregation(terms("group_by_category").field("category.name").subAggregation(reverseNested("to_root").subAggregation(nested("nested_1", "sku").subAggregation(filter("filter_by_sku", termQuery("sku.sku_type", "bar1")).subAggregation(nested("nested_2", "sku.colors").subAggregation(filter("filter_sku_color", termQuery("sku.colors.name", "red")).subAggregation(reverseNested("reverse_to_sku").path("sku").subAggregation(count("sku_count").field("sku.sku_type")))))))))).get();
    assertNoFailures(response);
    assertHitCount(response, 1);
    nested0 = response.getAggregations().get("nested_0");
    assertThat(nested0.getDocCount(), equalTo(3L));
    terms = nested0.getAggregations().get("group_by_category");
    assertThat(terms.getBuckets().size(), equalTo(3));
    for (String bucketName : new String[] { "abc", "klm", "xyz" }) {
        logger.info("Checking results for bucket {}", bucketName);
        Terms.Bucket bucket = terms.getBucketByKey(bucketName);
        assertThat(bucket.getDocCount(), equalTo(1L));
        ReverseNested toRoot = bucket.getAggregations().get("to_root");
        assertThat(toRoot.getDocCount(), equalTo(1L));
        Nested nested1 = toRoot.getAggregations().get("nested_1");
        assertThat(nested1.getDocCount(), equalTo(5L));
        Filter filterByBar = nested1.getAggregations().get("filter_by_sku");
        assertThat(filterByBar.getDocCount(), equalTo(3L));
        Nested nested2 = filterByBar.getAggregations().get("nested_2");
        assertThat(nested2.getDocCount(), equalTo(8L));
        Filter filterBarColor = nested2.getAggregations().get("filter_sku_color");
        assertThat(filterBarColor.getDocCount(), equalTo(2L));
        ReverseNested reverseToBar = filterBarColor.getAggregations().get("reverse_to_sku");
        assertThat(reverseToBar.getDocCount(), equalTo(2L));
        ValueCount barCount = reverseToBar.getAggregations().get("sku_count");
        assertThat(barCount.getValue(), equalTo(2L));
    }
}