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

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]"
               ]
            }
         }
      }
   }
}

没有更多的排序阶段！

---

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