MongoDB中的索引项目练习

最新推荐文章于 2023-11-08 21:31:33 发布
最新推荐文章于 2023-11-08 21:31:33 发布
阅读量300 收藏 2
点赞数
分类专栏： 数据库系统 项目练习 文章标签： mongodb 索引 indexing
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jifu_M/article/details/112624314
版权

MongoDB indexing


关于MongoDB索引的介绍可以看一下我的这篇文章：
https://blog.csdn.net/Jifu_M/article/details/112578054

项目介绍

我们拥有一个bookshop.js的文件，将文件导入的MongoDB后按照要求进行操作。

练习用的bookshop.js已被上传到我的资源。
https://download.csdn.net/download/Jifu_M/14159088

为下面4个查询语句创建索引：
(1) 查找具有给定书名的图书的标题、出版商、出版年份和价格。

(2) 查找具有给定作者姓名的书籍的标题、出版商、出版年份和价格。

(3) 使用给定的关键字查找图书的标题、出版商、出版年份和价格。

(4) 查找给定年份的书籍的标题、出版商、出版年份和价格。
对于每个查询，做4步工作：

  1. 创建一个索引，以加速与模式一致的查询处理
  2. 使用getIndexes()列出所有现有的索引，例如db.collection.getIndexes()。
  3. 应用一个explain()来验证系统是否计划使用我们创建的索引来查询。
  4. 使用dropIndex()删除步骤1中创建的索引。

项目开始

首先要创建一个文件夹来进行项目，之后启动MongoDB，最后读取文件：

mkdir DATA

mongod –dbpath DATA –port 4000

mongo –port 4000

load("bookshop.js");

(1)

db.bookshop.createIndex( {"book.title": 1},{"unique": false} );
db.bookshop.getIndexes();
db.bookshop.find({"book.title":"Database Systems"},				
				 {"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
db.bookshop.dropIndex("book.title_1");

运行结果如下：

> db.bookshop.createIndex( {"book.title": 1},{"unique": false} );
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.bookshop.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.bookshop"
        },
        {
                "v" : 2,
                "key" : {
                        "book.title" : 1
                },
                "name" : "book.title_1",
                "ns" : "test.bookshop"
        }
]
> db.bookshop.find({"book.title":"Database Systems"},{"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.bookshop",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "book.title" : {
                                "$eq" : "Database Systems"
                        }
                },
                "queryHash" : "14A0A730",
                "planCacheKey" : "39101E2A",
                "winningPlan" : {
                        "stage" : "PROJECTION_DEFAULT",
                        "transformBy" : {
                                "_id" : 0,
                                "book.title" : 1,
                                "book.publisher" : 1,
                                "book.year" : 1,
                                "book.price" : 1
                        },
                        "inputStage" : {
                                "stage" : "FETCH",
                                "inputStage" : {
                                        "stage" : "IXSCAN",
                                        "keyPattern" : {
                                                "book.title" : 1
                                        },
                                        "indexName" : "book.title_1",
                                        "isMultiKey" : false,
                                        "multiKeyPaths" : {
                                                "book.title" : [ ]
                                        },
                                        "isUnique" : false,
                                        "isSparse" : false,
                                        "isPartial" : false,
                                        "indexVersion" : 2,
                                        "direction" : "forward",
                                        "indexBounds" : {
                                                "book.title" : [
                                                        "[\"Database Systems\", \"Database Systems\"]"
                                                ]
                                        }
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "DESKTOP-UFKEQ4V",
                "port" : 27017,
                "version" : "4.2.1",
                "gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
        },
        "ok" : 1
}
> db.bookshop.dropIndex("book.title_1");
{ "nIndexesWas" : 2, "ok" : 1 }

(2)

db.bookshop.createIndex( {"book.authors.fname": 1, "book.authors.lname":1},{"unique": false} );
db.bookshop.getIndexes();
db.bookshop.find({"book.authors.fname":"Horstmann","book.authors.lname":"Cornell"},	
				 {"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
db.bookshop.dropIndex("book.authors.fname_1_book.authors.lname_1");

运行结果如下：

> db.bookshop.createIndex( {"book.authors.fname": 1, "book.authors.lname":1},{"unique": false} );
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.bookshop.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.bookshop"
        },
        {
                "v" : 2,
                "key" : {
                        "book.authors.fname" : 1,
                        "book.authors.lname" : 1
                },
                "name" : "book.authors.fname_1_book.authors.lname_1",
                "ns" : "test.bookshop"
        }
]
> db.bookshop.find({"book.authors.fname":"Horstmann","book.authors.lname":"Cornell"},{"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.bookshop",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "book.authors.fname" : {
                                                "$eq" : "Horstmann"
                                        }
                                },
                                {
                                        "book.authors.lname" : {
                                                "$eq" : "Cornell"
                                        }
                                }
                        ]
                },
                "queryHash" : "567B5B84",
                "planCacheKey" : "B395D723",
                "winningPlan" : {
                        "stage" : "PROJECTION_DEFAULT",
                        "transformBy" : {
                                "_id" : 0,
                                "book.title" : 1,
                                "book.publisher" : 1,
                                "book.year" : 1,
                                "book.price" : 1
                        },
                        "inputStage" : {
                                "stage" : "FETCH",
                                "filter" : {
                                        "book.authors.lname" : {
                                                "$eq" : "Cornell"
                                        }
                                },
                                "inputStage" : {
                                        "stage" : "IXSCAN",
                                        "keyPattern" : {
                                                "book.authors.fname" : 1,
                                                "book.authors.lname" : 1
                                        },
                                        "indexName" : "book.authors.fname_1_book.authors.lname_1",
                                        "isMultiKey" : true,
                                        "multiKeyPaths" : {
                                                "book.authors.fname" : [
                                                        "book.authors"
                                                ],
                                                "book.authors.lname" : [
                                                        "book.authors"
                                                ]
                                        },
                                        "isUnique" : false,
                                        "isSparse" : false,
                                        "isPartial" : false,
                                        "indexVersion" : 2,
                                        "direction" : "forward",
                                        "indexBounds" : {
                                                "book.authors.fname" : [
                                                        "[\"Horstmann\", \"Horstmann\"]"
                                                ],
                                                "book.authors.lname" : [
                                                        "[MinKey, MaxKey]"
                                                ]
                                        }
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "DESKTOP-UFKEQ4V",
                "port" : 27017,
                "version" : "4.2.1",
                "gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
        },
        "ok" : 1
}
> db.bookshop.dropIndex("book.authors.fname_1_book.authors.lname_1");
{ "nIndexesWas" : 2, "ok" : 1 }

(3)

db.bookshop.createIndex( {"book.keywords": 1},{"unique": false, "sparse":true} );
db.bookshop.getIndexes();
db.bookshop.find({"book.keywords":"Database"},
				 {"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
db.bookshop.dropIndex("book.keywords_1");

运行结果如下：

> db.bookshop.createIndex( {"book.keywords": 1},{"unique": false, "sparse":true} );
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.bookshop.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.bookshop"
        },
        {
                "v" : 2,
                "key" : {
                        "book.keywords" : 1
                },
                "name" : "book.keywords_1",
                "ns" : "test.bookshop",
                "sparse" : true
        }
]
> db.bookshop.find({"book.keywords":"Database"},{"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.bookshop",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "book.keywords" : {
                                "$eq" : "Database"
                        }
                },
                "queryHash" : "24DDB67D",
                "planCacheKey" : "ABFCDB63",
                "winningPlan" : {
                        "stage" : "PROJECTION_DEFAULT",
                        "transformBy" : {
                                "_id" : 0,
                                "book.title" : 1,
                                "book.publisher" : 1,
                                "book.year" : 1,
                                "book.price" : 1
                        },
                        "inputStage" : {
                                "stage" : "FETCH",
                                "inputStage" : {
                                        "stage" : "IXSCAN",
                                        "keyPattern" : {
                                                "book.keywords" : 1
                                        },
                                        "indexName" : "book.keywords_1",
                                        "isMultiKey" : true,
                                        "multiKeyPaths" : {
                                                "book.keywords" : [
                                                        "book.keywords"
                                                ]
                                        },
                                        "isUnique" : false,
                                        "isSparse" : true,
                                        "isPartial" : false,
                                        "indexVersion" : 2,
                                        "direction" : "forward",
                                        "indexBounds" : {
                                                "book.keywords" : [
                                                        "[\"Database\", \"Database\"]"
                                                ]
                                        }
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "DESKTOP-UFKEQ4V",
                "port" : 27017,
                "version" : "4.2.1",
                "gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
        },
        "ok" : 1
}
> db.bookshop.dropIndex("book.keywords_1");
{ "nIndexesWas" : 2, "ok" : 1 }
>

(4)

db.bookshop.createIndex( {"book.year": 1},{"unique": false} );
db.bookshop.getIndexes();
db.bookshop.find({"book.year":2015},{"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
db.bookshop.dropIndex("book.year_1");

运行结果如下：

> db.bookshop.createIndex( {"book.year": 1},{"unique": false} );
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.bookshop.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test.bookshop"
        },
        {
                "v" : 2,
                "key" : {
                        "book.year" : 1
                },
                "name" : "book.year_1",
                "ns" : "test.bookshop"
        }
]
> db.bookshop.find({"book.year":2015},{"_id":0,"book.title":1,"book.publisher":1,"book.year":1,"book.price":1}).explain();
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.bookshop",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "book.year" : {
                                "$eq" : 2015
                        }
                },
                "queryHash" : "772840C7",
                "planCacheKey" : "674A9A1C",
                "winningPlan" : {
                        "stage" : "PROJECTION_DEFAULT",
                        "transformBy" : {
                                "_id" : 0,
                                "book.title" : 1,
                                "book.publisher" : 1,
                                "book.year" : 1,
                                "book.price" : 1
                        },
                        "inputStage" : {
                                "stage" : "FETCH",
                                "inputStage" : {
                                        "stage" : "IXSCAN",
                                        "keyPattern" : {
                                                "book.year" : 1
                                        },
                                        "indexName" : "book.year_1",
                                        "isMultiKey" : false,
                                        "multiKeyPaths" : {
                                                "book.year" : [ ]
                                        },
                                        "isUnique" : false,
                                        "isSparse" : false,
                                        "isPartial" : false,
                                        "indexVersion" : 2,
                                        "direction" : "forward",
                                        "indexBounds" : {
                                                "book.year" : [
                                                        "[2015.0, 2015.0]"
                                                ]
                                        }
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "DESKTOP-UFKEQ4V",
                "port" : 27017,
                "version" : "4.2.1",
                "gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
        },
        "ok" : 1
}
> db.bookshop.dropIndex("book.year_1");
{ "nIndexesWas" : 2, "ok" : 1 }
Jifu_M
关注
专栏目录
【MongoDB】（一）——关于MondoDB索引的总结
To Begin,Begin　　
09-29 924
导读 为数据创建索引有助于提高查询数据的性能，本篇文章总结了创建MongoDB索引应遵循的规则。 我将这些规则分成四类：1.“query” 2.“sort” 3.“RAM” 4.“selectivity”querydb.collection.find({})　　这一部分主要针对查询中的query部分，也就是find操作，说明我们如何创建索引，以及什么样的查询能够使该索引有效。
练习 MongoDB 操作 —— 索引篇（二）
weixin_33675507的博客
09-19 221
本文围绕索引、游标两部分进行探索，对MongoDB数据库的索引部分有一个大概的了解； 索引 索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。...
2021-05-11 MongoDB面试题 MongoDb中索引是什么
热门推荐
微软MVP Eleven
05-11 3万+
在MongoDb中索引是什么？ 索引用于高效的执行查询，没有索引的MongoDB将扫描整个集合中的所有文档，这种扫描效率很低，需要处理大量的数据，索引是一种特殊的数据结构,将一小块数据集合保存为容易遍历的形式。索引能够存储某种特殊字段或字段集的值，并按照索引指定的方式将字段值进行排序。 ...
MongoDB 之滴滴、摩拜都在用的索引
2301_77225918的博客
11-08 1415
如图4所示，有6个人 A、B、C、D、E、F 的位置，请将这些位置信息插入到数据库 test3 的集合 people 中，并建立地理位置索引 personloc。填写完成之后点击评测，平台会对你的命令进行测试，如果成功，平台会输出如测试集所示的结果，否则会显示报错信息。展示当前数据库 test2 中 article 集合的所有索引，符合编程要求便可通过。展示当前数据库 test 中 student 集合的所有索引，符合编程要求便可通过。然后在集合中创建成绩的降序索引。本关只需在代码文件中打即可。
MongoDB 聚合框架练习题(仅供个人学习参考)
qq_55795222的博客
01-08 755
mongodb聚合框架练习题
MongoDB练习
Me11on的博客
09-09 258
联合查询，查询年龄小于20的或者系别为计算机系并且名字叫张海的。创建一个数据库study和一个集合learn。OR查询，查询系别为计算机系或者名字叫张海的。AND查询，查询计算机系并且年龄为20的。查询所有计算机系的信息并按年龄倒序排列。删除数据库study。查询以学号以2结尾的。
nodetunes:MongoDB CRUD练习
05-11
"nodetunes" 是一个针对 MongoDB 的 CRUD（创建、读取、更新、删除）操作的实践项目，旨在帮助开发者加深对 MongoDB 和 JavaScript 的使用理解。 在这个项目中，"nodetunes" 涉及到以下关键知识点： 1. **MongoDB ...
NOSQL，MongoDB的操作和索引
ghb741649543的博客
09-09 867
MongoDB创建和查看数据库 MongoDB 将 BSON 文档（即数据记录）存储在集合中，数据库包含文档集合。在 MongoDB 里面存在数据库的概念，但没有模式，保存数据的结构是 BSON 结构，只不过在进行一些数据处理的时候才会使用 MongoDB 自己的操作。 MongoDB 自带了一个功能强大的 JavaScript Shell，可以用于管理或操作 MongoDB。 MongoDB 数据库初始安装完成后，默认的数据库是 test，学习时可以在默认 test 数据库上进行各种练习操作。当然在实际的
MongoDB期末考试测试题
最新发布
12-16
这份期末考试测试题旨在帮助学生巩固MongoDB的相关知识，包括数据库管理、数据操作、查询语法、索引优化等核心概念。 1. 数据库创建与数据插入： 在MongoDB中，可以使用`use`命令切换到特定的数据库，如`xsgl`，...
MongoDb 学习笔记（2）
大O的博客
03-30 390
我设计了一个测试用例来练习MongoDb： 假定要设计一个书本的集合，有标题，页数，作者，价格，储存量，类型等属性，其中作者属性是一个数组，储存了作者对象，其包含4个属性：名，姓，年龄，性别： 1. 创建集合并插入文档 db.book.insert( { title:"Cat empire", nb_page:350, author:[ { name:"Kit...
mongoDB数据库入门操作
Snow、杨
12-28 393
MongoDB数据库在Linux系统下的常规操作 概念：             mongoDB中的三要素：数据库、集合、文档             mongoDB模式自由 注：更改Linux系统中的编码：             http://www.cnblogs.com/saneri/p/5779119.html 帮助文档：（http://www.runoob.com/mo...
mongodb查询2
习惯一个人面对所有
04-12 183
db.class2.insertMany([ { name:"c语言程序设计", category:["图书","计算机"], price:{ 进价:35, 售价:35 }, 版本:[ { edition_name:"第一版", date:201001, grade:9 }, { edition_name:"第二版"...
MongoDB aggregate性能优化与排序
www_xue_xi的博客
03-20 4643
MongoDB 在使用aggregate操作对数据进行处理时，需要显示排序操作，否则性能上会有很大的差别。
MongoDB索引Index
Kiven_ch的博客
08-05 2081
什么是索引   索引是一种单独的、物理的对数据库表中一列或多列的值进行排序的一种存储结构，它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单。索引的作用相当于图书的目录，可以根据目录中的页码快速找到所需的内容。索引目标是提高数据库的查询效率，没有索引的话，查询会进行全表扫描（scan every document in a collection）,数据量大时严重降低了查询效率。默认情况下Mongo在一个集合（collection）创建时，自动地对集合的_id创建了唯一索引。
学习MongoDB 七： MongoDB索引（索引基本操作）（一）
在前进的路上
07-19 1万+
在MongoDB建立索引能提高查询效率，只需要扫描索引只存储的这个集合的一小部分，并只把这小部分加载到内存中，效率大大的提高，如果没有建立索引，在查询时，MongoDB必须执行全表扫描，在数据量大时，效率差别就很明显，对于包括一个没有索引的排序操作的查询，服务器必须在返回任何结果之前将所有的文档加载到内存中来进行排序。 索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。索引项的排序支持高效的相等匹配和基于范围的查询操作。
索引覆盖与回表
AF_0228的博客
09-09 5659
懂的越多，不懂的越多 上回书说到：什么情况下，索引下推没办法提高sql查询效率？ 表 info 主键 id 名称 name 值 value 别名 realname 对于info表，我们现在有（name,value）联合索引
【clickhouse】clickhouse强大智能的 Projection (投影) 功能
九师兄
01-07 3645
相比普通物化视图是一张独立的表，Projection 物化的数据就保存在原表的分区目录中，支持明细数据的普通Projection 和 预聚合Projection。好了，今天的分享就到这里，再有了 PROJECTION 之后，可以说 ClickHouse 更加的如虎添翼了。通过刚才的例子，你能发现在查询时， PROJECTION 的使用是无感的，ClickHouse 会根据提交的 SQL 语句自动匹配。因为物化的数据保存在原表的分区，所以数据的更新、合并都是同源的，也就不会出现不一致的情况了。
MongoDB练习题（尚硅谷）
xiaosa的博客
05-23 1505
//1.进入my_test数据库 use my_test //2.向数据库的user集合中插入一个文档 db.users.insert({ username:"sunwukong" }); //3.查询user集合中的文档 db.users.find(); //4.向数据库的user集合中插入一个文档 db.users.insert({ username:"zhubajie" }); //5.查询数据库user集合中的文档 db.users.find(); //6....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值