ElasticSearch中composite聚合的使用

最新推荐文章于 2024-06-12 18:30:00 发布

AngusC·

最新推荐文章于 2024-06-12 18:30:00 发布

阅读量1.5w

点赞数 19

分类专栏： elasticsearch 文章标签： elasticsearch多字段聚合 es多字段聚合 composite的使用 composite的java composite聚合

本文链接：https://blog.csdn.net/qq_18895659/article/details/86540548

版权

elasticsearch 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

简介composite

composite是一个多桶聚合，它从不同的源创建复合桶，与其他多桶聚合不同，复合聚合可用于高效地对多级聚合中的所有桶进行分页。这种聚合提供了一种方法来流特定聚合的所有桶，类似于滚动对文档所做的操作。

组合桶是由为每个文档提取/创建的值的组合构建的，每个组合被视为组合桶。如下为官方给的例子：

{
    "keyword": ["foo", "bar"],
    "number": [23, 65, 76]
}

如果我们同时对keyword和number两个字段进行聚合会得出以下的结果:

{ "keyword": "foo", "number": 23 }
{ "keyword": "foo", "number": 65 }
{ "keyword": "foo", "number": 76 }
{ "keyword": "bar", "number": 23 }
{ "keyword": "bar", "number": 65 }
{ "keyword": "bar", "number": 76 }

看到上面的例子是不是恍然大悟，就像类似sql中的多group by 多字段，可以对多个字段进行聚合，这非常适用于对于多维度出报表的需求，我这里建议使用的版本为6.5+，因为6.5版本以下此功能还处于测试阶段，设计和代码没有正式的GA功能成熟，并且没有担保。当然我这里也会提供6.5版本以下如何进行多聚合字段的使用。

首先上官方文档地址:

https://www.elastic.co/guide/en/elasticsearch/reference/6.5/search-aggregations-bucket-composite-aggregation.html

其实官方文档已经把该功能说得很详细，如果你只是单纯写DSL实现的话看官方文档就可以，我接下来就介绍如何调用他的javaAPI来使用，当然如果阅读源码能力强的话也可以直接看官方在github的test,地址如下:

https://github.com/elastic/elasticsearch/tree/master/server/src/test/java/org/elasticsearch/search/aggregations/bucket/composite

验证多字段聚合可行性

上面的例子为官方例子，我们需要自己弄个例子检查可行性，我们现在创建一个index,索引名为composite_test,mapping如下

{
         "area" : {
            "type" : "keyword"
          },
          "userid" : {
            "type" : "keyword"
          },
          "sendtime" : {
            "type" : "date",
            "format" : "yyyy-MM-dd HH:mm:ss"
          }
}

我们创建好了index，index中一共有三个字段，area，userid，sendtime三个字段，我们也使用MySQL数据建一个一模一样的表，方便对比聚合出来的数据是否正确，表名为composite_test。

我们首先对数据表composite_test插入5条记录，分别如下

使用group by对三个字段进行聚合，以下为在数据库中的实现：

SELECT COUNT(1),area,userid,sendtime FROM composite_test GROUP BY area,userid,sendtime

结果如下:

以上为数据库的聚合实现，所以我们使用ES进行多字段聚合的时候如果结果和以上的一样则是正确的，我们也一样往ES composite_test索引中插入相同的5条数据,在kibana上执行以下命令插入。

POST composite_test/_bulk
{ "index" : {"_type" :"_doc"}}
{"area":"33","userid":"400015","sendtime":"2019-01-17 00:00:00"}
{ "index" : {"_type" : "_doc"}}
{"area":"33","userid":"400015","sendtime":"2019-01-17 00:00:00"}
{ "index" : {"_type" : "_doc"}}
{"area":"35","userid":"400016","sendtime":"2019-01-18 00:00:00"}
{ "index" : { "_type" : "_doc"}}
{"area":"35","userid":"400016","sendtime":"2019-01-18 00:00:00"}
{ "index" : {"_type" : "_doc"}}
{"area":"33","userid":"400017","sendtime":"2019-01-17 00:00:00"}

查询ES，我们发现已经存在了这5条数据了。

接下来我们先使用composite的DSL查询：

GET composite_test/_search
{"size": 0, 
 "aggs" : {
      "my_buckets": {
        "composite" : {
           "sources" : [
              { "area": { "terms": {"field": "area" } } },
               { "userid": { "terms": {"field": "userid" } } },
               { "sendtime": { "date_histogram": { "field": "sendtime","interval": "1d","format": "yyyy-MM-dd"} } }
             ]
         }
        }
    }
}

DSL中参数的意思请自行参考官方文档，都说得很详细的,以上这句理论上是等值于数据库的那句聚合语句的，查询结果如下

[
        {
          "key" : {
            "area" : "33",
            "userid" : "400015",
            "sendtime" : "2019-01-17"
          },
          "doc_count" : 2
        },
        {
          "key" : {
            "area" : "33",
            "userid" : "400017",
            "sendtime" : "2019-01-17"
          },
          "doc_count" : 1
        },
        {
          "key" : {
            "area" : "35",
            "userid" : "400016",
            "sendtime" : "2019-01-18"
          },
          "doc_count" : 2
        }
]

从以上响应的json数组中我们不难看出，该聚合聚合出来的数据是和数据库聚合出来的数据是一致的，所以 composite是可以使用在多字段聚合上的。论证完可行性，我们接下来使用java来实现，实话说这一块我是看源代码才会使用的，网上资料基本为0，而且官方java使用文档里也没用，的确是与遇到了不少坑，写出来方便以后使用能快速回忆。

java使用composite聚合

首先创建Maven项目,加入ElasticSearch依赖：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>6.5.4</version>
</dependency>

直接上实现代码:

SearchRequest searchRequest = new SearchRequest("composite_test"); 
searchRequest.types("_doc");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); 
searchSourceBuilder.size(0);
/********************以下组装聚合的三个字段****************************/
List<CompositeValuesSourceBuilder<?>> sources = new ArrayList<>();
		
DateHistogramValuesSourceBuilder sendtime = new DateHistogramValuesSourceBuilder("sendtime")
                .field("sendtime")
                .dateHistogramInterval(DateHistogramInterval.days(1))
                .format("yyyy-MM-dd").order(SortOrder.DESC).missingBucket(false);
        sources.add(sendtime);
TermsValuesSourceBuilder userid = new TermsValuesSourceBuilder("userid").field("userid").missingBucket(true);
        sources.add(userid);
        TermsValuesSourceBuilder dttype = new TermsValuesSourceBuilder("area").field("area").missingBucket(true);
        sources.add(dttype);
        CompositeAggregationBuilder  composite =new CompositeAggregationBuilder("my_buckets", sources);
composite.size(1000);
/*********************执行查询******************************/
searchSourceBuilder.aggregation(composite);
searchRequest.source(searchSourceBuilder); 
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
/********************取出数据*******************/
Aggregations aggregations = searchResponse.getAggregations();
ParsedComposite parsedComposite = aggregations.get("my_buckets");
List<ParsedBucket> list =  parsedComposite.getBuckets();
Map<String,Object> data = new HashMap<>();
for(ParsedBucket parsedBucket:list){
	data.clear();
	for (Map.Entry<String, Object> m :  parsedBucket.getKey().entrySet()) {
		data.put(m.getKey(),m.getValue());
	}
	data.put("count",parsedBucket.getDocCount());
	    System.out.println(data);
}
/*************************************/

代码中的client为RestHighLevelClient，请自行初始化，然后执行代码，控制台打印如下:

{area=35, count=2, sendtime=2019-01-18, userid=400016}
{area=33, count=2, sendtime=2019-01-17, userid=400015}
{area=33, count=1, sendtime=2019-01-17, userid=400017}

数据正确，方法可用，其实这个方法是RestHighLevelClient替我们封装了composite生成DSL。

这里注意一下missingBucket的设置，这个的意思是如果该字段没值，为true的时候会返回null，为false不返回整条数据，注意这里是整条数据，而不是单单这个字段而已。

低版本使用ES多字段聚合

以上就是composite的验证和在java中的使用方法，建议在6.5+版本使用，但这个时候小伙伴可能会问，如果我是6.5以下的版本呢，这里我也有一个方法，只不过是有点绕，直接上代码：

SearchRequest searchRequest = new SearchRequest("composite_test"); 
searchRequest.types("_doc");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); 
searchSourceBuilder.size(0);
/********************以下组装聚合的三个字段****************************/
AggregationBuilder sendtime=AggregationBuilders.dateHistogram("sendtime").field("sendtime").format("yyyy-MM-dd").interval(86400000);
AggregationBuilder area=AggregationBuilders.terms("area").field("area");
AggregationBuilder userid=AggregationBuilders.terms("userid").field("userid");
//实现功能关键点
area.subAggregation(userid);
sendtime.subAggregation(area);
/*********************执行查询******************************/
searchSourceBuilder.aggregation(sendtime);
searchRequest.source(searchSourceBuilder); 
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
/********************取出数据*******************/
Aggregations aggregations = searchResponse.getAggregations();
//取出数据
aggHandle(aggregations);
/*************************************/

运行响应的数据为

{area=33, count=2, sendtime=2019-01-17, userid=400015}, 
{area=33, count=1, sendtime=2019-01-17, userid=400017}, 
{area=35, count=2, sendtime=2019-01-18, userid=400016}

所以使用这个方法也能多值聚合数据，其中实现的关键点在于

area.subAggregation(userid);
sendtime.subAggregation(area);

这里相当于把每个桶给串联起来，串联顺序无要求，但用这种方法最后取数据的时候比较麻烦，我这里也分享一个我取数据的方法


private static List<Map<String,Object>> listmap =new ArrayList<Map<String,Object>>();
private static Map<String,Object> map =new HashMap<String,Object>(16);
//使用递归的方式将聚合数据中的数据一一取出来
private static void aggHandle(Aggregations agg){
		 String name ="";
		 Long longValue = 0L;
	  for(Aggregation data:agg){
			 name = data.getName();
			 Object obj = agg.get(name);
		 if(obj instanceof Terms){
			 Terms terms = (Terms) obj;
			 name = terms.getName();
			 if(terms.getBuckets().size()==0){
				 listmap.add(clonMap(map));
			 }
			for (Terms.Bucket entry : terms.getBuckets()) {	
				
	     		map.put(name, entry.getKey());
	     		longValue = entry.getDocCount();
	     		map.put(count, longValue);
	     		List<Aggregation> list = entry.getAggregations().asList();
	     		if(list==null||list.isEmpty()){
	    			listmap.add(clonMap(map));
	     		}else{
	     			aggHandle(entry.getAggregations());
	     		}
			}
		 }else if(obj instanceof ParsedDateHistogram){
			 ParsedDateHistogram terms = (ParsedDateHistogram) obj; 
			 List<? extends Bucket> buckets = terms.getBuckets(); 
			 name = terms.getName();
			 if(buckets.size()==0){
				 listmap.add(clonMap(map));
			 }
			 for(Bucket entry:buckets){
				 	map.put(name,entry.getKeyAsString());
		     		longValue = entry.getDocCount();
		     		map.put(count, longValue);
				List<Aggregation> list = entry.getAggregations().asList();
		     	if(list==null||list.isEmpty()){
		    		listmap.add(clonMap(map));
		    		//map.clear();
		     	}else{
		     		aggHandle(entry.getAggregations());
	     		}
			 }
		 }else if(obj instanceof Max){
			 Max max =(Max) obj;
			 name = max.getName();
			 Double value = max.getValue();
			 longValue  =value.longValue();
			 map.put(name, longValue);
			 listmap.add(clonMap(map));
		 }else if(obj instanceof Min){
			 Min min =(Min) obj;
			 Double value = min.getValue();
			 longValue  =value.longValue();
			 map.put(min.getName(), longValue);
			 listmap.add(clonMap(map));
		 }else if(obj instanceof Avg){
			 Avg avg = (Avg) obj;
			 Double value = avg.getValue();
			 longValue  =value.longValue();
			 map.put(avg.getName(), longValue);
			 listmap.add(clonMap(map));
		 }else if(obj instanceof Sum){
			 Sum sum = (Sum) obj;
			 Double value = sum.getValue();
			 longValue  =value.longValue();
			 map.put(sum.getName(), longValue);
			 listmap.add(clonMap(map));
		 }else if(obj instanceof ValueCount){
			 ValueCount count = (ValueCount) obj;
			 longValue  =count.getValue();
			 map.put(count.getName(), longValue);
			 listmap.add(clonMap(map));
		 }else{
			 System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"+obj);
		 }
	   }
	 }
/**
 * 克隆map对象到另外一个map对象里面去
 * @param map
 * @return
 */
private static Map<String,Object> clonMap(Map<String,Object> mapTo){
	Map<String,Object> map = new HashMap<String,Object>(16);
	for (Map.Entry<String,Object> entry : mapTo.entrySet()) {
		String key = entry.getKey();
		Object value = entry.getValue();
		map.put(key, value);
	}
	return map;
}

个人开源推荐

好了，文章到此结束，我这里打个广告，如果需要导出ES中的数据可以使用我的这个开源软件

https://github.com/760515805/es_data_export

AngusC·

关注

19
点赞
踩
34

收藏

觉得还不错? 一键收藏
7
评论
ElasticSearch中composite聚合的使用

简介composite composite是一个多桶聚合，它从不同的源创建复合桶，与其他多桶聚合不同，复合聚合可用于高效地对多级聚合中的所有桶进行分页。这种聚合提供了一种方法来流特定聚合的所有桶，类似于滚动对文档所做的操作。组合桶是由为每个文档提取/创建的值的组合构建的，每个组合被视为组合桶。如下为官方给的例子：{ "keyword": ["foo...
复制链接

扫一扫

专栏目录