搜索查询执行以下聚合：
上的术语聚合 id 领域
最小聚集打开 listItems.value max bucket aggregation是一个同级管道聚合，它用同级聚合中指定度量的最大值标识存储桶，并输出存储桶的值和密钥。
请参阅嵌套聚合，以获得有关它的详细说明。
添加索引数据、索引Map、搜索查询和搜索结果的工作示例。
索引Map：

{
  "mappings": {
    "properties": {
      "listItems": {
        "type": "nested" 
      },
      "id":{
        "type":"text",
        "fielddata":"true"
      }
    }
  }
}

索引数据：

{
    "id" : "1",
    "listItems" : 
        [
            {
                "key" : "li1",
                "value" : 100
            },
            {
                "key" : "li2",
                "value" : 5000
            }
        ]
}
{
    "id" : "2",
    "listItems" : 
        [
            {
                "key" : "li3",
                "value" : 200
            },
            {
                "key" : "li2",
                "value" : 2000
            }
        ]
}

搜索查询：

{
    "size": 0,
    "aggs": {
        "id_terms": {
            "terms": {
                "field": "id"
            },
            "aggs": {
                "nested_entries": {
                    "nested": {
                        "path": "listItems"
                    },
                    "aggs": {
                        "min_position": {
                            "min": {
                                "field": "listItems.value"
                            }
                        }
                    }
                }
            }
        },
        "maxValue": {
            "max_bucket": {
                "buckets_path": "id_terms>nested_entries>min_position"
            }
        }
    }
}

搜索结果：

"aggregations": {
    "id_terms": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "1",
          "doc_count": 1,
          "nested_entries": {
            "doc_count": 2,
            "min_position": {
              "value": 100.0
            }
          }
        },
        {
          "key": "2",
          "doc_count": 1,
          "nested_entries": {
            "doc_count": 2,
            "min_position": {
              "value": 200.0
            }
          }
        }
      ]
    },
    "maxValue": {
      "value": 200.0,
      "keys": [
        "2"
      ]
    }
  }

最初的帖子提到了嵌套聚合，所以我确信问题是关于嵌套文档的。因为我在看到另一个答案之前就已经找到了解决方案，所以我将把整个问题保留下来，但实际上它的不同之处只是添加了嵌套聚合。
整个过程可以这样解释：
将每个文档放入一个存储桶中。
使用嵌套聚合可以在嵌套文档上进行聚合。
使用 min 聚合以在所有文档嵌套文档中找到最小值，并以此为基础找到文档本身的最小值。
最后，使用另一个聚合来计算上一个聚合结果中的最大值。
鉴于此设置：

// PUT /index
{
  "mappings": {
    "properties": {
      "children": {
        "type": "nested",
        "properties": {
          "value": {
            "type": "integer"
          }
        }
      }
    }
  }
}

// POST /index/_doc
{
  "children": [
    { "value": 12 },
    { "value": 45 }
  ]
}

// POST /index/_doc
{
  "children": [
    { "value": 7 },
    { "value": 35 }
  ]
}

我可以在请求中使用这些聚合来获得所需的值：

{
  "size": 0,
  "aggs": {
    "document": {
      "terms": {"field": "_id"},

      "aggs": {
        "children": {
          "nested": {
            "path": "children"
          },
          "aggs": {
            "minimum": {
              "min": {
                "field": "children.value"
              }
            }
          }
        }
      }
    },
    "result": {
      "max_bucket": {
        "buckets_path": "document>children>minimum"
      }
    }
  }
}

{
  "aggregations": {
    "document": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "O4QxyHQBK5VO9CW5xJGl",
          "doc_count": 1,
          "children": {
            "doc_count": 2,
            "minimum": {
              "value": 7.0
            }
          }
        },
        {
          "key": "OoQxyHQBK5VO9CW5kpEc",
          "doc_count": 1,
          "children": {
            "doc_count": 2,
            "minimum": {
              "value": 12.0
            }
          }
        }
      ]
    },
    "result": {
      "value": 12.0,
      "keys": [
        "OoQxyHQBK5VO9CW5kpEc"
      ]
    }
  }
}

还应该有一个使用脚本来计算max的解决方法-您所需要做的只是在这样的脚本中查找并返回文档中的最小值。