メトリクス集計 - 最小（Min） - 《Elasticsearchガイドv8.15》日本語

最小集約
スクリプト
欠損値
ヒストグラムフィールド

最小集約

数値文書から抽出された数値の中で最小値を追跡し、返す single-value メトリクス集約です。

min および max 集約は、データの double 表現に基づいて動作します。その結果、絶対値が 2^53 より大きい長整数で実行する場合、結果は近似値になる可能性があります。

すべての文書における最小価格値の計算:

Python

resp = client.search(
   index="sales",
   size="0",
   aggs={
   "min_price": {
   "min": {
   "field": "price"
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  size: 0,
  body: {
   aggregations: {
   min_price: {
   min: {
   field: 'price'
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  size: 0,
  aggs: {
   min_price: {
   min: {
   field: "price",
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search?size=0
{
  "aggs": {
   "min_price": { "min": { "field": "price" } }
  }
}

レスポンス:

コンソール-結果

{
  ...
  "aggregations": {
   "min_price": {
   "value": 10.0
   }
  }
}

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

スクリプト

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

Python

resp = client.search(
   index="sales",
   size=0,
   runtime_mappings={
   "price.adjusted": {
   "type": "double",
   "script": "\n        double price = doc['price'].value;\n        if (doc['promoted'].value) {\n          price *= 0.8;\n        }\n        emit(price);\n      "
   }
   },
   aggs={
   "min_price": {
   "min": {
   "field": "price.adjusted"
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  body: {
   size: 0,
   runtime_mappings: {
   'price.adjusted' => {
   type: 'double',
   script: "\n        double price = doc['price'].value;\n        if (doc['promoted'].value) {\n          price *= 0.8;\n        }\n        emit(price);\n      "
   }
   },
   aggregations: {
   min_price: {
   min: {
   field: 'price.adjusted'
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  size: 0,
  runtime_mappings: {
   "price.adjusted": {
   type: "double",
   script:
   "\n        double price = doc['price'].value;\n        if (doc['promoted'].value) {\n          price *= 0.8;\n        }\n        emit(price);\n      ",
   },
  },
  aggs: {
   min_price: {
   min: {
   field: "price.adjusted",
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search
{
  "size": 0,
  "runtime_mappings": {
   "price.adjusted": {
   "type": "double",
   "script": """
   double price = doc['price'].value;
   if (doc['promoted'].value) {
   price *= 0.8;
   }
   emit(price);
   """
   }
  },
  "aggs": {
   "min_price": {
   "min": { "field": "price.adjusted" }
   }
  }
}

欠損値

missing パラメータは、値が欠損している文書がどのように扱われるべきかを定義します。デフォルトでは無視されますが、値があるかのように扱うことも可能です。

Python

resp = client.search(
   index="sales",
   aggs={
   "grade_min": {
   "min": {
   "field": "grade",
   "missing": 10
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  body: {
   aggregations: {
   grade_min: {
   min: {
   field: 'grade',
   missing: 10
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  aggs: {
   grade_min: {
   min: {
   field: "grade",
   missing: 10,
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search
{
  "aggs": {
   "grade_min": {
   "min": {
   "field": "grade",
   "missing": 10
   }
   }
  }
}


	`grade` フィールドに値がない文書は、値が `10` である文書と同じバケットに入ります。

ヒストグラムフィールド

min がヒストグラムフィールドで計算されると、集約の結果は 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={
   "min_latency": {
   "min": {
   "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: {
   min_latency: {
   min: {
   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: {
   min_latency: {
   min: {
   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" : {
   "min_latency" : { "min" : { "field" : "latency_histo" } }
  }
}

min 集約は、すべてのヒストグラムフィールドの最小値を返します:

コンソール-結果

{
  "aggregations": {
   "min_latency": {
   "value": 0.1
   }
  }
}