es_聚合用法详解

迷南。 2024-03-25 20:30 46阅读 0赞

## 前言 ##

ES统计分析概念

> ES中的聚合查询，类似SQL的SUM/AVG/COUNT/GROUP BY分组查询，主要用于统计分析场景。  
> 下面先介绍ES聚合查询的核心流程和核心概念。

## 1、 ES聚合查询流程 ##

> ES聚合查询类似SQL的GROUP by，一般统计分析主要分为两个步骤：

> 分组 组内聚合  
> 对查询的数据首先进行一轮分组，可以设置分组条件，例如：新生入学，把所有的学生按专业分班，这个分班的过程就是对学生进行了分组。

> 组内聚合，就是对组内的数据进行统计，例如：计算总数、求平均值等等，接上面的例子，学生都按专业分班了，那么就可以统计每个班的学生总数， 这个统计每个班学生总数的计算，就是组内聚合计算。

> 提示：分组类似SQL的group by语句设定的条件，组内聚合，就是在select编写的avg、sum、count统计函数；熟悉SQL语句都知道sum、count这些统计函数不一定要跟group by语句配合使用，单独使用统计函数等同于将所有数据分成一个组，直接对所有数据进行统计。

## 2、 核心概念 ##

> 通过上面的聚合查询流程，下面是ES聚合的核心概念就很容易理解了

### 2.1. 桶 ###

> 满足特定条件的文档的集合，叫做桶。  
> 桶的就是一组数据的集合，对数据分组后，得到一组组的数据，就是一个个的桶。  
> 提示：桶等同于组，分桶和分组是一个意思，ES使用桶代表一组相同特征的数据。

> ES中桶聚合，指的就是先对数据进行分组，ES支持多种分组条件，例如：支持类似SQL的group by根据字段分组，当然ES比SQL更强大，支持更多的分组条件，以满足各种统计需求。

### 2.2.、指标 ###

> 指标指的是对文档进行统计计算方式，又叫指标聚合。  
> 桶内聚合，说的就是先对数据进行分组（分桶），然后对每一个桶内的数据进行指标聚合。  
> 说白了就是，前面将数据经过一轮桶聚合，把数据分成一个个的桶之后，我们根据上面计算指标对桶内的数据进行统计。  
> 常用的指标有：SUM、COUNT、MAX等统计函数。  
> 借助SQL的统计语句理解桶和指标：

SELECT COUNT(*) 
    FROM order
    GROUP BY shop_id

> 说明：  
> COUNT(*) 相当于指标, 也叫统计指标。  
> GROUP BY shop\_id 相当于分桶的条件，也可以叫分组条件，相同shop\_id的数据都分到一个桶内。  
> 这条SQL语句的作用就是统计每一个店铺的订单数，所以SQL统计的第一步是根据group by shop\_id这个条件，把shop\_id（店铺ID）相同的数据分到一个组（桶）里面，然后每一组数据使用count(*)统计函数（指标）计算总数，最终得到每一个店铺的订单总数，ES也是类似的过程。

## 3、ES聚合查询语法 ##

> 大家可以先大致了解下ES聚合查询的基本语法结构

{
        
      "aggregations" : {
        
        "<aggregation_name>" : {
        
            "<aggregation_type>" : {
        
                <aggregation_body>
            }
            [,"aggregations" : {
         [<sub_aggregation>]+ } ]? // 嵌套聚合查询，支持多层嵌套
        }
        [,"<aggregation_name_2>" : {
         ... } ]* // 多个聚合查询，每个聚合查询取不同的名字
      }
    }

> 说明：  
> aggregations - 代表聚合查询语句，可以简写为aggs  
> <aggregation\_name> - 代表一个聚合计算的名字，可以随意命名，因为ES支持一次进行多次统计分析查询，后面需要通过这个名字在查询结果中找到我们想要的计算结果。  
> <aggregation\_type> - 聚合类型，代表我们想要怎么统计数据，主要有两大类聚合类型，桶聚合和指标聚合，这两类聚合又包括多种聚合类型，例如：指标聚合：sum、avg， 桶聚合：terms、Date histogram等等。  
> <aggregation\_body> - 聚合类型的参数，选择不同的聚合类型，有不同的参数。  
> aggregation\_name\_2 - 代表其他聚合计算的名字，意思就是可以一次进行多种类型的统计。  
> 下面看个简单的聚合查询的例子：  
> 假设存在一个order索引，存储了每一笔汽车销售订单，里面包含了汽车颜色字段color.

GET /order/_search
    {
        
        "size" : 0, // 设置size=0的意思就是，仅返回聚合查询结果，不返回普通query查询结果。
        "aggs" : {
         // 聚合查询语句的简写
            "popular_colors" : {
         // 给聚合查询取个名字，叫popular_colors
                "terms" : {
         // 聚合类型为，terms，terms是桶聚合的一种，类似SQL的group by的作用，根据字段分组，相同字段值的文档分为一组。
                  "field" : "color" // terms聚合类型的参数，这里需要设置分组的字段为color，根据color分组
                }
            }
        }
    }

> 上面使用了terms桶聚合，而且没有明确指定指标聚合函数，默认使用的是Value Count聚合指标统计文档总数， 整个统计的意思是统计每一种汽车颜色的销量。  
> 等价SQL如下：

select count(color) from order group by color
    {
        
    ...
       "hits": {
         // 因为size=0,所以query查询结果为空
          "hits": [] 
       },
       "aggregations": {
         // 聚合查询结果
          "popular_colors": {
         // 这个就是popular_colors聚合查询的结果，这就是为什么需要给聚合查询取个名字的原因，如果有多个聚合查询，可以通过名字查找结果
             "buckets": [ // 因为是桶聚合，所以看到返回一个buckets数组，代表分组的统计情况，下面可以看到每一种颜色的销量情况
                {
        
                   "key": "red", 
                   "doc_count": 4 // 红色的汽车销量为4
                },
                {
        
                   "key": "blue",
                   "doc_count": 2
                },
                {
        
                   "key": "green",
                   "doc_count": 2
                }
             ]
          }
       }
    }

## 4、指标聚合 ##

> ES指标聚合，就是类似SQL的统计函数，指标聚合可以单独使用，也可以跟桶聚合一起使用。  
> 常用的统计函数如下：  
> Value Count - 类似sql的count函数，统计总数  
> Cardinality - 类似SQL的count(DISTINCT 字段)， 统计不重复的数据总数  
> Avg - 求平均值  
> Sum - 求和  
> Max - 求最大值  
> Min - 求最小值  
> 下面分别介绍Elasticsearch常用统计函数的用法。

### 4.1、Value Count ###

> 值聚合，主要用于统计文档总数，类似SQL的count函数。  
> 例子：

GET /sales/_search?size=0
    {
        
      "aggs": {
        
        "types_count": {
         // 聚合查询的名字，随便取个名字
          "value_count": {
         // 聚合类型为：value_count
            "field": "type" // 计算type这个字段值的总数
          }
        }
      }
    }

> 等价SQL：  
> select count(type) from sales

> 返回结果：

{
        
        ...
        "aggregations": {
        
            "types_count": {
         // 聚合查询的名字
                "value": 7 // 统计结果
            }
        }
    }

### 4.2、Cardinality ###

> 基数聚合，也是用于统计文档的总数，跟Value Count的区别是，基数聚合会去重，不会统计重复的值，类似SQL的count(DISTINCT 字段)用法。  
> 例子：

POST /sales/_search?size=0
    {
        
        "aggs" : {
        
            "type_count" : {
         // 聚合查询的名字，随便取一个
                "cardinality" : {
         // 聚合查询类型为：cardinality
                    "field" : "type" // 根据type这个字段统计文档总数
                }
            }
        }
    }

等价SQL：

select count(DISTINCT type) from sales

{
        
        ...
        "aggregations" : {
        
            "type_count" : {
         // 聚合查询的名字
                "value" : 3 // 统计结果
            }
        }
    }

> 提示：前面提到基数聚合的作用等价于SQL的count(DISTINCT 字段)的用法，其实不太准确，因为SQL的count统计结果是精确统计不会丢失精度，但是ES的cardinality基数聚合统计的总数是一个近似值，会有一定的误差，这么做的目的是为了性能，因为在海量的数据中精确统计总数是非常消耗性能的，但是很多业务场景不需要精确的结果，只要近似值，例如：统计网站一天的访问量，有点误差没关系。

### 4.3、Avg ###

> 求平均值  
> 例子:

POST /exams/_search?size=0
    {
        
      "aggs": {
        
        "avg_grade": {
         // 聚合查询名字，随便取一个名字
          "avg": {
         // 聚合查询类型为: avg
            "field": "grade" // 统计grade字段值的平均值
          }
        }
      }
    }

> 返回结果：

{
        
        ...
        "aggregations": {
        
            "avg_grade": {
         // 聚合查询名字
                "value": 75.0 // 统计结果
            }
        }
    }

### 4.4、Sum ###

> 求和计算  
> 例子:

POST /sales/_search?size=0
    {
        
      "aggs": {
        
        "hat_prices": {
         // 聚合查询名字，随便取一个名字
          "sum": {
         // 聚合类型为：sum
            "field": "price" // 计算price字段值的总和
          }
        }
      }
    }

> 返回结果：

{
        
        ...
        "aggregations": {
        
            "hat_prices": {
         // 聚合查询名字
               "value": 450.0 // 统计结果
            }
        }
    }

### 4.5.Max ###

> 求最大值  
> 例子:

POST /sales/_search?size=0
    {
        
      "aggs": {
        
        "max_price": {
         // 聚合查询名字,随便取一个名字
          "max": {
         // 聚合类型为：max
            "field": "price" // 求price字段的最大值
          }
        }
      }
    }

> 返回结果:

{
        
        ...
        "aggregations": {
        
            "max_price": {
         // 聚合查询名字
                "value": 200.0 // 最大值
            }
        }
    }

### 4.6.Min ###

> 求最小值  
> 例子:

POST /sales/_search?size=0
    {
        
      "aggs": {
        
        "min_price": {
         // 聚合查询名字，随便取一个
          "min": {
         // 聚合类型为: min
            "field": "price" // 求price字段值的最小值
          }
        }
      }
    }

> 返回:

{
        
        ...
    
        "aggregations": {
        
            "min_price": {
         // 聚合查询名字
                "value": 10.0 // 最小值
            }
        }
    }

### 4.7.综合例子 ###

> 前面的例子，仅仅介绍聚合指标单独使用的情况，实际应用中经常先通过query查询，搜索索引中的数据，然后对query查询的结果进行统计分析。  
> 例子：

GET /sales/_search
    {
        
      "size": 0, // size = 0,代表不想返回query查询结果，只要统计结果
      "query": {
         // 设置query查询条件，后面的aggs统计，仅对query查询结果进行统计
        "constant_score": {
        
          "filter": {
        
            "match": {
        
              "type": "hat"
            }
          }
        }
      },
      "aggs": {
         // 统计query查询结果, 默认情况如果不写query语句，则代表统计所有数据
        "hat_prices": {
         // 聚合查询名字，计算price总和
          "sum": {
        
            "field": "price"
          }
        },
        "min_price": {
         // 聚合查询名字，计算price最小值
          "min": {
         
            "field": "price" 
          }
        },
        "max_price": {
         // 聚合查询名字，计算price最大值
          "max": {
         
            "field": "price"
          }
        }
      }
    }

> 返回:

{
        
        ...
        "aggregations": {
        
            "hat_prices": {
         // 求和
               "value": 450.0
            },
            "min_price": {
         // 最小值
                "value": 10.0 
            },
            "max_price": {
         // 最大值
                "value": 200.0 
            }
        }
    }

## 5、分组聚合查询 ##

> Elasticsearch桶聚合，目的就是数据分组，先将数据按指定的条件分成多个组，然后对每一个组进行统计。 组的概念跟桶是等同的，在ES中统一使用桶（bucket）这个术语。

> ES桶聚合的作用跟SQL的group by的作用是一样的，区别是ES支持更加强大的数据分组能力，SQL只能根据字段的唯一值进行分组，分组的数量跟字段的唯一值的数量相等，例如: group by 店铺id， 去掉重复的店铺ID后，有多少个店铺就有多少个分组。

> ES常用的桶聚合如下：  
> Terms聚合 - 类似SQL的group by，根据字段唯一值分组  
> Histogram聚合 - 根据数值间隔分组，例如: 价格按100间隔分组，0、100、200、300等等  
> Date histogram聚合 - 根据时间间隔分组，例如：按月、按天、按小时分组  
> Range聚合 - 按数值范围分组，例如: 0-150一组，150-200一组，200-500一组。  
> 提示：桶聚合一般不单独使用，都是配合指标聚合一起使用，对数据分组之后肯定要统计桶内数据，在ES中如果没有明确指定指标聚合，默认使用Value Count指标聚合，统计桶内文档总数。

### 5.1、Terms聚合 ###

> terms聚合的作用跟SQL中group by作用一样，都是根据字段唯一值对数据进行分组（分桶），字段值相等的文档都分到同一个桶内。  
> 例子：

GET /order/_search?size=0
    {
        
      "aggs": {
        
        "shop": {
         // 聚合查询的名字，随便取个名字
          "terms": {
         // 聚合类型为: terms
            "field": "shop_id" // 根据shop_id字段值，分桶
          }
        }
      }
    }

> 等价SQL：  
> select shop\_id, count(\*) from order group by shop\_id

> 返回结果:

{
        
        ...
        "aggregations" : {
        
            "shop" : {
         // 聚合查询名字
                "buckets" : [ // 桶聚合结果，下面返回各个桶的聚合结果
                    {
        
                        "key" : "1", // key分桶的标识，在terms聚合中，代表的就是分桶的字段值
                        "doc_count" : 6 // 默认的指标聚合是统计桶内文档总数
                    },
                    {
        
                        "key" : "5",
                        "doc_count" : 3
                    },
                    {
        
                        "key" : "9",
                        "doc_count" : 2
                    }
                ]
            }
        }
    }

### 5.2、Histogram聚合 ###

> histogram（直方图）聚合，主要根据数值间隔分组，使用histogram聚合分桶统计结果，通常用在绘制条形图报表。  
> 例子：

POST /sales/_search?size=0
    {
        
        "aggs" : {
        
            "prices" : {
         // 聚合查询名字，随便取一个
                "histogram" : {
         // 聚合类型为：histogram
                    "field" : "price", // 根据price字段分桶
                    "interval" : 50 // 分桶的间隔为50，意思就是price字段值按50间隔分组
                }
            }
        }
    }

> 返回结果：

{
        
        ...
        "aggregations": {
        
            "prices" : {
         // 聚合查询名字
                "buckets": [ // 分桶结果
                    {
        
                        "key": 0.0, // 桶的标识，histogram分桶，这里通常是分组的间隔值
                        "doc_count": 1 // 默认按Value Count指标聚合，统计桶内文档总数
                    },
                    {
         
                        "key": 50.0,
                        "doc_count": 1
                    },
                    {
        
                        "key": 100.0,
                        "doc_count": 0
                    },
                    {
        
                        "key": 150.0,
                        "doc_count": 2
                    }
                ]
            }
        }
    }

### 5.3、Date histogram聚合 ###

> 类似histogram聚合，区别是Date histogram可以很好的处理时间类型字段，主要用于根据时间、日期分桶的场景。  
> 例子：

POST /sales/_search?size=0
    {
        
        "aggs" : {
        
            "sales_over_time" : {
         // 聚合查询名字，随便取一个
                "date_histogram" : {
         // 聚合类型为: date_histogram
                    "field" : "date", // 根据date字段分组
                    "calendar_interval" : "month", // 分组间隔：month代表每月、支持minute（每分钟）、hour（每小时）、day（每天）、week（每周）、year（每年）
                    "format" : "yyyy-MM-dd" // 设置返回结果中桶key的时间格式
                }
            }
        }
    }

> 返回结果:

{
        
        ...
        "aggregations": {
        
            "sales_over_time": {
         // 聚合查询名字
                "buckets": [ // 桶聚合结果
                    {
        
                        "key_as_string": "2015-01-01", // 每个桶key的字符串标识，格式由format指定
                        "key": 1420070400000, // key的具体字段值
                        "doc_count": 3 // 默认按Value Count指标聚合，统计桶内文档总数
                    },
                    {
        
                        "key_as_string": "2015-02-01",
                        "key": 1422748800000,
                        "doc_count": 2
                    },
                    {
        
                        "key_as_string": "2015-03-01",
                        "key": 1425168000000,
                        "doc_count": 2
                    }
                ]
            }
        }
    }

### 5.4、Range聚合 ###

> range聚合，按数值范围分桶。  
> 例子：

GET /_search
    {
        
        "aggs" : {
        
            "price_ranges" : {
         // 聚合查询名字，随便取一个
                "range" : {
         // 聚合类型为： range
                    "field" : "price", // 根据price字段分桶
                    "ranges" : [ // 范围配置
                        {
         "to" : 100.0 }, // 意思就是 price <= 100的文档归类到一个桶
                        {
         "from" : 100.0, "to" : 200.0 }, // price>100 and price<200的文档归类到一个桶
                        {
         "from" : 200.0 } // price>200的文档归类到一个桶
                    ]
                }
            }
        }
    }

> 返回结果:

{
        
        ...
        "aggregations": {
        
            "price_ranges" : {
         // 聚合查询名字
                "buckets": [ // 桶聚合结果
                    {
        
                        "key": "*-100.0", // key可以表达分桶的范围
                        "to": 100.0, // 结束值
                        "doc_count": 2 // 默认按Value Count指标聚合，统计桶内文档总数
                    },
                    {
        
                        "key": "100.0-200.0",
                        "from": 100.0, // 起始值
                        "to": 200.0, // 结束值
                        "doc_count": 2
                    },
                    {
        
                        "key": "200.0-*",
                        "from": 200.0,
                        "doc_count": 3
                    }
                ]
            }
        }
    }

> 大家仔细观察的话，发现range分桶，默认key的值不太友好，尤其开发的时候，不知道key长什么样子，处理起来比较麻烦，我们可以为每一个分桶指定一个有意义的名字。  
> 例子:

GET /_search
    {
        
        "aggs" : {
        
            "price_ranges" : {
        
                "range" : {
        
                    "field" : "price",
                    "keyed" : true,
                    "ranges" : [
                        // 通过key参数，配置每一个分桶的名字
                        {
         "key" : "cheap", "to" : 100 },
                        {
         "key" : "average", "from" : 100, "to" : 200 },
                        {
         "key" : "expensive", "from" : 200 }
                    ]
                }
            }
        }
    }

### 5.5、综合例子 ###

> 前面的例子，都是单独使用aggs聚合语句，代表直接统计所有的文档，实际应用中，经常需要配合query语句，先搜索目标文档，然后使用aggs聚合语句对搜索结果进行统计分析。  
> 例子:

GET /cars/_search
    {
        
        "size": 0, // size=0代表不需要返回query查询结果，仅仅返回aggs统计结果
        "query" : {
         // 设置查询语句，先赛选文档
            "match" : {
        
                "make" : "ford"
            }
        },
        "aggs" : {
         // 然后对query搜索的结果，进行统计
            "colors" : {
         // 聚合查询名字
                "terms" : {
         // 聚合类型为：terms 先分桶
                  "field" : "color"
                },
                "aggs": {
         // 通过嵌套聚合查询，设置桶内指标聚合条件
                  "avg_price": {
         // 聚合查询名字
                    "avg": {
         // 聚合类型为: avg指标聚合
                      "field": "price" // 根据price字段计算平均值
                    }
                  },
                  "sum_price": {
         // 聚合查询名字
                    "sum": {
         // 聚合类型为: sum指标聚合
                      "field": "price" // 根据price字段求和
                    }
                  }
                }
            }
        }
    }

> 聚合查询支持多层嵌套。

## 6、聚合后排序 ##

> 类似terms、histogram、date\_histogram这类桶聚合都会动态生成多个桶，如果生成的桶特别多，我们如何确定这些桶的排序顺序，如何限制返回桶的数量。

### 6.1、多桶排序 ###

> 默认情况，ES会根据doc\_count文档总数，降序排序。  
> ES桶聚合支持两种方式排序：  
> 内置排序  
> 按度量指标排序

> 内置排序，内置排序参数：  
> \_count - 按文档数排序。对 terms 、 histogram 、 date\_histogram 有效  
> \_term - 按词项的字符串值的字母顺序排序。只在 terms 内使用  
> \_key - 按每个桶的键值数值排序, 仅对 histogram 和 date\_histogram 有效  
> 例子:

GET /cars/_search
    {
        
        "size" : 0,
        "aggs" : {
        
            "colors" : {
         // 聚合查询名字，随便取一个
                "terms" : {
         // 聚合类型为: terms
                  "field" : "color", 
                  "order": {
         // 设置排序参数
                    "_count" : "asc"  // 根据_count排序，asc升序，desc降序
                  }
                }
            }
        }
    }

### 6.2、按度量排序 ###

> 通常情况下，我们根据桶聚合分桶后，都会对桶内进行多个维度的指标聚合，所以我们也可以根据桶内指标聚合的结果进行排序。  
> 例子:  
> GET

GET /cars/_search
    {
        
        "size" : 0,
        "aggs" : {
        
            "colors" : {
         // 聚合查询名字
                "terms" : {
         // 聚合类型: terms，先分桶
                  "field" : "color", // 分桶字段为color
                  "order": {
         // 设置排序参数
                    "avg_price" : "asc"  // 根据avg_price指标聚合结果，升序排序。
                  }
                },
                "aggs": {
         // 嵌套聚合查询，设置桶内聚合指标
                    "avg_price": {
         // 聚合查询名字，前面排序引用的就是这个名字
                        "avg": {
        "field": "price"} // 计算price字段平均值
                    }
                }
            }
        }
    }

### 6.3、限制返回桶的数量 ###

> 如果分桶的数量太多，可以通过给桶聚合增加一个size参数限制返回桶的数量。  
> 例子:

GET /_search
    {
        
        "aggs" : {
        
            "products" : {
         // 聚合查询名字
                "terms" : {
         // 聚合类型为: terms
                    "field" : "product", // 根据product字段分桶
                    "size" : 5 // 限制最多返回5个桶
                }
            }
        }
    }