nested字段聚合

于 2023-10-26 23:59:48 发布
阅读量704 收藏 1
点赞数
文章标签： 运维 elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jifgnie/article/details/134067287
版权 
PUT test_aggr
{
    "settings": {
        "number_of_shards": 3,
        "number_of_replicas": 2
    },
    "mappings": {
        "properties": {
            "id": {
                "type": "keyword"
            },
            "aa": {
                "type": "nested",
                "properties": {
                    "bb": {
                        "type": "keyword"
                    }
                }
            }
        }
    }
}

PUT test_aggr/_doc/1  
{  
  "id":"1",
  "aa": [  
    {  
      "bb": "value1"  
    },  
    {  
      "bb": "value2"  
    }  
  ]  
}

PUT test_aggr/_doc/2  
{   
  "id":"2",
  "aa": [  
    {  
      "bb": "value3"  
    },  
    {  
      "bb": "value4"  
    }  
  ]  
}

PUT test_aggr/_doc/3
{  
  "id":"3" 
}


PUT test_aggr/_doc/4
{   
  "id":"4",
  "aa": [  
    {  
       
    }
  ]  
}

PUT test_aggr/_doc/5
{   
  "id":"5",
  "aa": [  

  ]  
}

POST test_aggr/_search
{
  "size": 0,
  "aggs": {
    "aa_values": {
      "nested": {
        "path": "aa"
      },
      "aggs": {
        "bb_terms": {
          "terms": {
            "field": "aa.bb"
          }
        }
      }
    }
  }
}

如何查询出这2个bb为空的数据？

POST test_aggr/_search
{
  "query": {
    "bool": {
      "must_not": {
        "nested": {
          "path": "aa",
          "query": {
            "exists": {
              "field": "aa.bb"
            }
          }
        }
      }
    }
  }
}

import org.apache.http.HttpHost;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.search.builder.SearchSourceBuilder;

public class ElasticsearchJavaExample {

    public static void main(String[] args) throws IOException {
        // 配置 Elasticsearch 主机和端口
        RestClientBuilder builder = RestClient.builder(new HttpHost("your_elasticsearch_host", 9200));

        // 创建高级 REST 客户端
        RestHighLevelClient client = new RestHighLevelClient(builder);

        try {
            // 创建查询请求
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            sourceBuilder.query(QueryBuilders.boolQuery()
                    .mustNot(QueryBuilders.nestedQuery("aa",
                            QueryBuilders.existsQuery("aa.bb"), ScoreMode.None)));

            Request request = new Request("POST", "test_aggr/_search");
            request.setJsonEntity(sourceBuilder.toString());
            request.setOptions(RequestOptions.DEFAULT);

            // 执行查询请求
            Response response = client.getLowLevelClient().performRequest(request);

            // 处理查询结果
            String responseBody = EntityUtils.toString(response.getEntity());
            System.out.println("Query Response: " + responseBody);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

对一层嵌套字段做聚合
{
“size”: 0,
“query”: {
“match_all”: {}
},
“aggs”: {
“aa_values”: {
“nested”: {
“path”: “aa”
},
“aggs”: {
“bb_terms”: {
“terms”: {
“field”: “aa.bb”
}
}
}
}
}
}

java代码：

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.nested.NestedAggregationBuilder;

import java.io.IOException;

public class ElasticsearchJavaQuery {
public static void main(String[] args) throws IOException {
// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient();

    // 创建SearchRequest
    SearchRequest searchRequest = new SearchRequest("test_aggr");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.size(0); // 设置size为0以仅获取聚合结果

    // 创建Nested Aggregation
    NestedAggregationBuilder nestedAggregation = AggregationBuilders.nested("aa_values", "aa");

    // 创建Terms Aggregation
    TermsAggregationBuilder termsAggregation = AggregationBuilders.terms("bb_terms").field("aa.bb");

    // 将Terms Aggregation添加到Nested Aggregation中
    nestedAggregation.subAggregation(termsAggregation);

    // 将Nested Aggregation添加到SearchSourceBuilder
    searchSourceBuilder.aggregation(nestedAggregation);

    searchRequest.source(searchSourceBuilder);

    // 执行查询
    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

    // 处理查询结果
    // 可以通过searchResponse获取聚合结果
    // searchResponse.getAggregations()...

    // 关闭Elasticsearch客户端
    client.close();
}

}

聚合结果：

{
“took” : 0,
“timed_out” : false,
“_shards” : {
“total” : 3,
“successful” : 3,
“skipped” : 0,
“failed” : 0
},
“hits” : {
“total” : {
“value” : 2,
“relation” : “eq”
},
“max_score” : null,
“hits” : [ ]
},
“aggregations” : {
“aa_values” : {
“doc_count” : 4,
“bb_terms” : {
“doc_count_error_upper_bound” : 0,
“sum_other_doc_count” : 0,
“buckets” : [
{
“key” : “value1”,
“doc_count” : 1
},
{
“key” : “value2”,
“doc_count” : 1
},
{
“key” : “value3”,
“doc_count” : 1
},
{
“key” : “value4”,
“doc_count” : 1
}
]
}
}
}
}

===============================================================
二层嵌套
PUT test_aggr_double
{
“settings”: {
“number_of_shards”: 3,
“number_of_replicas”: 2
},
“mappings”: {
“properties”: {
“AA”: {
“type”: “nested”,
“properties”: {
“BB”: {
“type”: “nested”,
“properties”: {
“CC”: {
“type”: “keyword”
},
“DD”: {
“type”: “keyword”
}
}
}
}
}
}
}
}

PUT test_aggr_double/_doc/1
{
“AA”: [
{
“BB”: [
{
“CC”: “value1”,
“DD”: “value2”
},
{
“CC”: “value3”,
“DD”: “value4”
}
]
},
{
“BB”: [
{
“CC”: “value5”,
“DD”: “value6”
},
{
“CC”: “value7”,
“DD”: “value8”
}
]
}
]
}

PUT test_aggr_double/_doc/2
{
“AA”: [
{
“BB”: [
{
“CC”: “value9”,
“DD”: “value10”
},
{
“CC”: “value11”,
“DD”: “value12”
}
]
},
{
“BB”: [
{
“CC”: “value13”,
“DD”: “value14”
},
{
“CC”: “value15”,
“DD”: “value16”
}
]
}
]
}

GET test_aggr_double/_search

{
“took” : 1,
“timed_out” : false,
“_shards” : {
“total” : 3,
“successful” : 3,
“skipped” : 0,
“failed” : 0
},
“hits” : {
“total” : {
“value” : 2,
“relation” : “eq”
},
“max_score” : 1.0,
“hits” : [
{
“_index” : “test_aggr_double”,
“_type” : “_doc”,
“_id” : “2”,
“_score” : 1.0,
“_source” : {
“AA” : [
{
“BB” : [
{
“CC” : “value9”,
“DD” : “value10”
},
{
“CC” : “value11”,
“DD” : “value12”
}
]
},
{
“BB” : [
{
“CC” : “value13”,
“DD” : “value14”
},
{
“CC” : “value15”,
“DD” : “value16”
}
]
}
]
}
},
{
“_index” : “test_aggr_double”,
“_type” : “_doc”,
“_id” : “1”,
“_score” : 1.0,
“_source” : {
“AA” : [
{
“BB” : [
{
“CC” : “value1”,
“DD” : “value2”
},
{
“CC” : “value3”,
“DD” : “value4”
}
]
},
{
“BB” : [
{
“CC” : “value5”,
“DD” : “value6”
},
{
“CC” : “value7”,
“DD” : “value8”
}
]
}
]
}
}
]
}
}

POST test_aggr_double/_search
{
“size”: 0,
“aggs”: {
“dd_aggregation”: {
“nested”: {
“path”: “AA.BB”
},
“aggs”: {
“dd_terms”: {
“terms”: {
“field”: “AA.BB.DD”,
“size”: 10
}
}
}
}
}
}

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.nested.NestedAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;

public class ElasticsearchAggregationExample {
public static void main(String[] args) throws IOException {
// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
new HttpHost(“localhost”, 9200, “http”)
));

    // 创建聚合查询
    SearchRequest searchRequest = new SearchRequest("test_aggr_double");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    // 设置大小为0，因为我们不需要返回文档，只需要聚合结果
    sourceBuilder.size(0);

    // 创建嵌套聚合
    NestedAggregationBuilder nestedAggregation = AggregationBuilders.nested("dd_aggregation", "AA.BB");
    sourceBuilder.aggregation(nestedAggregation);

    // 在嵌套聚合内创建terms聚合
    TermsAggregationBuilder termsAggregation = AggregationBuilders.terms("dd_terms").field("AA.BB.DD").size(10);
    nestedAggregation.subAggregation(termsAggregation);

    searchRequest.source(sourceBuilder);

    try {
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        // 处理聚合结果
        // 这里可以提取聚合结果并对其进行进一步处理
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 关闭Elasticsearch客户端
    client.close();
}

}

{
“took” : 1,
“timed_out” : false,
“_shards” : {
“total” : 3,
“successful” : 3,
“skipped” : 0,
“failed” : 0
},
“hits” : {
“total” : {
“value” : 2,
“relation” : “eq”
},
“max_score” : null,
“hits” : [ ]
},
“aggregations” : {
“dd_aggregation” : {
“doc_count” : 8,
“dd_terms” : {
“doc_count_error_upper_bound” : 0,
“sum_other_doc_count” : 0,
“buckets” : [
{
“key” : “value10”,
“doc_count” : 1
},
{
“key” : “value12”,
“doc_count” : 1
},
{
“key” : “value14”,
“doc_count” : 1
},
{
“key” : “value16”,
“doc_count” : 1
},
{
“key” : “value2”,
“doc_count” : 1
},
{
“key” : “value4”,
“doc_count” : 1
},
{
“key” : “value6”,
“doc_count” : 1
},
{
“key” : “value8”,
“doc_count” : 1
}
]
}
}
}
}

tebukaopu148
关注
搜索引擎onesearch2(基于elasticsearch6.7)nested字段/动态扩展索引属性
leehom的博客
04-20 321
Nested类型字段是一对多关联对象搜索的解决方案，动态扩展字段在业务系统很常见，搜索引擎需要支持，本文介绍onesearch组件如何使用nested，使用nested实现索引和查询动态扩展索引属性。
ES nested 聚合统计仅符合过滤的子项
liaofucheng123的博客
11-13 2168
ES nested 统计仅符合的子项 相似SQL select sum(item.sku_cnt) from table_main main left join table_item item on main.id = item.main_id where main.id in (4,5,6) and item.sku_id is not null; 2.ES queryDSL查询 { "size": 0, "query": { "bool": {
Elasticsearch Java API 分组、聚合、嵌套相关查询
qq_34910179的博客
06-24 1万+
Elasticsearch Java API 分组、聚合、嵌套相关查询 翼支付监控系统正使用es做后端存储，这边我们是将日志计算处理过后的数据通过kafka储存到es。选择用es作为数据储存端是考虑到es有一套完整的数据处理方式，功能全面性能优越，以及索引滚动可以方便管理es存储的数据。这理我主要是分享下Elasticsearch Java API对ES数据分组、聚合、嵌套以及时间直方图方面相关查...
RestHighLevelClient对字段进行聚合
m0_57302315的博客
11-02 700
引入elasticsearch坐标 <dependencies> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>6.5.4
Es 聚合查询 nested分组聚合时无需指定字段类型
qq_37158147的博客
04-24 1087
行程单索引，一个订单对应多个游客，将游客信息采用nested类型存入订单索引中。//在最外层的查询将agg聚合设置进去,并且使用nested。2.nested分组聚合查询。//统计出现频数最多的前5条。统计游客来源地top5。
ES分组聚合Agg nested
h321880947的博客
08-01 2827
类似于select brandId,sum(salesVolume) from live_room group by brandId 分组之后，再进行求和等运算
Es的针对于nested类型的多重子聚合
xiaoye1360715890的博客
12-12 1729
es关于nested类型的聚合,以及过滤聚合
使用Elasticsearch进行分组聚合统计
ue4的博客
05-18 8842
使用Elasticsearch进行分组聚合统计
ElasticSearch - 嵌套字段类型 nested
qq_36571947的博客
04-17 549
nested类型是object数据类型的专用版本，它允许以可以彼此独立地查询它们的方式对对象数组进行索引。 Elasticsearch没有内部对象的概念。因此，它将对象层次结构简化为字段名称和值的简单列表。 如: PUT my-index-000001/_doc/1 { "group" : "fans", "user" : [ { "first" : "John", "last" : "Smith" }, { "first" : "Alice", "last" :
kibana 如何查询、聚合nested字段
weixin_38374023的博客
02-28 2051
1 kibana对nested字段支持情况截止kibana6.2.1版，仍不能针对nested字段进行查询和聚合。2 ElasticSearch如何操作nested字段2.1 创建样例如下（其中labelInfoList为nested字段）PUT metadatainfo{  "settings": {    ……    },  "mappings": {    "facedataMD": {  ...
springboot中ElasticSearch入门与进阶：组合查询、Aggregation聚合查询（你想要的都有）
像雾像雨又像风_的博客
08-06 6万+
1.springboot中配置elasticSearch 1.1在工程中引入相关的jar包   1.1.1 在build.gradle中添加需要的jar包       我创建的gradle工程，对应的maven工程也是一样，添加对应的jar包即可 // 添加 Spring Data Elasticsearch 的依赖 compile('org.springframework.boot:...
Elastic实战：spring-data-elasticsearch聚合查询指南｜spring-data-elasticsearch实现各类聚合
55555的博客
05-31 5640
0.引言 elasticsearch支持各种类型的聚合查询，给我们做数据统计、数据分析时提供了强大的处理能力，但是作为java开发者，如何在java client中实现这些聚合呢？ 我们知道spring-data-elasticsearch提供了针对整合spring的es java client，但是在elastic、spring-data官方文档中都没有详细说明聚合查询在java client中如何实现。 所以本期，我们的目标就是一篇将这些聚合操作一网打尽！ 为了更好的将这些聚合讲解清楚，我们结合es官方
Elasticsearch嵌套字段的聚合操作
大风的博客
11-05 7932
数据库字段 在之前介绍Elasticsearch字段的时候介绍过Elasticsearch的嵌套字段。在日常使用中，针对嵌套类型的聚合操作和普通字段类型有些许的不同。 嵌套类型 nested 是ES对对象数组设置的类型，它可以对对象数组进行索引。 我们插入一个这样的数据。 { "group" : "fans", "user" : [ { "first" : "Jo...
ElasticSearch java API - 聚合查询-聚合多字段聚合demo
weixin_34088598的博客
07-12 1747
2019独角兽企业重金招聘Python工程师标准>>> ...
elasticsearch中的聚合分组查询
qq_40708942的博客
12-05 4846
分组聚合及嵌套查询 聚合查询可以理解为SQL中的求和、求最大值、最小值以及求均值的需求 嵌套可以理解为es存值的某一个字段为对象属性的值做处理.Elasticsearch Java API分组与聚合结合 需要对多个字段分组 需要将分组结果的其他字段再进行统计的sum、min、max、avg聚合 只聚合不分组 简单的分组查询 解析查聚合结果 上面是最简单的一层聚合查询,其实其他复杂的聚合也都是大同小异,就是一个套娃的操作.复杂聚合查询 ElasticSearch Java API嵌套 上面E
elasticsearch 学习之路-过滤后聚合（FilterAggregationBuilder）
weixin_34004576的博客
04-20 7568
2019独角兽企业重金招聘Python工程师标准>>> ...
【ElasticSearch实战】——ES常用查询条件与mysql对比
热门推荐
Jack 架构师之路
07-11 17万+
类比mysql，我们需要=、&gt;、&gt;=、&lt;、&lt;= 、or、and、in、like、count、sum、group by、order by、limit 在高版本的ES里面使用了boolquery替换了filter1、等于号=QueryBuilders.termQuery("isDel",1)); //termQuery相当于=，相当于isDel=1122、大于小于号QueryB...
Elasticsearch教程(13) Elasticsearch工具类 支持树形结构
Java Spring Elasticsearch
05-15 3798
Elasticsearch工具类 支持树形结构1. 前言2. 目标2.1 目标：基于实体类的CRUD2.2 目标：支持查询ES中树形结构数据3. 问题和解决3.1 问题：获取泛型T的class，避免显示传入class3.1 解决：抄Spring Data的作业3.2 问题：树形结构如何设计3.2 解决：利用ES的nested类型，记录祖先节点ID4. 代码结构设计4.1 普通结构接口-EsRepository4.2 树形结构接口-EsTreeRepository4.3 普通结构抽象类-AbstractEsR
es查询nested类型聚合语法
最新发布
06-15
在Elasticsearch中，`nested`类型用于表示嵌套的数据结构，例如文章中的评论或产品中的属性。当你需要对这些嵌套数据进行查询和聚合时，会用到特定的聚合语法。`nested`类型的聚合通常与`aggs`（聚合）和`bucket_sort`（桶排序）配合使用。 `nested`聚合的基本语法如下： ```json { "aggs": { "nested_agg": { "nested": { "path": "parent_field" }, // "parent_field"是你嵌套数据所在的上级字段名 "aggs": { "child_agg": { ... } // 这里是你对嵌套数据的子聚合，如`terms`、`avg`等 } } } } ``` 例如，假设你有一个文档模型，其中包含一个`comments`字段，每个评论都有`author`和`text`字段，你可以这样进行聚合： ```json { "aggs": { "by_author": { "nested": { "path": "comments" }, "aggs": { "top_comments": { "top_hits": { "_source": ["author", "text"], "size": 1 // 取出每个作者的最新一条评论 } } } } } } ``` 这将返回每个作者及其最新的评论。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值