mongo索引性能

最新推荐文章于 2025-01-08 15:04:56 发布
最新推荐文章于 2025-01-08 15:04:56 发布
阅读量696 收藏 1
点赞数
分类专栏： Mongo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangzhenkang/article/details/82142736
版权

mongo索引性能

标签（空格分隔）： mongo

https://www.cnblogs.com/c-abc/p/6023824.html

测试mongo索引性能

有索引，每个值都是唯一值


 "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1,
        "executionTimeMillis" : 0,  ## 总耗时
        "totalKeysExamined" : 1,  ##
        "totalDocsExamined" : 1, ## 检索文档数
        "executionStages" : {
            "stage" : "FETCH",
            "nReturned" : 1,
            "executionTimeMillisEstimate" : 0,
            "works" : 2,
            "advanced" : 1,
            "needTime" : 0,
            "needYield" : 0,
            "saveState" : 0,
            "restoreState" : 0,
            "isEOF" : 1,
            "invalidates" : 0,
            "docsExamined" : 1,
            "alreadyHasObj" : 0,
            "inputStage" : {
                "stage" : "IXSCAN",
                "nReturned" : 1,
                "executionTimeMillisEstimate" : 0,
                "works" : 2,
                "advanced" : 1,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 0,
                "restoreState" : 0,
                "isEOF" : 1,
                "invalidates" : 0,
                "keyPattern" : {
                    "attr" : 1
                },
                "indexName" : "attr",
                "isMultiKey" : false,
                "multiKeyPaths" : {
                    "attr" : []
                },
                "isUnique" : false,
                "isSparse" : false,
                "isPartial" : false,
                "indexVersion" : 2,
                "direction" : "forward",
                "indexBounds" : {
                    "attr" : [ 
                        "[\"所属国家\", \"所属国家\"]"
                    ]
                },
                "keysExamined" : 1,
                "seeks" : 1,
                "dupsTested" : 0,
                "dupsDropped" : 0,
                "seenInvalidated" : 0
            }
        }
    },

无索引，每个值都是唯一值

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1,
        "executionTimeMillis" : 6,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 4723,
        "executionStages" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "attr" : {
                    "$eq" : "所属国家"
                }
            },
            "nReturned" : 1,
            "executionTimeMillisEstimate" : 0,
            "works" : 4725,
            "advanced" : 1,
            "needTime" : 4723,
            "needYield" : 0,
            "saveState" : 36,
            "restoreState" : 36,
            "isEOF" : 1,
            "invalidates" : 0,
            "direction" : "forward",
            "docsExamined" : 4723
        }
    },

可以看出，有索引后只需要检索一个文档，并且时间由原来的6降低到了0

有索引，只有两个值

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 4723,
        "executionTimeMillis" : 13,  ## 
        "totalKeysExamined" : 4723, ## 这里有查找索引需要的时间
        "totalDocsExamined" : 4723,  ##
        "executionStages" : {
            "stage" : "FETCH",
            "nReturned" : 4723,
            "executionTimeMillisEstimate" : 20,
            "works" : 4724,
            "advanced" : 4723,
            "needTime" : 0,
            "needYield" : 0,
            "saveState" : 36,
            "restoreState" : 36,
            "isEOF" : 1,
            "invalidates" : 0,
            "docsExamined" : 4723,
            "alreadyHasObj" : 0,
            "inputStage" : {
                "stage" : "IXSCAN",
                "nReturned" : 4723,
                "executionTimeMillisEstimate" : 20,
                "works" : 4724,
                "advanced" : 4723,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 36,
                "restoreState" : 36,
                "isEOF" : 1,
                "invalidates" : 0,
                "keyPattern" : {
                    "domain_has_entity" : 1
                },
                "indexName" : "ha",
                "isMultiKey" : false,
                "multiKeyPaths" : {
                    "domain_has_entity" : []
                },
                "isUnique" : false,
                "isSparse" : false,
                "isPartial" : false,
                "indexVersion" : 2,
                "direction" : "forward",
                "indexBounds" : {
                    "domain_has_entity" : [ 
                        "[\"False\", \"False\"]"
                    ]
                },
                "keysExamined" : 4723,
                "seeks" : 1,
                "dupsTested" : 0,
                "dupsDropped" : 0,
                "seenInvalidated" : 0
            }
        }
    },

you无索引，只有两个值

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 4723,
        "executionTimeMillis" : 6,
        "totalKeysExamined" : 0,  ## 可以看出不需要检索key值，所以没有索引反而省时间了
        "totalDocsExamined" : 4723,
        "executionStages" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "domain_has_entity" : {
                    "$eq" : "False"
                }
            },
            "nReturned" : 4723,
            "executionTimeMillisEstimate" : 0,
            "works" : 4725,
            "advanced" : 4723,
            "needTime" : 1,
            "needYield" : 0,
            "saveState" : 36,
            "restoreState" : 36,
            "isEOF" : 1,
            "invalidates" : 0,
            "direction" : "forward",
            "docsExamined" : 4723
        }
    },

对于个数较少的字段，就不要建索引了，省得他还有查索引的时间

无索引，联合查询

db.getCollection(‘rdf_useful’).find({“entity” : “蒋官屯街道”,”attr” : “辖社区数”}).explain(“executionStats”)

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1,
        "executionTimeMillis" : 974,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 1805242,
        "executionStages" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "$and" : [ 
                    {
                        "attr" : {
                            "$eq" : "辖社区数" }
                    }, 
                    {
                        "entity" : {
                            "$eq" : "蒋官屯街道" }
                    }
                ]
            },
            "nReturned" : 1,
            "executionTimeMillisEstimate" : 880,
            "works" : 1805244,
            "advanced" : 1,
            "needTime" : 1805242,
            "needYield" : 0,
            "saveState" : 14103,
            "restoreState" : 14103,
            "isEOF" : 1,
            "invalidates" : 0,
            "direction" : "forward",
            "docsExamined" : 1805242
        }
    },

只对一个字段建索引，但联合查询

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1,
        "executionTimeMillis" : 0
        "totalKeysExamined" : 16,
        "totalDocsExamined" : 16,
        "executionStages" : {
            "stage" : "FETCH",
            "filter" : {
                "attr" : {
                    "$eq" : "辖社区数"
                }
            },
            "nReturned" : 1,
            "executionTimeMillisEstimate" : 0,
            "works" : 17,
            "advanced" : 1,
            "needTime" : 15,
            "needYield" : 0,
            "saveState" : 0,
            "restoreState" : 0,
            "isEOF" : 1,
            "invalidates" : 0,
            "docsExamined" : 16,
            "alreadyHasObj" : 0,
            "inputStage" : {
                "stage" : "IXSCAN",
                "nReturned" : 16,
                "executionTimeMillisEstimate" : 0,
                "works" : 17,
                "advanced" : 16,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 0,
                "restoreState" : 0,
                "isEOF" : 1,
                "invalidates" : 0,
                "keyPattern" : {
                    "entity" : 1
                },
                "indexName" : "wn",
                "isMultiKey" : false,
                "multiKeyPaths" : {
                    "entity" : []
                },
                "isUnique" : false,
                "isSparse" : false,
                "isPartial" : false,
                "indexVersion" : 2,
                "direction" : "forward",
                "indexBounds" : {
                    "entity" : [ 
                        "[\"蒋官屯街道\", \"蒋官屯街道\"]"
                    ]
                },
                "keysExamined" : 16,
                "seeks" : 1,
                "dupsTested" : 0,
                "dupsDropped" : 0,
                "seenInvalidated" : 0
            }
        }
    },
    ```

建立联合索引，联合查询

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1,
        "executionTimeMillis" : 0,
        "totalKeysExamined" : 1,
        "totalDocsExamined" : 1,
        "executionStages" : {
            "stage" : "FETCH",
            "nReturned" : 1,
            "executionTimeMillisEstimate" : 0,
            "works" : 2,
            "advanced" : 1,
            "needTime" : 0,
            "needYield" : 0,
            "saveState" : 0,
            "restoreState" : 0,
            "isEOF" : 1,
            "invalidates" : 0,
            "docsExamined" : 1,
            "alreadyHasObj" : 0,
            "inputStage" : {
                "stage" : "IXSCAN",
                "nReturned" : 1,
                "executionTimeMillisEstimate" : 0,
                "works" : 2,
                "advanced" : 1,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 0,
                "restoreState" : 0,
                "isEOF" : 1,
                "invalidates" : 0,
                "keyPattern" : {
                    "entity" : 1,
                    "attr" : 1
                },
                "indexName" : "wn",
                "isMultiKey" : false,
                "multiKeyPaths" : {
                    "entity" : [],
                    "attr" : []
                },
                "isUnique" : false,
                "isSparse" : false,
                "isPartial" : false,
                "indexVersion" : 2,
                "direction" : "forward",
                "indexBounds" : {
                    "entity" : [ 
                        "[\"蒋官屯街道\", \"蒋官屯街道\"]"
                    ],
                    "attr" : [ 
                        "[\"辖社区数\", \"辖社区数\"]"
                    ]
                },
                "keysExamined" : 1,
                "seeks" : 1,
                "dupsTested" : 0,
                "dupsDropped" : 0,
                "seenInvalidated" : 0
            }
        }
    },

联合查询，建立单一索引就已经有很大的性能提升了，建立联合索引后，更是飞快

比较查询，无索引

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1279,
        "executionTimeMillis" : 7,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 4723,
        "executionStages" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "num_of_domain" : {
                    "$gt" : 5.0
                }
            },
            "nReturned" : 1279,
            "executionTimeMillisEstimate" : 0,
            "works" : 4725,
            "advanced" : 1279,
            "needTime" : 3445,
            "needYield" : 0,
            "saveState" : 36,
            "restoreState" : 36,
            "isEOF" : 1,
            "invalidates" : 0,
            "direction" : "forward",
            "docsExamined" : 4723
        }
    },

有索引，比较查询

"executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1279,
        "executionTimeMillis" : 5,
        "totalKeysExamined" : 1279,
        "totalDocsExamined" : 1279,
        "executionStages" : {
            "stage" : "FETCH",
            "nReturned" : 1279,
            "executionTimeMillisEstimate" : 0,
            "works" : 1280,
            "advanced" : 1279,
            "needTime" : 0,
            "needYield" : 0,
            "saveState" : 10,
            "restoreState" : 10,
            "isEOF" : 1,
            "invalidates" : 0,
            "docsExamined" : 1279,
            "alreadyHasObj" : 0,
            "inputStage" : {
                "stage" : "IXSCAN",
                "nReturned" : 1279,
                "executionTimeMillisEstimate" : 0,
                "works" : 1280,
                "advanced" : 1279,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 10,
                "restoreState" : 10,
                "isEOF" : 1,
                "invalidates" : 0,
                "keyPattern" : {
                    "num_of_domain" : 1
                },
                "indexName" : "nu",
                "isMultiKey" : false,
                "multiKeyPaths" : {
                    "num_of_domain" : []
                },
                "isUnique" : false,
                "isSparse" : false,
                "isPartial" : false,
                "indexVersion" : 2,
                "direction" : "forward",
                "indexBounds" : {
                    "num_of_domain" : [ 
                        "(5.0, inf.0]"
                    ]
                },
                "keysExamined" : 1279,
                "seeks" : 1,
                "dupsTested" : 0,
                "dupsDropped" : 0,
                "seenInvalidated" : 0
            }
        }
    },

对比较查询影响不大，提高一半左右

【Springboot系列】项目启动时怎么给mongo表加自动过期索引
我是香菜
04-25 1714
在Mongo数据库中创建过期索引，定期清理过期数据以保证数据的质量和性能。创建过期索引可以大大简化过期数据的清理过程，并且可以帮助我们避免在查询和数据分析时出现问题。同时，定期清理过期数据可以提高查询和分析的效率，保证系统的性能。希望本文对您在Mongo数据库管理和维护方面有所帮助。如果您有任何问题或建议，请在下方留言区留言，我将尽快回复。
Mongo：笔记四(索引 性能优化)
云端
01-28 778
索引 MongoDB提供了多样性的索引支持，索引信息被保存在system.indexes中，MongoDB中_id字段在创建的时候，默认已经建立了索引，这个索引比较特殊，并且不可删除，不过CappedCollections 例外。 1、建立索引(普通索引) 建立索引的函数：ensureIndex() 例子：在name上建立索引1(升序)，-1(降序) >db.persons.e
Mongo Index
方丈的寺院
12-12 2693
摘要 mongo 的索引非常强大，和关系型数据库索引没什么区别。这里主要介绍mongo索引基本知识和mongo本人在索引上的犯的错。 索引种类 单字段索引 复合索引 复合索引各个字段的顺序应该是精确匹配字段(=xxx),排序字段(避免在内存中排序，使用index排序)，范围查询字段 如db.book.find({company: ‘xxx’, age:{$lt:30}).sort(...
mongo索引小结
iteye_8338的博客
01-17 186
官方文档索引部分的地址： http://docs.mongodb.org/manual/indexes/ 以下大部分内容来自官方文档。   1.创建索引 1）创建单个索引 db.collection.ensureIndex({a:1}) 在a字段上创建一个升序的索引(对于单个字段的索引，升序或是降序都一样)。 2)创建复合索引 db.collection.ensureIndex...
mongo-索引
面朝大海，春暖花开
03-06 162
mongo索引 准备 假设有一数据库 user [ { "address": { "city": "shanghai", "state": "shanghai", "pincode": "232321" }, "age": 12, "name": "jack", "tags": ["music", "cricket", "blogs"] } ] 索引基本操作 查看索引 删除索引 重建索引 创建索引的参数 查看索引 db
mongo索引
liujuntao921的博客
07-06 909
mongo索引和关系型数据库相似。 语法如下：db.people.ensureIndex("username":1)。按照username首字母升序排列。同样的索引只会创建一次，对对某个键的索引只会加速该键的查询，对其他查询可能没有什么帮助。并不是索引越多越好，索引会增加数据库插入非常慢，占用很多空间，并且还可能对查询的速度没啥帮助。 但是没有索引，服务器会“查询怎本书”，做表扫描。当集合很大
mongo索引浅析
m0_37322399的博客
10-17 1074
索引是一种用来方便查询数据的数据结构B Tree就是一种常用的数据库索引数据结构，MongoDB采用 B 树做索引，索引创建在colletions 上。我们可以在这个网站上直观的看到索引的效果。
Mongodb索引的优化
09-10
7. **平衡索引大小与查询性能**：虽然索引可以提高查询速度，但也会占用额外的存储空间，并且插入、更新和删除操作需要维护索引，可能导致性能下降。因此，合理规划索引数量和大小至关重要。 8. **索引重建**：随着...
MongoTemplate 性能优化指南
专注于技术分享
01-08 1298
最大连接数 = ((核心数 *2) + 有效磁盘数) * 服务器数量。最小连接数 = 最大连接数 0.25。
建立常用的mongo索引
nodeDocker的博客
03-10 486
mongo索引建立索引方式索引属性索引类型(6种常用)1. 单字段索引2. 唯一索引3. 复合索引查询需求4. 多key索引5.部分索引6. 稀疏索引应用场景：建立索引注意事项 建立索引方式 1. 是在schema定义字段时 2. 通过index方法给schema添加 3. db.modle.creatIndex({filed: 1}) mongo shell添加索引 索引属性 1. index: 布尔值 是否对这个属性创建索引 2. unique: 布尔值 是否对这个属性创建唯
MongoDB教程之索引介绍
12-15
一、索引基础：     MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：   代码如下:     > db.test.ensureIndex({“username”:1})       可以通过下面的名称查看索引是否已经成功建立：   代码如下:     > db.test.getIndexes()       删除索引的命令是：   代码如下:     > db.test.dropIndex({“username”:1})       在MongoDB中，我们同样可以创建复合索引，如：   代码如下:     — 数字1表示user
MongoDB：索引与性能
MitKey的博客
02-18 3116
一、索引 MongoDB 提供了多样性的索引支持索引信息被保存在 system.indexes 中且默认总是为 _id 创建索引。 1、基础索引在字段 age 上创建索引 1 (升序)； -1 (降序)上例显示出来的一共有2个索引其中_id是创建表的时候自动创建的索引此索引是不能够删除的。当系统已有大量数据时创建索引就是个非常耗时的活我们可以在后台执行只需指定“backgroud:true”即可
MongoDB之索引
热门推荐
ntzzzsj的博客
06-22 1万+
数据库索引类似于图书索引。有了索引便不需要浏览整本书，而是可以采取一种快捷方式，只查看一个有内容引用的有序列表。这使得 MongoDB 的查找速度提高了好几个数量级。
【Mongo】创建索引
EDDYCJY的博客
07-20 1566
一、【创建索引】 db.COLLECTION_NAME.ensureIndex({KEY:1},{background: true}) *可选参数列表如下： Parameter Type Description background Boolean 建索引过程会阻塞其它数据库操作，background可指定
MongoDB的查询索引
路漫漫其修远兮，吾将上下而求索。
10-31 2567
  目录 为什么要建立索引？ 索引的分类有哪些？ _id索引 单键索引 多键索引 复合索引 过期索引 hello，今天是万圣节
MongoDB索引
qq15035899256的博客
05-08 2548
本文是对MongoDB的学习，先认识了MongoDB的数据存储结构和索引数据结构，又学习了如何创建、查看、删除索引，最后深入学习了索引的多种类型和属性。之后的学习内容将持续更新！！！
MongoDB 索引
qq_62866151的博客
10-01 1595
GeoJSON 是一种基于 JSON (JavaScript Object Notation) 的格式，用于表示各种地理数据结构。它是基于 JSON 的一种标准，用于编码地理信息，包括点、线、面（多边形）以及其他地理集合。GeoJSON 通常用于 Web 地图和地理信息服务中，以便于数据的传输和处理。点（Point）表示一个地理位置上的单个点。线（LineString）表示一系列由线段连接的点。多边形（Polygon）
mongo lookup 索引
最新发布
01-21
### MongoDB Lookup 操作使用索引的方法和注意事项 在执行 `$lookup` 操作时，为了提高查询性能并减少资源消耗，合理利用索引至关重要。当涉及集合间的数据关联时，确保被联接字段上有合适的索引可以显著提升效率。 #### 创建适当索引 对于参与 `pipeline` 中用于匹配条件的字段创建索引是最基本的要求之一。如果目标是在右侧集合上查找特定键，则应在该键上建立索引[^1]： ```javascript db.rightCollection.createIndex({ "foreignField": 1 }) ``` 这有助于加速基于此字段进行过滤的过程。 #### 使用管道优化 现代版本中的 `$lookup` 支持更复杂的聚合框架管道表达式作为其参数的一部分。这意味着可以在实际执行跨集合连接之前先对数据源应用初步筛选逻辑，从而缩小处理范围并充分利用现有索引结构[^2]: ```json { $lookup: { from: 'rightCollection', let: { localField: '$localField' }, pipeline: [ { $match: { $expr: { $eq: ['$$localField', '$foreignField'] } } } ], as: 'result' } } ``` 上述例子展示了如何通过定义一个带有变量 (`let`) 的内嵌管道来实现更加灵活高效的外键映射关系，并且允许内部使用标准的 `$match` 阶段以便更好地兼容已有的单侧索引策略。 #### 注意事项 - **评估必要性**：并非所有的场景都需要启用索引来支持 `$lookup`；只有当预期会有大量记录需要比较或存在频繁读取需求的情况下才值得考虑增加额外开销。 - **监控效果**：即使建立了看似合理的索引模式，在生产环境中仍需持续关注实际运行状况以及可能产生的副作用（比如写入延迟），适时调整方案以达到最佳平衡点。 - **避免过度设计**：过多不必要的索引反而会拖累整体表现，因此建议遵循最小化原则只针对真正瓶颈所在之处采取措施。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值