MongoDB 内存排序在索引创建前后的效果样例

最新推荐文章于 2023-12-22 22:07:26 发布
最新推荐文章于 2023-12-22 22:07:26 发布
阅读量923 收藏
点赞数
分类专栏： mongo MongoDB执行计划 文章标签： MongoDB 内存排序在索引创建前后的效果样例 MongoDB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyh200896/article/details/101441046
版权

假设一个collection tygzJyrzVO，有7512条数据

数据长这样子的

试图排序后拿前10条数据
报排序超过了最大内存限制异常。报错的完整信息如下

 

Error: error: {    "operationTime" : Timestamp(1569469310, 2),    "ok" : 0,    "errmsg" : "Executor error during find command :: caused by :: Sort operation used more than the maximum 33554432 bytes of RAM. Add an index, or specify a smaller limit.",    "code" : 96,    "codeName" : "OperationFailed",    "$clusterTime" : {        "clusterTime" : Timestamp(1569469310, 2),        "signature" : {            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),            "keyId" : NumberLong(0)        }    }}

提示也非常明显：增加索引或者指定更小的limit

减小limit

expalin limit(8)的时候，看下查询分析数据 db.tygzJyrzVO.find().sort({lrrq:-1}).limit(8).explain("allPlansExecution");

{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "taxcp_dev.tygzJyrzVO",
        "indexFilterSet" : false,
        "parsedQuery" : {
            
        },
        "winningPlan" : {
            "stage" : "SORT",
            "sortPattern" : {
                "lrrq" : -1
            },
            "limitAmount" : 8,
            "inputStage" : {
                "stage" : "SORT_KEY_GENERATOR",
                "inputStage" : {
                    "stage" : "COLLSCAN",
                    "direction" : "forward"
                }
            }
        },
        "rejectedPlans" : [ ]
    },
    "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 8,
        "executionTimeMillis" : 138,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 7512,
        "executionStages" : {
            "stage" : "SORT",
            "nReturned" : 8,
            "executionTimeMillisEstimate" : 106,
            "works" : 7524,
            "advanced" : 8,
            "needTime" : 7515,
            "needYield" : 0,
            "saveState" : 60,
            "restoreState" : 60,
            "isEOF" : 1,
            "invalidates" : 0,
            "sortPattern" : {
                "lrrq" : -1
            },
            "memUsage" : 19217,
            "memLimit" : 33554432,
            "limitAmount" : 8,
            "inputStage" : {
                "stage" : "SORT_KEY_GENERATOR",
                "nReturned" : 7512,
                "executionTimeMillisEstimate" : 5,
                "works" : 7515,
                "advanced" : 7512,
                "needTime" : 2,
                "needYield" : 0,
                "saveState" : 60,
                "restoreState" : 60,
                "isEOF" : 1,
                "invalidates" : 0,
                "inputStage" : {
                    "stage" : "COLLSCAN",
                    "nReturned" : 7512,
                    "executionTimeMillisEstimate" : 2,
                    "works" : 7514,
                    "advanced" : 7512,
                    "needTime" : 1,
                    "needYield" : 0,
                    "saveState" : 60,
                    "restoreState" : 60,
                    "isEOF" : 1,
                    "invalidates" : 0,
                    "direction" : "forward",
                    "docsExamined" : 7512
                }
            }
        },
        "allPlansExecution" : [ ]
    },
    "serverInfo" : {
        "host" : "dyh231",
        "port" : 27017,
        "version" : "4.0.11",
        "gitVersion" : "417d1a712e9f040d54beca8e4943edce218e9a8c"
    },
    "ok" : 1,
    "operationTime" : Timestamp(1569470061, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1569470061, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

 

expalin limit(10)的时候 ，db.tygzJyrzVO.find().sort({lrrq:-1}).limit(10).explain("allPlansExecution");

{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "taxcp_dev.tygzJyrzVO",
        "indexFilterSet" : false,
        "parsedQuery" : {
            
        },
        "winningPlan" : {
            "stage" : "SORT",
            "sortPattern" : {
                "lrrq" : -1
            },
            "limitAmount" : 10,
            "inputStage" : {
                "stage" : "SORT_KEY_GENERATOR",
                "inputStage" : {
                    "stage" : "COLLSCAN",
                    "direction" : "forward"
                }
            }
        },
        "rejectedPlans" : [ ]
    },
    "executionStats" : {
        "executionSuccess" : false,
        "errorMessage" : "Exec error resulting in state FAILURE :: caused by :: Sort operation used more than the maximum 33554432 bytes of RAM. Add an index, or specify a smaller limit.",
        "errorCode" : 96,
        "nReturned" : 0,
        "executionTimeMillis" : 115,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 7080,
        "executionStages" : {
            "stage" : "SORT",
            "nReturned" : 0,
            "executionTimeMillisEstimate" : 112,
            "works" : 7083,
            "advanced" : 0,
            "needTime" : 7082,
            "needYield" : 0,
            "saveState" : 56,
            "restoreState" : 56,
            "isEOF" : 0,
            "invalidates" : 0,
            "sortPattern" : {
                "lrrq" : -1
            },
            "memUsage" : 36125389,
            "memLimit" : 33554432,
            "limitAmount" : 10,
            "inputStage" : {
                "stage" : "SORT_KEY_GENERATOR",
                "nReturned" : 7080,
                "executionTimeMillisEstimate" : 6,
                "works" : 7082,
                "advanced" : 7080,
                "needTime" : 2,
                "needYield" : 0,
                "saveState" : 56,
                "restoreState" : 56,
                "isEOF" : 0,
                "invalidates" : 0,
                "inputStage" : {
                    "stage" : "COLLSCAN",
                    "nReturned" : 7080,
                    "executionTimeMillisEstimate" : 0,
                    "works" : 7081,
                    "advanced" : 7080,
                    "needTime" : 1,
                    "needYield" : 0,
                    "saveState" : 56,
                    "restoreState" : 56,
                    "isEOF" : 0,
                    "invalidates" : 0,
                    "direction" : "forward",
                    "docsExamined" : 7080
                }
            }
        },
        "allPlansExecution" : [ ]
    },
    "serverInfo" : {
        "host" : "dyh231",
        "port" : 27017,
        "version" : "4.0.11",
        "gitVersion" : "417d1a712e9f040d54beca8e4943edce218e9a8c"
    },
    "ok" : 1,
    "operationTime" : Timestamp(1569470101, 722),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1569470101, 722),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

说明，在排序过程中，limit(10)无法获取所有collection记录来进行排序就排序内存大小超限了（32MB）,而limit(8)的时候排序成功了。

建立索引

db.tygzJyrzVO.ensureIndex({lrrq:-1},{background:true});

再看 db.tygzJyrzVO.find().sort({lrrq:-1}).limit(10).explain("allPlansExecution");

{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "taxcp_dev.tygzJyrzVO",
        "indexFilterSet" : false,
        "parsedQuery" : {
            
        },
        "winningPlan" : {
            "stage" : "LIMIT",
            "limitAmount" : 10,
            "inputStage" : {
                "stage" : "FETCH",
                "inputStage" : {
                    "stage" : "IXSCAN",
                    "keyPattern" : {
                        "lrrq" : -1
                    },
                    "indexName" : "lrrq_-1",
                    "isMultiKey" : false,
                    "multiKeyPaths" : {
                        "lrrq" : [ ]
                    },
                    "isUnique" : false,
                    "isSparse" : false,
                    "isPartial" : false,
                    "indexVersion" : 2,
                    "direction" : "forward",
                    "indexBounds" : {
                        "lrrq" : [
                            "[MaxKey, MinKey]"
                        ]
                    }
                }
            }
        },
        "rejectedPlans" : [ ]
    },
    "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 10,
        "executionTimeMillis" : 0,
        "totalKeysExamined" : 10,
        "totalDocsExamined" : 10,
        "executionStages" : {
            "stage" : "LIMIT",
            "nReturned" : 10,
            "executionTimeMillisEstimate" : 0,
            "works" : 11,
            "advanced" : 10,
            "needTime" : 0,
            "needYield" : 0,
            "saveState" : 0,
            "restoreState" : 0,
            "isEOF" : 1,
            "invalidates" : 0,
            "limitAmount" : 10,
            "inputStage" : {
                "stage" : "FETCH",
                "nReturned" : 10,
                "executionTimeMillisEstimate" : 0,
                "works" : 10,
                "advanced" : 10,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 0,
                "restoreState" : 0,
                "isEOF" : 0,
                "invalidates" : 0,
                "docsExamined" : 10,
                "alreadyHasObj" : 0,
                "inputStage" : {
                    "stage" : "IXSCAN",
                    "nReturned" : 10,
                    "executionTimeMillisEstimate" : 0,
                    "works" : 10,
                    "advanced" : 10,
                    "needTime" : 0,
                    "needYield" : 0,
                    "saveState" : 0,
                    "restoreState" : 0,
                    "isEOF" : 0,
                    "invalidates" : 0,
                    "keyPattern" : {
                        "lrrq" : -1
                    },
                    "indexName" : "lrrq_-1",
                    "isMultiKey" : false,
                    "multiKeyPaths" : {
                        "lrrq" : [ ]
                    },
                    "isUnique" : false,
                    "isSparse" : false,
                    "isPartial" : false,
                    "indexVersion" : 2,
                    "direction" : "forward",
                    "indexBounds" : {
                        "lrrq" : [
                            "[MaxKey, MinKey]"
                        ]
                    },
                    "keysExamined" : 10,
                    "seeks" : 1,
                    "dupsTested" : 0,
                    "dupsDropped" : 0,
                    "seenInvalidated" : 0
                }
            }
        },
        "allPlansExecution" : [ ]
    },
    "serverInfo" : {
        "host" : "dyh231",
        "port" : 27017,
        "version" : "4.0.11",
        "gitVersion" : "417d1a712e9f040d54beca8e4943edce218e9a8c"
    },
    "ok" : 1,
    "operationTime" : Timestamp(1569478794, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1569478794, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

 建立索引后，好了，在内存进行排序操作都避免了（memLimit，memUsage没有了）。效果提升很明显。

dyh200896
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mongodb查询语句_技术分享 | MongoDB 一次排序超过内存限制的排查
weixin_39593498的博客
12-01 402
本文目录：一、背景1. 配置参数检查2. 排序字段是否存在索引二、测试环境模拟索引对排序的影响1. 测试环境信息2. 报错语句的执行计划解释 3. 建立新的组合索引进行测试三、引申的组合索引问题1. 查询语句中，排序字段 _id 使用降序2. 查询语句中，排序字段 Num 和 _id 全部使用降序四、引申的聚合查询问题1.Sort stage 使用内存排序五、结论1. 排序内存限制的问题...
索引优化-世人皆知Mysql，谁人懂我MongoDB
weixin_47067712的博客
05-09 415
查看执行计划 索引优化是一个永远都绕不过的话题,作为NoSQL的MongoDB也不例外。Mysql中通过explain命令来查看对应的索引信息,MongoDB亦如此。 1.db.collection.explain().<method(...)> db.products.explain().remove({category:"apparel"},{justOne:true}) 2.db.collection.<method(...)>.expl...
MongoDB索引Index
Kiven_ch的博客
08-05 2031
什么是索引   索引是一种单独的、物理的对数据库表中一列或多列的值进行排序的一种存储结构，它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单。索引的作用相当于图书的目录，可以根据目录中的页码快速找到所需的内容。索引目标是提高数据库的查询效率，没有索引的话，查询会进行全表扫描（scan every document in a collection）,数据量大时严重降低了查询效率。默认情况下Mongo在一个集合（collection）创建时，自动地对集合的_id创建了唯一索引。
MongoDB多键索引（数组上建立索引）
热门推荐
duzm200542901104的专栏
08-21 2万+
如果要索引数组类型的字段，MongoDB可以在数组每个元素上创建索引。这种多键索引可以有效的支持数组元素查询。多键索引建立在具体的值（比如字符串、数字）或内嵌文档的数组上。     一、创建多键索引 创建多键索引的语法：db.collection.createIndex() db.coll.createIndex({&lt;field&gt;:&lt;1 or -1&gt;}) M...
MongoDB 中如何使用 explain 分析查询
weixin_64307933的博客
09-19 324
创建完索引，如何分析索引的执行情况呢，MongoDB 中同样提供了 explain 来帮助我们进行分析，这里来看下 explain 的使用细节。
解决MongoDB 排序超过内存限制的问题
09-09
`allowDiskUse`选项允许MongoDB在排序时利用磁盘空间，而不是仅依赖内存。这可以通过在聚合查询或排序操作中添加`{allowDiskUse: true}`来启用。例如，针对上述错误，可以修改查询如下： ```javascript db.bigdata....
关于MongoDB索引管理－索引的创建、查看、删除操作详解
09-09
在MongoDB中，索引的管理包括创建、查看和删除等操作，这些操作对于优化数据库性能至关重要。 1. **创建/重建索引** - **创建索引**：MongoDB 使用 `ensureIndex()` 方法创建新索引。例如，`db.COLLECTION_NAME....
MongoDB创建一个索引而性能提升1000倍示例代码
09-09
MongoDB 是一个流行的开源文档型数据库，以其高性能、高可用性和可伸缩性著称。在MongoDB中，创建索引...在日常工作中，可以根据查询日志分析最常查询的字段，优先为这些字段创建索引，从而达到最佳的性能优化效果。
pymongo给mongodb创建索引的简单实现方法
09-10
在Python环境中，我们通常使用`pymongo`这个库来与MongoDB进行交互，包括创建索引。下面我们将深入探讨如何使用`pymongo`为MongoDB创建索引。 首先，我们需要导入`pymongo`库，它提供了连接MongoDB服务器、管理...
MongoDB性能篇之创建索引，组合索引，唯一索引，删除索引和explain执行计划
09-10
MongoDB在创建集合时，默认为`_id`字段创建一个唯一的升序索引，这是无法删除的。创建其他索引，例如在`age`字段上创建升序索引，可以使用`db.collection.ensureIndex()`命令，如`db.users.ensureIndex({age: 1})`。...
MongoDB：索引
拒绝熬夜啊的博客
03-03 997
MongoDB：索引
在MongoDB中使用数组字段和子文档字段进行索引
最新发布
一起学习
12-22 1718
文主要介绍在MongoDB使用数组字段和子文档字段进行索引。
MongoDB特殊索引和集合类型
ntzzzsj的博客
06-27 1240
MongoDB 中的一些特殊的索引和集合类型，包括：MongoDB 有两种类型的地理空间索引：2dsphere 和 2d。2dsphere 索引可以与基于 WGS84 基准的地球球面几何模型一起使用。这个基准将地球表面模拟成一个扁圆球体，这意味着在两极会比较扁。因此，使用 2dsphere 索引的距离计算考虑到了地球的形状，提供了比 2d 索引更准确的距离处理，比如计算两个城市之间的距离。在存储二维平面上的点时使用 2d 索引。2dsphere 允许以 GeoJSON 格式指定点、线和多边形这些几何图形。.
MongoDB 复合索引
xwnxwn的专栏
10-18 357
一、复合索引相关概述 1、复合索引创建语法 db.collection.createIndex( { : , : , ... } ) 同创建单键(列)索引一样，索引创建时需要指定每一个键索引的顺序 多个键直接用逗号分隔 索引创建语法可以参考：http://blog.csdn.net/leshami/article/details/5
MongoDB学习（六）：集群之复制集
Yhc不是咸鱼
02-08 560
目录 1 概念 2 配置 3 原理 1）oplog 2）心跳机制 4 客户端连接集群 在MongoDB学习（一）：安装&amp;基础概念&amp;数据类型&amp;部分shell操作曾经提到过，MongoDB有复制集（副本集）和分片集的概念。 1 概念 复制集是主从机制的扩展与改进，例如： 容灾机制：主节点（Primary）down之后，自动通过选举机制提升从节点（Second...
mongodb副本集群搭建 以及踩过的坑
wenzhenyu1990的专栏
02-20 929
1、准备三台linux服务器：172.16.8.140 、 172.16.8.141 、 172.16.8.142在三台服务器上安装上mongodb 启动文件内容 dbpath=/usr/local/mongodb/data/db logpath=/usr/local/mongodb/data/logs/mongodb.logs logappend=true fork=true...
关于给mongodb集合中的某些字段添加索引
u012379844的专栏
12-21 6914
我们知道mongodb是一种文本数据库，它和mysql数据库一样，都存在索引这一概念。给字段添加索引，可以加快数据查询的速度。当然了，在数据量足够大的情况下，加索引和不加索引的差距是很明显的。但是加了索引之后，在保存方面大概是会很浪费时间的。 1、单一索引 mongodb中使用以下命令来给字段添加索引。现在先简单的介绍一下，项目中用到的两种单一索引、集合索引。首先在mongod...
mongo索引
乾复道
07-26 4328
不同于MySQL的索引，mongo的索引是有方向的，value代表了索引的方向，这个特性在排序的使用很好用。就能查看是否使用了索引，以及其他的一些详细信息，包括，使用的索引，扫描的文档数据，结果的数量，查询用时等等。如此我们就建立了一个唯一索引，当然类似MySQL的联合唯一索引mongo也是有的，只需要指定多个字段即可。索引好用，但是切记复合索引是有顺序排列的，如果将查询字段顺序写错，是不会使用索引的哈！需要注意的是，如果集合中包含多个待索引字段是数组，则无法创建复合多键索引。...
Allowed memory size of 33554432 bytes exhausted (tried to allocate 43148176 bytes) in php
chamtianjiao的专栏
06-20 1万+
Allowed memory size of 33554432 bytes exhausted (tried to allocate 43148176 bytes) in php 本人在用thinkphp做项目时，在做图片压缩时，在上传容量大的图片时， 总是提示：Allowed memory size of 33554432 bytes exhausted (tried to alloca
MongoDB如何创建TTL索引
06-02
MongoDB可以通过创建TTL（Time-To-Live，生存时间）索引来自动删除过期的文档。...需要注意的是，如果你需要创建TTL索引，必须确保MongoDB的版本在2.2及以上，因为TTL索引是在MongoDB 2.2版本中加入的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值