转自： https://blog.csdn.net/zx711166/article/details/81906881

聚合查询
聚合是一种基于查询条件对数据进行分桶、计算的方法。

聚合可以嵌套，由此可以组合复杂的操作（Bucketing 聚合可以包含 sub-aggregation）。

聚合的三种分类：

Metric（指标聚合）：
对文档进行权值计算，输出结果既是权值。
基于特定字段（field）或脚本值（generated using scripts）计算。
Bucketing（分桶聚合）：
对文档进行分组操作，把满足相关特性的文档分到一个桶里，即桶分。输出结果是包含多个文档的桶。
基于一个关键字（field、script），以及一些桶分（分组）的判断条件进行聚合，符合条件的会分到对应的组（fall in）。
Pipeline（管道聚合）：
对其它聚合操作的输出以及关联指标进行聚合。
此类聚合的作用对象大多是桶，而不是文档，是一种后期对每一个分桶的一些计算操作。
指标聚合
sum 聚合（single-value）
sum是一个求累加值的聚合，其作用与关系型数据库中相同。

Top hits 聚合
最高匹配权值聚合，跟踪聚合中相关性最高的文档。

该聚合一般用做 sub-aggregation，以此来聚合每个桶中的最高匹配的文档。

参数：

from：最匹配的结果中的文档个数偏移；
size：top matching hits 返回的最大文档个数（default 3）；
sort：最匹配的文档的排序方式。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺失字段时的默认值。
GET /lib4/items/_search
{
    "size": 0, # 表示查询多少条文档，聚合只需就和结果，输出文档可以设置为0条
    "aggs": {
        "price_of_sum": { # 自行取名作为结果集
            "sum": {
                "field": "price"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
min 聚合（single）
min是一个求最小值的聚合，其作用与关系型数据库中相同。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺失字段时的默认值。
GET /lib4/items/_search
{
    "size": 0,
    "aggs": {
        "price_of_min": {
            "min": {
                "field": "price"
            }
        }
    }
}

//最小值，script
{
    "size", 0
    "aggs" : {
        "price_of_min_script" : {
            "min" : {
                "script" : {                //script 计算 value
                    "file": "my_script",
                    "params": {
                        "field": "price"
                    }
                }
             }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
max 聚合（single）
max是一个求最大值聚合，其作用与关系型数据库中相同。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺失字段时的默认值。
GET /lib4/items/_search
{
    "size": 0,
    "aggs": {
        "price_of_max": {
            "max": {
                "field": "price"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
avg 聚合（single-value numeric metrics）
avg是一个求平均值的聚合，其作用与关系型数据库中相同。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺失字段时的默认值。
GET /lib4/items/_search
{
    "size": 0,
    "aggs": {
        "price_of_avg": {
            "avg": {
                "field": "price"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
cardinality 聚合（single-value）
cardinality是一个求基数的聚合，其作用与关系型数据库中相同。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
precision_threshold：精度阈值，用于处理准确度问题；
missing：文档缺失字段时的默认值。
GET /lib4/items/_search
{
    "size": 0,
    "aggs": {
        "price_of_cardi": {
            "cardinality": { # 其实相当于该字段互不相同的值有多少类，输出的是种类数
                "field": "price"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
stats 聚合（multi-value）
统计聚合，基于文档的某个值，计算出一些统计信息（min、max、sum、count、avg）。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺失字段时的默认值。
{
    "aggs" : {
        "grades_stats" : {
            "stats" : {
                "field" : "grade"
            }
        }
    }
}
//输出
{
    ...
    "aggregations": {
        "grades_stats": {
            "count": 6,
            "min": 60,
            "max": 98,
            "avg": 78.5,
            "sum": 471
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Extended stats 聚合（multi-value）
扩展统计聚合，基于文档的某个值，计算出一些统计信息（比普通的stats聚合多了sum_of_squares、variance、std_deviation、std_deviation_bounds）。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺失字段时的默认值；
sigma：标准差界限。
{
    ...

"aggregations": {
        "grade_stats": {
           "count": 9,
           "min": 72,
           "max": 99,
           "avg": 86,
           "sum": 774,
           //输出比 stats 聚合多了一些值
           "sum_of_squares": 67028,
           "variance": 51.55555555555556,
           "std_deviation": 7.180219742846005,
           "std_deviation_bounds": {
            "upper": 100.36043948569201,
            "lower": 71.63956051430799
           }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Geo Bounds 聚合
地理边界聚合，基于文档的某个字段（geo-point类型字段），计算出该字段所有地理坐标点的边界（左上角/右下角坐标点）。

参数：

field：用于计算的字段；
wrap_longitude：是否允许地理边界与国际日界线存在重叠。
{
    "query" : {
        "match" : { "business_type" : "shop" }
    },
    "aggs" : {
        "viewport" : {
            "geo_bounds" : {
                "field" : "location",
                "wrap_longitude" : true
            }
        }
    }
}
//输出
{
    ...
    "aggregations": {
        "viewport": {
            "bounds": {
                "top_left": {                    //左上角经纬度
                    "lat": 80.45,
                    "lon": -160.22
                },
                "bottom_right": {               //右下角经纬度
                    "lat": 40.65,
                    "lon": 42.57
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Geo Centroid 聚合
地理重心聚合，基于文档的某个字段（geo-point类型字段），计算所有坐标的加权重心。

参数：

field：用于计算的字段（geo-point类型）。
{
    "query" : {
        "match" : { "crime" : "burglary" }
    },
    "aggs" : {
        "centroid" : {
            "geo_centroid" : {
                "field" : "location"
            }
        }
    }
}
//输出
{
    ...
    "aggregations": {
        "centroid": {
            "location": {      //重心经纬度
                "lat": 80.45,
                "lon": -160.22
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Percentiles 聚合（multi-value）
百分百聚合，基于聚合文档中某个数值类型的值，求这些值中。

参数：

field：用于计算的字段；
script：由脚本生成用来计算的 value；
missing：文档缺省字段时的默认。
Script Metric 聚合
基于脚本的权值聚合，用脚本来计算出一个权值。

参数：

init_script：用于计算的字段；
map_script：由脚本生成用来计算的 value；
combine_script：文档缺省字段时的默认值；
reduce_script：
{
    "query" : {
        "match_all" : {}
    },
    "aggs": {
        "profit": {
            "scripted_metric": {
                "init_script" : "_agg['transactions'] = []",
                "map_script" : "if (doc['type'].value == \"sale\") { _agg.transactions.add(doc['amount'].value) } else { _agg.transactions.add(-1 * doc['amount'].value) }",
                "combine_script" : "profit = 0; for (t in _agg.transactions) { profit += t }; return profit",
                "reduce_script" : "profit = 0; for (a in _aggs) { profit += a }; return profit"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Top hits 聚合
最高匹配权值聚合，跟踪聚合中相关性最高的文档。

该聚合一般用做 sub-aggregation，以此来聚合每个桶中的最高匹配的文档。

参数：

from：最匹配的结果中的文档个数偏移；
size：top matching hits 返回的最大文档个数（default 3）；
sort：最匹配的文档的排序方式。
{
    "aggs": {
        "top-tags": {
            "terms": {
                "field": "tags",
                "size": 3
            },
            "aggs": {
                "top_tag_hits": {
                    "top_hits": {                  //用 tags 字段分组，每个 tag（即一个分组）只显示最后一个问题，并且只在 _source 中保留 title 字段
                        "sort": [
                            {
                                "last_activity_date": {
                                    "order": "desc"
                                }
                            }
                        ],
                        "_source": {
                            "include": [
                                "title"
                            ]
                        },
                        "size" : 1
                    }
                }
            }
        }
    }
}
//输出
"top_tags_hits": {
     "hits": {
          "total": 25365,
          "max_score": 1,
          "hits": [
              {
                 "_index": "stack",
                 "_type": "question",
                 "_id": "602679",
                 "_score": 1,
                 "_source": {
                      "title": "Windows port opening"
                 },
                 "sort": [
                  ]
               }
           ]
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
Value Count 聚合（single-value）
值计数聚合，计算聚合文档中某个值的个数。

用于计数的值可以是特定的数值型字段，也可以通过脚本计算而来。

该聚合一般域其它 single-value 聚合联合使用，比如在计算一个字段的平均值的时候，可能还会关注这个平均值是由多少个值计算而来。

参数：

field：用于计算的字段
script：由脚本生成用来计算的 value
{
    "aggs" : {
        "grades_count" : {
            "value_count" : {
                "field" : "grade"
            }
        }    //计算 grade 字段共有多少个值，和 cardinality 聚合不同的
    }
}
1
2
3
4
5
6
7
8
9
桶聚合查询
histogram 聚合（multi-bucket）
直方图聚合，基于文档中的某个【数值类型】字段，通过计算来动态的分桶。

计算如下：

rem = value % interval
if (rem < 0) {
    rem += interval
}
bucket_key = value - rem
1
2
3
4
5
参数：

field：字段，必须为数值类型
interval：分桶间距
min_doc_count：最少文档数桶过滤，只有不少于这么多文档的桶才会返回
extended_bounds：范围扩展
order：对桶排序，如果 histogram 聚合有一个权值聚合类型的"直接"子聚合，那么排序可以使用子聚合中的结果
offset：桶边界位移，默认从0开始
keyed：hash结构返回，默认以数组形式返回每一个桶
missing：配置缺省默认值
{
    "aggs" : {
        "prices" : {
            "histogram" : {
                "field" : "price",
                "interval" : 50,
                "min_doc_count" : 1,
                "extended_bounds" : {
                    "min" : 0,
                    "max" : 500
                },
                "order" : { "_count" : "desc" },
                "keyed":true,
                "missing":0
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Data Histogram 聚合（multi-bucket）
日期直方图聚合——基于日期类型，以【日期间隔】来桶分聚合。

可用的时间间隔类型为：

year、quarter、month、week、day、hour、minute、second
其中，除了year、quarter 和 month，其余可用小数形式。
参数：

field：字段，必须为数值类型
interval：分桶间距
format：定义日期的格式，配置后会返回一个 key_as_string 的字符串类型日期（默认只有key）
time_zone：定义时区，用作时间值的调整
offset：桶边界位移，默认从0开始
missing：配置缺省默认值
{
    "aggs" : {
        "articles_over_time" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month",
                "format" : "yyyy-MM-dd",
                "time_zone": "+08:00"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
Range 聚合（multi-bucket）
范围聚合——基于某个值（可以是 field 或 script），以【字段范围】来桶分聚合。

范围聚合包括 from 值，不包括 to 值（区间前闭后开）。

参数：

ranges：配置区间，数组，每一个元素是一个区间。例如：[{from:0}, {from:50, to:100}, {to:200}]
keyed：以一个关联的唯一字符串作为键，以 HASH 形式返回，而不是默认的数组
script：利用 script 执行结果替代普通的 field 值进行聚合。script可以用file给出，还可以对其它 field 进行求值计算。
{
    "aggs" : {
        "price_ranges" : {
            "range" : {
                "field" : "price",
                "ranges" : [                       //包含 3 个桶
                    { "to" : 50 },
                    { "from" : 50, "to" : 100 },
                    { "from" : 100 }
                ],
                "keyed" : true
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Date Range 聚合（multi-bucket）
日期范围聚合，基于日期类型的值，以【日期范围】来桶分聚合。

日期范围可以用各种 Date Math 表达式。

同样的，包括 from 的值，不包括 to 的值。

参数：

format：定义日期格式，配置后会返回一个 [to/from]_as_string 的字符串类型日期，默认是 to/from 的数值表示。
{
    "aggs": {
        "range": {
            "date_range": {
                "field": "date",
                "format": "MM-yyy",               
                "ranges": [                            //包含 3 个桶
                    { "to": "now-10M/M" },
                    { "from": "now-10M/M" },
                    {"from":"1970-1-1", "to":"2000-1-1"}
                ]
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
terms 聚合（multi-bucket）
terms是一个分组聚合，其作用与关系型数据库中相同。

默认返回顺序是按照文档个数多少排序。

当不返回所有 buckets 的情况，文档个数可能不准确

参数：

size：size用来定义需要返回多个 buckets（防止太多），默认会全部返回。（注意，如果只返回部分buckets，统计的文档个数不一定准确（每个分片各自的top size个）。size 越大，count 会越精确。）
order：排序方式
min_doc_count：只返回文档个数不小于该值的 buckets
script：用基本来生成词元
include：包含过滤
exclude：排除过滤
execution_hint：
collect_mode：
missing：配置缺省默认值
GET /lib4/items/_search
{
    "size": 0,
    "aggs": {
        "price_of_by": {
            "terms": {
                "field": "price"
            }
        }
    }
}

# 对那些有唱歌兴趣的用户按年龄分组
GET /lib3/user/_search
{
    "query": {
        "match": {
            "interests": "changge"
        }
    },
    "size": 0,
    "aggs": {
        "agg_group_by": {
            "field": "age",
            "order": {
                "avg_of_age": "desc"
            }
        },
        "aggs": {
            "avg_of_age": {
                "age": {
                    "field": "age"
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
Filters 聚合（multi-bucket）
多过滤聚合，基于多个过滤条件，来对当前文档进行【过滤】的聚合，每个过滤都包含所有满足它的文档（多个bucket中可能重复）。

参数：

filters： 配置过滤条件，支持 HASH 或 数组格式
other_bucket： 是否计算不满足任何匹配条件的文档
other_bucket_key： 作为不匹配所有过滤条件的文档的 bucket 名称
{
  "aggs" : {
    "messages" : {
      "filters" : {
        "other_bucket_key": "other_messages",                //不在过滤条件范围内的文档都归属于 other_messages 桶
        "filters" : {                                        //过滤条件
          "errors" :   { "term" : { "body" : "error"   }},   
          "warnings" : { "term" : { "body" : "warning" }}
        }
      },
      "aggs" : {
        "monthly" : {
          "histogram" : {
            "field" : "timestamp",
            "interval" : "1M"
          }
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Filter 聚合（single-bucket）
过滤聚合，基于一个条件，来对当前的文档进行过滤的聚合。

{
    "aggs" : {
        "red_products" : {
            "filter" : { "term": { "color": "red" } },
            "aggs" : {
                "avg_price" : { "avg" : { "field" : "price" } }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
IPv4 Range 聚合（multi-bucket）
IP4聚合——基于一个 IPv4 字段，对文档进行【IPv4范围】的桶分聚合。

和 Range Aggregation 类似，只是应用字段必须是 IPv4 数据类型。

{
    "aggs" : {
        "ip_ranges" : {
            "ip_range" : {
                "field" : "ip",
                "ranges" : [                                //包含 3 个桶，各个桶之间可能有文档重复
                    { "to" : "10.0.0.5" },
                    { "from" : "10.0.0.5" },
                    { "from":"1.1.1.1", "to" : "10.0.0.5" },
                ]
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Nested 聚合（single-bucket）
嵌套类型聚合，基于嵌套（nested）数据类型，把该【嵌套类型的信息】聚合到单个桶里，然后就可以对嵌套类型做进一步的聚合操作。

// resellers 是一个嵌套类型
{
    ...
    "product" : {
        "properties" : {
            "resellers" : {
                "type" : "nested",
                "properties" : {
                    "name" : { "type" : "string" },
                    "price" : { "type" : "double" }
                }
            }
        }
    }
}
// 对 nested 对象里面的信息做其它聚合操作
{
    "query" : {
        "match" : { "name" : "led tv" }
    },
    "aggs" : {
        "resellers" : {
            "nested" : {                           //"嵌套类型聚合"把所有嵌套信息都包含在单一的桶里，以供进一步处理
                "path" : "resellers"
            },
            "aggs" : {
                "min_price" : { "min" : { "field" : "resellers.price" } }   //对嵌套类型聚合输出的桶做进一步处理，这里是计算其 price 的 average
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
管道聚合
管道聚合处理的对象是其它聚合的输出（桶或者桶的某些权值），而不是直接针对文档。

管道聚合的作用是为输出增加一些有用信息。

管道聚合大致分为两类：

parent
此类聚合的"输入"是其【父聚合】的输出，并对其进行进一步处理。一般不生成新的桶，而是对父聚合桶信息的增强。

sibling
此类聚合的输入是其【兄弟聚合】的输出。并能在同级上计算新的聚合。

管道聚合通过 buckets_path 参数指定他们要进行聚合计算的权值对象，buckets_path 参数有其自己的使用语法。

管道聚合不能包含子聚合，但是某些类型的管道聚合可以链式使用（比如计算导数的导数）。

bucket_path语法
聚合分隔符 ==> “>”，指定父子聚合关系，如：“my_bucket>my_stats.avg”

权值分隔符 ==> “.”，指定聚合的特定权值

聚合名称 ==> ，直接指定聚合的名称

权值 ==> ，直接指定权值

完整路径 ==> agg_name[> agg_name]*[. metrics] ，综合利用上面的方式指定完整路径

特殊值 ==> “_count”，输入的文档个数

特殊情况
要进行 pipeline aggregation 聚合的对象名称或权值名称包含小数点
“buckets_path”: “my_percentile[99.9]”
处理对象中包含空桶（无文档的桶分）
参数 gap_policy，可选值有 skip、insert_zeros
Avg Bucket 聚合（sibliing）
桶均值聚合，基于兄弟聚合的某个权值，求所有桶的权值均值。

用于计算的兄弟聚合必须是多桶聚合。

用于计算的权值必须是数值类型。

参数：

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {
                        "field": "price"
                    }
                }
            }
        },
        "avg_monthly_sales": {
            "avg_bucket": {             //对所有月份的销售总 sales 求平均值
                "buckets_path": "sales_per_month>sales"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Derivative 聚合（parent）
求导聚合，基于父聚合（只能是histogram或date_histogram类型）的某个权值，对权值求导。

用于求导的权值必须是数值类型。

封闭直方图（histogram）聚合的 min_doc_count 必须是 0。

参数：

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {
                        "field": "price"
                    }
                },
                "sales_deriv": {       //对每个月销售总和 sales 求导
                    "derivative": {
                        "buckets_path": "sales"  //同级，直接用 metric 值
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Max Bucket 聚合（sibling）
桶最大值聚合，基于兄弟聚合的某个权值，输出权值最大的那一个桶。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

参数：

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
Min Bucket 聚合（sibling）
桶最小值聚合，基于兄弟聚合的某个权值，输出权值最小的一个桶。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
Sum Buchet 聚合（sibling）
桶求和聚合，基于兄弟聚合的权值，对所有桶的权值求和。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {
                        "field": "price"
                    }
                }
            }
        },
        "max_monthly_sales": {        //输出兄弟聚合 sales_per_month 的每月销售总和 sales 的最大一个桶
            "max_bucket": {
                "buckets_path": "sales_per_month>sales"
            }
        },
        "min_monthly_sales": {         //输出兄弟聚合 sales_per_month 的每月销售总和 sales 的最小一个桶
            "min_bucket": {
                "buckets_path": "sales_per_month>sales"
            }
        },
        "sum_monthly_sales": {         //输出兄弟聚合 sales_per_month 的每月销售总和 sales 的最小一个桶
            "sum_bucket": {
                "buckets_path": "sales_per_month>sales"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Stats Bucket 聚合（sibling）
桶统计信息聚合，基于兄弟聚合的某个权值，对【桶的信息】进行一些统计学运算（总计多少个桶、所有桶中该权值的最大值、最小等）。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {
                        "field": "price"
                    }
                }
            }
        },
        "stats_monthly_sales": {               // 对父聚合的每个桶（每月销售总和）的一些基本信息进行聚合
            "stats_bucket": {
                "buckets_paths": "sales_per_month>sales"
            }
        }
    }
}
//输出结果
{
   "aggregations": {
      "sales_per_month": {
         "buckets": [
            {
               "key_as_string": "2015/01/01 00:00:00",
               "key": 1420070400000,
               "doc_count": 3,
               "sales": {
                  "value": 550
               }
            },
            {
               "key_as_string": "2015/02/01 00:00:00",
               "key": 1422748800000,
               "doc_count": 2,
               "sales": {
                  "value": 60
               }
            },
            {
               "key_as_string": "2015/03/01 00:00:00",
               "key": 1425168000000,
               "doc_count": 2,
               "sales": {
                  "value": 375
               }
            }
         ]
      },
      "stats_monthly_sales": {        //注意，统计的是桶的信息
         "count": 3,
         "min": 60,
         "max": 550,
         "avg": 328.333333333,
         "sum": 985
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
** Extended Stats Bucket 聚合（sibling）**
扩展桶统计聚合，基于兄弟聚合的某个权值，对【桶信息】进行一系列统计学计算（比普通的统计聚合多了一些统计值）。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

参数

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
sigma：偏差显示位置（above/below）
** Percentiles Bucket 聚合（sibling）**
桶百分比聚合，基于兄弟聚合的某个权值，计算权值的百分百。

用于计算的权值必须是数值类型。

用于计算的兄弟聚合必须是多桶聚合类型。

对百分百的计算是精确的（不像Percentiles Metric聚合是近似值），所以可能会消耗大量内存

参数：

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
percents：需要计算的百分百列表（数组形式）
Moving Average 聚合（parent）
窗口平均值聚合，基于已经排序过的数据，计算出处在当前出口中数据的平均值。

比如窗口大小为 5 ，对数据 1—10 的部分窗口平均值如下：

(1 + 2 + 3 + 4 + 5) / 5 = 3
(2 + 3 + 4 + 5 + 6) / 5 = 4
(3 + 4 + 5 + 6 + 7) / 5 = 5
参数：

buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
window：窗口大小
model：移动模型
minimize：
settings：

{
    "the_movavg":{
        "moving_avg":{
            "buckets_path": "the_sum",
            "window" : 30,
            "model" : "simple"
        }
    }
}
1
2
3
4
5
6
7
8
9
Cumulative Sum 聚合（parent）
累计和聚合，基于父聚合（只能是histogram或date_histogram类型）的某个权值，对权值在每一个桶中求所有之前的桶的该值累计的和。

用于计算的权值必须是数值类型。

封闭直方图（histogram）聚合的 min_doc_count 必须是 0。

参数：

buckets_path：用于计算均值的权值路径
format：该聚合的输出格式定义
{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {
                        "field": "price"
                    }
                },
                "cumulative_sales": {
                    "cumulative_sum": {
                        "buckets_path": "sales"
                    }
                }
            }
        }
    }
}
//输出
{
   "aggregations": {
      "sales_per_month": {
         "buckets": [
            {
               "key_as_string": "2015/01/01 00:00:00",
               "key": 1420070400000,
               "doc_count": 3,
               "sales": {
                  "value": 550
               },
               "cumulative_sales": {
                  "value": 550                //总计 sales = 550
               }
            },
            {
               "key_as_string": "2015/02/01 00:00:00",
               "key": 1422748800000,
               "doc_count": 2,
               "sales": {
                  "value": 60
               },
               "cumulative_sales": {
                  "value": 610               //总计 sales = 550 + 60
               }
            },
            ...
         ]
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
** Bucket Script 聚合（parent）**
桶脚本聚合，基于父聚合的【一个或多个权值】，对这些权值通过脚本进行运算。

用于计算的父聚合必须是多桶聚合。

用于计算的权值必须是数值类型。

执行脚本必须要返回数值型结果。

参数

script：用于计算的脚本，脚本可以是 inline，也可以是 file，还可以是 Scripting 指定的
buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义
{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "total_sales": {
                    "sum": {
                        "field": "price"
                    }
                },
                "t-shirts": {
                  "filter": {
                    "term": {
                      "type": "t-shirt"
                    }
                  },
                  "aggs": {
                    "sales": {
                      "sum": {
                        "field": "price"
                      }
                    }
                  }
                },
                "t-shirt-percentage": {
                    "bucket_script": {
                        "buckets_path": {                    //对两个权值进行计算
                          "tShirtSales": "t-shirts>sales",
                          "totalSales": "total_sales"
                        },
                        "script": "tShirtSales / totalSales * 100"
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Bucket Selector 聚合（parent）
桶选择器聚合，基于父聚合的【一个或多个权值】，通过脚本对权值进行计算，并决定父聚合的哪些桶需要保留，其余的将被丢弃。

用于计算的父聚合必须是多桶聚合。

用于计算的权值必须是数值类型。

运算的脚本必须是返回 boolean 类型，如果脚本是脚本表达式形式给出，那么允许返回数值类型。

参数：

script：用于计算的脚本，脚本可以是 inline，也可以是 file，还可以是 Scripting 指定的
buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
{
    "bucket_selector": {
        "buckets_path": {
            "my_var1": "the_sum",
            "my_var2": "the_value_count"
        },
        "script": "my_var1 > my_var2"    // true 则保留该桶；false 则丢弃
    }
}
1
2
3
4
5
6
7
8
9
** Serial Differencing 聚合（parent）**
串行差分聚合，基于父聚合（只能是histogram或date_histogram类型）的某个权值，对权值值进行差分运算，（取时间间隔，后一刻的值减去前一刻的值：f(X) = f(Xt) – f(Xt-n)）。

用于计算的父聚合必须是多桶聚合。

参数

lag：滞后间隔（比如lag=7，表示每次从当前桶的值中减去其前面第7个桶的值）
buckets_path：用于计算均值的权值路径
gap_policy：空桶处理策略（skip/insert_zeros）
format：该聚合的输出格式定义

{
   "aggs": {
      "my_date_histo": {                  
         "date_histogram": {
            "field": "timestamp",
            "interval": "day"
         },
         "aggs": {
            "the_sum": {
               "sum": {
                  "field": "lemmings"     
               }
            },
            "thirtieth_difference": {
               "serial_diff": {                
                  "buckets_path": "the_sum",
                  "lag" : 30                        //差分间隔为 30 day
               }
            }
         }
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
复合查询
使用bool查询
接受以下参数：

must：文档必须匹配设定条件才能被包含进来
must_not：文档必须不匹配设定条件才能被包含进来
should：如果满足语句中的任意语句，将增加_source，否则，无任何影响。主要用于修正每个文档的相关性得分
filter：必须匹配，但以不评分、过滤模式来进行。这些语句对评分没有贡献，只是根据过滤标准来排除或包含文档
相关性得分是如何组合的？
每一个子查询都独自的计算文档的相关性得分，bool查询将对计算出的等分进行合并，然后返回一个代表整个布尔操作的等分。

下面的查询用于查找title字段匹配 how to make millions 并且不被标识为 spam的文档。那些被标识为 starred 或在2014之后的文档，将比另外那些文档拥有更高的排名。如果 两者 都满足，那么它的排名将更高。

GET /lib3/user/_search
{
    "query": {
        "bool": {
            "must": {
                "match": {
                    "interests": "changge"
                }
            },
            "must_not": {
                "match": {
                    "interests": "lvyou"
                }
            },
            "should": [
                {
                    "match": {
                        "address": "bei jing"
                    }
                },
                {
                    "range": {
                        "birthday": {
                            "gte": "1996-01-01"
                        }
                    }
                }
            ]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
如果没有 must 语句，那么至少需要能够匹配其中的一条 should 语句。但如果存在至少一条 must 语句，则对 should 语句的匹配没有要求。如果不想因为文档的时间影响得分，可以用 filter 语句来重写前面的例子

# 可以在bool内嵌套filter过滤
GET /lib3/user/_search
{
    "query": {
        "bool": {
            "must": {
                "match": {
                    "interests": "changge"
                }
            },
            "must_not": {
                "match": {
                    "interests": "lvyou"
                }
            },
            "should": [
                {
                    "match": {
                        "address": "bei jing"
                    }
                }
            ],
            "filter": {
                "range": {
                    "birthday": {
                        "gte": "1996-01-01"
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
通过将 range 查询移动到 filter 语句中，我们将它转成不评分的查询，将不在影响文档的相关性排名，由于它现在是一个不评分的查询，可以使用各种对 filter 查询有效的优化手段来提升性能。

bool 查询本身也可以被用作不评分的查询，简单的将它放置到 filter 语句中并在内部构建布尔逻辑

# 在bool内嵌套fliter，在fliter下嵌套另一个bool作为过滤条件
GET /lib3/user/_search
{
    "query": {
        "bool": {
            "must": {
                "match": {
                    "interests": "changge"
                }
            },
            "must_not": {
                "match": {
                    "interests": "lvyou"
                }
            },
            "should": [
                {
                    "match": {
                        "address": "bei jing"
                    }
                }
            ],
            "filter": {
                "bool": {
                    "must": [
                        {
                            "range": {
                                "birthday": {
                                    "gte": "1990-01-01"
                                }
                            }
                        },
                        {
                            "range": {
                                "age": {
                                    "lte": 30
                                }
                            }
                        }
                    ],
                    "must_not": [
                        {
                            "term": {
                                "age": "29"
                            }
                        }
                    ]
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
constant_score查询
constant_score将一个不变的量评分应用于所有匹配的文档，被经常用于你只需要执行一个 fliter 而没有其他查询（例如：评分查询）的情况下。
请求结构如下：

{
    "constant_score": {
        "filter": {
            "term": {
                "category": "ebooks"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
示例：

GET /lib4/items/_search
{
    "query": {
        "constant_score": {
            "filter": {
                "term": {
                    "interests": "changge"
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
term 查询被放置在constant_score中，转成不评分的 filter。这种方式可以用来取代只有 filter 语句的 bool 查询。
————————————————
版权声明：本文为CSDN博主「迷途码界」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zx711166/article/details/81906881

（转）Elasticsearch 聚合查询、桶聚合、管道聚合及复合查询相关推荐

  1. Elasticsearch 管道聚合

    管道聚合 管道聚合处理其他聚合产生的输出,而不是处理文档集,它将信息添加到输出树.存在许多不同类型的管道聚合,这些聚合从其他的聚合中计算不同的信息,这些聚合主要分成两类: 双亲:与双亲聚合输出一起提供 ...

  2. Elasticsearch（三）——Es搜索（简单使用、全文查询、复合查询）、地理位置查询、特殊查询、聚合操作、桶聚合、管道聚合

    Elasticsearch(三)--Es搜索(简单使用.全文查询.复合查询).地理位置查询.特殊查询.聚合操作.桶聚合.管道聚合 一.Es搜索 这里的 Es 数据博主自己上网找的,为了练习 Es 搜索 ...

  3. Elasticsearch 7.X-8.0 AggregationBuliders 相关聚合函数（二）桶聚合-嵌套查询

    global 全局聚合 定义搜索执行上下文中所有文档的单个存储桶.此上下文由要搜索的索引和文档类型定义,但不受搜索查询‎‎本身的影响.‎ ‎全局聚合器只能作为顶级聚合器放置,因为将全局聚合器嵌入到另一 ...

  4. Elasticsearch笔记（七）：聚合查询

    聚合框架有助于根据搜索查询提供聚合数据.聚合查询是数据库中重要的功能特性,ES作为搜索引擎兼数据库,同样提供了强大的聚合分析能力.它基于查询条件来对数据进行分桶.计算的方法.有点类似于 SQL 中的 ...

  5. ElasticSearch 文档检索、查询建议、数据聚合

    目录 结构化搜索 term 单词匹配(单个值) terms 单词匹配(多个值) range 范围查询 exists 存在查询.miss 缺失查询 ids id匹配 prefix 前缀匹配 wildca ...

  6. 深耕ElasticSearch - 过滤和聚合/多桶排序

    文章目录 1. 数据准备 2. 过滤和聚合 2.1 过滤 2.2 过滤桶 3. 多桶排序 3.1 内置排序 3.2 按度量排序 4. 近似聚合 1. 数据准备 1.创建索引映射mapping : PU ...

  7. 理解Elasticsearch中的桶聚合（Bucket aggregation）

    0. 前言 Elasticsearch除了在搜索方面非常之快,对数据分析也是非常重要的一面.正确理解Bucket aggregation对我们使用Kibana非常重要.Elasticsearch提供了 ...

  8. elasticsearch in查询_Python Elasticsearch DSL 查询、过滤、聚合操作实例

    技术博客: https://github.com/yongxinz/tech-blog 同时,也欢迎关注我的微信公众号 AlwaysBeta,更多精彩内容等你来. Elasticsearch 基本概念 ...

  9. ES聚合查询详解(四):管道聚合

    前言 前面已经介绍了指标聚合和桶聚合的使用,本文继续介绍管道聚合. 一.简介 管道聚合 Pipeline aggregations 官方文档:Pipeline Aggregations 管道聚合主要用 ...

最新文章

  1. mysql 最小日期函数_MySQL 日期加减函数汇总
  2. 51Nod 1003 阶乘后面0的数量(数学,思维题)
  3. 生成对抗网络（GAN）的统计推断
  4. javascript笔记：javascript的前世，至于今生嘛地球人都知道了哈
  5. LeetCode 33. 搜索旋转排序数组（二分查找）
  6. 甘肃计算机教室中标,大单纷至沓来 甘肃百亿工程浪潮电脑中标8000台
  7. 机器学习实战7-sklearn集成学习和随机森林
  8. 7-4 求下一天 (30 分)
  9. C语言学习笔记---结构体作为函数参数和返回值
  10. 华为交换机重制_华为交换机重置命令
  11. C#操作ini文件类
  12. MySql性能优化学习路线图
  13. Nginx 配置 SSL 证书 + 搭建 HTTPS 网站
  14. anguar4 共享服务在多个组件中数据通信
  15. paip.java桌面开发应用与WEB RIA应用
  16. docker下修改mysql配置文件
  17. linux系统 锐捷_linux系统的锐捷安装
  18. Mac下遇到的npm install失败问题 err！
  19. 计算机专业我的工匠梦作文,【推荐】我的科技梦作文7篇
  20. nodejs插件knex 日志打印

热门文章

  1. CF932G-Palindrome Partition【PAM】
  2. 欢乐纪中某B组赛【2019.1.27】
  3. nssl1254-A(林下风气)【树形dp】
  4. P2375-[NOI2014]动物园【KMP,字符串】
  5. 2016 Multi-University Training Contest 1 1004 GCD（ST表+二分）
  6. P4564 [CTSC2018]假面（期望）
  7. 牛客练习赛 57——manacher算法 树形dp？
  8. 【01背包】最大约数和(jzoj 2126)
  9. 我的ACM之路-写于南宁站后
  10. TCP为什么是三次握手和四次挥手