最大（Max）

最大集約

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

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

すべての文書にわたる最大価格値の計算

Python

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

Ruby

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

Js

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

コンソール

POST /sales/_search?size=0
{
  "aggs": {
   "max_price": { "max": { "field": "price" } }
  }
}

レスポンス:

コンソール-結果

{
  ...
  "aggregations": {
   "max_price": {
   "value": 200.0
   }
  }
}

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

スクリプト

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

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={
   "max_price": {
   "max": {
   "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: {
   max_price: {
   max: {
   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: {
   max_price: {
   max: {
   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": {
   "max_price": {
   "max": { "field": "price.adjusted" }
   }
  }
}

欠損値

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

Python

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

Ruby

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

Js

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

コンソール

POST /sales/_search
{
  "aggs" : {
   "grade_max" : {
   "max" : {
   "field" : "grade",
   "missing": 10
   }
   }
  }
}

ヒストグラムフィールド

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

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

コンソール-結果

{
  "aggregations": {
   "max_latency": {
   "value": 0.5
   }
  }
}