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)

产生错误

Sort operation used more than the maximum 33554432 bytes of RAM

我在“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]"
               ]
            }
         }
      }
   }
}

不再需要排序阶段!

<小时/>

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