sorting - 对嵌套数组进行排序并返回弹性中的前 10 名

标签 sorting elasticsearch

我在弹性索引中有一个嵌套数据类型,并且希望对所有返回的结果进行升序排序。我尝试过以下方法:

GET indexname/_search
{
                "_source" : ["m_iTopicID", "m_iYear", "m_Companies"],
                "query": {
                    "terms":{
                        "m_iTopicID": [11,12,13]
                    }
                },
   "sort" : [
       {
          "m_Companies.value" : {
             "order" : "asc",
             "nested_path" : "m_Companies"
          }
       }
    ]
}

索引的映射如下:

{
  "indexname": {
    "mappings": {
      "topicyear": {
        "properties": {
          "m_Companies": {
            "type": "nested",
            "properties": {
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "value": {
                "type": "float"
              }
            }
          },
          "m_People": {
            "type": "nested",
            "properties": {
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "value": {
                "type": "float"
              }
            }
          },
          "m_Places": {
            "type": "nested",
            "properties": {
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "value": {
                "type": "float"
              }
            }
          },
          "m_Subtopics": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "m_fActivation": {
            "type": "float"
          },
          "m_iDocBodyWordCnt": {
            "type": "long"
          },
          "m_iNodeID": {
            "type": "long"
          },
          "m_iTopicID": {
            "type": "long"
          },
          "m_iYear": {
            "type": "long"
          },
          "m_szDocID": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "m_szDocTitle": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "m_szGeo1": {
            "type": "nested",
            "properties": {
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "value": {
                "type": "float"
              }
            }
          },
          "m_szSourceType": {
            "type": "nested",
            "properties": {
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "value": {
                "type": "float"
              }
            }
          },
          "m_szSrcUrl": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "m_szTopicNames": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    }
  }
}

这将返回 ID 为 11、12 或 13 的所有主题以及 m_Companies 列表...但列表不会按值字段升序排序。

然后我只想返回每个列表的前 10 个。因此该列表不会像当前那样返回数百个,而是仅返回 n 个。如果我无法实现此选项,我将仅使用 javascript splice(0,10) 在前端获取前 10 个,但如果 elastic 可以为我做到这一点,那就太好了。

提前致谢。

最佳答案

由于您在主/父级别查询中提供了排序,因此这将仅对父/根文档进行排序。正如您可能在结果中观察到的那样,文档按照 m_Companes.value 的最小值进行排序。

要对每个文档的嵌套文档进行排序,您必须深入嵌套文档并应用排序,因为 m_Companies 是父文档中的子文档。您必须使用嵌套的inner_hits,然后对 inner_hits 进行排序.

这个github这个问题有一个很好的例子,说明了我试图解释的内容,即如何根据嵌套文档中的值仅对父/根文档进行排序。

由于您希望所有文档都是嵌套的,因此您可以让嵌套查询使用 match_all 获取所有嵌套文档并根据值字段进行排序。

您可以使用以下查询

{
    "_source": ["m_iYear", "m_Companies"],
    "query": {
        "bool": {
            "must": [{
                    "terms": {
                        "m_iTopicID": [11, 12, 13]
                    }
                },
                {
                    "nested": {
                        "path": "m_Companies",
                        "query": {
                            "match_all": {}
                        },
                        "inner_hits": {
                            "sort": [{
                                "m_Companies.value": "asc"
                            }]
                        }
                    }
                }
            ]
        }
    },
    "sort": [{
        "m_Companies.value": {
            "order": "asc",
            "nested_path": "m_Companies"
        }
    }]
}

希望这有帮助, 谢谢

关于sorting - 对嵌套数组进行排序并返回弹性中的前 10 名,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/43426444/

相关文章:

elasticsearch - 查询中的Elasticsearch索引

python - md5 id批量导入数据到elasticsearch时出现UnicodeDecodeError

python - 使用其构造函数初始化 OrderedDict 以使其保留初始数据顺序的正确方法?

python - 如何在 Python 中对列表进行排序和过滤?

elasticsearch - 在 Elasticsearch 上索引任意属性值对的最佳方法

elasticsearch - logstash dns 过滤器中的 hit_cache_size 如何工作?

elasticsearch - 如何在 Elasticsearch 中返回以特定字母或特定字母开头的字段的结果?

algorithm - 为合并排序算法创建决策树

sorting - <=>在grails排序中是什么意思

javascript - 这个 JavaScript 数字比较函数实际上是如何工作的?