本篇着重讲解的 terms 聚合,它是按照某个字段中的值来分类:
比如性别有男、女,就会创建两个桶,分别存放男女的信息。默认会搜集 doc_count 的信息,即记录有多少男生,有多少女生,然后返回给客户端,这样就完成了一个 terms 的统计。
Terms 聚合
{
"aggs" : {
"genders" : {
"terms" : { "field" : "gender" }
}
}
}
得到的结果如下:
{
...
"aggregations" : {
"genders" : {
"doc_count_error_upper_bound": 0,
"sum_other_doc_count": 0,
"buckets" : [
{
"key" : "male",
"doc_count" : 10
},
{
"key" : "female",
"doc_count" : 10
},
]
}
}
}
数据的不确定性
使用 terms 聚合,结果可能带有一定的偏差与错误性。
举个例子:
我们想要获取 name 字段中出现频率最高的前 5 个。
此时,客户端向 ES 发送聚合请求,主节点接收到请求后,会向每个独立的分片发送该请求。
分片独立的计算自己分片上的前 5 个 name,然后返回。当所有的分片结果都返回后,在主节点进行结果的合并,再求出频率最高的前 5 个,返回给客户端。
这样就会造成一定的误差,比如最后返回的前 5 个中,有一个叫 A 的,有 50 个文档;B 有 49。但是由于每个分片独立的保存信息,信息的分布也是不确定的。有可能第一个分片中 B 的信息有 2 个,但是没有排到前 5,所以没有在最后合并的结果中出现。这就导致B的总数少计算了 2,本来可能排到第一位,却排到了 A 的后面。
size 与 shard_size
为了改善上面的问题,就可以使用 size 和 shard_size 参数。
- size 参数规定了最后返回的 term 个数(默认是10个)
- shard_size 参数规定了每个分片上返回的个数
- 如果 shard_size 小于 size,那么分片也会按照 size 指定的个数计算
通过这两个参数,如果我们想要返回前 5 个,size=5;shard_size 可以设置大于 5,这样每个分片返回的词条信息就会增多,相应的误差几率也会减小。
order 排序
order 指定了最后返回结果的排序方式,默认是按照 doc_count 排序。
{
"aggs" : {
"genders" : {
"terms" : {
"field" : "gender",
"order" : { "_count" : "asc" }
}
}
}
}
也可以按照字典方式排序:
{
"aggs" : {
"genders" : {
"terms" : {
"field" : "gender",
"order" : { "_term" : "asc" }
}
}
}
}
当然也可以通过 order 指定一个单值的 metric 聚合来排序。
{
"aggs" : {
"genders" : {
"terms" : {
"field" : "gender",
"order" : { "avg_height" : "desc" }
},
"aggs" : {
"avg_height" : { "avg" : { "field" : "height" } }
}
}
}
}
同时也支持多值的 metric 聚合,不过要指定使用的多值字段:
{
"aggs" : {
"genders" : {
"terms" : {
"field" : "gender",
"order" : { "height_stats.avg" : "desc" }
},
"aggs" : {
"height_stats" : { "stats" : { "field" : "height" } }
}
}
}
}
min_doc_count 与 shard_min_doc_count
聚合的字段可能存在一些频率很低的词条,如果这些词条数目比例很大,那么就会造成很多不必要的计算。
因此可以通过设置 min_doc_count 和 shard_min_doc_count 来规定最小的文档数目,只有满足这个参数要求的个数的词条才会被记录返回。
通过名字就可以看出:
- min_doc_count:规定了最终结果的筛选
- shard_min_doc_count:规定了分片中计算返回时的筛选
script
桶聚合也支持脚本的使用:
{
"aggs" : {
"genders" : {
"terms" : {
"script" : "doc['gender'].value"
}
}
}
}
以及外部脚本文件:
{
"aggs" : {
"genders" : {
"terms" : {
"script" : {
"file": "my_script",
"params": {
"field": "gender"
}
}
}
}
}
}
filter
filter 字段提供了过滤的功能,使用两种方式:include 可以过滤出包含该值的文档;相反则使用 exclude。
例如:
{
"aggs" : {
"tags" : {
"terms" : {
"field" : "tags",
"include" : ".*sport.*",
"exclude" : "water_.*"
}
}
}
}
上面的例子中,最后的结果应该包含 sport 并且不包含 water。
也支持数组的方式,定义包含与排除的信息:
{
"aggs" : {
"JapaneseCars" : {
"terms" : {
"field" : "make",
"include" : ["mazda", "honda"]
}
},
"ActiveCarManufacturers" : {
"terms" : {
"field" : "make",
"exclude" : ["rover", "jensen"]
}
}
}
}
多字段聚合
通常情况,terms 聚合都是仅针对于一个字段的聚合。因为该聚合是需要把词条放入一个哈希表中,如果多个字段就会造成 n^2 的内存消耗。
不过,对于多字段,ES 也提供了下面两种方式:
- 1 使用脚本合并字段
- 2 使用 copy_to 方法,合并两个字段,创建出一个新的字段,对新字段执行单个字段的聚合。
collect 模式
对于子聚合的计算,有两种方式:
- depth_first 直接进行子聚合的计算
- breadth_first 先计算出当前聚合的结果,针对这个结果在对子聚合进行计算。
默认情况下 ES 会使用深度优先,不过可以手动设置成广度优先,比如:
{
"aggs" : {
"actors" : {
"terms" : {
"field" : "actors",
"size" : 10,
"collect_mode" : "breadth_first"
},
"aggs" : {
"costars" : {
"terms" : {
"field" : "actors",
"size" : 5
}
}
}
}
}
}
当然,多字段聚合需要写好长一串的查询体,如果字段太多,那岂不是要疯了(当然一般也不会太多,太多的话对性能也有影响)。不过,我们可以自己写个递归函数来构建 aggs 。
# Ruby
# test.rb
def build_aggs_from_fields(fields, aggs_hash)
return if fields.empty?
field = fields.shift
aggs_hash['aggs'] = {
"all_#{field}" => {
'terms' => { field: field, size: 1000 }
}
}
build_aggs_from_fields(fields, aggs_hash['aggs']["all_#{field}"])
end
fields = ['os', 'os_version', 'job_state']
aggs_hash = {}
build_aggs_from_fields(fields, aggs_hash)
pp aggs_hash
[root@master ruby_learning]# ruby test.rb
{"aggs"=>
{"all_os"=>
{"terms"=>{:field=>"os", :size=>1000},
"aggs"=>
{"all_os_version"=>
{"terms"=>{:field=>"os_version", :size=>1000},
"aggs"=>
{"all_job_state"=>{"terms"=>{:field=>"job_state", :size=>1000}}}}}}}}
------------------------------------------------------------
# Ruby
# test.rb
def build_aggs_from_fields(fields)
aggs_hash = {}
return if fields.empty?
field = fields.shift
aggs_hash['aggs'] ||= {}
aggs_hash['aggs']["all_#{field}"] = {
'terms' => { field: field, size: 1000 }
}
sub_aggs = build_aggs_from_fields(fields)
aggs_hash['aggs']["all_#{field}"].merge!(sub_aggs) if sub_aggs
aggs_hash
end
fields = ['os', 'os_version', 'job_state']
pp build_aggs_from_fields(fields)
[root@master ruby_learning]# ruby test.rb
{"aggs"=>
{"all_os"=>
{"terms"=>{:field=>"os", :size=>1000},
"aggs"=>
{"all_os_version"=>
{"terms"=>{:field=>"os_version", :size=>1000},
"aggs"=>
{"all_job_state"=>{"terms"=>{:field=>"job_state", :size=>1000}}}}}}}}
缺省值 Missing value
缺省值指定了缺省的字段的处理方式:
{
"aggs" : {
"tags" : {
"terms" : {
"field" : "tags",
"missing": "N/A"
}
}
}
}
上面的例子都是只有聚合而没有查询,如果你认为 ElasticSearch 的功能也不过如此的话,那你就大错特错了!
带查询的 Terms 聚合
{
"query" : {
"bool" : {
# must: build_multi_field_subquery_body(items)
"must" : [{:term=>{"os"=>"openeuler"}}]
}
},
"aggs" : {
"all_os" : {
"terms" : { field: "os" },
"aggs" : {
"all_state" : {
"terms" : { "field" : "job_state" },
}
}
}
},
"size" : 0
}