ElasticSearch 聚合搜索总结

最新推荐文章于 2024-03-10 23:31:21 发布
最新推荐文章于 2024-03-10 23:31:21 发布
阅读量443 收藏 1
点赞数
文章标签： 大数据 java python
原文链接：https://my.oschina.net/LucasZhu/blog/1504396
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

ES的聚合项目：有相关基于ElasticSearch5.6v Java API 的各种用法

源码地址： GitHub

聚合概念

聚合(Aggregations)也拥有一种可组合(Composable)的语法：独立的功能单元可以被混合在一起来满足你的需求。这意味着需要学习的基本概念虽然不多，但是它们的组合方式是几近无穷的。

为了掌握聚合，你只需要了解两个主要概念：

Buckets(桶)：

满足某个条件的文档集合。

Metrics(指标)：

为某个桶中的文档计算得到的统计信息。

就是这样！每个聚合只是简单地由一个或者多个桶，零个或者多个指标组合而成。可以将它粗略地转换为SQL：

SELECT COUNT(color) 
FROM table
GROUP BY color

以上的COUNT(color)就相当于指标。GROUP BY color则相当于桶。

桶和SQL中的组(Grouping)拥有相似的概念，而指标则与COUNT()，SUM()，MAX()等相似。

桶(Buckets)

一个桶就是满足特定条件的一个文档集合：

  • 一名员工要么属于男性桶，或者女性桶。
  • 城市Albany属于New York州这个桶。
  • 日期2014-10-28属于十月份这个桶。

指标(Metrics)

桶能够让我们对文档进行有意义的划分，但是最终我们还是需要对每个桶中的文档进行某种指标计算。分桶是达到最终目的的手段：提供了对文档进行划分的方法，从而让你能够计算需要的指标。

多数指标仅仅是简单的数学运算(比如，min，mean，max以及sum)，它们使用文档中的值进行计算。在实际应用中，指标能够让你计算例如平均薪资，最高出售价格，或者百分之95的查询延迟。

将两者结合起来

一个聚合就是一些桶和指标的组合。一个聚合可以只有一个桶，或者一个指标，或者每样一个。在桶中甚至可以有多个嵌套的桶。比如，我们可以将文档按照其所属国家进行分桶，然后对每个桶计算其平均薪资(一个指标)。

因为桶是可以嵌套的，我们能够实现一个更加复杂的聚合操作：

  1. 将文档按照国家进行分桶。(桶)
  2. 然后将每个国家的桶再按照性别分桶。(桶)
  3. 然后将每个性别的桶按照年龄区间进行分桶。(桶)
  4. 最后，为每个年龄区间计算平均薪资。(指标)

此时，就能够得到每个<国家，性别，年龄>组合的平均薪资信息了。它可以通过一个请求，一次数据遍历来完成！

聚合的测试数据(Aggregation Test-Drive)

让我们从一个例子开始。我们会建立一个也许对汽车交易商有所用处的聚合。数据是关于汽车交易的：汽车型号，制造商，销售价格，销售时间以及一些其他的相关数据。

首先，通过批量索引(Bulk-Index)来添加一些数据：

PUT http://node1:9200/cars
{
	"mappings":{
		"transactions":{
			"properties":{
				"price":{
					"type":"integer"
				},
				"color":{
					"type":"keyword"
				},
				"make":{
					"type":"keyword"
				},
				"sold":{
					"type":"date"
				}
			}
		}
	}
}
或者===========================================================
{
	"mappings":{
		"transactions":{
			"properties":{
				"price":{
					"type":"integer"
				},
				"color":{
					"type":"text",
					"fielddata":true
				},
				"make":{
					"type":"text",
					"fielddata":true
				},
				"sold":{
					"type":"date"
				}
			}
		}
	}
}



POST http://node1:9200/cars/transactions/_bulk
{ "index": {}}
{ "price" : 10000, "color" : "red", "make" : "honda", "sold" : "2014-10-28" }
{ "index": {}}
{ "price" : 20000, "color" : "red", "make" : "honda", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 30000, "color" : "green", "make" : "ford", "sold" : "2014-05-18" }
{ "index": {}}
{ "price" : 15000, "color" : "blue", "make" : "toyota", "sold" : "2014-07-02" }
{ "index": {}}
{ "price" : 12000, "color" : "green", "make" : "toyota", "sold" : "2014-08-19" }
{ "index": {}}
{ "price" : 20000, "color" : "red", "make" : "honda", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 80000, "color" : "red", "make" : "bmw", "sold" : "2014-01-01" }
{ "index": {}}
{ "price" : 25000, "color" : "blue", "make" : "ford", "sold" : "2014-02-12" }

因为我们并不关心搜索结果，所以size:0 。聚合工作在顶层的aggs参数下(当然你也可以使用更长的aggregations)。 然后给这个聚合起了一个名字：colors。 最后，我们定义了一个terms类型的桶，它针对color字段。

聚合是以搜索结果为上下文而执行的，这意味着它是搜索请求中的另一个顶层参数(Top-level Parameter)。聚合可以和查询同时使用，这一点我们在后续的范围聚合(Scoping Aggregations)中介绍。

接下来我们为聚合起一个名字。命名规则是有你决定的; 聚合的响应会被该名字标记，因此在应用中你就能够根据名字来得到聚合结果，并对它们进行操作了。

然后，我们开始定义聚合本身。比如，我们定义了一个terms类型的桶。terms桶会动态地为每一个它遇到的不重复的词条创建一个新的桶。因为我们针对的是color字段，那么terms桶会动态地为每种颜色创建一个新桶。

如果执行出现报错,搜了一下应该是5.x后对排序，聚合这些操作用单独的数据结构(fielddata)缓存到内存里了，需要单独开启，简单来说就是在聚合前执行如下操作

让我们执行该聚合来看看其结果：

{
    "took": 27,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "colors": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "red",
                    "doc_count": 4
                },
                {
                    "key": "green",
                    "doc_count": 2
                },
                {
                    "key": "blue",
                    "doc_count": 1
                }
            ]
        }
    }
}

因为我们使用的size为0，所以没有搜索结果被返回。 每个桶中的key对应的是在color字段中找到的不重复的词条。它同时也包含了一个doc_count，用来表示包含了该词条的文档数量。

响应包含了一个桶列表，每个桶都对应着一个不重复的颜色(比如，红色或者绿色)。每个桶也包含了“掉入”该桶中的文档数量。比如，有4辆红色的车。

前面的例子是完全实时(Real-Time)的：如果文档是可搜索的，那么它们就能够被聚合。这意味着你能够将拿到的聚合结果置入到一个图形库中来生成实时的仪表板(Dashboard)。一旦你卖出了一台银色汽车，在图形上关于银色汽车的统计数据就会被动态地更新。

添加一个指标(Metric)

从前面的例子中，我们可以知道每个桶中的文档数量。但是，通常我们的应用会需要基于那些文档的更加复杂的指标(Metric)。比如，每个桶中的汽车的平均价格是多少？

为了得到该信息，我们得告诉ES需要为哪些字段计算哪些指标。这需要将指标嵌套到桶中。指标会基于桶中的文档的值来计算相应的统计信息。

让我们添加一个计算平均值的指标：

GET /cars/transactions/_search
{
    "size": 0,
    "aggs" : { 
        "colors" : { 
            "terms" : {
              "field" : "color" 
            },
            "aggs":{
            	"avg_price":{
            		"avg":{
            			"field":"price"
            		}
            	}
            }
        }
    }
}

我们添加了一个新的aggs层级来包含该指标。然后给该指标起了一个名字：avg_price。最后定义了该指标作用的字段为price。

正如你所看到的，我们向前面的例子中添加了一个新的aggs层级。这个新的聚合层级能够让我们将avg指标嵌套在terms桶中。这意味着我们能为每种颜色都计算一个平均值。

同样的，我们需要给指标起一个名(avg_price)来让我们能够在将来得到其值。最后，我们指定了指标本身(avg)以及该指标作用的字段(price)：

{
    "took": 29,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "colors": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "red",
                    "doc_count": 4,
                    "avg_price": {
                        "value": 32500
                    }
                },
                {
                    "key": "green",
                    "doc_count": 2,
                    "avg_price": {
                        "value": 21000
                    }
                },
                {
                    "key": "blue",
                    "doc_count": 1,
                    "avg_price": {
                        "value": 15000
                    }
                }
            ]
        }
    }
}

桶定义及指标定义都是通过aggs来进行的 但是定义关键字不同，一个是terms桶定义 ，一个是avg等指标定义符

现在，在响应中多了一个avg_price元素。

尽管得到的响应只是稍稍有些变化，但是获得的数据增加的了许多。之前我们只知道有4辆红色汽车。现在我们知道了红色汽车的平均价格是32500刀。这些数据你可以直接插入到报表中。

桶中的桶(Buckets inside Buckets)

桶中桶，桶必须有自己的名字，桶中的指标也必须有自己的名字。

当你开始使用不同的嵌套模式时，聚合强大的能力才会显现出来。在前面的例子中，我们已经知道了如何将一个指标嵌套进一个桶的，它的功能已经十分强大了。

但是真正激动人心的分析功能来源于嵌套在其它桶中的桶。现在，让我们来看看如何找到每种颜色的汽车的制造商分布信息：

POST http://node1:9200/cars/transactions/_search
{
   "aggs": 
   {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": 
         {
            "avg_price": { 
               "avg": {
                  "field": "price"
               }
            },
            "make": { 
                "terms": {
                    "field": "make" 
                }
            }
         } 
      }
   },
   "size": 0
}

此时发生了一些有意思的事情。首先，你会注意到前面的avg_price指标完全没有变化。一个聚合的每个层级都能够拥有多个指标或者桶。avg_price指标告诉了我们每种汽车颜色的平均价格。为每种颜色创建的桶和指标是各自独立的。

这个性质对你的应用而言是很重要的，因为你经常需要收集一些互相关联却又完全不同的指标。聚合能够让你对数据遍历一次就得到所有需要的信息。

另外一件重要的事情是添加了新聚合make，它是一个terms类型的桶(嵌套在名为colors的terms桶中)。这意味着我们会根据数据集创建不重复的(color, make)组合。

每个桶中添加桶 或者 计算所在桶的集合函数 必须在与桶名称下一级声明 aggs（同级有所在桶的terms声明） ，然后再aggs下级定义 桶的名称 或者 函数的名称， 也可以在aggs 下级同时进行桶中桶的定义 和 桶中函数的定义。如上面例子：

在colors桶中添加桶make:首先在colors 中声明aggs ,然后在aggs 声明新的桶的名称make,make下级利用terms定义该桶按什么分。

让我们来看看得到的响应：

{
    "took": 26,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "colors": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "red",
                    "doc_count": 4,
                    "avg_price": {
                        "value": 32500
                    },
                    "make": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "honda",
                                "doc_count": 3
                            },
                            {
                                "key": "bmw",
                                "doc_count": 1
                            }
                        ]
                    }
                },
                {
                    "key": "green",
                    "doc_count": 2,
                    "avg_price": {
                        "value": 21000
                    },
                    "make": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "ford",
                                "doc_count": 1
                            },
                            {
                                "key": "toyota",
                                "doc_count": 1
                            }
                        ]
                    }
                },
                {
                    "key": "blue",
                    "doc_count": 1,
                    "avg_price": {
                        "value": 15000
                    },
                    "make": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "toyota",
                                "doc_count": 1
                            }
                        ]
                    }
                }
            ]
        }
    }
}

该响应告诉了我们如下信息：

有4辆红色汽车。
红色汽车的平均价格是32500美刀。
红色汽车中的3辆是Honda，1辆是BMW。

最后的一个修改(One Final Modification)

为每个制造商添加两个指标来计算最低和最高价格：

POST http://node1:9200/cars/transactions/_search
{
   "aggs": {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": {
            "avg_price": { "avg": { "field": "price" }
            },
            "make" : {
                "terms" : {
                    "field" : "make"
                },
                "aggs" : { 
                    "min_price" : { "min": { "field": "price"} }, 
                    "max_price" : { "max": { "field": "price"} } 
                }
            }
         }
      }
   },
   "size": 0
}

我们需要添加另一个aggs层级来进行对min和max的嵌套。 
得到的响应如下：

{
    "took": 90,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "colors": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "red",
                    "doc_count": 4,
                    "avg_price": {
                        "value": 32500
                    },
                    "make": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "honda",
                                "doc_count": 3,
                                "max_price": {
                                    "value": 20000
                                },
                                "min_price": {
                                    "value": 10000
                                }
                            },
                            {
                                "key": "bmw",
                                "doc_count": 1,
                                "max_price": {
                                    "value": 80000
                                },
                                "min_price": {
                                    "value": 80000
                                }
                            }
                        ]
                    }
                },
                {
                    "key": "green",
                    "doc_count": 2,
                    "avg_price": {
                        "value": 21000
                    },
                    "make": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "ford",
                                "doc_count": 1,
                                "max_price": {
                                    "value": 30000
                                },
                                "min_price": {
                                    "value": 30000
                                }
                            },
                            {
                                "key": "toyota",
                                "doc_count": 1,
                                "max_price": {
                                    "value": 12000
                                },
                                "min_price": {
                                    "value": 12000
                                }
                            }
                        ]
                    }
                },
                {
                    "key": "blue",
                    "doc_count": 1,
                    "avg_price": {
                        "value": 15000
                    },
                    "make": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "toyota",
                                "doc_count": 1,
                                "max_price": {
                                    "value": 15000
                                },
                                "min_price": {
                                    "value": 15000
                                }
                            }
                        ]
                    }
                }
            ]
        }
    }
}

在每个make桶下，多了min和max的指标。

此时，我们可以得到如下信息：

有4辆红色汽车。
红色汽车的平均价格是32500美刀。
红色汽车中的3辆是Honda，1辆是BMW。
红色Honda汽车中，最便宜的价格为10000美刀。
最贵的红色Honda汽车为20000美刀。

直接求值：

POST http://node1:9200/cars/transactions/_search
{
   "aggs": {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": {
            "avg_price": { "avg": { "field": "price" }},
            "min_price" : { "min": { "field": "price"}} , 
            "max_price" : { "max": { "field": "price"}}
         }
      }
   },
   "size": 0
}
==========================================================================================
{
    "took": 62,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "colors": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "red",
                    "doc_count": 4,
                    "max_price": {
                        "value": 80000
                    },
                    "min_price": {
                        "value": 10000
                    },
                    "avg_price": {
                        "value": 32500
                    }
                },
                {
                    "key": "green",
                    "doc_count": 2,
                    "max_price": {
                        "value": 30000
                    },
                    "min_price": {
                        "value": 12000
                    },
                    "avg_price": {
                        "value": 21000
                    }
                },
                {
                    "key": "blue",
                    "doc_count": 1,
                    "max_price": {
                        "value": 15000
                    },
                    "min_price": {
                        "value": 15000
                    },
                    "avg_price": {
                        "value": 15000
                    }
                }
            ]
        }
    }
}

创建条形图(Building Bar Charts)

柱状图桶(Histogram Bucket)非常有用。柱状图在本质上就是条形图，如果你创建过一份报告或者分析面板(Analytics Dashboard)，毫无疑问其中会有一些条形图。柱状图通过指定一个间隔(Interval)来工作。如果我们使用柱状图来表示销售价格，你或许会指定一个值为20000的间隔。因此每20000美刀会创建一个桶。然后文档会被分配到桶中。

对于我们的仪表板，我们想要知道每个价格区间中有多少辆车。同时我们也想知道该价格桶中产生了多少收入。这是通过将该间隔中所有的车的售价累加而计算得到的。

为了达到这一目的，我们使用了一个histogram（柱状图）类型的聚合然后在其中嵌套了一个sum指标：

POST http://node1:9200/cars/transactions/_search
{
   "aggs": {
      "price": {
         "histogram": {
            "field": "price",
            "interval":20000
         },
         "aggs": {
            "revenue":{
            	"sum":{
            		"field":"price"
            	}
            }
         }
      }
   },
   "size": 0
}

正如你能看到的那样，我们的查询是围绕着价格聚合而建立的，该聚合包含了一个柱状图桶。该桶需要一个数值字段以及一个间隔值来进行计算。间隔用来定义每个桶有“多宽”。间隔为20000意味着我们能够拥有区间[0-19999, 20000-39999, 等]。

接下来，我们在柱状图中定义了一个嵌套的指标。它是一个sum类型的指标，会将该区间中的文档的price字段进行累加。这就得到了每个价格区间中的收入，因此我们就能够从中看出是普通车还是豪华车赚的更多。

以下是得到的响应：

{
    "took": 32,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "price": {
            "buckets": [
                {
                    "key": 0,
                    "doc_count": 3,
                    "revenue": {
                        "value": 37000
                    }
                },
                {
                    "key": 20000,
                    "doc_count": 3,
                    "revenue": {
                        "value": 70000
                    }
                },
                {
                    "key": 40000,
                    "doc_count": 0,
                    "revenue": {
                        "value": 0
                    }
                },
                {
                    "key": 60000,
                    "doc_count": 0,
                    "revenue": {
                        "value": 0
                    }
                },
                {
                    "key": 80000,
                    "doc_count": 1,
                    "revenue": {
                        "value": 80000
                    }
                }
            ]
        }
    }
}

从图形上，你可以将前面的数据表示如下：

07205204_DCga.jpg

当然，你可以使用任何生成类别和统计信息的聚合来创建条形图，并不仅限于使用histogram桶。让我们创建一个受欢迎的汽车制造商的条形图，其中包含了它们的平均价格和标准误差(Standard Error)。需要使用的而是terms桶以及一个extended_stats指标：

POST http://node1:9200/cars/transactions/_search
{
  "aggs": {
    "makes": {
      "terms": {
        "field": "make",
        "size": 10
      },
      "aggs": {
        "stats": {
          "extended_stats": {
            "field": "price"
          }
        }
      }
    }
  },
  "size":0
}

它会返回一个制造商列表(根据受欢迎程度排序)以及针对每个制造商的一些列统计信息。其中，我们对stats.avg，stats.count以及stats.std_deviation感兴趣。有了这一信息，我们能够计算出标准误差：

std_err = std_deviation / count
{
    "took": 35,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "makes": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "honda",
                    "doc_count": 3,
                    "stats": {
                        "count": 3,
                        "min": 10000,
                        "max": 20000,
                        "avg": 16666.666666666668,
                        "sum": 50000,
                        "sum_of_squares": 900000000,
                        "variance": 22222222.22222221,
                        "std_deviation": 4714.045207910315,
                        "std_deviation_bounds": {
                            "upper": 26094.757082487296,
                            "lower": 7238.5762508460375
                        }
                    }
                },
                {
                    "key": "toyota",
                    "doc_count": 2,
                    "stats": {
                        "count": 2,
                        "min": 12000,
                        "max": 15000,
                        "avg": 13500,
                        "sum": 27000,
                        "sum_of_squares": 369000000,
                        "variance": 2250000,
                        "std_deviation": 1500,
                        "std_deviation_bounds": {
                            "upper": 16500,
                            "lower": 10500
                        }
                    }
                },
                {
                    "key": "bmw",
                    "doc_count": 1,
                    "stats": {
                        "count": 1,
                        "min": 80000,
                        "max": 80000,
                        "avg": 80000,
                        "sum": 80000,
                        "sum_of_squares": 6400000000,
                        "variance": 0,
                        "std_deviation": 0,
                        "std_deviation_bounds": {
                            "upper": 80000,
                            "lower": 80000
                        }
                    }
                },
                {
                    "key": "ford",
                    "doc_count": 1,
                    "stats": {
                        "count": 1,
                        "min": 30000,
                        "max": 30000,
                        "avg": 30000,
                        "sum": 30000,
                        "sum_of_squares": 900000000,
                        "variance": 0,
                        "std_deviation": 0,
                        "std_deviation_bounds": {
                            "upper": 30000,
                            "lower": 30000
                        }
                    }
                }
            ]
        }
    }
}

07205206_RhcR.jpg

时间数据处理(Looking at Time)

如果在ES中，搜索是最常见的行为，那么创建日期柱状图(Date Histogram)肯定是第二常见的。

 

  • 今年的每个月销售了多少辆车？
  • 过去的12小时中，这只股票的价格是多少？
  • 上周每个小时我们的网站的平均延迟是多少？

常规的histogram通常使用条形图来表示，而date_histogram倾向于被装换为线图(Line Graph)来表达时间序列(Time Series)。很多公司使用ES就是为了对时间序列数据进行分析。

date_histogram的工作方式和常规的histogram类似。常规的histogram是基于数值字段来创建数值区间的桶，而date_histogram则是基于时间区间来创建桶。因此每个桶是按照某个特定的日历时间定义的(比如，1个月或者是2.5天)。

常规Histogram能够和日期一起使用吗？

从技术上而言，是可以的。常规的histogram桶可以和日期一起使用。但是，它不懂日期相关的信息(Not calendar-aware)。而对于date_histogram，你可以将间隔(Interval)指定为1个月，它知道2月份比12月份要短。date_histogram还能够和时区一同工作，因此你可以根据用户的时区来对图形进行定制，而不是根据服务器。

常规的histogram会将日期理解为数值，这意味着你必须将间隔以毫秒的形式指定。同时聚合也不理解日历间隔，所以它对于日期几乎是没法使用的。

第一个例子中，我们会创建一个简单的线图(Line Chart)来回答这个问题：每个月销售了多少辆车？

GET /cars/transactions/_search?search_type=count
{
   "aggs": {
      "sales": {
         "date_histogram": {
            "field": "sold",
            "interval": "month", 
            "format": "yyyy-MM-dd" 
         }
      }
   }
}

在查询中有一个聚合，它为每个月创建了一个桶。它能够告诉我们每个月销售了多少辆车。同时指定了一个额外的格式参数让桶拥有更"美观"的键值。在内部，日期被简单地表示成数值。然而这会让UI设计师生气，因此使用格式参数可以让日期以更常见的格式进行表示。 5.x以下 空桶不会显示 5.x以上默认空桶会显示。

{
    "took": 326,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "sales": {
            "buckets": [
                {
                    "key_as_string": "2014-01-01",
                    "key": 1388534400000,
                    "doc_count": 1
                },
                {
                    "key_as_string": "2014-02-01",
                    "key": 1391212800000,
                    "doc_count": 0
                },
                {
                    "key_as_string": "2014-03-01",
                    "key": 1393632000000,
                    "doc_count": 0
                },
                {
                    "key_as_string": "2014-04-01",
                    "key": 1396310400000,
                    "doc_count": 0
                },
                {
                    "key_as_string": "2014-05-01",
                    "key": 1398902400000,
                    "doc_count": 1
                },
                {
                    "key_as_string": "2014-06-01",
                    "key": 1401580800000,
                    "doc_count": 0
                },
                {
                    "key_as_string": "2014-07-01",
                    "key": 1404172800000,
                    "doc_count": 1
                },
                {
                    "key_as_string": "2014-08-01",
                    "key": 1406851200000,
                    "doc_count": 1
                },
                {
                    "key_as_string": "2014-09-01",
                    "key": 1409529600000,
                    "doc_count": 0
                },
                {
                    "key_as_string": "2014-10-01",
                    "key": 1412121600000,
                    "doc_count": 1
                },
                {
                    "key_as_string": "2014-11-01",
                    "key": 1414800000000,
                    "doc_count": 2
                }
            ]
        }
    }
}

聚合完整地被表达出来了。你能看到其中有用来表示月份的桶，每个桶中的文档数量，以及漂亮的key_as_string。

返回空桶

5.x之前不会返回空桶, 5.x之后会空桶和非空桶同时返回

因此本质上，我们需要返回所有的桶，哪怕其中不含有任何文档。我们可以设置两个额外的参数来实现这一行为：

{
   "aggs": {
      "sales": {
         "date_histogram": {
            "field": "sold",
            "interval": "month", 
            "format": "yyyy-MM-dd" ,
            "min_doc_count":0,
            "extended_bounds":{
            	"min":"2014-01-01",
            	"max":"2014-12-31"
            }
            
         }
      }
   },
   "size":0
}

以上的min_doc_count参数会强制返回空桶，extended_bounds参数会强制返回一整年的数据。

这两个参数会强制返回该年中的所有月份，无论它们的文档数量是多少。min_doc_count的意思很容易懂：它强制返回哪怕为空的桶。

extended_bounds参数需要一些解释。min_doc_count会强制返回空桶，但是默认ES只会返回在你的数据中的最小值和最大值之间的桶。

因此如果你的数据分布在四月到七月，你得到的桶只会表示四月到七月中的几个月(可能为空，如果使用了min_doc_count=0)。为了得到一整年的桶，我们需要告诉ES需要得到的桶的范围。extended_bounds参数就是用来告诉ES这一范围的。一旦你添加了这两个设置，得到的响应就很容易被图形生成库处理而最终得到下图：

08111153_ZtcL.jpg

另外的例子

我们已经看到过很多次，为了实现更复杂的行为，桶可以嵌套在桶中。为了说明这一点，我们会创建一个用来显示每个季度，所有制造商的总销售额的聚合。同时，我们也会在每个季度为每个制造商单独计算其总销售额，因此我们能够知道哪种汽车创造的收益最多：

POST http://node1:9200/cars/transactions/_search
{
   "aggs": {
      "sales": {
         "date_histogram": {
            "field": "sold",
            "interval": "quarter", 
            "format": "yyyy-MM-dd",
            "min_doc_count" : 0,
            "extended_bounds" : {
                "min" : "2014-01-01",
                "max" : "2014-12-31"
            }
         },
         "aggs": {
            "per_make_sum": {
               "terms": {
                  "field": "make"
               },
               "aggs": {
                  "sum_price": {
                     "sum": { "field": "price" } 
                  }
               }
            },
            "total_sum": {
               "sum": { "field": "price" } 
            }
         }
      }
   },
   "size":0
}

可以发现，interval参数被设成了quarter。季度

得到的响应如下(删除了很多)：

{
    "took": 32,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
    },
    "hits": {
        "total": 7,
        "max_score": 0,
        "hits": []
    },
    "aggregations": {
        "sales": {
            "buckets": [
                {
                    "key_as_string": "2014-01-01",
                    "key": 1388534400000,
                    "doc_count": 1,
                    "per_make_sum": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "bmw",
                                "doc_count": 1,
                                "sum_price": {
                                    "value": 80000
                                }
                            }
                        ]
                    },
                    "total_sum": {
                        "value": 80000
                    }
                },
                {
                    "key_as_string": "2014-04-01",
                    "key": 1396310400000,
                    "doc_count": 1,
                    "per_make_sum": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "ford",
                                "doc_count": 1,
                                "sum_price": {
                                    "value": 30000
                                }
                            }
                        ]
                    },
                    "total_sum": {
                        "value": 30000
                    }
                },
                {
                    "key_as_string": "2014-07-01",
                    "key": 1404172800000,
                    "doc_count": 2,
                    "per_make_sum": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "toyota",
                                "doc_count": 2,
                                "sum_price": {
                                    "value": 27000
                                }
                            }
                        ]
                    },
                    "total_sum": {
                        "value": 27000
                    }
                },
                {
                    "key_as_string": "2014-10-01",
                    "key": 1412121600000,
                    "doc_count": 3,
                    "per_make_sum": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "honda",
                                "doc_count": 3,
                                "sum_price": {
                                    "value": 50000
                                }
                            }
                        ]
                    },
                    "total_sum": {
                        "value": 50000
                    }
                }
            ]
        }
    }
}

我们可以将该响应放入到一个图形中，使用一个线图(Line Chart)来表达总销售额，一个条形图来显示每个制造商的销售额(每个季度)，如下所示：

08111154_rlQ3.jpg

无限的可能性

显然它们都是简单的例子，但是在对聚合进行绘图时，是存在无限的可能性的。比如，下图是Kibana中的一个用来进行实时分析的仪表板，它使用了很多聚合：

08111156_tOhf.jpg

因为聚合的实时性，类似这样的仪表板是很容易进行查询，操作和交互的。这让它们非常适合非技术人员和分析人员对数据进行分析，而不需要他们创建一个Hadoop任务。

为了创建类似Kibana的强大仪表板，你需要掌握一些高级概念，比如作用域(Scoping)，过滤(Filtering)和聚合排序(Sorting Aggregations)。

 

ES聚合剩余内容

[Elasticsearch] 聚合作用域(Scoping Aggregations)

[Elasticsearch] 过滤查询以及聚合(Filtering Queries and Aggregations)

 

 

 

 

 

 

 

 

 

 

转载于:https://my.oschina.net/LucasZhu/blog/1504396

weixin_33974433
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ES搜索引擎入门+最佳实践(七):聚合
柳老师的博客
08-09 409
聚合,排序,分页这些概念在MySQL中都有,但是ES中的实现与MySQL既有相似又有不同.在学习这些内容的时候可以做类比.本章将会介绍,桶聚合,聚合方式,聚合排序,聚合分页.
Elasticsearch 聚合系列：adjacency matrix aggregation（邻接矩阵聚合）
weixin_40601534的博客
01-10 1379
定义 对某个字段的值做矩阵，返回单独满足一个/同时满足两个的结果 A B C A A A&B A&C B B B&C C C 测试： 环境准备 初始化一个带 Kibana 的 ES 集群 参考 环境搭建攻略 本文使用的是 ES 7.16，与上文中的集群版本不一致 在首页中添加示例数据 add sample data 测试执行 分别执行以下命令，可以得到以下结果 POST kibana_sample_data_ecommerce/_sear
es聚合查询
weixin_44764345的博客
05-22 142
https://blog.csdn.net/topdandan/article/details/81436141 https://www.cnblogs.com/fnlingnzb-learner/p/10750868.html https://www.cnblogs.com/chentop/p/10313164.html Scroll 查询 https://blog.csdn.net/carolcoral/article/details/82662407?utm_medium=distribute.pc_
es中的聚合查找
荣山的博客
08-28 221
es中的聚合查找
ES-聚合查询
蓝天⊙白云的博客
03-16 8048
size=0 { “aggs”: { “”: { “histogram”: { “field”: “price”, #字段名称 “interval”: 1000, #区间间隔 “keyed”: true, #返回数据的结构化类型 “min_doc_count”: , #返回桶的最小文档数阈值，即文档数小于num的桶不会被输出 “missing”: 1999 #空值的替换值，即如果文档对应字段的值为空，则默认输出1999（参数值） } } } }
es-聚合查询
迎接小天使
02-14 185
elasticsearch聚合值过滤
03-02
而“elasticsearch聚合值过滤”是ES聚合功能的一个高级应用场景，它允许我们根据聚合计算出的结果来进一步筛选文档，即在聚合后的基础上进行过滤操作。这一特性在数据分析和报表生成时非常有用，能够帮助我们得到更...
ElasticSearch搜索引擎常见面试题总结
12-28
Elasticsearch是一个强大的基于Lucene的分布式实时全文搜索引擎，它以RESTful的方式工作，使得数据交互变得简单。其核心特性包括高效存储、搜索和分析大量数据。以下是对Elasticsearch基础知识的详细阐述： 1. ...
数据聚合的艺术：如何在 Elasticsearch 中使用聚合？
最新发布
07-18
Elasticsearch 作为一个强大的搜索与分析引擎，在处理海量数据方面表现出色。其内置的聚合功能更是数据分析领域的重要工具之一。本篇文章将详细探讨 Elasticsearch 聚合的功能及其应用场景，并通过具体实例展示如何...
Elasticsearch总结.doc
04-01
Elasticsearch不仅是一个搜索引擎，它也是一个分布式、实时的文档存储系统，支持对结构化和非结构化数据进行搜索和分析。它具有以下特性： 1. **分布式**：通过横向扩展，能够轻松应对大规模数据和高并发场景。 2. ...
ES 聚合查询结果转换成相应的List对象
07-11
ES 聚合查询结果转换成相应的对象集合，ES 聚合查询结果转换成相应的对象集合
【Elasticsearch实践】（七）ES聚合搜索
RobertLab
06-27 437
【转载】 ES聚合搜索案例
Elesticsearch(es)聚合搜索（入门到精通）1
yuec1998的博客
01-27 804
大纲 1 两个核心概念：bucket和metric bucket：一个数据分组 metric: 就是对一个bucket执行的某种聚合分析的操作，比如说求平均值，求最大值，求最小值 select count(*) from access_log group by user_id bucket：group by user_id --> 那些user_id相同的数据，就会被划分到一个bucket中 metric：count(*)，对每个user_id bucket中所有的数据，计算一个数量 2
elasticsearch聚合搜索
longlovefilm的博客
06-12 823
1 select count(*) as num from tableName groupby class_id having num > 50000 { "query": { "bool": { "must": [], "must_not": [], "should": [] } }, "aggs": { "AsC...
ElasticSearch聚合操作
weixin_45162862的博客
03-10 1073
Elasticsearch除搜索以外，提供了针对ES 数据进行统计分析的功能。可以让我们极其方便的实现对数据的统计、分析、运算。使用场景聚合查询可以用于各种场景，比如商业智能、数据挖掘、日志分析等等。电商平台的销售分析：统计每个地区的销售额、每个用户的消费总额、每个产品的销售量等，以便更好地了解销售情况和趋势。社交媒体的用户行为分析：统计每个用户的发布次数、转发次数、评论次数等，以便更好地了解用户行为和趋势，同时可以将数据按照地区、时间、话题等维度进行分析。
ES聚合查询详解(一)
热门推荐
弹指天下
10-19 1万+
聚合查询可以将数据汇总为度量、统计或其他分析。 聚合查询主要分为三个类别: - Metric 指标聚合 - Bucket 桶聚合 - Pipeline 管道聚合
elasticsearch 手动开启聚合查询
若疆~赤云
01-26 445
curl -X PUT 'localhost:9200/&lt;index&gt;(索引)/_mapping/&lt;type&gt;(类型)' -H 'Content-Type: application/json' -d'{ "properties": { "field&lt;字段&gt;": { "type": "text", &quot
Elasticsearch 基本使用（四）聚合查询
冰糖的博客
06-18 8468
说到聚合查询，马上会想到 SQL 中的 group by，ES中也有类似的功能，名叫 Aggregation。默认，ES的聚合以分组内数量倒序排序。我们基于上面最后的统计结果，自定义聚合结果排序默认排序方式按数量升序之前说过，默认分组，提供了两个字段的返回；key 和 doc_count，如果要自定义这两个基本字段排序方式，需要在前面加上 下划线 _当然还可以按照其他聚合函数的结果排序。
ElasticSearch一点点bucket跟metric语法
计算机王的博客
06-10 500
在划分区间的同时，histogram会类似terms进行数据数量的统计（count），可以通过嵌套aggs对聚合分组后的组内数据做再次聚合分析。在分组后，可能需要对组内的数据进行排序，并选择其中排名高的数据。对每个分组执行的count(size可以设置为0，表示不返回ES中的文档，只返回ES聚合之后的数据，提高查询速度，当然如果你需要这些文档的话，也可以按照实际情况进行设置。表现，会变成红色，所以说你的指定的field中，如果包含了那个搜索词的话，就会在那个field的文本中，对搜索词进行红色的高亮显示。
Elasticsearch入门教程：搜索、聚合与分词解析
"ELASTICSEARCH快速入门文档涵盖了ES的基础知识，包括其作为基于Lucene的分布式搜索引擎的特点，如全文搜索、分布式架构、RESTful接口，以及与Solr的比较。文档详细介绍了倒排索引的概念，并讲解了ES的安装过程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值