ES中的桶聚合
2024-06-25
桶聚合
在前面几篇博客中介绍的聚合指标是指符合条件的文档字段的聚合，有时还需要根据某些维度进行聚合。例如在搜索酒店时，按照城市、是否满房、标签和创建时间等维度统计酒店的平均价格。这些字段统称为“桶”，在同一维度内有一个或者多个桶。例如城市桶，有“北京”、“天津”等，是否满房桶，有“满房”和“非满房”。
1.1 单维度同聚合
最简单的桶聚合是单维度桶聚合，指的是按照一个维度对文档进行分组聚合。在桶聚合时，聚合的桶也需要匹配，匹配的方式有terms、filter和ranges等。这里只介绍比较有代表性的terms查询和ranges查询。
1.1.1 terms聚合
terms聚合是按照字段的实际完整值进行匹配和分组的，它使用的维度字段必须是keyword、bool、keyword数组等适合精确匹配的数据类型，因此不能对text字段直接使用terms聚合，如果对text字段有terms聚合的需求，则需要在创建索引时为该字段增加多字段功能。
以下的DSL描述的是按照城市进行聚合的查询：
# 按照城市进行聚合
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"my_agg": {
"terms": { //按照城市进行聚合
"field": "city"
}
}
}
}
因为ES支持多聚合，所以每个桶聚合需要定义一个名字，此处定义了一个桶聚合，名字为my_agg。在这个桶聚合中使用了一个terms聚合，聚合字段选择了城市，目的是统计各个城市的酒店的文档个数。在聚合外面，因为不希望返回任何文档，所以指定查询返回的文档为0。执行该DSL后，ES返回的结果如下：
在默认情况下，进行桶聚合时如果不指定指标，则ES默认聚合的是文档计数，该值以doc_count为key存储在每一个bucket子句中。在聚合结果的buckets的两个bucket中，key字段的值分别为“北京”“天津”，表示两个bucket的唯一标识；doc_count字段的值分别为3和2，表示两个bucket的文档计数。返回的doc_count是近似值，并不是一个准确数，因此在聚合外围，ES给出了连个参考值doc_count_error_upper_bound和sum_other_doc_count。
doc_count_error_upper_bound表示被遗漏的文档数量可能存在的最大值sum_other_doc_count表示除了返回给用户的文档外剩下的文档总数
以下DSL是按照满房状态进行聚合的查询，注意该字段是bool型：
# 按照满房状态进行查询
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"my_agg": {
"terms": {
"field": "full_room"
}
}
}
}
ES返回的结果如下：
在上述结果中可以看到，在满房和非满房的bucket结果中多出了一个字段，名称为key_as_string，其值分别为true和false。另外，这两个bucket的key值分别为1和0.这是因为，如果桶字段类型不是keyword类型，ES在聚合时会将桶字段转换为Lucene存储的实际值进行识别。true在Lucene中存储为1，false在Lucene中存储为0，这就是为什么满房和非满房的key字段分别为1和0的原因。
这种情况给用户的使用带来了一些困惑，因为和原始值的差别比较大。针对这个问题，我们可以使用ES提供的
key_as_string桶识别字段，它是原始值的字符串形式，和原始值的差别比较小。
在Java中国使用terms聚合进行单维度桶聚合的逻辑如下：
public void getBucketDocCountAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel_poly");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName = "my_terms"; //指定聚合的名称
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("full_room");
//添加聚合
searchSourceBuilder.aggregation(termsAggregationBuilder);
//设置查询请求
searchRequest.source(searchSourceBuilder);
//执行查询
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
//获取聚合返回的对象
Terms terms = aggregations.get(termsAggName);
for (Terms.Bucket bucket : terms.getBuckets()) {
String bucketKey = bucket.getKeyAsString();//获取桶名称
long docCount = bucket.getDocCount(); //获取文档个数
log.info("termsKey={},docCount={}", bucketKey, docCount);
}
}
1.1.2 ranges聚合
ragnes聚合也是经常使用的一种聚合。它匹配的是数值字段，表示按照数值范围进行分组。用户可以在ranges中添加分组，每个分组使用from和to表示分组的起止数值。注意该分组包含起始数值，不包含终止数值。
示例如下：
# ranges聚合
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"my_agg":{
"range": {
"field": "price",
"ranges": [ //多个范围桶
{
"to": 200 //不指定from,默认from为0
},
{
"from": 200,
"to": 500
},
{
"from": 500 //不指定to,默认to为该字段最大值
}
]
}
}
}
}
执行上述DSL后，ES返回的结果如下：
在上面的分组划分中，第一个分组规则为price<200，没有文档与其匹配，因此其doc_count为0；第二个分组规则为200 \le price<500，文档003与其匹配，因此其doc_count为1；第三个分组规则为price \ge 500，文档001、004和005与其匹配，因此其doc_count值为3。
以下代码演示了在Java中使用ranges聚合的逻辑：
public void getRangeDocCountAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel_poly");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String rangeAggName = "my_range"; //聚合的名称
//定义ranges聚合，指定字段为price
RangeAggregationBuilder rangeAgg = AggregationBuilders.range(rangeAggName).field("price");
rangeAgg.addRange(new RangeAggregator.Range(null, null, 200d));
rangeAgg.addRange(new RangeAggregator.Range(null, 200d, 500d));
rangeAgg.addRange(new RangeAggregator.Range(null, 500d, null));
//添加ranges聚合
searchSourceBuilder.aggregation(rangeAgg);
//设置查询请求
searchRequest.source(searchSourceBuilder);
//执行查询
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Range range = aggregations.get(rangeAggName);
for (Range.Bucket bucket : range.getBuckets()) {
String bucketKey = bucket.getKeyAsString(); //获取桶名称
long docCount = bucket.getDocCount(); //获取聚合文档个数
log.info("termsKey={},docCount={}", bucketKey, docCount);
}
}
有时还需要对单维度桶指定聚合指标，聚合指标单独使用子aggs进行封装。
以下请求表示按照城市维度进行聚合，统计各个城市的平均酒店价格：
# 按照城市维度进行聚合，统计各个城市的平均酒店价格
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"my_agg": { //单维度聚合名称
"terms": { //定义单维度桶
"field": "city"
},
"aggs": { //用于封装单维度桶下的聚合指标
"my_sum": { //聚合指标名称
"sum": { //最price字段进行加和
"field": "price",
"missing": 200
}
}
}
}
}
}
在上面的结果中，聚合桶的维度是城市，当前索引中城市为“北京”的文档个数为3，城市为“天津”的文档个数为2.将这两组文档的聚合结果在buckets子句中进行了封装，可以根据key字段进行聚合桶的识别，每个聚合的组中既有文档个数又有价格的加和值。
在Java中使用桶聚合和指标聚合的逻辑如下：
public void getBucketAggSearch() throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel_poly");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName="my_terms"; //聚合的名称
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggregationBuilder=AggregationBuilders.terms(termsAggName).field("city");
//sum聚合的名称
String sumAggName="my_sum";
//定义sum聚合，指定字段为价格
SumAggregationBuilder sumAggregationBuilder=AggregationBuilders.sum(sumAggName).field("price");
sumAggregationBuilder.missing(200);
//定义聚合的父子关系
termsAggregationBuilder.subAggregation(sumAggregationBuilder);
//添加聚合
searchSourceBuilder.aggregation(termsAggregationBuilder);
//设置查询请求
searchRequest.source(searchSourceBuilder);
//执行查询
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(termsAggName); //获取聚合返回的对象
for (Terms.Bucket bucket : terms.getBuckets()) {
String termsKey = bucket.getKey().toString();
log.info("termsKey={}",termsKey);
Sum sum=bucket.getAggregations().get(sumAggName);
String key=sum.getName(); //获取聚合名称
double sumVal = sum.getValue(); //获取聚合值
log.info("key={},count={}",key,sumVal);
}
}
1.2 多维度桶嵌套聚合
在某些业务需求中，不仅需要一个维度的桶聚合，而且还可能有多维度桶嵌套聚合的需求。例如在搜索酒店时，可能需要统计各个城市的满房和非满房状态下的酒店平均价格。ES支持嵌套桶聚合，进行嵌套时，可以使用aggs子句进行子桶的继续嵌套，指标放在最里面的子桶内。
以下DSL演示多维度桶的使用方法：
# 多维度桶嵌套聚合
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"group_city": { //多维度桶名称
"terms": {
"field": "city"
},
"aggs": { //单维度桶
"group_full_room": {
"terms": {
"field": "full_room"
},
"aggs": { //聚合指标
"my_sum":{
"sum": {
"field": "price",
"missing": 200
}
}
}
}
}
}
}
}
ES返回结果如下：
从结果中可以看到，第一层的分桶先按照城市分组分为“北京”“天津”；第二层在“北京”“天津”桶下面继续分桶，分为“满房”和“非满房”桶，对应的聚合指标即价格的加和值存储在内部的my_sum字段中。
在Java中使用多维度桶进行聚合的逻辑如下：
public void getExternalBucketAggSearch() throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel_poly");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//按城市聚合的名称
String aggNameCity="my_terms_city";
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggCity=AggregationBuilders.terms(aggNameCity).field("city");
//按满房状态聚合的名称
String aggNameFullRoom="my_terms_full_room";
//定义terms聚合，指定字段为满房状态
TermsAggregationBuilder termsAggFullRoom=AggregationBuilders.terms(aggNameFullRoom).field("full_room");
//sum聚合的名称
String sumAggName="my_sum";
//定义sum聚合，指定字段为价格
SumAggregationBuilder sumAgg=AggregationBuilders.sum(sumAggName).field("price").missing(200);
//定义聚合的父子关系
termsAggFullRoom.subAggregation(sumAgg);
termsAggCity.subAggregation(termsAggFullRoom);
//添加聚合
searchSourceBuilder.aggregation(termsAggCity);
//设置查询请求
searchRequest.source(searchSourceBuilder);
//执行查询
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
//获取聚合返回的对象
Terms terms=aggregations.get(aggNameCity);
for (Terms.Bucket bucket : terms.getBuckets()) { //遍历第一层bucket
//获取第一层bucket名称
String termsKeyCity = bucket.getKey().toString();
log.info("-------termsKeyCity={}--------",termsKeyCity);
Terms termsFullRoom = bucket.getAggregations().get(aggNameFullRoom);
//遍历第二层bucket
for (Terms.Bucket bucketFullRoom : termsFullRoom.getBuckets()) {
//获取第二层bucket名称
String termsKeyFullRoom = bucketFullRoom.getKeyAsString();
log.info("termsKeyFullRoom={}",termsKeyFullRoom);
//获取聚合指标
Sum sum=bucketFullRoom.getAggregations().get(sumAggName);
//获取聚合指标名称
String key=sum.getName();
//获取聚合指标值
double sumVal=sum.getValue();
log.info("key={},count={}",key,sumVal);
}
}
}
1.3 地理距离聚合
按照地理距离聚合是一个非常实用的功能，例如在搜索酒店时，可能需要对附近的酒店个数先预览一下：查看距离当前位置2km范围内、2~3km范围内、5km范围内的酒店个数。
用户可以使用geo_distance聚合进行地理距离聚合，通过field参数来设置距离计算的字段，可以在origin子句中设定距离的原点，通过unit参数来设置距离的单位，可以选择mi和km，分别表示米和千米。ranges子句用来对距离进行阶段性的分组，该子句的使用方式和前面介绍的range聚合类似。
示例DSL如下：
# 地理距离聚合
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"my_agg":{
"geo_distance": {
"field": "location",
"origin": { //指定聚合的中心点经纬度
"lat": 39.915143,
"lon": 116.4039
},
"unit": "km", //指定聚合时的距离计量单位
"ranges": [ //指定每一个聚合桶的距离范围
{
"to": 3
},
{
"from": 3,
"to": 10
},
{
"from":10
}
]
}
}
}
}
在上述DSL中，给定了一个地理位置，此处使用ranges聚合对距离该位置的就带你划分了3个分组的桶：第1个桶为3km范围内；第2个桶为3~10km；第3个桶为大于等于10km。执行上述DSL后，ES返回结果如下：
其中，在aggregations结果子句中对应查询的分组有3个bucket桶，表示按照距离划分的3个组，每个bucket桶内分别给出了key和文档数量等信息。
也可以指定聚合指标进行地理距离聚合，下面的DSL将按照bucket分桶聚合酒店的最低价格：
# 指定聚合指标进行地理距离聚合
GET /hotel_poly/_search
{
"size": 0,
"aggs": {
"my_agg": {
"geo_distance": {
"field": "location",
"origin": {
"lat": 39.915143,
"lon": 116.4039
},
"unit": "km",
"ranges": [
{
"to": 3
},
{
"from": 3,
"to": 10
},
{
"from": 10
}
]
},
"aggs": {
"my_min": {
"min": {
"field": "price",
"missing": 100
}
}
}
}
}
}
ES返回结果如下：
在上面的结果中，ES给出了各个地理距离分组的名称及最低价格。
在Java中使用地理距离分组并计算最低价格的逻辑如下：
public void getGeoDistanceAggSearch() throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel_poly");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//聚合的名称
String geoDistanceAggName="location";
//定义GeoDistance聚合
GeoDistanceAggregationBuilder geoDistanceAgg = AggregationBuilders.geoDistance(geoDistanceAggName, new GeoPoint(39.915143, 116.4039));
geoDistanceAgg.unit(DistanceUnit.KILOMETERS);
geoDistanceAgg.field("location");
//指定分桶范围规则
geoDistanceAgg.addRange(new GeoDistanceAggregationBuilder.Range(null,0d,3d));
geoDistanceAgg.addRange(new GeoDistanceAggregationBuilder.Range(null,3d,10d));
geoDistanceAgg.addRange(new GeoDistanceAggregationBuilder.Range(null,10d,null));
//min聚合的名称
String minAggName="my_min";
//定义sum聚合，指定字段为价格
MinAggregationBuilder minAgg=AggregationBuilders.min(minAggName).field("price");
minAgg.missing(100); //指定默认值
//定义聚合的父子关系
geoDistanceAgg.subAggregation(minAgg);
searchSourceBuilder.aggregation(geoDistanceAgg); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
//获取GeoDistance聚合返回的对象
ParsedGeoDistance range=aggregations.get(geoDistanceAggName);
for (Range.Bucket bucket : range.getBuckets()) {
//获取bucket名称的字符串形式
String termsKey = bucket.getKeyAsString();
log.info("termsKey={}",termsKey);
ParsedMin min = bucket.getAggregations().get(minAggName);
String key = min.getName(); //获取聚合名称
double minVal = min.getValue(); //获取聚合值
log.info("key={},min={}",key,minVal); //打印结果
}
}
数据源
索引结构
PUT /hotel_poly
{
"settings": {
"number_of_shards": 1
},
"mappings": {
"properties": {
"title":{
"type": "text"
},
"city":{
"type": "keyword"
},
"price":{
"type": "double"
},
"create_time":{
"type": "date"
},
"full_room":{
"type": "boolean"
},
"location":{
"type": "geo_point"
},
"tags":{
"type": "keyword"
},
"comment_info":{
"properties": {
"favourable_comment":{
"type":"integer"
},
"negative_comment":{
"type":"integer"
}
}
}
}
}
}
酒店数据
POST /_bulk
{"index":{"_index":"hotel_poly","_id":"001"}}
{"title":"文雅假日酒店","city":"北京","price":556.00,"create_time":"20200418120000","full_room":true,"location":{"lat":39.938838,"lon":106.449112},"tags":["wifi","小型电影院"],"comment_info":{"favourable_comment":20,"negative_comment":10}}
{"index":{"_index":"hotel_poly","_id":"002"}}
{"title":"金都嘉怡假日酒店","city":"北京","create_time":"20210315200000","full_room":false,"location":{"lat":39.915153,"lon":116.4030},"tags":["wifi","免费早餐"],"comment_info":{"favourable_comment":20,"negative_comment":10}}
{"index":{"_index":"hotel_poly","_id":"003"}}
{"title":"金都假日酒店","city":"北京","price":200.00,"create_time":"20210509160000","full_room":true,"location":{"lat":40.002096,"lon":116.386673},"comment_info":{"favourable_comment":20,"negative_comment":10}}
{"index":{"_index":"hotel_poly","_id":"004"}}
{"title":"金都假日酒店","city":"天津","price":500.00,"create_time":"20210218080000","full_room":false,"location":{"lat":39.155004,"lon":117.203976},"tags":["wifi","免费车位"]}
{"index":{"_index":"hotel_poly","_id":"005"}}
{"title":"文雅精选酒店","city":"天津","price":800.00,"create_time":"20210101080000","full_room":true,"location":{"lat":39.178447,"lon":117.219999},"tags":["wifi","充电车位"],"comment_info":{"favourable_comment":20,"negative_comment":10}}
- 0
- 0
-
分享