aggregations —— 聚合,提供了一种基于查询条件来对数据进行分桶、计算的方法。有点类似于 SQL 中的 group by 再加一些函数方法的操作。
聚合可以嵌套,由此可以组成复杂的操作(Bucketing聚合可以包含sub-aggregation)。
聚合整体上可以分为 3 类:
1. Bucketing:桶分聚合:
2. Metric:指标聚合:
3. Pipeline:管道聚合:
应用场景
对于 3 中聚合,常见的应用场景如下流程:
buckets 聚合对文档进行必要的归类(桶分) ——> metric 聚合对每个桶进行一些额外的信息计算(如:max) ——> pipeline 聚合针对所有桶做一些桶层面的统计或计算应用示例:
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : { // bucket 聚合,按照月份进行分桶,每个月的归属一个桶
"field" : "date",
"interval" : "month"
},
"aggs": {
"sales": {
"sum": { // metric 聚合,对每个桶类的 price 求和,即每月的销售额
"field": "price"
}
}
}
},
"max_monthly_sales": {
"max_bucket": { // pipeline 聚合,求所有桶中销售额 sales 最大的值
"buckets_path": "sales_per_month>sales"
}
}
}
}
聚合可以是父子(嵌套)关系聚合,buckets 聚合作为父,metric 聚合作为子。
聚合也可以是兄弟关系聚合,buckets 聚合在前,pipeline 聚合在后。
结构如下:
"aggregations" : { //定义聚合对象,也可用 "aggs"
"" : { //聚合的名称,用户自定义
"" : { //聚合类型,比如 "histogram"
//每个聚合类型都有其自己的结构定义
}
[,"meta" : { [] } ]?
[,"aggregations" : { []+ } ]? //可以定义多个 sub-aggregation
}
[,"" : { ... } ]* //定义额外的多个平级 aggregation,只有 Bucketing 类型才有意义
}
权值聚合类型从需要聚合的文档中取一个值(value)来计算文档的相应权值(比如该值在这些文档中的max、sum等)。
用于计算的值(value)可以是文档的字段(field),也可以是脚本(script)生成的值。
数值权值聚合是特殊的权值聚合类型,因为它的输出权值也是数字。
数值权值聚合(注意分类只针对数值权值聚合,非数值的无此分类)输出单个权值的,叫做 single-value numeric metrics,其它生成多个权值(比如:stats)的被叫做 multi-value numeric metrics。
单值和多值数字权值聚合,在它们作为一些 Bucket 聚合的直接子聚合的时候会有明显区别。
均值聚合——基于文档的某个值,计算该值在聚合文档中的均值。
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
{
"aggs" : {
"avg_grade" : { "avg" : { "field" : "grade" } } //计算字段 grade 在文档中的平均值
}
}
//输出
{
...
"aggregations": {
"avg_grade": {
"value": 75
}
}
}
基数聚合——基于文档的某个值,计算文档非重复的个数(去重计数)。
用于计算的值可以是特定的字段,也可以通过脚本计算而来。
配置参数
{
"aggs" : {
"author_count" : {
"cardinality" : {
"field" : "author" //count the unique authors that match a query
}
}
}
}
统计聚合——基于文档的某个值,计算出一些统计信息(min、max、sum、count、avg)。
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
{
"aggs" : {
"grades_stats" : { "stats" : { "field" : "grade" } }
}
}
//输出
{
...
"aggregations": {
"grades_stats": {
"count": 6,
"min": 60,
"max": 98,
"avg": 78.5,
"sum": 471
}
}
}
扩展统计聚合——基于文档的某个值,计算出一些统计信息(比普通的stats聚合多了sum_of_squares、
variance、
std_deviation
、std_deviation_bounds
)。
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
{
...
"aggregations": {
"grade_stats": {
"count": 9,
"min": 72,
"max": 99,
"avg": 86,
"sum": 774,
//输出比 stats 聚合多了一些值
"sum_of_squares": 67028,
"variance": 51.55555555555556,
"std_deviation": 7.180219742846005,
"std_deviation_bounds": {
"upper": 100.36043948569201,
"lower": 71.63956051430799
}
}
}
}
地理边界聚合——基于文档的某个字段(geo-point类型字段),计算出该字段所有地理坐标点的边界(左上角/右下角坐标点)。
配置参数
{
"query" : {
"match" : { "business_type" : "shop" }
},
"aggs" : {
"viewport" : {
"geo_bounds" : {
"field" : "location",
"wrap_longitude" : true
}
}
}
}
//输出
{
...
"aggregations": {
"viewport": {
"bounds": {
"top_left": { //左上角经纬度
"lat": 80.45,
"lon": -160.22
},
"bottom_right": { //右下角经纬度
"lat": 40.65,
"lon": 42.57
}
}
}
}
}
地理重心聚合——基于文档的某个字段(geo-point类型字段),计算所有坐标的加权重心。
配置参数
{
"query" : {
"match" : { "crime" : "burglary" }
},
"aggs" : {
"centroid" : {
"geo_centroid" : {
"field" : "location"
}
}
}
}
//输出
{
...
"aggregations": {
"centroid": {
"location": { //重心经纬度
"lat": 80.45,
"lon": -160.22
}
}
}
}
最大值聚合——基于文档的某个值,求该值在聚合文档中的最大值。
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
最小值聚合——基于文档的某个值,求该值在聚合文档中的最小值。
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
求和聚合——基于文档的某个值,求该值在聚合文档中的统计和。
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
//最大值,field
{
"aggs" : {
"max_price" : { "max" : { "field" : "price" } } // field
}
}
//最小值,script
{
"aggs" : {
"min_price" : {
"min" : {
"script" : { //script 计算 value
"file": "my_script",
"params": {
"field": "price"
}
}
}
}
}
}
//总和,value script
{
"aggs" : {
...
"aggs" : {
"daytime_return" : {
"sum" : {
"field" : "change", // field
"script" : "_value * _value" // 基于 field 用 script 计算 value
}
}
}
}
}
百分百聚合——基于聚合文档中某个数值类型的值,求这些值中
用于计算的值可以是特定的数值型字段,也可以通过脚本计算而来。
配置参数
基于脚本的权值聚合——用脚本来计算出一个权值
配置参数
{
"query" : {
"match_all" : {}
},
"aggs": {
"profit": {
"scripted_metric": {
"init_script" : "_agg['transactions'] = []",
"map_script" : "if (doc['type'].value == \"sale\") { _agg.transactions.add(doc['amount'].value) } else { _agg.transactions.add(-1 * doc['amount'].value) }",
"combine_script" : "profit = 0; for (t in _agg.transactions) { profit += t }; return profit",
"reduce_script" : "profit = 0; for (a in _aggs) { profit += a }; return profit"
}
}
}
}
最高匹配权值聚合——跟踪聚合中相关性最高的文档。
该聚合一般用做 sub-aggregation,以此来聚合每个桶中的最高匹配的文档。
配置参数
{
"aggs": {
"top-tags": {
"terms": {
"field": "tags",
"size": 3
},
"aggs": {
"top_tag_hits": {
"top_hits": { //用 tags 字段分组,每个 tag(即一个分组)只显示最后一个问题,并且只在 _source 中保留 title 字段
"sort": [
{
"last_activity_date": {
"order": "desc"
}
}
],
"_source": {
"include": [
"title"
]
},
"size" : 1
}
}
}
}
}
}
//输出
"top_tags_hits": {
"hits": {
"total": 25365,
"max_score": 1,
"hits": [
{
"_index": "stack",
"_type": "question",
"_id": "602679",
"_score": 1,
"_source": {
"title": "Windows port opening"
},
"sort": [
1370143231177
]
}
]
}
}
值计数聚合——计算聚合文档中某个值的个数。
用于计数的值可以是特定的数值型字段,也可以通过脚本计算而来。
该聚合一般域其它 single-value 聚合联合使用,比如在计算一个字段的平均值的时候,可能还会关注这个平均值是由多少个值计算而来。
配置参数
{
"aggs" : {
"grades_count" : { "value_count" : { "field" : "grade" } } //计算 grade 字段共有多少个值,和 cardinality 聚合不同的
}
}
桶分聚合不进行权值的计算,他们对文档根据聚合请求中提供的判断条件(比如:{"from":0, "to":100})来进行分组(桶分)。
桶分聚合还会额外返回每一个桶内文档的个数。
桶分聚合可以包含子聚合——sub-aggregations(权值聚合不能包含子聚合,可以作为子聚合),子聚合操作将会应用到由父(parent)聚合产生的每一个桶上。
桶分聚合根据聚合条件,可以只定义输出一个桶;也可以输出多个;还可以在根据聚合条件动态确定桶个数(比如:terms aggregation)。
直方图聚合——基于文档中的某个【数值类型】字段,通过计算来动态的分桶。
一个文档属于某个桶,计算过程大致如下:
rem = value % interval
if (rem < 0) {
rem += interval
}
bucket_key = value - rem
配置参数
{
"aggs" : {
"prices" : {
"histogram" : {
"field" : "price",
"interval" : 50,
"min_doc_count" : 1,
"extended_bounds" : {
"min" : 0,
"max" : 500
},
"order" : { "_count" : "desc" },
"keyed":true,
"missing":0
}
}
}
}
日期直方图聚合——基于日期类型,以【日期间隔】来桶分聚合。
可用的时间间隔类型为:year、quarter、month、week、day、hour、minute、second,其中,除了year、quarter 和 month,其余可用小数形式。
配置参数
{
"aggs" : {
"articles_over_time" : {
"date_histogram" : {
"field" : "date",
"interval" : "month",
"format" : "yyyy-MM-dd",
"time_zone": "+08:00"
}
}
}
}
范围聚合——基于某个值(可以是 field 或 script),以【字段范围】来桶分聚合。
范围聚合包括 from 值,不包括 to 值(区间前闭后开)。
配置参数
{
"aggs" : {
"price_ranges" : {
"range" : {
"field" : "price",
"ranges" : [ //包含 3 个桶
{ "to" : 50 },
{ "from" : 50, "to" : 100 },
{ "from" : 100 }
],
"keyed" : true
}
}
}
}
日期范围聚合——基于日期类型的值,以【日期范围】来桶分聚合。
日期范围可以用各种 Date Math 表达式。
同样的,包括 from 的值,不包括 to 的值。
配置参数
{
"aggs": {
"range": {
"date_range": {
"field": "date",
"format": "MM-yyy",
"ranges": [ //包含 3 个桶
{ "to": "now-10M/M" },
{ "from": "now-10M/M" },
{"from":"1970-1-1", "to":"2000-1-1"}
]
}
}
}
}
词元聚合——基于某个field,该 field 内的每一个【唯一词元】为一个桶,并计算每个桶内文档个数。
默认返回顺序是按照文档个数多少排序。
当不返回所有 buckets 的情况,文档个数可能不准确。
配置参数
{
"aggs" : {
"genders" : {
"terms" : {
"field" : "gender",
"size" : 5,
"order" : { "_count" : "asc" },
"min_doc_count": 10,
"include" : ".*sport.*",
"exclude" : "water_.*",
"missing": "N/A"
}
}
}
}
多过滤聚合——基于多个过滤条件,来对当前文档进行【过滤】的聚合,每个过滤都包含所有满足它的文档(多个bucket中可能重复)。
配置参数
{
"aggs" : {
"messages" : {
"filters" : {
"other_bucket_key": "other_messages", //不在过滤条件范围内的文档都归属于 other_messages 桶
"filters" : { //过滤条件
"errors" : { "term" : { "body" : "error" }},
"warnings" : { "term" : { "body" : "warning" }}
}
},
"aggs" : {
"monthly" : {
"histogram" : {
"field" : "timestamp",
"interval" : "1M"
}
}
}
}
}
}
过滤聚合——基于一个条件,来对当前的文档进行过滤的聚合。
{
"aggs" : {
"red_products" : {
"filter" : { "term": { "color": "red" } },
"aggs" : {
"avg_price" : { "avg" : { "field" : "price" } }
}
}
}
}
IP4聚合——基于一个 IPv4 字段,对文档进行【IPv4范围】的桶分聚合。
和 Range Aggregation 类似,只是应用字段必须是 IPv4 数据类型。
{
"aggs" : {
"ip_ranges" : {
"ip_range" : {
"field" : "ip",
"ranges" : [ //包含 3 个桶,各个桶之间可能有文档重复
{ "to" : "10.0.0.5" },
{ "from" : "10.0.0.5" },
{ "from":"1.1.1.1", "to" : "10.0.0.5" },
]
}
}
}
}
嵌套类型聚合——基于嵌套(nested)数据类型,把该【嵌套类型的信息】聚合到单个桶里,然后就可以对嵌套类型做进一步的聚合操作。
// resellers 是一个嵌套类型
{
...
"product" : {
"properties" : {
"resellers" : {
"type" : "nested",
"properties" : {
"name" : { "type" : "string" },
"price" : { "type" : "double" }
}
}
}
}
}
// 对 nested 对象里面的信息做其它聚合操作
{
"query" : {
"match" : { "name" : "led tv" }
},
"aggs" : {
"resellers" : {
"nested" : { //"嵌套类型聚合"把所有嵌套信息都包含在单一的桶里,以供进一步处理
"path" : "resellers"
},
"aggs" : {
"min_price" : { "min" : { "field" : "resellers.price" } } //对嵌套类型聚合输出的桶做进一步处理,这里是计算其 price 的 average
}
}
}
}
管道聚合处理的对象是其它聚合的输出(桶或者桶的某些权值),而不是直接针对文档。
管道聚合的作用是为输出增加一些有用信息。
管道聚合大致分为两类:
parent
sibling
管道聚合通过 buckets_path 参数指定他们要进行聚合计算的权值对象,buckets_path 参数有其自己的使用语法。
管道聚合不能包含子聚合,但是某些类型的管道聚合可以链式使用(比如计算导数的导数)。
1. 聚合分隔符 ==> ">",指定父子聚合关系,如:"my_bucket>my_stats.avg"
2. 权值分隔符 ==> ".",指定聚合的特定权值
3. 聚合名称 ==> <name of the aggregation> ,直接指定聚合的名称
4. 权值 ==> <name of the metric> ,直接指定权值
5. 完整路径 ==> agg_name[> agg_name]*[. metrics] ,综合利用上面的方式指定完整路径
6. 特殊值 ==> "_count",输入的文档个数
1. 要进行 pipeline aggregation 聚合的对象名称或权值名称包含小数点
2. 处理对象中包含空桶(无文档的桶分)
桶均值聚合——基于兄弟聚合的某个权值,求所有桶的权值均值。
用于计算的兄弟聚合必须是多桶聚合。
用于计算的权值必须是数值类型。
配置参数
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : {
"field" : "date",
"interval" : "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"avg_monthly_sales": {
"avg_bucket": { //对所有月份的销售总 sales 求平均值
"buckets_path": "sales_per_month>sales"
}
}
}
}
求导聚合——基于父聚合(只能是histogram或date_histogram类型)的某个权值,对权值求导。
用于求导的权值必须是数值类型。
封闭直方图(histogram)聚合的 min_doc_count 必须是 0。
配置参数
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : {
"field" : "date",
"interval" : "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"sales_deriv": { //对每个月销售总和 sales 求导
"derivative": {
"buckets_path": "sales" //同级,直接用 metric 值
}
}
}
}
}
}
桶最大值聚合——基于兄弟聚合的某个权值,输出权值最大的那一个桶。
用于计算的权值必须是数值类型。
用于计算的兄弟聚合必须是多桶聚合类型。
配置参数
桶最小值聚合——基于兄弟聚合的某个权值,输出权值最小的一个桶。
用于计算的权值必须是数值类型。
用于计算的兄弟聚合必须是多桶聚合类型。
配置参数
桶求和聚合——基于兄弟聚合的权值,对所有桶的权值求和。
用于计算的权值必须是数值类型。
用于计算的兄弟聚合必须是多桶聚合类型。
配置参数
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : {
"field" : "date",
"interval" : "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"max_monthly_sales": { //输出兄弟聚合 sales_per_month 的每月销售总和 sales 的最大一个桶
"max_bucket": {
"buckets_path": "sales_per_month>sales"
}
},
"min_monthly_sales": { //输出兄弟聚合 sales_per_month 的每月销售总和 sales 的最小一个桶
"min_bucket": {
"buckets_path": "sales_per_month>sales"
}
},
"sum_monthly_sales": { //输出兄弟聚合 sales_per_month 的每月销售总和 sales 的最小一个桶
"sum_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
桶统计信息聚合——基于兄弟聚合的某个权值,对【桶的信息】进行一些统计学运算(总计多少个桶、所有桶中该权值的最大值、最小等)。
用于计算的权值必须是数值类型。
用于计算的兄弟聚合必须是多桶聚合类型。
配置参数
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : {
"field" : "date",
"interval" : "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"stats_monthly_sales": { // 对父聚合的每个桶(每月销售总和)的一些基本信息进行聚合
"stats_bucket": {
"buckets_paths": "sales_per_month>sales"
}
}
}
}
//输出结果
{
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375
}
}
]
},
"stats_monthly_sales": { //注意,统计的是桶的信息
"count": 3,
"min": 60,
"max": 550,
"avg": 328.333333333,
"sum": 985
}
}
}
扩展桶统计聚合——基于兄弟聚合的某个权值,对【桶信息】进行一系列统计学计算(比普通的统计聚合多了一些统计值)。
用于计算的权值必须是数值类型。
用于计算的兄弟聚合必须是多桶聚合类型。
配置参数
桶百分比聚合——基于兄弟聚合的某个权值,计算权值的百分百。
用于计算的权值必须是数值类型。
用于计算的兄弟聚合必须是多桶聚合类型。
对百分百的计算是精确的(不像Percentiles Metric聚合是近似值),所以可能会消耗大量内存
配置参数
窗口平均值聚合——基于已经排序过的数据,计算出处在当前出口中数据的平均值。
比如窗口大小为 5 ,对数据 1—10 的部分窗口平均值如下:
配置参数
{
"the_movavg":{
"moving_avg":{
"buckets_path": "the_sum",
"window" : 30,
"model" : "simple"
}
}
}
累计和聚合——基于父聚合(只能是histogram或date_histogram类型)的某个权值,对权值在每一个桶中求所有之前的桶的该值累计的和。
用于计算的权值必须是数值类型。
封闭直方图(histogram)聚合的 min_doc_count 必须是 0。
配置参数
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : {
"field" : "date",
"interval" : "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"cumulative_sales": {
"cumulative_sum": {
"buckets_path": "sales"
}
}
}
}
}
}
//输出
{
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550
},
"cumulative_sales": {
"value": 550 //总计 sales = 550
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60
},
"cumulative_sales": {
"value": 610 //总计 sales = 550 + 60
}
},
桶脚本聚合——基于父聚合的【一个或多个权值】,对这些权值通过脚本进行运算。
用于计算的父聚合必须是多桶聚合。
用于计算的权值必须是数值类型。
执行脚本必须要返回数值型结果。
配置参数
{
"aggs" : {
"sales_per_month" : {
"date_histogram" : {
"field" : "date",
"interval" : "month"
},
"aggs": {
"total_sales": {
"sum": {
"field": "price"
}
},
"t-shirts": {
"filter": {
"term": {
"type": "t-shirt"
}
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"t-shirt-percentage": {
"bucket_script": {
"buckets_path": { //对两个权值进行计算
"tShirtSales": "t-shirts>sales",
"totalSales": "total_sales"
},
"script": "tShirtSales / totalSales * 100"
}
}
}
}
}
}
桶选择器聚合——基于父聚合的【一个或多个权值】,通过脚本对权值进行计算,并决定父聚合的哪些桶需要保留,其余的将被丢弃。
用于计算的父聚合必须是多桶聚合。
用于计算的权值必须是数值类型。
运算的脚本必须是返回 boolean 类型,如果脚本是脚本表达式形式给出,那么允许返回数值类型。
配置参数
{
"bucket_selector": {
"buckets_path": {
"my_var1": "the_sum",
"my_var2": "the_value_count"
},
"script": "my_var1 > my_var2" // true 则保留该桶;false 则丢弃
}
}
串行差分聚合——基于父聚合(只能是histogram或date_histogram类型)的某个权值,对权值值进行差分运算,(取时间间隔,后一刻的值减去前一刻的值:f(X) = f(Xt) – f(Xt-n))。
用于计算的父聚合必须是多桶聚合。
配置参数
{
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "timestamp",
"interval": "day"
},
"aggs": {
"the_sum": {
"sum": {
"field": "lemmings"
}
},
"thirtieth_difference": {
"serial_diff": {
"buckets_path": "the_sum",
"lag" : 30 //差分间隔为 30 day
}
}
}
}
}
}