ElasticSearch - 聚合 aggs 详解

小镇程序员

已于 2023-11-25 18:04:54 修改

阅读量5.5k

点赞数 4

分类专栏： Elasticsearch 文章标签： elasticsearch jenkins 大数据

于 2020-09-29 12:02:46 首次发布

本文链接：https://blog.csdn.net/weixin_46742102/article/details/108866057

版权

Elasticsearch 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

聚合概念

ElasticSearch除了致力于搜索之外，也提供了聚合实时分析数据的功能
- 如果把搜索比喻为大海捞针(从海量的文档中找出符合条件的那一个)，那麽聚合就是去分析大海中的针们的特性，像是
  - 在大海里有多少针？
  - 针的平均长度是多少？
  - 按照针的製造商来划分，针的长度中位值是多少？
  - 每月加入到海中的针有多少？
  - 这里面有异常的针麽？
- 因此透过聚合，我们可以得到一个数据的概览，聚合能做的是分析和总结全套的数据，而不是查找单个文档(这是搜索做的事)
聚合允许我们向数据提出一些複杂的问题，虽然他的功能完全不同于搜索，但他们其实使用了相同的数据结构，这表示聚合的执行速度很快，并且就像搜索一样几乎是实时的
- 并且由于聚合和搜索是使用同样的数据结构，因此聚合和搜索可以是一起执行的
- 这表示我们可以在一次json请求裡，同时对相同的数据进行搜索/过滤 + 分析，两个愿望一次满足
聚合的两个主要的概念，分别是桶和指标
- 桶(Buckets) : 满足特定条件的文档的集合
  - 当聚合开始被执行，每个文档会决定符合哪个桶的条件，如果匹配到，文档将放入相应的桶并接着进行聚合操作
    - 像是一个员工属于男性桶或者女性桶，日期2014-10-28属于十月桶，也属于2014年桶
  - 桶可以被嵌套在其他桶里面
    - 像是北京能放在中国桶裡，而中国桶能放在亚洲桶裡
  - Elasticsearch提供了很多种类型的桶，像是时间、最受欢迎的词、年龄区间、地理位置桶等等，不过他们在根本上都是通过同样的原理进行操作，也就是基于条件来划分文档，一个文档只要符合条件，就可以加入那个桶，因此一个文档可以同时加入很多桶
- 指标(Metrics) : 对桶内的文档进行统计计算
  - 桶能让我们划分文档到有意义的集合，但是最终我们需要的是对这些桶内的文档进行一些指标的计算
  - 指标通常是简单的数学运算(像是min、max、avg、sum），而这些是通过当前桶中的文档的值来计算的，利用指标能让你计算像平均薪资、最高出售价格、95%的查询延迟这样的数据
aggs 聚合的模板
- 当query和aggs一起存在时，会先执行query的主查询，主查询query执行完后会搜出一批结果，而这些结果才会被拿去aggs拿去做聚合
  - 另外要注意aggs后面会先接一层自定义的这个聚合的名字，然后才是接上要使用的聚合桶
  - 如果有些情况不在意查询结果是什麽，而只在意aggs的结果，可以把size设为0，如此可以让返回的hits结果集是0，加快返回的速度
- 一个aggs裡可以有很多个聚合，每个聚合彼此间都是独立的，因此可以一个聚合拿来统计数量、一个聚合拿来分析数据、一个聚合拿来计算标准差...，让一次搜索就可以把想要做的事情一次做完
  - 像是此例就定义了3个聚合，分别是custom_name1、custom_name2、custom_name3
- aggs可以嵌套在其他的aggs裡面，而嵌套的桶能作用的文档集范围，是外层的桶所输出的结果集
```
 
```
1. GET 127.0.0.1/mytest/doc/_search
2. {
3. "query": { ... },
4. "size": 0,
5. "aggs": {
6. "custom_name1": { //aggs后面接著的是一个自定义的name
7. "桶": { ... } //再来才是接桶
8. },
9. "custom_name2": { //一个aggs裡可以有很多聚合
10. "桶": { ... }
11. },
12. "custom_name3": {
13. "桶": {
14. .....
15. },
16. "aggs": { //aggs可以嵌套在别的aggs裡面
17. "in_name": { //记得使用aggs需要先自定义一个name
18. "桶": { ... } //in_name的桶作用的文档是custom_name3的桶的结果
19. }
20. }
21. }
22. }
23. }
- 结果
```
 
```
  1. {
  2. "hits": {
  3. "total": 8,
  4. "max_score": 0,
  5. "hits": [] //因为size设为0，所以没有查询结果返回
  6. },
  7. "aggregations": {
  8. "custom_name1": {
  9. ...
  10. },
  11. "custom_name2": {
  12. ...
  13. },
  14. "custom_name3": {
  15. ... ,
  16. "in_name": {
  17. ....
  18. }
  19. }
  20. }
  21. }

聚合中常用的桶 terms、filter、top_hits

terms桶 : 针对某个field的值进行分组，field有几种值就分成几组
- terms桶在进行分组时，会爲此field中的每种值创建一个新的桶
- 要注意此 "terms桶" 和平常用在主查询query中的 "查找terms" 是不同的东西
- 具体实例
  - 首先插入几笔数据，其中color是一个keyword类型
```
 
```
    1. { "color": "red" }
    2. { "color": "green" }
    3. { "color": ["red", "blue"] }
  - 执行terms聚合
```
 
```
    1. GET 127.0.0.1/mytest/doc/_search
    2. {
    3. "query": {
    4. "match_all": {}
    5. },
    6. "size": 0,
    7. "aggs": {
    8. "my_name": {
    9. "terms": {
    10. "field": "color" //使用color来进行分组
    11. }
    12. }
    13. }
    14. }
  - 结果
    - 因为color总共有3种值，red、blue、green，所以terms桶为他们产生了3个bucket，并计算了每个bucket中符合的文档有哪些
    - bucket和bucket间是独立的，也就是说一个文档可以同时符合好几个bucket，像是{"color": ["red", "blue"]}就同时符合了red和blue bucket
```
 
```
    1. "aggregations": {
    2. "my_name": {
    3. "doc_count_error_upper_bound": 0,
    4. "sum_other_doc_count": 0,
    5. "buckets": [
    6. {
    7. "key": "blue",
    8. "doc_count": 1
    9. },
    10. {
    11. "key": "red",
    12. "doc_count": 2 //表示color为red的文档有2个，此例中就是 {"color": "red"} 和 {"color": ["red", "blue"]}这两个文档
    13. },
    14. {
    15. "key": "green",
    16. "doc_count": 1
    17. }
    18. ]
    19. }
    20. }
- 具体实例二
  - 将terms桶搭配度量指标(avg、min、max、sum...)一起使用
    - 其实度量指标也可以看成一种"桶"，他可以和其他正常的桶们进行嵌套作用，差别只在指标关注的是这些文档中的某个数值的统计，而桶关注的是文档
  - 首先准备数据，color一样为keyword类型，而price为integer类型
```
 
```
    1. { "color": "red", "price": 100 }
    2. { "color": "green", "price": 500 }
    3. { "color": ["red", "blue"], "price": 1000 }
  - 将avg指标嵌套在terms桶裡一起使用
```
 
```
    1. GET 127.0.0.1/mytest/doc/_search
    2. {
    3. "query": {
    4. "match_all": {}
    5. },
    6. "size": 0,
    7. "aggs": {
    8. "my_name": {
    9. "terms": {
    10. "field": "color"
    11. },
    12. "aggs": { //嵌套两个指标avg、min在terms桶中
    13. "my_avg_price": { //my_avg_price计算每个bucket的平均price
    14. "avg": {
    15. "field": "price"
    16. }
    17. },
    18. "my_min_price": { //my_min_price计算每个bucket中的最小price
    19. "min": {
    20. "field": "price"
    21. }
    22. }
    23. }
    24. }
    25. }
    26. }
  - 结果
```
 
```
    1. "aggregations": {
    2. "my_name": {
    3. "doc_count_error_upper_bound": 0,
    4. "sum_other_doc_count": 0,
    5. "buckets": [ //terms桶中的每个bucket都会计算avg和min两个指标
    6. {
    7. "key": "blue",
    8. "doc_count": 1,
    9. "my_avg_price": { //avg指标
    10. "value": 1000
    11. },
    12. "my_min_price": { //min指标
    13. "value": 100
    14. }
    15. },
    16. {
    17. "key": "red",
    18. "doc_count": 2,
    19. "my_avg_price": { //avg指标计算的值，因为符合color为red的文档有两笔，所以平均price为100+1000/2 = 550
    20. "value": 550
    21. },
    22. "my_min_price": {
    23. "value": 100
    24. }
    25. },
    26. {
    27. "key": "green",
    28. "doc_count": 1,
    29. "my_avg_price": {
    30. "value": 500
    31. },
    32. "my_min_price": {
    33. "value": 500
    34. }
    35. }
    36. ]
    37. }
    38. }
filter桶 : 一个用来过滤的桶
- 要注意此处的 "filter桶" 和用在主查询query的 "过滤filter" 的用法是一模一样的，都是过滤
- 不过差别是 "filter桶" 会自己给创建一个新的桶，而不会像 "过滤filter" 一样依附在query下
  - 因为filter桶毕竟还是一个聚合桶，因此他可以和别的桶进行嵌套，但他不是依附在别的桶上
- 具体实例
  - 取得color为red或是blue的文档
```
 
```
    1. GET 127.0.0.1/mytest/doc/_search
    2. {
    3. "query": {
    4. "match_all": {}
    5. },
    6. "size": 0,
    7. "aggs": {
    8. "my_name": {
    9. "filter": { //因为他用法跟一般的过滤filter一样，所以也能使用bool嵌套
    10. "bool": {
    11. "must": {
    12. "terms": { //注意此terms是查找terms，不是terms桶
    13. "color": [ "red", "blue" ]
    14. }
    15. }
    16. }
    17. }
    18. }
    19. }
    20. }
  - 结果
```
 
```
    1. "aggregations": {
    2. "my_name": {
    3. "doc_count": 2 //filter桶计算出来的文档数量
    4. }
    5. }
- 具体实例二
  - filter桶和terms桶嵌套使用，先过滤出color为red以及blue的文档，再对这些文档进行color分组
```
 
```
    1. GET 127.0.0.1/mytest/doc/_search
    2. {
    3. "query": {
    4. "match_all": {}
    5. },
    6. "size": 0,
    7. "aggs": {
    8. "my_name": { //my_name聚合
    9. "filter": { //filter桶
    10. "bool": {
    11. "must": {
    12. "terms": {
    13. "color": [ "red", "blue" ]
    14. }
    15. }
    16. }
    17. },
    18. "aggs": {
    19. "my_name2": { //my_name2聚合，嵌套在my_name聚合裡
    20. "terms": { //terms桶
    21. "field": "color"
    22. }
    23. }
    24. }
    25. }
    26. }
    27. }
  - 结果
    - 因为terms桶嵌套在filter桶内，所以query查询出来的文档们会先经过filter桶，如果符合filter桶，才会进入到terms桶内
    - 此处通过filter桶的文档只有两笔，分别是{"color": "red"}以及{"color": ["red", "blue"]}，所以terms桶只会对这两笔文档做分组
    - 这也是为什麽terms桶裡没有出现color为green的分组，因为这个文档在filter桶就被挡下来了
```
 
```
    1. "aggregations": {
    2. "my_name": {
    3. "doc_count": 2, //filter桶计算的数量，通过此处的文档只有2笔
    4. "my_name2": {
    5. "doc_count_error_upper_bound": 0,
    6. "sum_other_doc_count": 0,
    7. "buckets": [
    8. {
    9. "key": "red",
    10. "doc_count": 2 //terms桶计算的数量
    11. },
    12. {
    13. "key": "blue",
    14. "doc_count": 1 //terms桶计算的数量
    15. }
    16. ]
    17. }
    18. }
    19. }
top_hits桶 : 在某个桶底下找出这个桶的前几笔hits，返回的hits格式和主查询query返回的hits格式一模一样
- top_hits桶支持的参数
  - from、size
  - sort : 设置返回的hits的排序
    - 要注意，假设在主查询query裡已经对数据设置了排序sort，此sort并不会对aggs裡面的数据造成影响，也就是说主查询query查找出来的数据会先丢进aggs而非先经过sort，因此就算主查询设置了sort，也不会影响aggs数据裡的排序
    - 因此如果在top_hits桶裡的返回的hits数据想要排序，需要自己在top_hits桶裡设置sort
    - 如果没有设置sort，默认使用主查询query所查出来的_score排序
  - _source : 设置返回的字段
- 具体实例
  - 首先准备数据，color是keyword类型
```
 
```
    1. { "color": "red", "price": 100 }
    2. { "color": ["red", "blue"], "price": 1000 }
  - 使用terms桶分组，再使用top_hits桶找出每个group裡面的price最小的前5笔hits
```
 
```
    1. GET 127.0.0.1/mytest/doc/_search
    2. {
    3. "query": {
    4. "match_all": {}
    5. },
    6. "size": 0,
    7. "aggs": {
    8. "my_name": {
    9. "terms": {
    10. "field": "color"
    11. },
    12. "aggs": {
    13. "my_top_hits": {
    14. "top_hits": {
    15. "size": 5,
    16. "sort": {
    17. "price": "asc"
    18. }
    19. }
    20. }
    21. }
    22. }
    23. }
    24. }
  - 结果
```
 
```
    1. "aggregations": {
    2. "my_name": {
    3. "doc_count_error_upper_bound": 0,
    4. "sum_other_doc_count": 0,
    5. "buckets": [
    6. {
    7. "key": "red",
    8. "doc_count": 2, //terms桶计算出来的color为red的文档数
    9. "my_top_hits": {
    10. "hits": { //top_hits桶找出color为red的这些文档中，price从小到大排序取前5笔
    11. "total": 2,
    12. "max_score": null,
    13. "hits": [
    14. {
    15. "_score": null,
    16. "_source": { "color": "red", "price": 100 },
    17. "sort": [ 100 ]
    18. },
    19. {
    20. "_score": null,
    21. "_source": { "color": [ "red", "blue" ], "price": 1000 },
    22. "sort": [ 1000 ]
    23. }
    24. ]
    25. }
    26. }
    27. },
    28. {
    29. "key": "blue",
    30. "doc_count": 1, //terms桶计算出来的color为blue的文档数
    31. "my_top_hits": {
    32. "hits": { //top_hits桶找出的hits
    33. "total": 1,
    34. "max_score": null,
    35. "hits": [
    36. {
    37. "_source": {
    38. "color": [ "red", "blue" ], "price": 1000 },
    39. "sort": [ 1000 ]
    40. }
    41. ]
    42. }
    43. }
    44. }
    45. ]
    46. }
    47. }

多桶排序

terms桶、histogram桶、data_histogram桶这些桶属于多值桶，也就是说他们会动态生成很多桶，对于这些生成出来的桶们，Elasticsearch默认会使用doc_value进行降序排序，也就是说哪个生成桶的doc_value文档数较多，哪个生成桶就排在前面
- 如果想要改变这个生成桶与生成桶之间的排序，可以在使用terms桶、histogram桶、data_histogram桶时，使用order进行排序
- order支持的参数
  - _count : 按照文档数排序
  - _key : 按照每个桶的字符串值的字母顺序排序
具体实例
- 准备数据，color是keyword类型
```
 
```
  1. { "color": "red", "price": 100 }
  2. { "color": ["red", "blue"], "price": 1000 }
- 使用terms桶进行分组，并且规定按照桶的字母顺序升序，因此a生成桶会排在最前面而z生成桶会排在最后面
```
 
```
  1. GET 127.0.0.1/mytest/doc/_search
  2. {
  3. "query": {
  4. "match_all": {}
  5. },
  6. "size": 0,
  7. "aggs": {
  8. "my_name": {
  9. "terms": {
  10. "field": "color",
  11. "order": {
  12. "_key": "asc"
  13. }
  14. }
  15. }
  16. }
  17. }
- 结果
```
 
```
  1. "aggregations": {
  2. "my_name": {
  3. "doc_count_error_upper_bound": 0,
  4. "sum_other_doc_count": 0,
  5. "buckets": [
  6. {
  7. "key": "blue",
  8. "doc_count": 1
  9. },
  10. {
  11. "key": "red",
  12. "doc_count": 2
  13. }
  14. ]
  15. }
  16. }
- 更多精彩文章请访问：百考汇

小镇程序员

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
ElasticSearch - 聚合 aggs 详解

聚合概念 ElasticSearch除了致力于搜索之外，也提供了聚合实时分析数据的功能如果把搜索比喻为大海捞针(从海量的文档中找出符合条件的那一个)，那麽聚合就是去分析大海中的针们的特性，像是在大海里有多少针？针的平均长度是多少？按照针的製造商来划分，针的长度中位值是多少？每月加入到海中的针有多少？这里面有异常的针麽？因此透过聚合，我们可以得到一个数据的
复制链接

扫一扫