Question

我有一个代码可以进行相当简单的查询 - 跳过限制 - 排序。我遇到了一个我很难解释的现象。

On＆＃34; small＆＃34;跳过价值 - 一切都很好。在＆＃34;高＆＃34;跳过值（＆gt; 18000） - 我无法获得超过20但不会出现以下错误的结果：

OperationFailure: Executor error during find command: OperationFailed: Sort operation used more than the maximum 33554432 bytes of RAM. Add an index, or specify a smaller limit.

问题是 - 为什么只有大跳数才会发生这种情况？我该如何解决这个问题？

在mongoShell上运行它（即使使用DBQuery.shellBatchSize = 300）也可以。它似乎正在使用索引。db.my_collection.find（{＆＃39;富＆＃39;：假}）跳过（19000）.limit（100）的.sort（{＆＃39; meta_data.created_at＆＃39; - 1}）。解释（）

"queryPlanner" : {
    "plannerVersion" : 1,
    "namespace" : "bla.my_collection",
    "indexFilterSet" : false,
    "parsedQuery" : {
        "foo" : {
            "$eq" : false
        }
    },
    "winningPlan" : {
        "stage" : "LIMIT",
        "limitAmount" : 100,
        "inputStage" : {
            "stage" : "SKIP",
            "skipAmount" : 9000,
            "inputStage" : {
                "stage" : "FETCH",
                "inputStage" : {
                    "stage" : "IXSCAN",
                    "keyPattern" : {
                        "foo" : 1,
                        "meta_data.created_at" : -1
                    },
                    "indexName" : "foo_1_meta_data.created_at_-1",
                    "isMultiKey" : false,
                    "multiKeyPaths" : {
                        "foo" : [ ],
                        "meta_data.created_at" : [ ]
                    },
                    "isUnique" : false,
                    "isSparse" : false,
                    "isPartial" : false,
                    "indexVersion" : 1,
                    "direction" : "forward",
                    "indexBounds" : {
                        "foo" : [
                            "[false, false]"
                        ],
                        "meta_data.created_at" : [
                            "[MaxKey, MinKey]"
                        ]
                    }
                }
            }
        }
    },

}

更多信息： 看来确实排序是在内存中完成的 - 它存在于被拒绝的计划中。那么可以做些什么呢？

"rejectedPlans" : [
            {
                "stage" : "SKIP",
                "skipAmount" : 19000,
                "inputStage" : {
                    "stage" : "SORT",
                    "sortPattern" : {
                        "meta_data.created_at" : -1
                    },
                    "limitAmount" : 19100,
                    "inputStage" : {
                        "stage" : "SORT_KEY_GENERATOR",
                        "inputStage" : {
                            "stage" : "FETCH",
                            "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                    "foo" : 1,
                                    "_id" : 1
                                },
                                "indexName" : "foo_1__id_1",
                                "isMultiKey" : false,
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 1,
                                "direction" : "forward",
                                "indexBounds" : {
                                    "foo" : [
                                        "[false, false]"
                                    ],
                                    "_id" : [
                                        "[MinKey, MaxKey]"
                                    ]
                                }
                            }
                        }
                    }
                }
            }

另一个问题。为什么只在大跳数时发生？为什么重要？

Answer 1

问题是-为什么仅在跳过次数大的情况下会发生这种情况？

这是因为排序正在内存中进行。提供排序和限制时，必须保留在内存中的文档数等于限制。如果存在跳过和限制，则保存在内存中的数字必须为“ skip + limit”。

我该如何解决？

您可以确保存在一个既支持排序又支持过滤器的索引，如果有一个索引但未被选择，则可以使用hint指定查询应使用的索引

为什么只在跳过次数大的情况下发生？

第一次运行特定查询时会选择“最佳”计划，然后在以后将其缓存（记住）。当跳过计数足够大时，可能效果不错且数量较少的最佳计划将不再有效。

Python Mongo＆＃34;排序操作使用超过最大值＆＃34;当跳过很高时

1 个答案: