Elasticsearch 聚合查询、桶聚合、管道聚合及复合查询_zx711166 的博客 - CSDN 博客

本文由 简悦 SimpRead 转码， 原文地址 blog.csdn.net

聚合查询

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

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

聚合的三种分类：

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

指标聚合

• sum 聚合（single-value） sum 是一个求累加值的聚合，其作用与关系型数据库中相同。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • missing：文档缺失字段时的默认值。

  1 2 3 4 5 6 7 8 9 10 11

  GET /lib4/items/_search { "size": 0, # 表示查询多少条文档，聚合只需就和结果，输出文档可以设置为0条 "aggs": { "price_of_sum": { # 自行取名作为结果集 "sum": { "field": "price" } } } }

• ‍

• min 聚合（single） min 是一个求最小值的聚合，其作用与关系型数据库中相同。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • missing：文档缺失字段时的默认值。

  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

  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" } } } } } }

• max 聚合（single） max 是一个求最大值聚合，其作用与关系型数据库中相同。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • missing：文档缺失字段时的默认值。

  1 2 3 4 5 6 7 8 9 10 11

  GET /lib4/items/_search { "size": 0, "aggs": { "price_of_max": { "max": { "field": "price" } } } }

• avg 聚合（single-value numeric metrics） avg 是一个求平均值的聚合，其作用与关系型数据库中相同。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • missing：文档缺失字段时的默认值。

  1 2 3 4 5 6 7 8 9 10 11

  GET /lib4/items/_search { "size": 0, "aggs": { "price_of_avg": { "avg": { "field": "price" } } } }

• cardinality 聚合（single-value） cardinality 是一个求基数的聚合，其作用与关系型数据库中相同。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • precision_threshold：精度阈值，用于处理准确度问题；
  • missing：文档缺失字段时的默认值。

  1 2 3 4 5 6 7 8 9 10 11

  GET /lib4/items/_search { "size": 0, "aggs": { "price_of_cardi": { "cardinality": { # 其实相当于该字段互不相同的值有多少类，输出的是种类数 "field": "price" } } } }

• stats 聚合（multi-value） 统计聚合，基于文档的某个值，计算出一些统计信息（min、max、sum、count、avg）。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • missing：文档缺失字段时的默认值。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  { "aggs" : { "grades_stats" : { "stats" : { "field" : "grade" } } } } //输出 { ... "aggregations": { "grades_stats": { "count": 6, "min": 60, "max": 98, "avg": 78.5, "sum": 471 } } }

• Extended stats 聚合（multi-value） 扩展统计聚合，基于文档的某个值，计算出一些统计信息（比普通的 stats 聚合多了 sum_of_squares、variance、std_deviation、std_deviation_bounds）。

  参数：

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

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  { ... "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 } } } }

• Geo Bounds 聚合 地理边界聚合，基于文档的某个字段（geo-point 类型字段），计算出该字段所有地理坐标点的边界（左上角 / 右下角坐标点）。

  参数：

  • field：用于计算的字段；
  • wrap_longitude：是否允许地理边界与国际日界线存在重叠。

  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

  { "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 } } } } }

• Geo Centroid 聚合 地理重心聚合，基于文档的某个字段（geo-point 类型字段），计算所有坐标的加权重心。

  参数：

  • field：用于计算的字段（geo-point 类型）。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  { "query" : { "match" : { "crime" : "burglary" } }, "aggs" : { "centroid" : { "geo_centroid" : { "field" : "location" } } } } //输出 { ... "aggregations": { "centroid": { "location": { //重心经纬度 "lat": 80.45, "lon": -160.22 } } } }

• Percentiles 聚合（multi-value） 百分百聚合，基于聚合文档中某个数值类型的值，求这些值中。

  参数：

  • field：用于计算的字段；
  • script：由脚本生成用来计算的 value；
  • missing：文档缺省字段时的默认。

• Script Metric 聚合 基于脚本的权值聚合，用脚本来计算出一个权值。

  参数：

  • init_script：用于计算的字段；
  • map_script：由脚本生成用来计算的 value；
  • combine_script：文档缺省字段时的默认值；
  • reduce_script：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  { "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" } } } }

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

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

  参数：

  • from：最匹配的结果中的文档个数偏移；
  • size：top matching hits 返回的最大文档个数（default 3）；
  • 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

  { "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": [ ] } ] } }

• Value Count 聚合（single-value） 值计数聚合，计算聚合文档中某个值的个数。

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

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

  参数：

  • field：用于计算的字段
  • script：由脚本生成用来计算的 value

  1 2 3 4 5 6 7 8 9

  { "aggs" : { "grades_count" : { "value_count" : { "field" : "grade" } } //计算 grade 字段共有多少个值，和 cardinality 聚合不同的 } }

桶聚合查询

• histogram 聚合（multi-bucket） 直方图聚合，基于文档中的某个【数值类型】字段，通过计算来动态的分桶。

  计算如下：

  1 2 3 4 5

  rem = value % interval if (rem < 0) { rem += interval } bucket_key = value - rem

  参数：

  • field：字段，必须为数值类型
  • interval：分桶间距
  • min_doc_count：最少文档数桶过滤，只有不少于这么多文档的桶才会返回
  • extended_bounds：范围扩展
  • order：对桶排序，如果 histogram 聚合有一个权值聚合类型的 “直接” 子聚合，那么排序可以使用子聚合中的结果
  • offset：桶边界位移，默认从 0 开始
  • keyed：hash 结构返回，默认以数组形式返回每一个桶
  • missing：配置缺省默认值

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  { "aggs" : { "prices" : { "histogram" : { "field" : "price", "interval" : 50, "min_doc_count" : 1, "extended_bounds" : { "min" : 0, "max" : 500 }, "order" : { "_count" : "desc" }, "keyed":true, "missing":0 } } } }

• 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：配置缺省默认值

  1 2 3 4 5 6 7 8 9 10 11 12

  { "aggs" : { "articles_over_time" : { "date_histogram" : { "field" : "date", "interval" : "month", "format" : "yyyy-MM-dd", "time_zone": "+08:00" } } } }

• Range 聚合（multi-bucket） 范围聚合——基于某个值（可以是 field 或 script），以【字段范围】来桶分聚合。

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

  参数：

  • ranges：配置区间，数组，每一个元素是一个区间。例如：[{from:0}, {from:50, to:100}, {to:200}]
  • keyed：以一个关联的唯一字符串作为键，以 HASH 形式返回，而不是默认的数组
  • script：利用 script 执行结果替代普通的 field 值进行聚合。script 可以用 file 给出，还可以对其它 field 进行求值计算。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  { "aggs" : { "price_ranges" : { "range" : { "field" : "price", "ranges" : [ //包含 3 个桶 { "to" : 50 }, { "from" : 50, "to" : 100 }, { "from" : 100 } ], "keyed" : true } } } }

• Date Range 聚合（multi-bucket） 日期范围聚合，基于日期类型的值，以【日期范围】来桶分聚合。

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

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

  参数：

  • format：定义日期格式，配置后会返回一个 [to/from]_as_string 的字符串类型日期，默认是 to/from 的数值表示。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  { "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"} ] } } } }

• 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：配置缺省默认值

  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

  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" } } } } }

• Filters 聚合（multi-bucket） 多过滤聚合，基于多个过滤条件，来对当前文档进行【过滤】的聚合，每个过滤都包含所有满足它的文档（多个 bucket 中可能重复）。

  参数：

  • filters： 配置过滤条件，支持 HASH 或 数组格式
  • other_bucket： 是否计算不满足任何匹配条件的文档
  • other_bucket_key： 作为不匹配所有过滤条件的文档的 bucket 名称

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  { "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" } } } } } }

• Filter 聚合（single-bucket） 过滤聚合，基于一个条件，来对当前的文档进行过滤的聚合。

  1 2 3 4 5 6 7 8 9 10

  { "aggs" : { "red_products" : { "filter" : { "term": { "color": "red" } }, "aggs" : { "avg_price" : { "avg" : { "field" : "price" } } } } } }

• IPv4 Range 聚合（multi-bucket） IP4 聚合——基于一个 IPv4 字段，对文档进行【IPv4 范围】的桶分聚合。

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

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  { "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" }, ] } } } }

• Nested 聚合（single-bucket） 嵌套类型聚合，基于嵌套（nested）数据类型，把该【嵌套类型的信息】聚合到单个桶里，然后就可以对嵌套类型做进一步的聚合操作。

  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

  // 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 } } } }

管道聚合

管道聚合处理的对象是其它聚合的输出（桶或者桶的某些权值），而不是直接针对文档。

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

管道聚合大致分为两类：

• parent 此类聚合的 “输入” 是其【父聚合】的输出，并对其进行进一步处理。一般不生成新的桶，而是对父聚合桶信息的增强。
• sibling 此类聚合的输入是其【兄弟聚合】的输出。并能在同级上计算新的聚合。

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

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

bucket_path 语法

1. 聚合分隔符 ==> “>”，指定父子聚合关系，如：“my_bucket>my_stats.avg”
2. 权值分隔符 ==> “.”，指定聚合的特定权值
3. 聚合名称 ==> ，直接指定聚合的名称
4. 权值 ==> ，直接指定权值
5. 完整路径 ==> agg_name[> agg_name]*[. metrics] ，综合利用上面的方式指定完整路径
6. 特殊值 ==> “_count”，输入的文档个数

特殊情况

1. 要进行 pipeline aggregation 聚合的对象名称或权值名称包含小数点 “buckets_path”: “my_percentile[99.9]”
2. 处理对象中包含空桶（无文档的桶分） 参数 gap_policy，可选值有 skip、insert_zeros

• Avg Bucket 聚合（sibliing） 桶均值聚合，基于兄弟聚合的某个权值，求所有桶的权值均值。

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

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

  参数：

  • buckets_path：用于计算均值的权值路径
  • gap_policy：空桶处理策略（skip/insert_zeros）
  • format：该聚合的输出格式定义

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  { "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" } } } }

• Derivative 聚合（parent） 求导聚合，基于父聚合（只能是 histogram 或 date_histogram 类型）的某个权值，对权值求导。

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

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

  参数：

  • buckets_path：用于计算均值的权值路径
  • gap_policy：空桶处理策略（skip/insert_zeros）
  • format：该聚合的输出格式定义

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  { "aggs" : { "sales_per_month" : { "date_histogram" : { "field" : "date", "interval" : "month" }, "aggs": { "sales": { "sum": { "field": "price" } }, "sales_deriv": { //对每个月销售总和 sales 求导 "derivative": { "buckets_path": "sales" //同级，直接用 metric 值 } } } } } }

• 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：该聚合的输出格式定义

  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

  { "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" } } } }

• Stats Bucket 聚合（sibling） 桶统计信息聚合，基于兄弟聚合的某个权值，对【桶的信息】进行一些统计学运算（总计多少个桶、所有桶中该权值的最大值、最小等）。

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

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

  参数

  • buckets_path：用于计算均值的权值路径
  • gap_policy：空桶处理策略（skip/insert_zeros）
  • format：该聚合的输出格式定义

  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

  { "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 } } }

• ** 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：

  

  1 2 3 4 5 6 7 8 9

  { "the_movavg":{ "moving_avg":{ "buckets_path": "the_sum", "window" : 30, "model" : "simple" } } }

• Cumulative Sum 聚合（parent） 累计和聚合，基于父聚合（只能是 histogram 或 date_histogram 类型）的某个权值，对权值在每一个桶中求所有之前的桶的该值累计的和。

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

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

  参数：

  • buckets_path：用于计算均值的权值路径
  • format：该聚合的输出格式定义

 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

{
    "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
               }
            },
            ...
         ]
      }
   }
}

• ** Bucket Script 聚合（parent）** 桶脚本聚合，基于父聚合的【一个或多个权值】，对这些权值通过脚本进行运算。

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

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

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

  参数

  • script：用于计算的脚本，脚本可以是 inline，也可以是 file，还可以是 Scripting 指定的
  • buckets_path：用于计算均值的权值路径
  • gap_policy：空桶处理策略（skip/insert_zeros）
  • format：该聚合的输出格式定义

  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

  { "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" } } } } } }

• Bucket Selector 聚合（parent） 桶选择器聚合，基于父聚合的【一个或多个权值】，通过脚本对权值进行计算，并决定父聚合的哪些桶需要保留，其余的将被丢弃。

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

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

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

  参数：

  • script：用于计算的脚本，脚本可以是 inline，也可以是 file，还可以是 Scripting 指定的
  • buckets_path：用于计算均值的权值路径
  • gap_policy：空桶处理策略（skip/insert_zeros）

  1 2 3 4 5 6 7 8 9

  { "bucket_selector": { "buckets_path": { "my_var1": "the_sum", "my_var2": "the_value_count" }, "script": "my_var1 > my_var2" // true 则保留该桶；false 则丢弃 } }

• ** 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：该聚合的输出格式定义

  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  { "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 } } } } } }

复合查询

使用 bool 查询

接受以下参数：

• must：文档必须匹配设定条件才能被包含进来
• must_not：文档必须不匹配设定条件才能被包含进来
• should：如果满足语句中的任意语句，将增加_source，否则，无任何影响。主要用于修正每个文档的相关性得分
• filter：必须匹配，但以不评分、过滤模式来进行。这些语句对评分没有贡献，只是根据过滤标准来排除或包含文档

相关性得分是如何组合的？ 每一个子查询都独自的计算文档的相关性得分，bool 查询将对计算出的等分进行合并，然后返回一个代表整个布尔操作的等分。

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

 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

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"
                        }
                    }
                }
            ]
        }
    }
}

如果没有 must 语句，那么至少需要能够匹配其中的一条 should 语句。但如果存在至少一条 must 语句，则对 should 语句的匹配没有要求。如果不想因为文档的时间影响得分，可以用 filter 语句来重写前面的例子

 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

# 可以在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"
                    }
                }
            }
        }
    }
}

通过将 range 查询移动到 filter 语句中，我们将它转成不评分的查询，将不在影响文档的相关性排名，由于它现在是一个不评分的查询，可以使用各种对 filter 查询有效的优化手段来提升性能。

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

 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

# 在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"
                            }
                        }
                    ]
                }
            }
        }
    }
}

constant_score 查询

constant_score 将一个不变的量评分应用于所有匹配的文档，被经常用于你只需要执行一个 fliter 而没有其他查询（例如：评分查询）的情况下。 请求结构如下：

1
2
3
4
5
6
7
8
9

{
	"constant_score": {
		"filter": {
			"term": {
				"category": "ebooks"
			}
		}
	}
}

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

GET /lib4/items/_search
{
    "query": {
        "constant_score": {
            "filter": {
                "term": {
                    "interests": "changge"
                }
            }
        }
    }
}

term 查询被放置在 constant_score 中，转成不评分的 filter。这种方式可以用来取代只有 filter 语句的 bool 查询。