ToB企服应用市场:ToB评测及商务社交产业平台

标题: Elasticsearch 的DSL查询，聚合查询与多维度数据统计 [打印本页]

---

作者: 瑞星    时间: 2024-8-5 13:45
标题: Elasticsearch 的DSL查询，聚合查询与多维度数据统计
搜索

即从一个索引下按照特定的字段或关键词搜索出符合用户预期的一个或者一堆cocument，然后根据文档的相关度得分，在返回的结果集里并根据得分对这些文档举行一定的排序。
聚合

根据业务需求，对文档中的某个或某几个字段举行数据的分组并做一些指标数据的统计分析，比如要盘算一批文档中某个业务字段的总数，匀称数，最大最小值等，都属于聚合的范畴。
以上两个概念后是明白下面实行的基础，如果是传统关系数据库mysql、oracle等存储的数据，也可以搜索和聚合，但是在数据聚合分析一块，毕竟不是它们的强项，而且需要在程序中做大量的处理，耗时费力，尤其是大数据量的环境下就有些力有未逮了。
但在es中，由于内置了聚合统计的相关功能，只需要使用好它的语法即可达到几近及时的聚合统计，和搜索花费时间根本上没有太大差异，因此使用es很适合在数据量大的业务场景下做聚合统计与分析。
高阶概念

• Buckets(桶/聚集):满足特定条件的文档的聚集
  
• Metrics(指标):对桶内的文档举行统计盘算(比方最小值,求和,最大值等)
  

在聚合统计分析中，使用很频仍的一个名词叫 aggs，它是聚合的关键词之一，下面就用实行来演示一下使用aggs举行数据聚合的多种场景。
1、实行准备数据，首先往es整合批量插入一些实行数据，这里我们以一个家电卖场的电视为背景举行模拟
设定文档中field的相关分词属性。

1. PUT http://192.168.56.235:9201/demo2
3. {
4.         "setting":{
5.                 "index":{
6.                         "number_of_shards":5,
7.                         "number_of_replicats":1
8.                 }
9.         },
10.         "mappings":{
11.                 "sales":{
12.                         "properties":{
13.                                 "price":{
14.                                         "type":"long"
15.                                 },
16.                                 "color":{
17.                                         "type":"keyword"
18.                                 },
19.                                 "brand":{
20.                                         "type":"keyword"
21.                                 },
22.                                 "sold_date":{
23.                                         "type":"date"
24.                                 }
25.                         }
26.                 }
27.         }
28. }

复制代码

2、批量插入数据

1. POST http://192.168.56.235:9201/demo2/sales
2.                
3. { "price" : 1000, "color" : "红色", "brand" : "长虹", "sold_date" : "2016-10-28" }
4. { "price" : 2000, "color" : "红色", "brand" : "长虹", "sold_date" : "2016-11-05" }
5. { "price" : 3000, "color" : "绿色", "brand" : "小米", "sold_date" : "2017-05-18" }
6. { "price" : 1500, "color" : "蓝色", "brand" : "TCL", "sold_date" : "2017-07-02" }
7. { "price" : 1200, "color" : "绿色", "brand" : "TCL", "sold_date" : "2018-08-19" }
8. { "price" : 2000, "color" : "红色", "brand" : "长虹", "sold_date" : "2017-11-05" }
9. { "price" : 8000, "color" : "红色", "brand" : "三星", "sold_date" : "2017-01-01" }
10. { "price" : 2500, "color" : "蓝色", "brand" : "小米", "sold_date" : "2018-02-12" }

复制代码

数据准备完毕

2、按照颜色分组统计各种颜色电视的数量
查询语法如下：

1. GET http://192.168.56.235:9201/demo2/sales/_search
2. {
3.         "size":0,
4.         "aggs":{
5.                 "group_color":{
6.                         "terms":{
7.                                 "field":"color"
8.                         }
9.                 }
10.         }
11. }

复制代码

查询结果如下，这里简朴对此中的几个参数和结果名称做一下阐明。
在查询语句中：

• size:0表示聚合查询的结果不需要返回中央的文档内容，
  
• group_color 我们自定义的分组名字，最好是见名知意的
  

在返回结果中：

• hits:{},这部分存放的是返回结果的根本统计结果，如果上面的size制指定了不为0，文档内容则会放在这个里面
  
• buckets：存放聚合后的统计结果详细信息，以key-value的形式显现
  

3、按照颜色分组统计各种颜色电视的数量，并在此基础上，统计出各种颜色电视的匀称代价
分析：
   按照color去分bucket，可以拿到每个color bucket中的数量，这个仅仅只是一个bucket操作， doc_count其实只是es的bucket操作默认实行的一个内置metric。
    在一个aggs实行的bucket操作（terms），平级的json布局下，再加一个aggs，这个第二个aggs内部，同样取个名字，实行一个metric操作，avg，对之前的每个bucket中的数据的指定的field、price
field，求一个匀称值
  就是一个metric，就是一个对一个bucket分组操作之后，对每个bucket都要实行的一个metric，也可以明白乐成嵌套聚合，在es中获取到某个指标的数据后，继续对这个指标的数据举行其他聚合分析也被叫做下钻
该需求查询语句如下：

1. {
2.         "size":0,
3.         "aggs":{
4.                 "group_color":{
5.                         "terms":{
6.                                 "field":"color"
7.                         },
8.                         "aggs":{
9.                                 "avg_color_price":{
10.                                         "avg":{
11.                                                 "field":"price"
12.                                         }
13.                                 }
14.                         }
15.                 }
16.         }
17. }

复制代码

返回结果如下，通过结果可以很清晰的看出来，在颜色统计分析的基础上，每一个{}里面还增长了一个指标，即自定义的盘算匀称值的avg_color_price，这个查询几乎是毫秒级的，根本没有延迟，如果转化为sql查询应该是这样的：

1. select avg(price) from tvs.sales group by color

复制代码

4、根据颜色分组，求出每种颜色的电视代价的最大值，最小值，匀称值

1. {
2.         "size":0,
3.         "aggs":{
4.                 "group_by_color":{
5.                         "terms":{
6.                                 "field":"color"
7.                         },
8.                         "aggs":{
9.                                 "max_price":{
10.                                         "max":{
11.                                                 "field":"price"
12.                                         }
13.                                 },
14.                                 "min_price":{
15.                                         "min":{
16.                                                 "field":"price"
17.                                         }
18.                                 },
19.                                 "avg_price":{
20.                                         "avg":{
21.                                                 "field":"price"
22.                                         }
23.                                 }
24.                         }
25.                 }
26.         }
27. }

复制代码

所得结果如下：

1. {
2.     "took": 4,
3.     "timed_out": false,
4.     "_shards": {
5.         "total": 5,
6.         "successful": 5,
7.         "skipped": 0,
8.         "failed": 0
9.     },
10.     "hits": {
11.         "total": 7,
12.         "max_score": 0,
13.         "hits": []
14.     },
15.     "aggregations": {
16.         "group_by_color": {
17.             "doc_count_error_upper_bound": 0,
18.             "sum_other_doc_count": 0,
19.             "buckets": [
20.                 {
21.                     "key": "红色",
22.                     "doc_count": 4,
23.                     "max_price": {
24.                         "value": 8000
25.                     },
26.                     "min_price": {
27.                         "value": 1000
28.                     },
29.                     "avg_price": {
30.                         "value": 3250
31.                     }
32.                 },
33.                 {
34.                     "key": "蓝色",
35.                     "doc_count": 2,
36.                     "max_price": {
37.                         "value": 2500
38.                     },
39.                     "min_price": {
40.                         "value": 1500
41.                     },
42.                     "avg_price": {
43.                         "value": 2000
44.                     }
45.                 },
46.                 {
47.                     "key": "绿色",
48.                     "doc_count": 1,
49.                     "max_price": {
50.                         "value": 1200
51.                     },
52.                     "min_price": {
53.                         "value": 1200
54.                     },
55.                     "avg_price": {
56.                         "value": 1200
57.                     }
58.                 }
59.             ]
60.         }
61.     }
62. }

复制代码

5、按照差异的代价区间对电视举行分别，并求出每个代价区间的电视的匀称代价
   在es中根据区间间隔分别，有一个叫做 histogram的语法可以帮助我们实行，雷同于terms，也是举行bucket分组操作，吸收一个field，按照这个field的值的各个范围区间，举行bucket分组操作。

1. “histogram”:{
2.         “field”: “price”,
3.         “interval”: 2000
4. },

复制代码

• interval：2000，分别范围，0 ~ 2000，2000 ~ 4000，4000 ~ 6000，6000 ~ 8000，8000 ~ 10000，buckets
  
• 根据price的值，比如2500，看落在哪个区间内，比如2000 ~ 4000，此时就会将这条数据放入2000 ~ 4000对应的谁人bucket中
  
• bucket分别的方法terms，将field值相同的数据分别到一个bucket中
  
• bucket有了之后，一样的，去对每个bucket实行avg，count，sum，max，min，等各种metric操作，聚合分析
  

1. {
2.         "size":0,
3.         "aggs":{
4.                 "interval_price":{
5.                         "histogram":{
6.                                 "field":"price",
7.                                 "interval":2000
8.                                 },
9.                                 "aggs":{
10.                                         "revenue":{
11.                                         "avg":{
12.                                                 "field":"price"
13.                                         }
14.                                 }
15.                         }
16.                 }
17.         }       
18. }

复制代码

查询的结果如下：可以看到，按照2000一个等级将全部电视的代价分别在差异的区间了，并将每个区间的代价匀称值统计了出来

1. {
2.     "took": 7,
3.     "timed_out": false,
4.     "_shards": {
5.         "total": 5,
6.         "successful": 5,
7.         "skipped": 0,
8.         "failed": 0
9.     },
10.     "hits": {
11.         "total": 7,
12.         "max_score": 0,
13.         "hits": []
14.     },
15.     "aggregations": {
16.         "interval_price": {
17.             "buckets": [
18.                 {
19.                     "key": 0,
20.                     "doc_count": 3,
21.                     "revenue": {
22.                         "value": 1233.3333333333333
23.                     }
24.                 },
25.                 {
26.                     "key": 2000,
27.                     "doc_count": 3,
28.                     "revenue": {
29.                         "value": 2166.6666666666665
30.                     }
31.                 },
32.                 {
33.                     "key": 4000,
34.                     "doc_count": 0,
35.                     "revenue": {
36.                         "value": null
37.                     }
38.                 },
39.                 {
40.                     "key": 6000,
41.                     "doc_count": 0,
42.                     "revenue": {
43.                         "value": null
44.                     }
45.                 },
46.                 {
47.                     "key": 8000,
48.                     "doc_count": 1,
49.                     "revenue": {
50.                         "value": 8000
51.                     }
52.                 }
53.             ]
54.         }
55.     }
56. }

复制代码

6、按照差异的时间区间对电视举行分别，并求出每个代价区间的电视的匀称代价
date histogram，按照我们指定的某个date类型的日期field，以及日期interval，按照一定的日期间隔，去分别bucket，这个概念的明白和上一个有点雷同，可以对照明白。
   date interval = 1 month
2017-01-01~2017-01-31，就是一个bucket
2017-02-01~2017-02-28，就是一个bucket
  然后会去扫描每个数据的date field，判定date落在哪个bucket中，就将其放入谁人bucket
2017-01-05，就将其放入2017-01-01~2017-01-31，就是一个bucket
min_doc_count：纵然某个日期interval，2017-01-01~2017-01-31中，一条数据都没有，那么这个区间也是要返回的，不然默认是会过滤掉这个区间的
extended_bounds，min，max：分别bucket的时候，会限定在这个起始日期，和截止日期内
根据上述分析我们构建查询语句

1. {
2.         "size":0,
3.         "aggs":{
4.                 "sales":{
5.                         "date_histogram":{
6.                                 "field":"sold_date",
7.                                 "interval":"month",
8.                                 "format":"yyyy-MM-dd",
9.                                 "min_doc_count":0,
10.                                 "extended_bounds":{
11.                                         "min":"2017-01-01",
12.                                         "max":"2018-12-31"
13.                                 }
14.                         }
15.                 }
16.         }
17. }

复制代码

返回结果如下，按照月份，将指定区间内各个月份的数量做了统计

当然，如果我们以为按照月份统计粒度太细，也可以根据季度对数据举行统计，只需要将month换成quarter即可，查询语法如下：

1. {
2.         "size":0,
3.         "aggs":{
4.                 "sales":{
5.                         "date_histogram":{
6.                                 "field":"sold_date",
7.                                 "interval":"quarter",
8.                                 "format":"yyyy-MM-dd",
9.                                 "min_doc_count":0,
10.                                 "extended_bounds":{
11.                                         "min":"2017-01-01",
12.                                         "max":"2018-12-31"
13.                                 }
14.                         }
15.                 }
16.         }
17. }

复制代码

查询结果如下：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4