aggregation分類

aggregations —— 聚合，提供了一種基於查詢條件來對資料進行分桶、計算的方法。有點類似於 SQL 中的 group by 再加一些函式方法的操作。

聚合可以巢狀，由此可以組成複雜的操作（Bucketing聚合可以包含sub-aggregation）。

聚合整體上可以分為 3 類：

1. Bucketing：桶分聚合：

• 此類聚合執行的是對文件分組的操作，把滿足相關特性的文件分到一個桶裡，即桶分。輸出結果往往是一個個包含多個文件的桶。
• 此類聚合會有一個關鍵字（field、script），以及一些桶分（分組）的判斷條件。執行聚合操作時候，文件會判斷每一個分組條件，如果滿足某個，該文件就會被分為該組（fall in）。

2. Metric：指標聚合：

• 此類聚合是對文件進行一些權值計算（比如求所有文件某個欄位的max值）。輸出結果往往是文件的權值，相當於為文件添加了一些統計資訊。
• 此類聚合基於特定欄位（field）或指令碼值（generated using scripts），計算聚合中文件的權值。

3. Pipeline：管道聚合：

• 對其它聚合操作的輸出及其關聯指標進行聚合。
• 此類聚合的作用物件往往是桶，而不是文件，是一種後期對每個分桶的一些計算操作。

應用場景

對於 3 中聚合，常見的應用場景如下流程：

buckets 聚合對文件進行必要的歸類（桶分） ——> metric 聚合對每個桶進行一些額外的資訊計算（如：max） ——> pipeline 聚合針對所有桶做一些桶層面的統計或計算應用示例：

{
    "aggs" : {
        "sales_per_month" : {
            "date_histogram" : {              // bucket 聚合，按照月份進行分桶，每個月的歸屬一個桶
                "field" : "date",
                "interval" : "month"
            },
            "aggs": {
                "sales": {
                    "sum": {                       // metric 聚合，對每個桶類的 price 求和，即每月的銷售額
                        "field": "price"
                    }
                }
            }
        },
        "max_monthly_sales": {
            "max_bucket": {                 // pipeline 聚合，求所有桶中銷售額 sales 最大的值
                "buckets_path": "sales_per_month>sales" 
            }
        }
    }
}


 

aggregation結構

聚合可以是父子（巢狀）關係聚合，buckets 聚合作為父，metric 聚合作為子。

聚合也可以是兄弟關係聚合，buckets 聚合在前，pipeline 聚合在後。

結構如下：

"aggregations" : {                                //定義聚合物件,也可用 "aggs"
      "<aggregation_name>" : {                    //聚合的名稱,使用者自定義
          "<aggregation_type>" : {                //聚合型別,比如 "histogram"
              <aggregation_body>                  //每個聚合型別都有其自己的結構定義
          }
          [,"meta" : {  [<meta_data_body>] } ]?
          [,"aggregations" : { [<sub_aggregation>]+ } ]?    //可以定義多個 sub-aggregation
      }
      [,"<aggregation_name_2>" : { ... } ]*       //定義額外的多個平級 aggregation,只有 Bucketing 型別才有意義
}

2 metrics aggregations

概述

權值聚合型別從需要聚合的文件中取一個值（value）來計算文件的相應權值（比如該值在這些文件中的max、sum等）。

用於計算的值（value）可以是文件的欄位（field），也可以是指令碼（script）生成的值。

數值權值聚合是特殊的權值聚合型別，因為它的輸出權值也是數字。

數值權值聚合（注意分類只針對數值權值聚合，非數值的無此分類）輸出單個權值的，叫做 single-value numeric metrics，其它生成多個權值（比如：stats）的被叫做 multi-value numeric metrics。

單值和多值數字權值聚合，在它們作為一些 Bucket 聚合的直接子聚合的時候會有明顯區別。

Avg Aggregation(single-value numeric metrics)

均值聚合——基於文件的某個值，計算該值在聚合文件中的均值。

用於計算的值可以是特定的數值型欄位，也可以通過指令碼計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value
• missing：文件預設欄位時的預設值

{
    "aggs" : {
        "avg_grade" : { "avg" : { "field" : "grade" } }    //計算欄位 grade 在文件中的平均值
    }
}
//輸出
{
    ...

    "aggregations": {
        "avg_grade": {
            "value": 75
        }
    }
}

Cardinality Aggregation(single-value)

基數聚合——基於文件的某個值，計算文件非重複的個數（去重計數）。

用於計算的值可以是特定的欄位，也可以通過指令碼計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value
• precision_threshold：
• missing：文件預設欄位時的預設值

{
    "aggs" : {
        "author_count" : {
            "cardinality" : {
                "field" : "author"  //count the unique authors that match a query
            }
        }
    }
}

stats aggregation(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 Aggregation(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 Aggregation

地理邊界聚合——基於文件的某個欄位（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 Aggregation

地理重心聚合——基於文件的某個欄位（geo-point型別欄位），計算所有座標的加權重心。

配置引數

• field：用於計算的欄位（geo-point型別）

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

Max Aggregation(single)

最大值聚合——基於文件的某個值，求該值在聚合文件中的最大值。

用於計算的值可以是特定的數值型欄位，也可以通過指令碼計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value
• missing：文件預設欄位時的預設值

Min Aggregation(single)

最小值聚合——基於文件的某個值，求該值在聚合文件中的最小值。

用於計算的值可以是特定的數值型欄位，也可以通過指令碼計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value
• missing：文件預設欄位時的預設值

Sum Aggregation(single-value)

求和聚合——基於文件的某個值，求該值在聚合文件中的統計和。

用於計算的值可以是特定的數值型欄位，也可以通過指令碼計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value
• missing：文件預設欄位時的預設值

//最大值，field
{
    "aggs" : {
        "max_price" : { "max" : { "field" : "price" } }      // field 
    }
}
//最小值，script
{
    "aggs" : {
        "min_price" : {
            "min" : {
                "script" : {                            //script 計算 value
                    "file": "my_script",
                    "params": {
                        "field": "price"
                    }
                }
            }
        }
    }
}
//總和，value script 
{
    "aggs" : {
        ...
        "aggs" : {
            "daytime_return" : {
                "sum" : {
                    "field" : "change",                  // field
                    "script" : "_value * _value"        // 基於 field 用 script 計算 value
                }
            }
        }
    }
}

Percentiles Aggregation(multi-value)

百分百聚合——基於聚合文件中某個數值型別的值，求這些值中

用於計算的值可以是特定的數值型欄位，也可以通過指令碼計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value
• missing：文件預設欄位時的預設值

Script Metric Aggregation

基於指令碼的權值聚合——用指令碼來計算出一個權值

配置引數

• 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 Aggregation

最高匹配權值聚合——跟蹤聚合中相關性最高的文件。

該聚合一般用做 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": [
                        1370143231177
                    ]
                 }
             ]
       }
  }
  
  
  

   

Value Count Aggregation(single-value)

值計數聚合——計算聚合文件中某個值的個數。

用於計數的值可以是特定的數值型欄位，也可以通過指令碼計算而來。

該聚合一般域其它 single-value 聚合聯合使用，比如在計算一個欄位的平均值的時候，可能還會關注這個平均值是由多少個值計算而來。

配置引數

• field：用於計算的欄位
• script：由指令碼生成用來計算的 value

{
    "aggs" : {
        "grades_count" : { "value_count" : { "field" : "grade" } }    //計算 grade 欄位共有多少個值，和 cardinality 聚合不同的
    }
}

3 bucket aggregation

概述

桶分聚合不進行權值的計算，他們對文件根據聚合請求中提供的判斷條件（比如：{"from":0,  "to":100}）來進行分組（桶分）。

桶分聚合還會額外返回每一個桶內文件的個數。

桶分聚合可以包含子聚合——sub-aggregations（權值聚合不能包含子聚合，可以作為子聚合），子聚合操作將會應用到由父（parent）聚合產生的每一個桶上。

桶分聚合根據聚合條件，可以只定義輸出一個桶；也可以輸出多個；還可以在根據聚合條件動態確定桶個數（比如：terms aggregation）。

Histogram Aggregation(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 Aggregation(multi-bucket)

日期直方圖聚合——基於日期型別，以【日期間隔】來桶分聚合。

可用的時間間隔型別為：year、quarter、month、week、day、hour、minute、second，其中，除了year、quarter 和 month，其餘可用小數形式。

配置引數

• field：
• interval：
• format：定義日期的格式，配置後會返回一個 key_as_string 的字串型別日期（預設只有key）
• time_zone：定義時區，用作時間值的調整
• offset：
• missing：

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

Range Aggregation(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 Aggregation(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 Aggregation(multi-bucket)

詞元聚合——基於某個field，該 field 內的每一個【唯一詞元】為一個桶，並計算每個桶內文件個數。

預設返回順序是按照文件個數多少排序。

當不返回所有 buckets 的情況，文件個數可能不準確。

配置引數

• size：size用來定義需要返回多個 buckets（防止太多），預設會全部返回。（注意，如果只返回部分buckets，統計的文件個數不一定準確（每個分片各自的top size個）。size 越大，count 會越精確。）
• order：排序方式
• min_doc_count：只返回文件個數不小於該值的 buckets
• script：用基本來生成詞元
• include：包含過濾
• exclude：排除過濾
• execution_hint：
• collect_mode：
• missing：

{
    "aggs" : {
        "genders" : {
            "terms" : { 
              "field" : "gender",
              "size" : 5,
              "order" : { "_count" : "asc" },
              "min_doc_count": 10,
              "include" : ".*sport.*",
              "exclude" : "water_.*",
              "missing": "N/A"
            }
        }
    }
}

Filters Aggregation(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 Aggregation(single-bucket)

過濾聚合——基於一個條件，來對當前的文件進行過濾的聚合。

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

IPv4 Range Aggregation(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 Aggregation(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
            }
        }
    }
}

4 pipeline aggregations

概述

管道聚合處理的物件是其它聚合的輸出（桶或者桶的某些權值），而不是直接針對文件。

管道聚合的作用是為輸出增加一些有用資訊。

管道聚合大致分為兩類：

parent

• 此類聚合的"輸入"是其【父聚合】的輸出，並對其進行進一步處理。一般不生成新的桶，而是對父聚合桶資訊的增強。

sibling

• 此類聚合的輸入是其【兄弟聚合】的輸出。並能在同級上計算新的聚合。

管道聚合通過 buckets_path 引數指定他們要進行聚合計算的權值物件，buckets_path 引數有其自己的使用語法。

管道聚合不能包含子聚合，但是某些型別的管道聚合可以鏈式使用（比如計算導數的導數）。

bucket_path語法

1. 聚合分隔符 ==> ">"，指定父子聚合關係，如："my_bucket>my_stats.avg"

2. 權值分隔符 ==> "."，指定聚合的特定權值

3. 聚合名稱 ==> <name of the aggregation> ，直接指定聚合的名稱

4. 權值 ==> <name of the metric> ，直接指定權值

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 Aggregation(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 Aggregation(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 Aggregation(sibling)

桶最大值聚合——基於兄弟聚合的某個權值，輸出權值最大的那一個桶。

用於計算的權值必須是數值型別。

用於計算的兄弟聚合必須是多桶聚合型別。

配置引數

• buckets_path：用於計算均值的權值路徑
• gap_policy：空桶處理策略（skip/insert_zeros）
• format：該聚合的輸出格式定義

 

Min Bucket Aggregation(sibling)

桶最小值聚合——基於兄弟聚合的某個權值，輸出權值最小的一個桶。

用於計算的權值必須是數值型別。

用於計算的兄弟聚合必須是多桶聚合型別。

配置引數

• buckets_path：用於計算均值的權值路徑
• gap_policy：空桶處理策略（skip/insert_zeros）
• format：該聚合的輸出格式定義

 

Sum Buchet Aggregation(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 Aggregation(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 Aggregation(sibling)

擴充套件桶統計聚合——基於兄弟聚合的某個權值，對【桶資訊】進行一系列統計學計算（比普通的統計聚合多了一些統計值）。

用於計算的權值必須是數值型別。

用於計算的兄弟聚合必須是多桶聚合型別。

配置引數

• buckets_path：用於計算均值的權值路徑
• gap_policy：空桶處理策略（skip/insert_zeros）
• format：該聚合的輸出格式定義
• sigma：偏差顯示位置（above/below）

 

Percentiles Bucket Aggregation(sibling)

桶百分比聚合——基於兄弟聚合的某個權值，計算權值的百分百。

用於計算的權值必須是數值型別。

用於計算的兄弟聚合必須是多桶聚合型別。

對百分百的計算是精確的（不像Percentiles Metric聚合是近似值），所以可能會消耗大量記憶體

配置引數

• buckets_path：用於計算均值的權值路徑
• gap_policy：空桶處理策略（skip/insert_zeros）
• format：該聚合的輸出格式定義
• percents：需要計算的百分百列表（陣列形式）

 

Moving Average Aggregation(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"
        }
    }
}

 

Cumulative Sum Aggregation(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 Aggregation(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 Aggregation(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 Aggregation(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
               }
            }
         }
      }
   }
}