Java ElasticSearch排序是'；t按字段排序

我试图对指定的字段执行字段排序，但没有效果。当我运行脚本时，查询一直返回相同的位置

以下是ElasticSearch脚本：

{
  "from": 0,
  "size": 10,
  "timeout": "60s",
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "must": [
              {
                "query_string": {
                  "query": "random",
                  "fields": [],
                  "type": "best_fields",
                  "default_operator": "or",
                  "max_determinized_states": 10000,
                  "enable_position_increments": true,
                  "fuzziness": "AUTO",
                  "fuzzy_prefix_length": 0,
                  "fuzzy_max_expansions": 50,
                  "phrase_slop": 0,
                  "escape": false,
                  "auto_generate_synonyms_phrase_query": true,
                  "fuzzy_transpositions": true,
                  "boost": 1
                }
              },
              {
                "nested": {
                  "query": {
                    "bool": {
                      "must": [
                        {
                          "match": {
                            "reviews.source": {
                              "query": "TEST",
                              "operator": "AND",
                              "prefix_length": 0,
                              "max_expansions": 50,
                              "fuzzy_transpositions": true,
                              "lenient": false,
                              "zero_terms_query": "NONE",
                              "auto_generate_synonyms_phrase_query": true,
                              "boost": 1
                            }
                          }
                        }
                      ],
                      "adjust_pure_negative": true,
                      "boost": 1
                    }
                  },
                  "path": "reviews",
                  "ignore_unmapped": false,
                  "score_mode": "avg",
                  "boost": 1,
                  "inner_hits": {
                    "name": "reviews",
                    "ignore_unmapped": false,
                    "from": 0,
                    "size": 3,
                    "version": false,
                    "seq_no_primary_term": false,
                    "explain": false,
                    "track_scores": false
                  }
                }
              }
            ],
            "adjust_pure_negative": true,
            "boost": 1
          }
        }
      ],
      "should": [
        {
          "match": {
            "dataset": {
              "query": "QUERY_TEST",
              "operator": "OR",
              "prefix_length": 0,
              "max_expansions": 50,
              "fuzzy_transpositions": true,
              "lenient": false,
              "zero_terms_query": "NONE",
              "auto_generate_synonyms_phrase_query": true,
              "boost": 1
            }
          }
        }
      ],
      "adjust_pure_negative": true,
      "minimum_should_match": "1",
      "boost": 1
    }
  },
  "sort": [
    {
      "_score": {
        "order": "desc"
      }
    },
    {
      "reviews.openedAt": {
        "order": "desc",
        "nested": {
          "path": "reviews"
        }
      }
    }
  ]
}

我当前使用的映射：

"reviews": {
        "type": "nested",
        "properties": {
          "id": {
            "type": "keyword",
            "copy_to": "fulltext"
          },
          "updatedAt": {
            "type": "date",
            "format": "strict_date_time",
            "index": false
          },
          "openedAt": {
            "type": "date",
            "format": "strict_date_time"
          }

我试图根据评论部分中的特定日期对记录进行排序。如果用户输入ASC，返回值（评审）应根据openedAt日期按升序排列。我相信排序函数不一定会找到正确的路径。排序函数应该是什么样的

我创建了一个Java API，用于调用请求并创建自己的记录集：

public SearchResponse(SearchResponse response, SearchRequest searchRequest) {
        this.facets = new ArrayList<>();
        if (searchRequest == null || searchRequest.getRestricted().isEmpty()) {
            this.records =
              Stream.of(response.getHits().getHits()).map(SearchHit::getSourceAsMap).collect(Collectors.toList());
        } else {
            this.records = processRestrictedResults(response, searchRequest);
        }
        if (response.getAggregations() != null) {
            for (Map.Entry<String, Aggregation> entry : response.getAggregations().getAsMap().entrySet()) {
                this.facets.add(Facet.create(entry));
            }
        }
        this.totalRecords = getTotalMatched(response);
}

public SearchResponse（SearchResponse响应，SearchRequest SearchRequest）{
this.facets=新的ArrayList（）；
if（searchRequest==null | | searchRequest.getRestricted（）.isEmpty（））{
这是我的记录=
Stream.of（response.getHits（）.getHits（））.map（SearchHit:：getSourceAsMap.collect（Collectors.toList（））；
}否则{
this.records=processRestrictedResults（响应、搜索请求）；
}
if（response.getAggregations（）！=null）{
对于（Map.Entry:response.getAggregations（）.getAsMap（）.entrySet（））{
this.facets.add（Facet.create（条目））；
}
}
this.totalRecords=getTotalMatched（响应）；
}

为了回答最初的问题，顶级点击量确实是按照最新的

评论进行排序的。openedAt

按降序排列-来自doc#2的其中一个评论的值

2021-04-06T08:13:53.552Z

大于唯一的

评论。openedAt

来自doc#1（

2021-03-30T08:13:53.552Z

），因此2排在1之前

不过，正如我解释和解释的那样，你缺少的是

在您的特定用例中，这意味着：

{
“from”：0，
“尺寸”：10，
“超时”：“60秒”，
“查询”：{
“布尔”：{
“必须”：[
…//您最初的查询
{
“嵌套”：{
“路径”：“评论”，与您期望的相比，压缩响应是什么样子的？这是压缩响应的两个记录：1:
“评论”：[{“assignedTo”：“Anna D.Analyst”，“openedAt”：“2021-03-30T08:13:53.552Z”，“updatedAt”：“2021-03-03T11:22:33.123Z”，}]
2:
“评论”：[{“assignedTo”：“Anna D.Analyst”，“openedAt”：“2021-03-06T08:13:53.552Z”，“privateComment”：“updatedAt”：“2021-03-03T11:22:33.123Z”}，{“assignedTo”：“Kevin D.Analyst”，“openedAt”：“2021-04-06T08:13:53.552Z”，“updatedAt”：“2021-03-03T11:22:33.123Z}
我希望响应根据openedAt字段按降序排序