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 数组比较用逗号分隔符连接元素，然后进行字符串比较。

建议的解决方案

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 阶段！

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