Elasticsearch 聚合查询、桶聚合、管道聚合及复合查询

约定不等于承诺〃 2023-07-06 14:34 80阅读 0赞

# 聚合查询 #

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

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

聚合的三种分类：

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

# 指标聚合 #

*  ### **sum 聚合（single-value）** ###

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

参数：

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

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

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

*  ### **max 聚合（single）** ###

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

参数：

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

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

*  ### **avg 聚合（single-value numeric metrics）** ###

avg是一个求平均值的聚合，其作用与关系型数据库中相同。

参数：

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

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

*  ### **cardinality 聚合（single-value）** ###

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

参数：

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

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：文档缺失字段时的默认值。

{
        "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：标准差界限。

{
        ...
    
        "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：是否允许地理边界与国际日界线存在重叠。

{
        "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类型）。

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

{
        "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：最匹配的文档的排序方式。

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

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

# 桶聚合查询 #

*  ### **histogram 聚合（multi-bucket）** ###

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

计算如下：

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

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

{
        "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 进行求值计算。

{
        "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 的数值表示。

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

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 名称

{
      "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）** ###

过滤聚合，基于一个条件，来对当前的文档进行过滤的聚合。

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

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

*  ### **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
                }
            }
        }
    }

# 管道聚合 #

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

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

管道聚合大致分为两类：

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

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

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

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

{
        "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：
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4NzExMTY2_size_16_color_FFFFFF_t_70_pic_center][]

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

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4NzExMTY2_size_16_color_FFFFFF_t_70_pic_center 1][]

{
       "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之后的文档，将比另外那些文档拥有更高的排名。如果 两者 都满足，那么它的排名将更高。

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 语句来重写前面的例子

# 可以在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 语句中并在内部构建布尔逻辑

# 在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 而没有其他查询（例如：评分查询）的情况下。  
请求结构如下：

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

示例：

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

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4NzExMTY2_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20190924165925133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4NzExMTY2,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4NzExMTY2_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20190924170559168.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4NzExMTY2,size_16,color_FFFFFF,t_70#pic_center