当前位置: 首页 > 面试题库 >

按嵌套文档之一中的值对文档进行排序

阮炯
2023-03-14
问题内容

我在基于所选嵌套文档中的值对文档进行排序时遇到问题。我正在使用这样的设置:

curl -XPUT 'http://127.0.0.1:9200/test/' -d '
index :
    number_of_shards : 1
    number_of_replicas : 1
'


curl -XPUT '127.0.0.1:9200/test/item/_mapping' -d '
{
"item" : {
 "properties" : {
  "name" : {"type" : "string", "store": "yes"},
  "children" : {
   "properties" : {
     "name" : {"type" : "string", "store": "yes"},
     "id" : {"type" : "integer", "store": "yes"},
     "size" : {"type" : "integer", "store": "yes"}
   },
   "type": "nested"
  }
 }
}
}'


curl -XPUT 'http://localhost:9200/test/item/1' -d '{
    "name" : "item1",
    "children": [
      {
        "id": 11,
        "size": 15
      }, 
      {
        "id":3,
        "size": 6
      }
     ]
    }
}'
curl -XPUT 'http://localhost:9200/test/item/2' -d '{
    "name" : "item2",
    "children": [
      {
        "id": 1,
        "size": 2
      }, 
      {
        "id":3,
        "size": 6
      }
     ]
    }
}'
curl -XPUT 'http://localhost:9200/test/item/3' -d '{
    "name" : "item3",
    "children": [
      {
        "id": 1,
        "size": 7
      }, 
      {
        "id":3,
        "size": 36
      }
     ]
    }
}'
curl -XPUT 'http://localhost:9200/test/item/4' -d '{
    "name" : "item4",
    "children": [
      {
        "id": 1,
        "size": 11
      }, 
      {
        "id":3,
        "size": 16
      }
     ]
    }
}'

我要检索的是具有所选子代ID的文档,这些文档将按所选子代的大小进行排序。因此查询看起来像:

    curl -XGET 'http://127.0.0.1:9200/test/item/_search?pretty=1'  -d '
{
  "query": {
    "filtered": {
      "query": {
        "match_all": {}
      },
      "filter": {
        "nested": {
          "filter": {
            "term": {
              "id": 1
            }
          },
          "path": "children"
        }
      }
    }
  },
  "sort": [
    {
      "children.size": {
        "order": "asc",
        "nested_filter": {
          "nested": {
            "filter": {
              "term": {
                "id": 1
              }
            },
            "path": "children"
          }
        }
      }
    }
  ]
}
'

在此查询中,无论我输入“ order”字段(asc还是desc),返回的文档都是相同的顺序。可能是什么问题?


问题答案:

看起来您构建嵌套过滤器的方式不正确。您在这里列出的内容也不适合我。

但是当我替换这个:

"sort": [
    {
      "children.size": {
        "order": "asc",
        "nested_filter": {
          "nested": {
            "filter": {
              "term": {
                "id": 1
              }
            },
            "path": "children"
          }
        }
      }
    }
]

有了这个:

"sort": [
   {
      "children.size": {
         "order": "desc",
         "nested_filter": {
            "term": {
               "id": 1
            }
         }
      }
   }
]

有效。

更准确地说,我建立了索引并添加了数据:

DELETE /test_index

PUT /test_index/
{
    "settings": {
        "number_of_shards": 1,
        "number_of_replicas": 0
    }
}

PUT /test_index/item/_mapping
{
   "item": {
      "properties": {
         "name": {
            "type": "string",
            "store": "yes"
         },
         "children": {
            "properties": {
               "name": {
                  "type": "string",
                  "store": "yes"
               },
               "id": {
                  "type": "integer",
                  "store": "yes"
               },
               "size": {
                  "type": "integer",
                  "store": "yes"
               }
            },
            "type": "nested"
         }
      }
   }
}

PUT /test_index/item/1
{"name":"item1","children":[{"id":11,"size":15},{"id":3,"size":6}]}

PUT /test_index/item/2
{"name":"item2","children":[{"id":1,"size":2},{"id":3,"size":6}]}

PUT /test_index/item/3
{"name":"item3","children":[{"id":1,"size":7},{"id":3,"size":36}]}

PUT /test_index/item/4
{"name":"item4","children":[{"id":1,"size":11},{"id":3,"size":16}]}

然后使用进行搜索,如下所示,"order": "desc"它似乎可以正常运行:

POST /test_index/item/_search
{
   "query": {
      "filtered": {
         "query": {
            "match_all": {}
         },
         "filter": {
            "nested": {
               "filter": {
                  "term": {
                     "id": 1
                  }
               },
               "path": "children"
            }
         }
      }
   },
   "sort": [
      {
         "children.size": {
            "order": "desc",
            "mode": "avg",
            "nested_filter": {
               "term": {
                  "id": 1
               }
            }
         }
      }
   ]
}
...
{
   "took": 2,
   "timed_out": false,
   "_shards": {
      "total": 1,
      "successful": 1,
      "failed": 0
   },
   "hits": {
      "total": 3,
      "max_score": null,
      "hits": [
         {
            "_index": "test_index",
            "_type": "item",
            "_id": "4",
            "_score": null,
            "_source": {
               "name": "item4",
               "children": [
                  {
                     "id": 1,
                     "size": 11
                  },
                  {
                     "id": 3,
                     "size": 16
                  }
               ]
            },
            "sort": [
               11
            ]
         },
         {
            "_index": "test_index",
            "_type": "item",
            "_id": "3",
            "_score": null,
            "_source": {
               "name": "item3",
               "children": [
                  {
                     "id": 1,
                     "size": 7
                  },
                  {
                     "id": 3,
                     "size": 36
                  }
               ]
            },
            "sort": [
               7
            ]
         },
         {
            "_index": "test_index",
            "_type": "item",
            "_id": "2",
            "_score": null,
            "_source": {
               "name": "item2",
               "children": [
                  {
                     "id": 1,
                     "size": 2
                  },
                  {
                     "id": 3,
                     "size": 6
                  }
               ]
            },
            "sort": [
               2
            ]
         }
      ]
   }
}

这是我使用的代码:

http://sense.qbox.io/gist/1582560ed13bec82dc321944a639336ad7ae6a60



 类似资料:
  • 问题内容: 可以说我有以下映射: 然后,我对父文档进行“ _geo_distance”排序,并能够对“ site.point”上的文档进行排序。但是,我还希望嵌套位置在父文档中按“ _geo_distance”排序。 这可能吗?如果是这样,怎么办? 问题答案: 不幸的是,没有(至少现在还没有)。 ElasticSearch中的查询仅标识与该查询匹配的文档以及它们的匹配程度。 要了解嵌套文档的用途,

  • 如何用条件(type=“block”)对所有记录进行分组? 我已尝试:db.itr.aggregate({$match:{“UIN”:“1396599472869”}},{$project:{“VM”:1}},{$group:{_id:null,r1:{$push:“$VM”}}},{$unwind:“$R1”},{$group:{_id:null,r2:{$push:“$R1”}},{$unwi

  • null 我也尝试使用scripted_field,但是脚本字段似乎是在最后一个阶段计算的,在查询过程中不可用。 我也有一个按照相同逻辑进行排序的方法(根据给定仓库中库存的总和对产品进行排序),它像一个魅力一样工作: 但我也找不到访问此排序值的方法:(

  • 在这里给ElasticSearch的初学者排名。 我有一个客户列表,他们的订单作为一个嵌套字段。假设文档结构如下: 我想查询的是:在两个日期之间订购了一定数量的用户列表。我希望能够将它与例如生日的范围查询结合起来。 我已经到了这样的地步,我可以使用聚合来获得每个订户在两个日期之间的排序总和: 但是,我想限制查询部分返回的结果,以便更好地与所有其他过滤器混合。 我的第一个想法是使用一个脚本过滤器,并

  • 问题内容: 我有看起来像这样的文档(以下是两个示例): 和 数组中子文档的格式将始终具有an 和a,但是这些子文档的数量将可变,每个子文档具有不同的值。 我想知道是否可以根据与特定值匹配的值之一对这种格式的文档进行排序。我真的很想能够做到这一点: 通过对文档进行排序下降,其中相关的。文档s 的最终排序为1234,6346。 通过对文档进行排序下降,其中相关的。文档s 的最终排序为6346,1234

  • 问题内容: 我正在编写资产管理应用程序。它允许用户通过向资产添加html控件(例如文本字段,选择菜单等)来存储任意资产属性。然后,该属性的JSON表示成为存储在beddb中的资产JSON文档的一部分。资产在ouchdb中具有以下结构: 我不确定将属性放入数组是否是允许基于属性值搜索资产的最佳方法。将属性直接附加到资产作为属性会更好吗?我正在用Elasticsearch做实验。如果我尝试按原样存储文