Question

如何通过按字符串数组排序进行查询，该字符串数组将在其计划中没有"stage" : "SORT"的情况下执行？

我正在使用mongo 3.6
“ mycoll”集合包含大约500.000个文档，如下所示：

{
    someobject:{
        arrayfield:["asd","qwe"]
    }
}

{
    someobject:{
        arrayfield:["zxc"]
    }
}

此查询

db.mycoll.find().sort({ "someobject.arrayfield": 1 }).skip(125340).limit(20)

产生错误

排序操作所使用的RAM超过了最大的33554432字节

我在“ someobject.arrayfield”上有索引，但是explain（）给了我：

 "winningPlan" : {
            "stage" : "SKIP",
            "skipAmount" : 125340,
            "inputStage" : {
                    "stage" : "SORT",
                    "sortPattern" : {
                            "someobject.arrayfield" : 1
                    },
                    "limitAmount" : 125360,
                    "inputStage" : {
                            "stage" : "SORT_KEY_GENERATOR",
                            "inputStage" : {
                                    "stage" : "FETCH",
                                    "inputStage" : {
                                            "stage" : "IXSCAN",
                                            "keyPattern" : {
                                                    "someobject.arrayfield" : 1
                                            },
                                            "indexName" : "arrayfield_indexname",

                                            "isMultiKey" : true,
                                            "multiKeyPaths" : {
                                                    "someobject.arrayfield" : [
                                                            "someobject.arrayfield"
                                                    ]
                                            },
                                            "isUnique" : false,
                                            "isSparse" : false,
                                            "isPartial" : false,
                                            "indexVersion" : 2,
                                            "direction" : "forward",
                                            "indexBounds" : {
                                                    "someobject.arrayfield" : [
                                                            "[MinKey, MaxKey]"
                                                    ]
                                            }
                                    }
                            }
                    }
            }
    }

我知道，我可以增加限制，将聚合与'allowdiskusage'或查询一起使用

db.mycoll.find().sort({ "someobject.arrayfield.1": 1 }).skip(125340).limit(20)

在“ someobject.arrayfield.1”上具有索引

Answer 1

我有一个潜在的解决方案，具体取决于数组中的实际值，以及您是否需要稳定的排序，或者是否需要基于mongodb使用的数组比较逻辑的排序。

如果您不想阅读有关mongodb如何比较数组的详细信息，请跳至建议的解决方案部分。

起初，我很好奇数组字段上的.sort()将如何对结果进行排序。它会使用第一个数组值进行比较吗？还是这些值的组合？

经过一些测试，看起来mongodb使用数组中的所有值进行比较和排序。这是我的测试数据（为简便起见，省略了_id字段）：

db.mycoll.find().sort({"someobject.arrayfield":1})
{ "someobject" : { "arrayfield" : [ "rty", "aaa" ] } }
{ "someobject" : { "arrayfield" : [ "xcv", "aaa", "bcd" ] } }
{ "someobject" : { "arrayfield" : [ "aaa", "xcv", "bcd" ] } }
{ "someobject" : { "arrayfield" : [ "asd", "qwe" ] } }
{ "someobject" : { "arrayfield" : [ "bnm" ] } }
{ "someobject" : { "arrayfield" : [ "dfg", "sdf" ] } }
{ "someobject" : { "arrayfield" : [ "qwe" ] } }

如您所见，它不是基于数组的第一个值进行排序，而是使用一些内部逻辑比较整个数组。如何确定[ "rty", "aaa" ]应该准确地排在[ "xcv", "aaa", "bcd" ]之前？为什么[ "xcv", "aaa", "bcd" ]在[ "aaa", "xcv", "bcd" ]之前？还是他们相等，并且使用_id作为决胜局？我真的不知道。

我认为可能是使用标准的javascript比较运算符，但事实并非如此。我为每个数组制作了一个数组，并在其中调用了.sort()并得到了它：

x.sort()
[ [ 'aaa', 'xcv', 'bcd' ],
  [ 'asd', 'qwe' ],
  [ 'bnm' ],
  [ 'dfg', 'sdf' ],
  [ 'qwe' ],
  [ 'rty', 'aaa' ],
  [ 'xcv', 'aaa', 'bcd' ] ]

这很有意义，因为显然javascript array comparison用逗号定界符将元素连接起来，然后进行字符串比较。

建议的解决方案

mongodb中的数组比较逻辑对我来说是一个谜。但是，这开辟了一种可能性，使您可能不在乎 mongodb的神秘数组比较逻辑。如果您想要的只是一种稳定的排序方式，以便您可以跳过和限制分页，那么我想我有一个解决方案。

如果我们像这样在数组的第一个值上创建索引（使用background:1以避免锁定数据库）：

db.mycoll.createIndex( { "someobject.arrayfield.0":1 }, {background:1} )

然后我们可以执行查找查询并对数组中的第一个对象进行排序，这将避免SORT阶段：

mongos> db.mycoll.find().sort({"someobject.arrayfield.0":1}).explain()

"winningPlan" : {
   "stage" : "LIMIT",
   "limitAmount" : 1,
   "inputStage" : {
      "stage" : "SKIP",
      "skipAmount" : 1,
      "inputStage" : {
         "stage" : "FETCH",
         "inputStage" : {
            "stage" : "IXSCAN",
            "keyPattern" : {
               "someobject.arrayfield.0" : 1
            },
            "indexName" : "someobject.arrayfield.0_1",
            "isMultiKey" : false,
            "multiKeyPaths" : {
               "someobject.arrayfield.0" : [ ]
            },
            "isUnique" : false,
            "isSparse" : false,
            "isPartial" : false,
            "indexVersion" : 2,
            "direction" : "forward",
            "indexBounds" : {
               "someobject.arrayfield.0" : [
                  "[MinKey, MaxKey]"
               ]
            }
         }
      }
   }
}

不再有SORT阶段！

此提议的解决方案基于一个很大的假设，即您愿意接受与原始查询所提供的排序顺序不同的排序顺序。我希望该解决方案能够起作用，并且您能够以这种方式实施它。如果没有，也许其他人可以扩展这个想法。

Mongodb按字符串数组排序并使用索引

1 个答案:

建议的解决方案