Elasticsearch - 大数据 架构+大数据进阶

Elasticsearch之aggregation详解

aggregation，类似于mysql中的Groupby+函数操作，但是比他还要强大的聚合操作

Posted by Steven on 2021-08-31
Estimated Reading Time 28 Minutes
Words 6.6k In Total
Viewed Times

一、相关链接

二、分类

  • 分桶聚合 （Bucketaggregations)

    示例：

    image-20210831103936349
    即对文档文档进行分组，把符合相关特性的文档分到一个桶里，即桶分，聚合的结果就是一个个包含多个文档的桶

    它会以一些关键字，如field、script，或者一些判读条件，就像是mysql中的group by,把某种属性的文档分为一组

  • 指标聚合 （Metric aggregations）
    即对文档进行一些指标计算，如Avg平均值、Max最大值、Min最小值、Sum求和、Cardinality 基数（去重）、Value Count计数、Stats统计聚合、Top Hits聚合等

  • 管道聚合 （Pipeline aggregations）
    对聚合的结果进行二次聚合，该聚合的对象通常为桶

    示例： 统计平均价格最低的商品分类，先对商品进行分类，计算其平均价格，然后才能计算最低的平均价格

三、应用场景

常见的应用场景流程：

分桶聚合对文档进行分类–>指标聚合对每个桶进行一些指标的计算–>管道聚合对前面的桶进行桶层面的计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
"aggs": {
    "groupbytype": {  //分桶(bucket)聚合,按照字段platform,即平台进行分组，每个platform的数据聚合到一个桶
      "terms": {
        "field": "platform"
      },
      "aggs": {
        "cost": {
          "avg": {  //指标（指标）聚合  对每个桶的cost_time 求平均值，即每个平台的某种业务耗时平均时长
            "field": "cost_time"
          }
        }
      }
    },
    "max_cost":{
      "max_bucket": {  //管道(pipeline)聚合 ,对所有的桶中耗时平均时长最大的值
        "buckets_path": "groupbytype>cost"
      }
    }
  }

响应结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
{
  "took": 20977,
  "timed_out": false,
  "num_reduce_phases": 3,
  "_shards": {
    "total": 1024,
    "successful": 1024,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 4825461,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "groupbytype": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": 2,
          "doc_count": 4755035,
          "cost": {
            "value": 383.67526863629814
          }
        },
        {
          "key": 3,
          "doc_count": 70125,
          "cost": {
            "value": 136.63362566844918
          }
        },
        {
          "key": 13,
          "doc_count": 301,
          "cost": {
            "value": 14905.621262458471
          }
        }
      ]
    },
    "max_cost": {
      "value": 14905.621262458471,
      "keys": [
        "13"
      ]
    }
  }
}

1、分桶聚合 （Bucketaggregations)

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

例如：统计不同平台的数量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
GET /{index}/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "event_type": 1
          }
        }
      ]
    }
  },
  "size": 0,
  "aggs": {
    "groupbytype": {
      "terms": {
        "field": "platform"
      }
    }
  }
}

查询结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
{
  "took": 2571,
  "timed_out": false,
  "num_reduce_phases": 3,
  "_shards": {
    "total": 1024,
    "successful": 1024,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 4825461,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "groupbytype": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": 2,
          "doc_count": 4755035
        },
        {
          "key": 3,
          "doc_count": 70125
        },
        {
          "key": 13,
          "doc_count": 301
        }
      ]
    }
  }
}

⚠️ 注意：只有在正排索引创建了的字段上才可以进行聚合操作，但是如果没有正排索引的话，其实也是可以通过field_data在搜索的时候来动态的创建正排索引，不过这个索引是保存在JVM中的,因此，当数据量较大的时候，很有可能会导致OOM,因此field_data尽量不要使用

doc_values是基于磁盘的，field_data是基于内存的

2、指标聚合 （Metric aggregations）

指标聚合通常用在业务场景为：统计最值（最贵、最便宜、最大、最小等）、平均值等中使用

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

数值权值聚合 （注意分类只针对数值权值聚合，非数值的无此分类）

输出单个权值的，叫做 single-value numeric metrics，其它生成多个权值（比如：stats）的被叫做 multi-value numeric metrics。

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

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

(1)、统计聚合(stats aggregation(multi))

按照文档中的某个字段，计算所有文档该字段的值的统计信息（min、max、sum、count、avg）

参数配置：

field：用于计算的字段

script：由脚本生成用来计算的 value

missing：文档缺省字段时的默认值

例如：

1
2
3
4
5
6
7
8
9
10
11
GET /{index}/_search
{
  "size": 0, 
  "aggs": {
    "stat_time": {
      "stats": {
        "field": "cost_time"
      }
    }
  }
}

聚合结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
  "took": 1176,
  "timed_out": false,
  "num_reduce_phases": 3,
  "_shards": {
    "total": 1024,
    "successful": 1024,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 7075883494,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "stat_time": {
      "count": 7075883494,
      "min": 0,
      "max": 5025434021,
      "avg": 1823322.15213653,
      "sum": 12901615120547430
    }
  }
}

(2)、均值、最值、求和、count等聚合

包括均值聚合Avg Aggregation(single)、最大值聚合Max Aggregation(single)、最小值聚合Min Aggregation(single)、求和聚合Sum Aggregation(single)、值计数聚合Value Count Aggregation(single)

配置参数:

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

上面的统计聚合stat是他们的合集

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
GET /{index}/_search
{
  "size": 0, 
  "aggs": {
    "max_time": {  //耗时最长的
      "max": {
        "field": "cost_time"
      }
    },
    "min_time": {  //耗时最短的
      "min": {
        "field": "cost_time"
      }
    },
    "avg_time": {
      "avg": {
        "field": "cost_time"
      }
    },
    "sum_time":{
      "sum": {
        "field": "cost_time"
      }
    },
    "count_time":{
      "value_count": {   //注意这里是value_count,不是count
        "field": "cost_time"
      }
    }
  }
}

查询结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
{
  "took": 10396,
  "timed_out": false,
  "num_reduce_phases": 3,
  "_shards": {
    "total": 1024,
    "successful": 1024,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 7169361655,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "count_time": {
      "value": 7169361655
    },
    "sum_time": {
      "value": 13121101759145820
    },
    "max_time": {
      "value": 5025434021
    },
    "min_time": {
      "value": 0
    },
    "avg_time": {
      "value": 1830163.184750905
    }
  }
}

(3)、基数聚合(Cardinality Aggregation(single))

去重计数,相当于mysql中的distinct

配置参数：

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

例如： sdk_app_id去重后的数量

1
2
3
4
5
6
7
8
9
10
11
GET /{index}/_search
{
  "size": 0, 
  "aggs": {
    "distinct_sdkappid": {
      "cardinality": {
        "field": "sdk_app_id"
      }
    }
  }
}

聚合结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
{
  "took": 6708,
  "timed_out": false,
  "num_reduce_phases": 3,
  "_shards": {
    "total": 1024,
    "successful": 1024,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 7203698871,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "distinct_sdkappid": {
      "value": 5621
    }
  }
}

(4)、百分比聚合(Percentiles Aggregation(multi))

对指定字段（脚本）的值按从小到大累计每个值对应的文档数的占比（占所有命中文档数的百分比），返回指定占比比例对应的值。默认返回[ 1, 5, 25, 50, 75, 95, 99 ]分位上的值

如果对分位不是很了解的，可以参考下这片文章百分位数的概念及计算

配置参数：

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

例如：

1
2
3
4
5
6
7
8
9
10
11
GET /{index}/_search
{
  "size": 0, 
  "aggs": {
    "percent_costtime": {
      "percentiles": {
        "field": "cost_time"
      }
    }
  }
}

聚合结果：

1

(5)、扩展统计聚合(Extended Stats Aggregation(multi))

对文档的某个值计算出一些额外的统计信息（比普通的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
}
}
}
}

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

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. 聚合名称 ==> ，直接指定聚合的名称

  4. 权值 ==> ，直接指定权值

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

如果您喜欢此博客或发现它对您有用，则欢迎对此发表评论。 也欢迎您共享此博客，以便更多人可以参与。 如果博客中使用的图像侵犯了您的版权，请与作者联系以将其删除。 谢谢 ！

特色标签
Elasticsearch - 大数据 架构+大数据进阶
链友
ESC