ES aggregation详解

最新推荐文章于 2024-09-08 11:05:50 发布

ZhaoYingChao88

最新推荐文章于 2024-09-08 11:05:50 发布

阅读量2.4w

点赞数 12

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

本文为博主原创文章，未经博主允许不得转载。如果对你有帮助，请记得点赞支持，谢谢！

本文链接：https://blog.csdn.net/zyc88888/article/details/83016513

版权

elasticsearch 专栏收录该内容

50 篇文章 39 订阅

订阅专栏

aggregation分类

aggregations —— 聚合，提供了一种基于查询条件来对数据进行分桶、计算的方法。有点类似于 SQL 中的 group by 再加一些函数方法的操作。

聚合可以嵌套，由此可以组成复杂的操作（Bucketing聚合可以包含sub-aggregation）。

聚合整体上可以分为 3 类：

1. Bucketing：桶分聚合：

此类聚合执行的是对文档分组的操作，把满足相关特性的文档分到一个桶里，即桶分。输出结果往往是一个个包含多个文档的桶。
此类聚合会有一个关键字（field、script），以及一些桶分（分组）的判断条件。执行聚合操作时候，文档会判断每一个分组条件，如果满足某个，该文档就会被分为该组（fall in）。

2. Metric：指标聚合：

此类聚合是对文档进行一些权值计算（比如求所有文档某个字段的max值）。输出结果往往是文档的权值，相当于为文档添加了一些统计信息。
此类聚合基于特定字段（field）或脚本值（generated using scripts），计算聚合中文档的权值。

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" 
            }
        }
    }
}

aggregation结构

聚合可以是父子（嵌套）关系聚合，buckets 聚合作为父，metric 聚合作为子。

聚合也可以是兄弟关系聚合，buckets 聚合在前，pipeline 聚合在后。

结构如下：


"aggregations" : {                                //定义聚合对象,也可用 "aggs"
      "<aggregation_name>" : {                    //聚合的名称,用户自定义
          "<aggregation_type>" : {                //聚合类型,比如 "histogram"
              <aggregation_body>                  //每个聚合类型都有其自己的结构定义
          }
          [,"meta" : {  [<meta_data_body>] } ]?
          [,"aggregations" : { [<sub_aggregation>]+ } ]?    //可以定义多个 sub-aggregation
      }
      [,"<aggregation_name_2>" : { ... } ]*       //定义额外的多个平级 aggregation,只有 Bucketing 类型才有意义
}

2 metrics aggregations

概述

权值聚合类型从需要聚合的文档中取一个值（value）来计算文档的相应权值（比如该值在这些文档中的max、sum等）。

用于计算的值（value）可以是文档的字段（field），也可以是脚本（script）生成的值。

数值权值聚合是特殊的权值聚合类型，因为它的输出权值也是数字。

数值权值聚合（注意分类只针对数值权值聚合，非数值的无此分类）输出单个权值的，叫做 single-value numeric metrics，其它生成多个权值（比如：stats）的被叫做 multi-value numeric metrics。

单值和多值数字权值聚合，在它们作为一些 Bucket 聚合的直接子聚合的时候会有明显区别。

Avg Aggregation(single-value numeric metrics)

均值聚合——基于文档的某个值，计算该值在聚合文档中的均值。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值


{
    "aggs" : {
        "avg_grade" : { "avg" : { "field" : "grade" } }    //计算字段 grade 在文档中的平均值
    }
}
//输出
{
    ...

    "aggregations": {
        "avg_grade": {
            "value": 75
        }
    }
}

Cardinality Aggregation(single-value)

基数聚合——基于文档的某个值，计算文档非重复的个数（去重计数）。

用于计算的值可以是特定的字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
precision_threshold：
missing：文档缺省字段时的默认值


{
    "aggs" : {
        "author_count" : {
            "cardinality" : {
                "field" : "author"  //count the unique authors that match a query
            }
        }
    }
}

stats aggregation(multi-value)

统计聚合——基于文档的某个值，计算出一些统计信息（min、max、sum、count、avg）。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值


{
    "aggs" : {
        "grades_stats" : { "stats" : { "field" : "grade" } }
    }
}
//输出
{
    ...
    "aggregations": {
        "grades_stats": {
            "count": 6,
            "min": 60,
            "max": 98,
            "avg": 78.5,
            "sum": 471
        }
    }
}

Extended Stats Aggregation(multi-value)

扩展统计聚合——基于文档的某个值，计算出一些统计信息（比普通的stats聚合多了sum_of_squares、variance、std_deviation、std_deviation_bounds）。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值
sigma：标准差界限


{
    ...

    "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 Bounds Aggregation

地理边界聚合——基于文档的某个字段（geo-point类型字段），计算出该字段所有地理坐标点的边界（左上角/右下角坐标点）。

配置参数

field：用于计算的字段
wrap_longitude：是否允许地理边界与国际日界线存在重叠


{
    "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 Centroid Aggregation

地理重心聚合——基于文档的某个字段（geo-point类型字段），计算所有坐标的加权重心。

配置参数

field：用于计算的字段（geo-point类型）


{
    "query" : {
        "match" : { "crime" : "burglary" }
    },
    "aggs" : {
        "centroid" : {
            "geo_centroid" : {
                "field" : "location" 
            }
        }
    }
}
//输出
{
    ...
    "aggregations": {
        "centroid": {
            "location": {      //重心经纬度
                "lat": 80.45,
                "lon": -160.22
            }
        }
    }
}

Max Aggregation(single)

最大值聚合——基于文档的某个值，求该值在聚合文档中的最大值。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值

Min Aggregation(single)

最小值聚合——基于文档的某个值，求该值在聚合文档中的最小值。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值

Sum Aggregation(single-value)

求和聚合——基于文档的某个值，求该值在聚合文档中的统计和。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值


//最大值，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
                }
            }
        }
    }
}

Percentiles Aggregation(multi-value)

百分百聚合——基于聚合文档中某个数值类型的值，求这些值中

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value
missing：文档缺省字段时的默认值

Script Metric Aggregation

基于脚本的权值聚合——用脚本来计算出一个权值

配置参数

init_script：用于计算的字段
map_script：由脚本生成用来计算的 value
combine_script：文档缺省字段时的默认值
reduce_script：


{
    "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"
            }
        }
    }
}

Top hits Aggregation

最高匹配权值聚合——跟踪聚合中相关性最高的文档。

该聚合一般用做 sub-aggregation，以此来聚合每个桶中的最高匹配的文档。

配置参数

from：最匹配的结果中的文档个数偏移
size：top matching hits 返回的最大文档个数（default 3）

sort：最匹配的文档的排序方式




{
    "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
                  ]
               }
           ]
     }
}

Value Count Aggregation(single-value)

值计数聚合——计算聚合文档中某个值的个数。

用于计数的值可以是特定的数值型字段，也可以通过脚本计算而来。

该聚合一般域其它 single-value 聚合联合使用，比如在计算一个字段的平均值的时候，可能还会关注这个平均值是由多少个值计算而来。

配置参数

field：用于计算的字段
script：由脚本生成用来计算的 value


{
    "aggs" : {
        "grades_count" : { "value_count" : { "field" : "grade" } }    //计算 grade 字段共有多少个值，和 cardinality 聚合不同的
    }
}

3 bucket aggregation

概述

桶分聚合不进行权值的计算，他们对文档根据聚合请求中提供的判断条件（比如：{"from":0, "to":100}）来进行分组（桶分）。

桶分聚合还会额外返回每一个桶内文档的个数。

桶分聚合可以包含子聚合——sub-aggregations（权值聚合不能包含子聚合，可以作为子聚合），子聚合操作将会应用到由父（parent）聚合产生的每一个桶上。

桶分聚合根据聚合条件，可以只定义输出一个桶；也可以输出多个；还可以在根据聚合条件动态确定桶个数（比如：terms aggregation）。

Histogram Aggregation(multi-bucket)

直方图聚合——基于文档中的某个【数值类型】字段，通过计算来动态的分桶。

一个文档属于某个桶，计算过程大致如下：

rem = value % interval
if (rem < 0) {
    rem += interval
}
bucket_key = value - rem

配置参数

field：字段，必须为数值类型
interval：分桶间距
min_doc_count：最少文档数桶过滤，只有不少于这么多文档的桶才会返回
extended_bounds：范围扩展
order：对桶排序，如果 histogram 聚合有一个权值聚合类型的"直接"子聚合，那么排序可以使用子聚合中的结果
offset：桶边界位移，默认从0开始
keyed：hash结构返回，默认以数组形式返回每一个桶
missing：配置缺省默认值


{
    "aggs" : {
        "prices" : {
            "histogram" : {
                "field" : "price",
                "interval" : 50,
                "min_doc_count" : 1,
                "extended_bounds" : {
                    "min" : 0,
                    "max" : 500
                },
                "order" : { "_count" : "desc" },
                "keyed":true,
                "missing":0
            }
        }
    }
}

Data Histogram Aggregation(multi-bucket)

日期直方图聚合——基于日期类型，以【日期间隔】来桶分聚合。

可用的时间间隔类型为：year、quarter、month、week、day、hour、minute、second，其中，除了year、quarter 和 month，其余可用小数形式。

配置参数

field：
interval：
format：定义日期的格式，配置后会返回一个 key_as_string 的字符串类型日期（默认只有key）
time_zone：定义时区，用作时间值的调整
offset：
missing：


{
    "aggs" : {
        "articles_over_time" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month",
                "format" : "yyyy-MM-dd",
                "time_zone": "+08:00"
            }
        }
    }
}

Range Aggregation(multi-bucket)

范围聚合——基于某个值（可以是 field 或 script），以【字段范围】来桶分聚合。

范围聚合包括 from 值，不包括 to 值（区间前闭后开）。

配置参数

ranges：配置区间，数组，每一个元素是一个区间。例如：[{from:0}, {from:50, to:100}, {to:200}]
keyed：以一个关联的唯一字符串作为键，以 HASH 形式返回，而不是默认的数组
script：利用 script 执行结果替代普通的 field 值进行聚合。script可以用file给出，还可以对其它 field 进行求值计算。


{
    "aggs" : {
        "price_ranges" : {
            "range" : {
                "field" : "price",
                "ranges" : [                       //包含 3 个桶
                    { "to" : 50 },
                    { "from" : 50, "to" : 100 },
                    { "from" : 100 }
                ],
                "keyed" : true
            }
        }
    }
}

Date Range Aggregation(multi-bucket)

日期范围聚合——基于日期类型的值，以【日期范围】来桶分聚合。

日期范围可以用各种 Date Math 表达式。

同样的，包括 from 的值，不包括 to 的值。

配置参数

format：定义日期格式，配置后会返回一个 [to/from]_as_string 的字符串类型日期，默认是 to/from 的数值表示


{
    "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"}
                ]
            }
        }
    }
}

Terms Aggregation(multi-bucket)

词元聚合——基于某个field，该 field 内的每一个【唯一词元】为一个桶，并计算每个桶内文档个数。

默认返回顺序是按照文档个数多少排序。

当不返回所有 buckets 的情况，文档个数可能不准确。

配置参数

size：size用来定义需要返回多个 buckets（防止太多），默认会全部返回。（注意，如果只返回部分buckets，统计的文档个数不一定准确（每个分片各自的top size个）。size 越大，count 会越精确。）
order：排序方式
min_doc_count：只返回文档个数不小于该值的 buckets
script：用基本来生成词元
include：包含过滤
exclude：排除过滤
execution_hint：
collect_mode：
missing：


{
    "aggs" : {
        "genders" : {
            "terms" : { 
              "field" : "gender",
              "size" : 5,
              "order" : { "_count" : "asc" },
              "min_doc_count": 10,
              "include" : ".*sport.*",
              "exclude" : "water_.*",
              "missing": "N/A"
            }
        }
    }
}

Filters Aggregation(multi-bucket)

多过滤聚合——基于多个过滤条件，来对当前文档进行【过滤】的聚合，每个过滤都包含所有满足它的文档（多个bucket中可能重复）。

配置参数

filters：配置过滤条件，支持 HASH 或数组格式
other_bucket：是否计算不满足任何匹配条件的文档
other_bucket_key：作为不匹配所有过滤条件的文档的 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"
          }
        }
      }
    }
  }
}

Filter Aggregation(single-bucket)

过滤聚合——基于一个条件，来对当前的文档进行过滤的聚合。


{
    "aggs" : {
        "red_products" : {
            "filter" : { "term": { "color": "red" } },
            "aggs" : {
                "avg_price" : { "avg" : { "field" : "price" } }
            }
        }
    }
}

IPv4 Range Aggregation(multi-bucket)

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 Aggregation(single-bucket)

嵌套类型聚合——基于嵌套（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
            }
        }
    }
}

4 pipeline aggregations

概述

管道聚合处理的对象是其它聚合的输出（桶或者桶的某些权值），而不是直接针对文档。

管道聚合的作用是为输出增加一些有用信息。

管道聚合大致分为两类：

parent

此类聚合的"输入"是其【父聚合】的输出，并对其进行进一步处理。一般不生成新的桶，而是对父聚合桶信息的增强。

sibling

此类聚合的输入是其【兄弟聚合】的输出。并能在同级上计算新的聚合。

管道聚合通过 buckets_path 参数指定他们要进行聚合计算的权值对象，buckets_path 参数有其自己的使用语法。

管道聚合不能包含子聚合，但是某些类型的管道聚合可以链式使用（比如计算导数的导数）。

bucket_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 聚合的对象名称或权值名称包含小数点

"buckets_path": "my_percentile[99.9]"

2. 处理对象中包含空桶（无文档的桶分）

参数 gap_policy，可选值有 skip、insert_zeros

Avg Bucket Aggregation(sibliing)

桶均值聚合——基于兄弟聚合的某个权值，求所有桶的权值均值。

用于计算的兄弟聚合必须是多桶聚合。

用于计算的权值必须是数值类型。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义


{
    "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" 
            }
        }
    }
}

Derivative Aggregation(parent)

求导聚合——基于父聚合（只能是histogram或date_histogram类型）的某个权值，对权值求导。

用于求导的权值必须是数值类型。

封闭直方图（histogram）聚合的 min_doc_count 必须是 0。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义


{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {
                        "field": "price"
                    }
                },
                "sales_deriv": {       //对每个月销售总和 sales 求导
                    "derivative": {
                        "buckets_path": "sales"  //同级，直接用 metric 值
                    }
                }
            }
        }
    }
}

Max Bucket Aggregation(sibling)

桶最大值聚合——基于兄弟聚合的某个权值，输出权值最大的那一个桶。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义

Min Bucket Aggregation(sibling)

桶最小值聚合——基于兄弟聚合的某个权值，输出权值最小的一个桶。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义

Sum Buchet Aggregation(sibling)

桶求和聚合——基于兄弟聚合的权值，对所有桶的权值求和。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义


{
    "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" 
            }
        }
    }
}

Stats Bucket Aggregation(sibling)

桶统计信息聚合——基于兄弟聚合的某个权值，对【桶的信息】进行一些统计学运算（总计多少个桶、所有桶中该权值的最大值、最小等）。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义


{
    "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
      }
   }
}

Extended Stats Bucket Aggregation(sibling)

扩展桶统计聚合——基于兄弟聚合的某个权值，对【桶信息】进行一系列统计学计算（比普通的统计聚合多了一些统计值）。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
sigma：偏差显示位置（above/below）

Percentiles Bucket Aggregation(sibling)

桶百分比聚合——基于兄弟聚合的某个权值，计算权值的百分百。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

对百分百的计算是精确的（不像Percentiles Metric聚合是近似值），所以可能会消耗大量内存

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
percents：需要计算的百分百列表（数组形式）

Moving Average Aggregation(parent)

窗口平均值聚合——基于已经排序过的数据，计算出处在当前出口中数据的平均值。

比如窗口大小为 5 ，对数据 1—10 的部分窗口平均值如下：

(1 + 2 + 3 + 4 + 5) / 5 = 3
(2 + 3 + 4 + 5 + 6) / 5 = 4
(3 + 4 + 5 + 6 + 7) / 5 = 5

配置参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
window：窗口大小
model：移动模型
minimize：
settings：


{
    "the_movavg":{
        "moving_avg":{
            "buckets_path": "the_sum",
            "window" : 30,
            "model" : "simple"
        }
    }
}

Cumulative Sum Aggregation(parent)

累计和聚合——基于父聚合（只能是histogram或date_histogram类型）的某个权值，对权值在每一个桶中求所有之前的桶的该值累计的和。

用于计算的权值必须是数值类型。

封闭直方图（histogram）聚合的 min_doc_count 必须是 0。

配置参数

buckets_path：用于计算均值的权值路径
format：该聚合的输出格式定义


{
    "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
               }
            },

Bucket Script Aggregation(parent)

桶脚本聚合——基于父聚合的【一个或多个权值】，对这些权值通过脚本进行运算。

用于计算的父聚合必须是多桶聚合。

用于计算的权值必须是数值类型。

执行脚本必须要返回数值型结果。

配置参数

script：用于计算的脚本，脚本可以是 inline，也可以是 file，还可以是 Scripting 指定的
buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义


{
    "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"
                    }
                }
            }
        }
    }
}

Bucket Selector Aggregation(parent)

桶选择器聚合——基于父聚合的【一个或多个权值】，通过脚本对权值进行计算，并决定父聚合的哪些桶需要保留，其余的将被丢弃。

用于计算的父聚合必须是多桶聚合。

用于计算的权值必须是数值类型。

运算的脚本必须是返回 boolean 类型，如果脚本是脚本表达式形式给出，那么允许返回数值类型。

配置参数

script：用于计算的脚本，脚本可以是 inline，也可以是 file，还可以是 Scripting 指定的
buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）


{
    "bucket_selector": {
        "buckets_path": {
            "my_var1": "the_sum", 
            "my_var2": "the_value_count"
        },
        "script": "my_var1 > my_var2"    // true 则保留该桶；false 则丢弃
    }
}

Serial Differencing Aggregation(parent)

串行差分聚合——基于父聚合（只能是histogram或date_histogram类型）的某个权值，对权值值进行差分运算，（取时间间隔，后一刻的值减去前一刻的值：f(X) = f(Xt) – f(Xt-n)）。

用于计算的父聚合必须是多桶聚合。

配置参数

lag：滞后间隔（比如lag=7，表示每次从当前桶的值中减去其前面第7个桶的值）
buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义


{
   "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
               }
            }
         }
      }
   }
}