合計（Sum）

合計集計

集計された文書から抽出された数値を合計する single-value メトリクス集計です。これらの値は、特定の数値または ヒストグラム フィールドから抽出できます。

データが販売記録を表す文書で構成されていると仮定すると、すべての帽子の販売価格を合計することができます:

Python

resp = client.search(
   index="sales",
   size="0",
   query={
   "constant_score": {
   "filter": {
   "match": {
   "type": "hat"
   }
   }
   }
   },
   aggs={
   "hat_prices": {
   "sum": {
   "field": "price"
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  size: 0,
  body: {
   query: {
   constant_score: {
   filter: {
   match: {
   type: 'hat'
   }
   }
   }
   },
   aggregations: {
   hat_prices: {
   sum: {
   field: 'price'
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  size: 0,
  query: {
   constant_score: {
   filter: {
   match: {
   type: "hat",
   },
   },
   },
  },
  aggs: {
   hat_prices: {
   sum: {
   field: "price",
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search?size=0
{
  "query": {
   "constant_score": {
   "filter": {
   "match": { "type": "hat" }
   }
   }
  },
  "aggs": {
   "hat_prices": { "sum": { "field": "price" } }
  }
}

結果は次のとおりです:

コンソール-結果

{
  ...
  "aggregations": {
   "hat_prices": {
   "value": 450.0
   }
  }
}

集計の名前（上記の hat_prices）は、返されたレスポンスから集計結果を取得するためのキーとしても機能します。

スクリプト

単一のフィールドよりも複雑な何かの sum を取得する必要がある場合は、ランタイムフィールド で集計を実行します。

Python

resp = client.search(
   index="sales",
   size="0",
   runtime_mappings={
   "price.weighted": {
   "type": "double",
   "script": "\n        double price = doc['price'].value;\n        if (doc['promoted'].value) {\n          price *= 0.8;\n        }\n        emit(price);\n      "
   }
   },
   query={
   "constant_score": {
   "filter": {
   "match": {
   "type": "hat"
   }
   }
   }
   },
   aggs={
   "hat_prices": {
   "sum": {
   "field": "price.weighted"
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  size: 0,
  body: {
   runtime_mappings: {
   'price.weighted' => {
   type: 'double',
   script: "\n        double price = doc['price'].value;\n        if (doc['promoted'].value) {\n          price *= 0.8;\n        }\n        emit(price);\n      "
   }
   },
   query: {
   constant_score: {
   filter: {
   match: {
   type: 'hat'
   }
   }
   }
   },
   aggregations: {
   hat_prices: {
   sum: {
   field: 'price.weighted'
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  size: 0,
  runtime_mappings: {
   "price.weighted": {
   type: "double",
   script:
   "\n        double price = doc['price'].value;\n        if (doc['promoted'].value) {\n          price *= 0.8;\n        }\n        emit(price);\n      ",
   },
  },
  query: {
   constant_score: {
   filter: {
   match: {
   type: "hat",
   },
   },
   },
  },
  aggs: {
   hat_prices: {
   sum: {
   field: "price.weighted",
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search?size=0
{
  "runtime_mappings": {
   "price.weighted": {
   "type": "double",
   "script": """
   double price = doc['price'].value;
   if (doc['promoted'].value) {
   price *= 0.8;
   }
   emit(price);
   """
   }
  },
  "query": {
   "constant_score": {
   "filter": {
   "match": { "type": "hat" }
   }
   }
  },
  "aggs": {
   "hat_prices": {
   "sum": {
   "field": "price.weighted"
   }
   }
  }
}

欠損値

欠損値を持つ文書がどのように扱われるかを定義するのが missing パラメータです。デフォルトでは、値が欠損している文書は無視されますが、値があるかのように扱うことも可能です。たとえば、これは価格のないすべての帽子の販売を 100 として扱います。

Python

resp = client.search(
   index="sales",
   size="0",
   query={
   "constant_score": {
   "filter": {
   "match": {
   "type": "hat"
   }
   }
   }
   },
   aggs={
   "hat_prices": {
   "sum": {
   "field": "price",
   "missing": 100
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  size: 0,
  body: {
   query: {
   constant_score: {
   filter: {
   match: {
   type: 'hat'
   }
   }
   }
   },
   aggregations: {
   hat_prices: {
   sum: {
   field: 'price',
   missing: 100
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  size: 0,
  query: {
   constant_score: {
   filter: {
   match: {
   type: "hat",
   },
   },
   },
  },
  aggs: {
   hat_prices: {
   sum: {
   field: "price",
   missing: 100,
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search?size=0
{
  "query": {
   "constant_score": {
   "filter": {
   "match": { "type": "hat" }
   }
   }
  },
  "aggs": {
   "hat_prices": {
   "sum": {
   "field": "price",
   "missing": 100
   }
   }
  }
}

ヒストグラムフィールド

ヒストグラムフィールド に対して合計が計算されると、集計の結果は values 配列内のすべての要素の合計に、counts 配列内の同じ位置の数を掛けたものになります。

たとえば、異なるネットワークのレイテンシメトリクスを持つ事前集計されたヒストグラムを保存する次のインデックスについて:

Python

resp = client.indices.create(
   index="metrics_index",
   mappings={
   "properties": {
   "latency_histo": {
   "type": "histogram"
   }
   }
   },
)
print(resp)
resp1 = client.index(
   index="metrics_index",
   id="1",
   refresh=True,
   document={
   "network.name": "net-1",
   "latency_histo": {
   "values": [
                0.1,
                0.2,
                0.3,
                0.4,
                0.5
   ],
   "counts": [
   3,
   7,
   23,
   12,
   6
   ]
   }
   },
)
print(resp1)
resp2 = client.index(
   index="metrics_index",
   id="2",
   refresh=True,
   document={
   "network.name": "net-2",
   "latency_histo": {
   "values": [
                0.1,
                0.2,
                0.3,
                0.4,
                0.5
   ],
   "counts": [
   8,
   17,
   8,
   7,
   6
   ]
   }
   },
)
print(resp2)
resp3 = client.search(
   index="metrics_index",
   size="0",
   filter_path="aggregations",
   aggs={
   "total_latency": {
   "sum": {
   "field": "latency_histo"
   }
   }
   },
)
print(resp3)

Ruby

response = client.indices.create(
  index: 'metrics_index',
  body: {
   mappings: {
   properties: {
   latency_histo: {
   type: 'histogram'
   }
   }
   }
  }
)
puts response
response = client.index(
  index: 'metrics_index',
  id: 1,
  refresh: true,
  body: {
   'network.name' => 'net-1',
   latency_histo: {
   values: [
        0.1,
        0.2,
        0.3,
        0.4,
        0.5
   ],
   counts: [
   3,
   7,
   23,
   12,
   6
   ]
   }
  }
)
puts response
response = client.index(
  index: 'metrics_index',
  id: 2,
  refresh: true,
  body: {
   'network.name' => 'net-2',
   latency_histo: {
   values: [
        0.1,
        0.2,
        0.3,
        0.4,
        0.5
   ],
   counts: [
   8,
   17,
   8,
   7,
   6
   ]
   }
  }
)
puts response
response = client.search(
  index: 'metrics_index',
  size: 0,
  filter_path: 'aggregations',
  body: {
   aggregations: {
   total_latency: {
   sum: {
   field: 'latency_histo'
   }
   }
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "metrics_index",
  mappings: {
   properties: {
   latency_histo: {
   type: "histogram",
   },
   },
  },
});
console.log(response);
const response1 = await client.index({
  index: "metrics_index",
  id: 1,
  refresh: "true",
  document: {
   "network.name": "net-1",
   latency_histo: {
   values: [0.1, 0.2, 0.3, 0.4, 0.5],
   counts: [3, 7, 23, 12, 6],
   },
  },
});
console.log(response1);
const response2 = await client.index({
  index: "metrics_index",
  id: 2,
  refresh: "true",
  document: {
   "network.name": "net-2",
   latency_histo: {
   values: [0.1, 0.2, 0.3, 0.4, 0.5],
   counts: [8, 17, 8, 7, 6],
   },
  },
});
console.log(response2);
const response3 = await client.search({
  index: "metrics_index",
  size: 0,
  filter_path: "aggregations",
  aggs: {
   total_latency: {
   sum: {
   field: "latency_histo",
   },
   },
  },
});
console.log(response3);

コンソール

PUT metrics_index
{
  "mappings": {
   "properties": {
   "latency_histo": { "type": "histogram" }
   }
  }
}
PUT metrics_index/_doc/1?refresh
{
  "network.name" : "net-1",
  "latency_histo" : {
   "values" : [0.1, 0.2, 0.3, 0.4, 0.5],
   "counts" : [3, 7, 23, 12, 6]
   }
}
PUT metrics_index/_doc/2?refresh
{
  "network.name" : "net-2",
  "latency_histo" : {
   "values" :  [0.1, 0.2, 0.3, 0.4, 0.5],
   "counts" : [8, 17, 8, 7, 6]
   }
}
POST /metrics_index/_search?size=0&filter_path=aggregations
{
  "aggs" : {
   "total_latency" : { "sum" : { "field" : "latency_histo" } }
  }
}

各ヒストグラムフィールドに対して、sum 集計は values 配列内の各数値を、その関連する counts 配列内のカウントで掛けて加算します。

最終的に、すべてのヒストグラムのすべての値を加算し、次の結果を返します:

コンソール-結果

{
  "aggregations": {
   "total_latency": {
   "value": 28.8
   }
  }
}