订购结果后订购嵌套字段集合

问题描述 投票:1回答:1

我有具有以下结构的文档:

{
    "name": "John Smith",
    "levels": [
        {
            "name": "Gold",
            "order": 4.0
        },
        {
            "name": "Bronze",
            "order": 2.0
        },
        {
            "name": "Silver",
            "order": 3.0
        }
    ]
}

一个人可以具有一个或多个“级别”,并且这些级别具有与之一起存储的“顺序”。

这个想法是,我们想按levels.order DESC排序ALL结果(所以那些白金和黄金人排在银/铜人之前)但是,在结果中,我要对源值ASC进行排序(所以青铜是第一位)

例如,说有两个文档:

[
    {
        "name": "Craig Jones",
        "levels": [
            {
                "name": "Silver",
                "order": 3.0
            },
            {
                "name": "Bronze",
                "order": 2.0
            }
        ]
    },
    {
        "name": "John Smith",
        "levels": [
            {
                "name": "Silver",
                "order": 3.0
            },
            {
                "name": "Gold",
                "order": 4.0
            },
            {
                "name": "Bronze",
                "order": 2.0
            }
        ]
    }
]

[当我以某种形式命中_search API(但没有查询)

{
    "sort": [
        {
            "levels.order": {
                "nested": {
                    "path": "levels"
                },
                "order": "desc"
            }
        }
    ]
}

...使我的结果恢复(按预期):

[
    {
        "name": "John Smith",
        "levels": [
            {
                "name": "Gold",
                "order": 4.0
            },
            {
                "name": "Silver",
                "order": 3.0
            },
            {
                "name": "Bronze",
                "order": 2.0
            }
        ]
    },
    {
        "name": "Craig Jones",
        "levels": [
            {
                "name": "Silver",
                "order": 3.0
            },
            {
                "name": "Bronze",
                "order": 2.0
            }
        ]
    }
]

[约翰·史密斯,然后是克雷格·琼斯(因为约翰有金)然后,对levels集合进行排序,但是方式错误。

我想做的是保持相同的文档顺序,但是返回级别集合ASC,所以我的预期结果将是:(请注意青铜,银,金-或2,3,4)

[
    {
        "name": "John Smith",
        "levels": [
            {
                "name": "Bronze",
                "order": 2.0
            },
            {
                "name": "Silver",
                "order": 3.0
            },
            {
                "name": "Gold",
                "order": 4.0
            },
        ]
    },
    {
        "name": "Craig Jones",
        "levels": [
            {
                "name": "Silver",
                "order": 3.0
            },
            {
                "name": "Bronze",
                "order": 2.0
            }
        ]
    }
]

这是可能做的,还是我需要编写此脚本?

也可能是相关的,如果我添加一个查询,例如必须具有'Gold'级别,则在排序中不遵循级别集合的顺序:

{
    "query": {
        "bool": {
            "filter": [
                {
                    "nested": {
                        "path": "levels",
                        "query": {
                            "bool": {
                                "must": [
                                    {
                                        "term": {
                                            "levels.name.keyword": {
                                                "value": "Gold"
                                            }
                                        }
                                    }
                                ]
                            }
                        }
                    }
                }
            ]
        }
    },
    "size": 10,
    "sort": [
        {
            "levels.order": {
                "nested": {
                    "path": "levels"
                },
                "order": "desc"
            }
        }
    ]
}

第一个文档的结果级别集合按其插入顺序:

"levels": [
    {
        "name": "Silver",
        "order": 3.0
    },
    {
        "name": "Gold",
        "order": 4.0
    },
    {
        "name": "Bronze",
        "order": 

此索引的映射如下:

{
    "index-name": {
        "mappings": {
            "properties": {
                "levels": {
                    "type": "nested",
                    "properties": {
                        "name": {
                            "type": "text",
                            "fields": {
                                "keyword": {
                                    "type": "keyword",
                                    "ignore_above": 256
                                }
                            }
                        },
                        "order": {
                            "type": "double"
                        }
                    }
                },

                "name": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256,
                            "normalizer": "case_insensitive_normalizer"
                        }
                    }
                },

            }
        }
    }
}
elasticsearch
1个回答
0
投票

要处理嵌套文档的排序,可以在嵌套查询中使用inner_hits属性。它支持inner_hits以及其他一些sort。使用下面的查询可获得所需的结果:

options

上述查询的结果将具有按GET <index>/_search { "query": { "nested": { "path": "levels", "query": { "match_all": {} }, "inner_hits": { "sort": { "levels.order": "asc" } } } }, "_source": { "excludes": "levels" }, "sort": [ { "levels.order": { "nested":{ "path":"levels" }, "order": "desc" } } ] } 排序的文档。对于每个命中,由于查询中levels.order_source属性,levels将包含除excludes以外的所有字段。每个匹配项都有另一个字段_source,其中嵌套的文档按level.order以asc顺序排序。

样本结果:

inner_hits
© www.soinside.com 2019 - 2024. All rights reserved.