値のカウント（Value count）

値のカウント集約

集約されたドキュメントから抽出された値の数をカウントする single-value メトリクス集約です。これらの値は、ドキュメント内の特定のフィールドから抽出されるか、提供されたスクリプトによって生成されることがあります。通常、この集約器は他の単一値集約と組み合わせて使用されます。たとえば、avg を計算する際には、平均が計算される値の数に関心があるかもしれません。

value_count は値を重複排除しないため、フィールドに重複があっても各値は個別にカウントされます。

Python

resp = client.search(
   index="sales",
   size="0",
   aggs={
   "types_count": {
   "value_count": {
   "field": "type"
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  size: 0,
  body: {
   aggregations: {
   types_count: {
   value_count: {
   field: 'type'
   }
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithIndex("sales"),
    es.Search.WithBody(strings.NewReader(`{
      "aggs": {
      "types_count": {
      "value_count": {
      "field": "type"
      }
      }
      }
    }`)),
    es.Search.WithSize(0),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  index: "sales",
  size: 0,
  aggs: {
   types_count: {
   value_count: {
   field: "type",
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search?size=0
{
  "aggs" : {
   "types_count" : { "value_count" : { "field" : "type" } }
  }
}

レスポンス:

コンソール結果

{
  ...
  "aggregations": {
   "types_count": {
   "value": 7
   }
  }
}

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

スクリプト

単一フィールドの値よりも複雑なものをカウントする必要がある場合は、ランタイムフィールドで集約を実行する必要があります。

Python

resp = client.search(
   index="sales",
   size=0,
   runtime_mappings={
   "tags": {
   "type": "keyword",
   "script": "\n        emit(doc['type'].value);\n        if (doc['promoted'].value) {\n          emit('hot');\n        }\n      "
   }
   },
   aggs={
   "tags_count": {
   "value_count": {
   "field": "tags"
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'sales',
  body: {
   size: 0,
   runtime_mappings: {
   tags: {
   type: 'keyword',
   script: "\n        emit(doc['type'].value);\n        if (doc['promoted'].value) {\n          emit('hot');\n        }\n      "
   }
   },
   aggregations: {
   tags_count: {
   value_count: {
   field: 'tags'
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "sales",
  size: 0,
  runtime_mappings: {
   tags: {
   type: "keyword",
   script:
   "\n        emit(doc['type'].value);\n        if (doc['promoted'].value) {\n          emit('hot');\n        }\n      ",
   },
  },
  aggs: {
   tags_count: {
   value_count: {
   field: "tags",
   },
   },
  },
});
console.log(response);

コンソール

POST /sales/_search
{
  "size": 0,
  "runtime_mappings": {
   "tags": {
   "type": "keyword",
   "script": """
   emit(doc['type'].value);
   if (doc['promoted'].value) {
   emit('hot');
   }
   """
   }
  },
  "aggs": {
   "tags_count": {
   "value_count": {
   "field": "tags"
   }
   }
  }
}

ヒストグラムフィールド

value_count 集約が ヒストグラムフィールド に対して計算されると、集約の結果はヒストグラムの counts 配列内のすべての数値の合計になります。

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

Python

resp = client.index(
   index="metrics_index",
   id="1",
   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(resp)
resp1 = client.index(
   index="metrics_index",
   id="2",
   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(resp1)
resp2 = client.search(
   index="metrics_index",
   size="0",
   aggs={
   "total_requests": {
   "value_count": {
   "field": "latency_histo"
   }
   }
   },
)
print(resp2)

Ruby

response = client.index(
  index: 'metrics_index',
  id: 1,
  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,
  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,
  body: {
   aggregations: {
   total_requests: {
   value_count: {
   field: 'latency_histo'
   }
   }
   }
  }
)
puts response

Go

{
    res, err := es.Index(
        "metrics_index",
        strings.NewReader(`{
      "network.name": "net-1",
      "latency_histo": {
      "values": [
          0.1,
          0.2,
          0.3,
          0.4,
          0.5
      ],
      "counts": [
      3,
      7,
      23,
      12,
      6
      ]
      }
    }`),
        es.Index.WithDocumentID("1"),
        es.Index.WithPretty(),
    )
    fmt.Println(res, err)
}
{
    res, err := es.Index(
        "metrics_index",
        strings.NewReader(`{
      "network.name": "net-2",
      "latency_histo": {
      "values": [
          0.1,
          0.2,
          0.3,
          0.4,
          0.5
      ],
      "counts": [
      8,
      17,
      8,
      7,
      6
      ]
      }
    }`),
        es.Index.WithDocumentID("2"),
        es.Index.WithPretty(),
    )
    fmt.Println(res, err)
}
{
    res, err := es.Search(
        es.Search.WithIndex("metrics_index"),
        es.Search.WithBody(strings.NewReader(`{
      "aggs": {
      "total_requests": {
      "value_count": {
      "field": "latency_histo"
      }
      }
      }
    }`)),
        es.Search.WithSize(0),
        es.Search.WithPretty(),
    )
    fmt.Println(res, err)
}

Js

const response = await client.index({
  index: "metrics_index",
  id: 1,
  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(response);
const response1 = await client.index({
  index: "metrics_index",
  id: 2,
  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(response1);
const response2 = await client.search({
  index: "metrics_index",
  size: 0,
  aggs: {
   total_requests: {
   value_count: {
   field: "latency_histo",
   },
   },
  },
});
console.log(response2);

コンソール

PUT metrics_index/_doc/1
{
  "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
{
  "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
{
  "aggs": {
   "total_requests": {
   "value_count": { "field": "latency_histo" }
   }
  }
}

各ヒストグラムフィールドに対して、value_count 集約は counts 配列内のすべての数値を合計します。最終的に、すべてのヒストグラムのすべての値を加算し、次の結果を返します:

コンソール結果

{
  ...
  "aggregations": {
   "total_requests": {
   "value": 97
   }
  }
}