ElasticSearch 的聚合（Aggregations）

最新推荐文章于 2023-05-18 17:32:09 发布

mllhxn

最新推荐文章于 2023-05-18 17:32:09 发布

阅读量1.3w

点赞数 5

分类专栏： elk 文章标签： elk

elk 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

Elasticsearch有一个功能叫做聚合(aggregations) ，它允许你在数据上生成复杂的分析统计。它很像SQL中的 GROUP BY 但是功能更强大。

Aggregations种类分为:

Metrics, Metrics 是简单的对过滤出来的数据集进行avg,max等操作，是一个单一的数值。
Bucket, Bucket 你则可以理解为将过滤出来的数据集按条件分成多个小数据集，然后Metrics会分别作用在这些小数据集上。

聚合概念

和查询DSL一样，聚合(Aggregations)也拥有一种可组合(Composable)的语法：独立的功能单元可以被混合在一起来满足你的需求。这意味着需要学习的基本概念虽然不多，但是它们的组合方式是几近无穷的。

为了掌握聚合，你只需要了解两个主要概念：
Buckets(桶)
满足某个条件的文档集合。
Metrics(指标)
为某个桶中的文档计算得到的统计信息。

就是这样！每个聚合只是简单地由一个或者多个桶，零个或者多个指标组合而成。可以将它粗略地转换为SQL：

[java] view plain copy 
    
 print?
 SELECT COUNT(color)   
 FROM table  
 GROUP BY color  

以上的COUNT(color)就相当于一个指标。GROUP BY color则相当于一个桶。
桶和SQL中的组(Grouping)拥有相似的概念，而指标则与COUNT()，SUM()，MAX()等相似。

让我们仔细看看这些概念。

一个桶就是满足特定条件的一个文档集合：

一名员工要么属于男性桶，或者女性桶。
城市Albany属于New York州这个桶。
日期2014-10-28属于十月份这个桶。

随着聚合被执行，每份文档中的值会被计算来决定它们是否匹配了桶的条件。如果匹配成功，那么该文档会被置入该桶中，同时聚合会继续执行。
桶也能够嵌套在其它桶中，能让你完成层次或者条件划分这些需求。比如，Cincinnati可以被放置在Ohio州这个桶中，而整个Ohio州则能够被放置在美国这个桶中。

ES中有很多类型的桶，让你可以将文档通过多种方式进行划分(按小时，按最流行的词条，按年龄区间，按地理位置，以及更多)。但是从根本上，它们都根据相同的原理运作：按照条件对文档进行划分。

指标(Metrics)

桶能够让我们对文档进行有意义的划分，但是最终我们还是需要对每个桶中的文档进行某种指标计算。分桶是达到最终目的的手段：提供了对文档进行划分的方法，从而让你能够计算需要的指标。

多数指标仅仅是简单的数学运算(比如，min，mean，max以及sum)，它们使用文档中的值进行计算。在实际应用中，指标能够让你计算例如平均薪资，最高出售价格，或者百分之95的查询延迟。

将两者结合起来

一个聚合就是一些桶和指标的组合。一个聚合可以只有一个桶，或者一个指标，或者每样一个。在桶中甚至可以有多个嵌套的桶。比如，我们可以将文档按照其所属国家进行分桶，然后对每个桶计算其平均薪资(一个指标)。

因为桶是可以嵌套的，我们能够实现一个更加复杂的聚合操作：

将文档按照国家进行分桶。(桶)
然后将每个国家的桶再按照性别分桶。(桶)
然后将每个性别的桶按照年龄区间进行分桶。(桶)
最后，为每个年龄区间计算平均薪资。(指标)

此时，就能够得到每个<国家，性别，年龄>组合的平均薪资信息了。它可以通过一个请求，一次数据遍历来完成

javaAPI

案例1

现有索引数据：

index:school
type:student --------------------------------------------------- {"grade":"1", "class":"1", "name":"xiao 1"} {"grade":"1", "class":"1", "name":"xiao 2"} {"grade":"1", "class":"2", "name":"xiao 3"} {"grade":"1", "class":"2", "name":"xiao 4"} {"grade":"1", "class":"2", "name":"xiao 5"}

Java分组统计年级和班级学生个数，如SQL: SELECT grade,class,count(1) FROM student GROUP BY grade,class;

[java] view plain copy 
    
 print?
 package test;  
   
 import java.util.Iterator;  
 import java.util.Map;  
   
 import org.elasticsearch.action.search.SearchRequestBuilder;  
 import org.elasticsearch.action.search.SearchResponse;  
 import org.elasticsearch.action.search.SearchType;  
 import org.elasticsearch.search.aggregations.Aggregation;  
 import org.elasticsearch.search.aggregations.AggregationBuilders;  
 import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;  
 import org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket;  
 import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder;  
 import org.junit.Test;  
   
 import utils.NesUtils;  
   
 public class TestAggregation  
 {  
     @Test  
     public void testAggregation()  
     {  
         SearchRequestBuilder srb = NesUtils.getSearcher("school");  
         srb.setTypes("student");  
         srb.setSearchType(SearchType.COUNT);  
           
         TermsBuilder gradeTermsBuilder = AggregationBuilders.terms("gradeAgg").field("grade");  
         TermsBuilder classTermsBuilder = AggregationBuilders.terms("classAgg").field("class");  
           
         gradeTermsBuilder.subAggregation(classTermsBuilder);  
           
         srb.addAggregation(gradeTermsBuilder);  
           
         SearchResponse sr = srb.execute().actionGet();  
           
         Map<String, Aggregation> aggMap = sr.getAggregations().asMap();  
           
         StringTerms gradeTerms = (StringTerms) aggMap.get("gradeAgg");  
           
         Iterator<Bucket> gradeBucketIt = gradeTerms.getBuckets().iterator();  
           
         while(gradeBucketIt.hasNext())  
         {  
             Bucket gradeBucket = gradeBucketIt.next();  
             System.out.println(gradeBucket.getKey() + "年级有" + gradeBucket.getDocCount() +"个学生。");  
               
             StringTerms classTerms = (StringTerms) gradeBucket.getAggregations().asMap().get("classAgg");  
             Iterator<Bucket> classBucketIt = classTerms.getBuckets().iterator();  
               
             while(classBucketIt.hasNext())  
             {  
                 Bucket classBucket = classBucketIt.next();  
                 System.out.println(gradeBucket.getKey() + "年级" +classBucket.getKey() + "班有" + classBucket.getDocCount() +"个学生。");  
             }  
             System.out.println();  
         }  
           
     }  
 }  

运行完成输出结果
---------------------------------------------------
1年级有5个学生。 1年级2班有3个学生。 1年级1班有2个学生
 
实现一个SQL: SELECT sum(field) from table group by field2
使用：AggregationBuilders.sum("name").field("field");

  
  
   
   
    
    
     
     [java] view plain copy
     
     
     
      print?
    
    
   
   
   
   public static void searchTest() throws IOException {  
        TermsBuilder companyNameAgg = AggregationBuilders.terms("companyName").field("companyName").size(10);  
        SumBuilder companyNameAggSum = AggregationBuilders.sum("companyNameSum").field("cvcount");  
        companyNameAgg.subAggregation(companyNameAggSum);//把sum聚合器放入到Term聚合器中，相当于先group by在sum  
        SearchRequestBuilder searchBuilder = ElasticClientFactory.getClient().prepareSearch(indexname).
setTypes(typeName).addAggregation(companyNameAgg);  
        SearchResponse searchResponse = searchBuilder.execute().actionGet();  
        Terms terms = searchResponse.getAggregations().get("companyName");  
        List<Terms.Bucket> buckets = terms.getBuckets();  
        List<String> list = Lists.newArrayList();  
        for (Terms.Bucket bucket : buckets) {  
            InternalSum internalSum = bucket.getAggregations().get("companyNameSum");//注意从bucket而不是searchResponse  
            System.out.println(bucket.getKeyAsString() + "\t" + bucket.getDocCount() + "\t"+internalSum.getValue());  
        }  
        System.out.println("done");  
    }


案例2

PUT /company
{
  "mappings": {
      "employee": {
        "properties": {
          "age": {
            "type": "long"
          },
          "country": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            },
            "fielddata": true
          },
          "join_date": {
            "type": "date"
          },
          "name": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "position": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "salary": {
            "type": "long"
          }
        }
      }
    }
}

GET /company/employee/_search
{
  "size": 0,
  "aggs": {
    "group_by_country": {
      "terms": {
        "field": "country"
      },
      "aggs": {
        "group_by_join_date": {
          "date_histogram": {
            "field": "join_date",
            "interval": "year"
          },
          "aggs": {
            "avg_salary": {
              "avg": {
                "field": "salary"
              }
            }
          }
        }
      }
    }
  }
}





  
  
   
   public class EmployeeAggrApp {

	@SuppressWarnings({ "unchecked", "resource" })
	public static void main(String[] args) throws Exception {
		Settings settings = Settings.builder()
				.put("cluster.name", "elasticsearch")
				.build();
		
		TransportClient client = new PreBuiltTransportClient(settings)
				.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("localhost"), 9300)); 
		
		SearchResponse searchResponse = client.prepareSearch("company") 
				.addAggregation(AggregationBuilders.terms("group_by_country").field("country")
						.subAggregation(AggregationBuilders
								.dateHistogram("group_by_join_date")
								.field("join_date")
								.dateHistogramInterval(DateHistogramInterval.YEAR)
								.subAggregation(AggregationBuilders.avg("avg_salary").field("salary")))
				)
				.execute().actionGet();
		
		Map<String, Aggregation> aggrMap = searchResponse.getAggregations().asMap();
		
		StringTerms groupByCountry = (StringTerms) aggrMap.get("group_by_country");
		Iterator<Bucket> groupByCountryBucketIterator = groupByCountry.getBuckets().iterator();
		while(groupByCountryBucketIterator.hasNext()) {
			Bucket groupByCountryBucket = groupByCountryBucketIterator.next();
			System.out.println(groupByCountryBucket.getKey() + ":" + groupByCountryBucket.getDocCount()); 
		
			Histogram groupByJoinDate = (Histogram) groupByCountryBucket.getAggregations().asMap().get("group_by_join_date");
			Iterator<org.elasticsearch.search.aggregations.bucket.histogram.Histogram.Bucket> groupByJoinDateBucketIterator = groupByJoinDate.getBuckets().iterator();
			while(groupByJoinDateBucketIterator.hasNext()) {
				org.elasticsearch.search.aggregations.bucket.histogram.Histogram.Bucket groupByJoinDateBucket = groupByJoinDateBucketIterator.next();
				System.out.println(groupByJoinDateBucket.getKey() + ":" +groupByJoinDateBucket.getDocCount()); 
			
				Avg avg = (Avg) groupByJoinDateBucket.getAggregations().asMap().get("avg_salary"); 
				System.out.println(avg.getValue()); 
			}
		}
		
		client.close();
	}
	
}

mllhxn

关注

5
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
ElasticSearch 的聚合（Aggregations）

Elasticsearch有一个功能叫做聚合(aggregations) ，它允许你在数据上生成复杂的分析统计。它很像SQL中的 GROUP BY 但是功能更强大。Aggregations种类分为:Metrics, Metrics 是简单的对过滤出来的数据集进行avg,max等操作，是一个单一的数值。Bucket, Bucket 你则可以理解为将过滤出来的数据集按条件分成多个
复制链接

扫一扫