首页 > 数据库 >MongoDB

MongoDB

时间：2024-10-12 18:48:28浏览次数：3  
标签：comment MongoDB userid 查询 db 索引 id

MongoDB快速上手

文章目录

前言

MongoDB是一个开源、高性能、无模式的文档型数据库，当初的设计就是用于简化开发和方便扩展，是NoSQL数据库产品中的一种。是最
像关系型数据库（MySQL）的非关系型数据库。
它支持的数据结构非常松散，是一种类似于 JSON 的 格式叫BSON，所以它既可以存储比较复杂的数据类型，又相当的灵活。
MongoDB中的记录是一个文档，它是一个由字段和值对（field:value）组成的数据结构。MongoDB文档类似于JSON对象，即一个文档认
为就是一个对象。字段的数据类型是字符型，它的值除了使用基本的一些类型外，还可以包括其他文档、普通数组和文档数组。

一、环境搭建

在这里我用的是服务器所搭建的MongoDB环境。
首先来到宝塔面板中的docker在这里插入图片描述拉取mongodb镜像

#拉取mongodb镜像
docker pull mongo:latest

然后创造容器

# 如果你并没有自定义 mongod.conf 文件，使用默认配置文件：
docker run -d --name mongodb \
-p 27017:27017 \
-v /data/mongo/data:/data/db \
-v /data/mongo/logs:/var/log/mongodb \
-e MONGO_INITDB_ROOT_USERNAME=admin \
-e MONGO_INITDB_ROOT_PASSWORD=123456 \
--restart=always \
mongo

请添加图片描述

在服务器和宝塔面板上把27017端口放行，然后可以去图形化界面连接
请添加图片描述请添加图片描述
然后可以在图形化界面进行操作了
请添加图片描述

二、MongoDB操作

1.数据库操作

1.1 选择和创建数据库

选择和创建数据库的语法格式：

use 数据库名称

如果数据库不存在则自动创建，例如，以下语句创建artticledb数据库:

 use articledb

查看有权限查看的所有的数据库命令

show dbs
或
show databases

注意: 在 MongoDB 中，数据库创建出来没有数据（集合）就不会存在磁盘中，还处于内存中
请添加图片描述
查看当前正在使用的数据库命令

db

MongoDB 中默认的数据库为 test，如果你没有选择数据库，集合将存放在 test 数据库中。

另外：
数据库名可以是满足以下条件的任意UTF-8字符串:

  • 不能是空字符串（“”)。
  • 不得含有’ '（空格)、.、$、/、\和\0 (空字符)。
  • 应全部小写。
  • 最多64字节。

有一些数据库名是保留的，可以直接访问这些有特殊作用的数据库。

  • admin ： 从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
  • local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合。
  • config : 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

1.2 数据库的删除

MongoDB 删除数据库的语法格式如下：

db.dropDatabase()

提示：主要用来删除已经持久化的数据库

2.集合操作

集合，类似关系型数据库中的表。可以显示的创建，也可以隐式的创建。

2.1 集合的显式创建（了解）

基本语法格式：

db.createCollection(name)

参数说明：

  • name: 要创建的集合名称

例如：创建一个名为mycollection的普通集合。

db.createCollection("mycollection")

查看当前库中的表：show tables命令

show collections
或
show tables

集合的命名规范：

  • 集合名不能是空字符串""。
  • 集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
  • 集合名不能以"system."开头，这是为系统集合保留的前缀。
  • 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除
    非你要访问这种系统创建的集合，否则千万不要在名字里出现$。

2.2 集合的隐式创建

当向一个集合中插入一个文档的时候，如果集合不存在，则会自动创建集合。
详见文档的插入章节。
提示：通常我们使用隐式创建文档即可。

2.3集合的删除

集合删除语法格式如下：

db.collection.drop()
或者
db.集合.drop()

返回值:如果成功删除选定集合，则 drop() 方法返回 true，否则返回 false。

例如：要删除mycollection集合

db.collection.drop()
或者
db.mycollection.drop()

3.文档基本CRUD

3.1 文档的插入

（1）单个文档插入

使用insert() 或 save() 方法向集合中插入文档，语法如下：

db.collection.insert(
	<document or array of documents>,
	{
		writeConcern: <document>,
		ordered: <boolean>
	}
)

参数：
请添加图片描述

【示例】
要向comment的集合(表)中插入一条测试数据：

db.comment.insert({
    "articleid": "100000",
    "content": "今天天气真好，阳光明媚",
    "userid": "1001",
    "nickname": "Rose",
    "createdatetime": new Date(),
    "likenum": NumberInt(10),
    "state": null
});

提示：

  1. comment集合如果不存在，则会隐式创建
  2. mongo中的数字，默认情况下是double类型，如果要存整型，必须使用函数NumberInt(整型数字)，否则取出来就有问题了。
  3. 插入当前日期使用new Date()
  4. 插入的数据没有指定_id，会自动生成主键值
  5. 如果某字段没值，可以赋值为null，或不写该字段。

执行后，如下，说明插入一个数据成功了。

WriteResult({ "nInserted" : 1 })

注意：

  1. 文档中的键/值对是有序的。
  2. 文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。
  3. MongoDB区分类型和大小写。
  4. MongoDB的文档不能有重复的键。
  5. 文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。

文档键命名规范：

  • 键不能含有\0 (空字符)。这个字符用来表示键的结尾。

  • .和$有特别的意义，只有在特定环境下才能使用。

  • 以下划线"_"开头的键是保留的(不是严格要求的)。

（2）批量插入

语法：

db.collection.insertMany(
 [ <document 1> , <document 2>, ... ],
 {
 writeConcern: <document>,
 ordered: <boolean>
 }
 )

参数：
请添加图片描述

【示例】
批量插入多条文章评论：

db.comment.insertMany([
    {
        "_id": "1",
        "articleid": "100001",
        "content": "我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我他。",
        "userid": "1002",
        "nickname": "相忘于江湖",
        "createdatetime": new Date("2019-08-05T22:08:15.522Z"),
        "likenum": NumberInt(1000),
        "state": "1"
    },
    {
        "_id": "2",
        "articleid": "100001",
        "content": "我夏天空腹喝凉开水，冬天喝温开水",
        "userid": "1005",
        "nickname": "伊人憔悴",
        "createdatetime": new Date("2019-08-05T23:58:51.485Z"),
        "likenum": NumberInt(888),
        "state": "1"
    },
    {
        "_id": "3",
        "articleid": "100001",
        "content": "我一直喝凉开水，冬天夏天都喝。",
        "userid": "1004",
        "nickname": "杰克船长",
        "createdatetime": new Date("2019-08-06T01:05:06.321Z"),
        "likenum": NumberInt(666),
        "state": "1"
    },
    {
        "_id": "4",
        "articleid": "100001",
        "content": "专家说不能空腹吃饭，影响健康。",
        "userid": "1003",
        "nickname": "凯撒",
        "createdatetime": new Date("2019-08-06T08:18:35.288Z"),
        "likenum": NumberInt(2000),
        "state": "1"
    },
    {
        "_id": "5",
        "articleid": "100001",
        "content": "研究表明，刚烧开的水千万不能喝，因为烫嘴。",
        "userid": "1003",
        "nickname": "凯撒",
        "createdatetime": new Date("2019-08-06T11:01:02.521Z"),
        "likenum": NumberInt(3000),
        "state": "1"
    }
]);

提示：
插入时指定了_id，则主键就是该值。

如果某条数据插入失败，将会终止插入，但已经插入成功的数据不会回滚掉。

因为批量插入由于数据较多容易出现失败，因此，可以使用try catch进行异常捕捉处理，测试的时候可以不处理。如（了解）：

try {
    db.comment.insertMany([
        {
            "_id": "1",
            "articleid": "100001",
            "content": "我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我他。",
            "userid": "1002",
            "nickname": "相忘于江湖",
            "createdatetime": new Date("2019-08-05T22:08:15.522Z"),
            "likenum": NumberInt(1000),
            "state": "1"
        },
        {
            "_id": "2",
            "articleid": "100001",
            "content": "我夏天空腹喝凉开水，冬天喝温开水",
            "userid": "1005",
            "nickname": "伊人憔悴",
            "createdatetime": new Date("2019-08-05T23:58:51.485Z"),
            "likenum": NumberInt(888),
            "state": "1"
        },
        {
            "_id": "3",
            "articleid": "100001",
            "content": "我一直喝凉开水，冬天夏天都喝。",
            "userid": "1004",
            "nickname": "杰克船长",
            "createdatetime": new Date("2019-08-06T01:05:06.321Z"),
            "likenum": NumberInt(666),
            "state": "1"
        },
        {
            "_id": "4",
            "articleid": "100001",
            "content": "专家说不能空腹吃饭，影响健康。",
            "userid": "1003",
            "nickname": "凯撒",
            "createdatetime": new Date("2019-08-06T08:18:35.288Z"),
            "likenum": NumberInt(2000),
            "state": "1"
        },
        {
            "_id": "5",
            "articleid": "100001",
            "content": "研究表明，刚烧开的水千万不能喝，因为烫嘴。",
            "userid": "1003",
            "nickname": "凯撒",
            "createdatetime": new Date("2019-08-06T11:01:02.521Z"),
            "likenum": NumberInt(3000),
            "state": "1"
        }
    ]);
} catch (e) {
    print(e);
}

3.2 文档的基本查询

查询数据的语法格式如下：

db.collection.find(<query>, [projection])

参数：
请添加图片描述

（1）查询所有

如果我们要查询comment集合的所有文档，我们输入以下命令

db.comment.find()
或
db.comment.find({})

这里你会发现每条文档会有一个叫_id的字段，这个相当于我们原来关系数据库中表的主键，当你在插入文档记录时没有指定该字段，MongoDB会自动创建，其类型是ObjectID类型。
如果我们在插入文档记录时指定该字段也可以，其类型可以是ObjectID类型，也可以是MongoDB支持的任意类型。

如果我想按一定条件来查询，比如我想查询userid为1003的记录，怎么办？很简单！只 要在find()中添加参数即可，参数也是json格式，如下：

db.comment.find({userid:'1003'})

如果你只需要返回符合条件的第一条数据，我们可以使用findOne命令来实现，语法和find一样。
如：查询用户编号是1003的记录，但只最多返回符合条件的第一条记录：

db.comment.findOne({userid:'1003'})
（2）投影查询（Projection Query）

如果要查询结果返回部分字段，则需要使用投影查询（不显示所有字段，只显示指定的字段）。

如：查询结果只显示_id、userid、nickname:

db.comment.find(
    { userid: "1003" },
    { userid: 1, nickname: 1} // 如果不想返回 _id 字段，可以加上 _id: 0
);

# 显示出
 { "_id" : "4", "userid" : "1003", "nickname" : "凯撒" }
 { "_id" : "5", "userid" : "1003", "nickname" : "凯撒" }

默认_id会显示。

如：查询结果只显示userid、nickname ，不显示_id：

db.comment.find(
    { userid: "1003" },
    { userid: 1, nickname: 1, _id: 0 }
);

# 显示出
 { "userid" : "1003", "nickname" : "凯撒" }
 { "userid" : "1003", "nickname" : "凯撒" }

再例如：查询所有数据，但只显示_id、userid、nickname:

db.comment.find(
    {},
    { userid: 1, nickname: 1, _id: 0 }
);

3.3 文档的更新

更新文档的语法：

db.collection.update(query, update, options)
 //或
db.collection.update(
 <query>,
 <update>,
 {
 upsert: <boolean>,
 multi: <boolean>,
 writeConcern: <document>,
 collation: <document>,
 arrayFilters: [ <filterdocument1>, ... ],
 hint:  <document|string>        
}
 )

参数：
请添加图片描述
提示：主要关注前四个参数即可。

【示例】

（1）覆盖的修改

如果我们想修改_id为1的记录，点赞量为1001，输入以下语句：

db.comment.update({_id:"1"},{likenum:NumberInt(1001)})

执行后，我们会发现，这条文档除了likenum字段其它字段都不见了

（2）局部修改

为了解决这个问题，我们需要使用修改器$set来实现，命令如下：
我们想修改_id为2的记录，浏览量为889，输入以下语句：

db.comment.update(
	{_id:"2"},
	{$set:{likenum:NumberInt(889)}}
)

这样就OK啦。

（3）批量的修改

更新所有用户为1003的用户的昵称为凯撒大帝。

//默认只修改第一条数据
db.comment.update(
	{userid:"1003"},
	{$set:{nickname:"凯撒2"}}
)
 //修改所有符合条件的数据
db.comment.update(
	{userid:"1003"},
	{$set:{nickname:"凯撒大帝"}},
	{multi:true}
)

提示：如果不加后面的参数，则只更新符合条件的第一条记录

（3）列值增长的修改

如果我们想实现对某列值在原有值的基础上进行增加或减少，可以使用$inc运算符来实现。
需求：对3号数据的点赞数，每次递增1

 db.comment.update(
 	{_id:"3"},
 	{$inc:{likenum:NumberInt(1)}}
 )

3.4 文档的删除

删除文档的语法结构：

db.集合名称.remove(条件)

以下语句可以将数据全部删除，请慎用

db.comment.remove({})

如果删除_id=1的记录，输入以下语句

db.comment.remove({_id:"1"})

3.5 文档的分页查询

3.5.1 统计查询

统计查询使用count()方法，语法如下：

db.collection.count(query, options)

参数：
请添加图片描述
提示：可选项暂时不使用。

【示例】
（1）统计所有记录数：
统计comment集合的所有的记录数：

db.comment.count()

（2）按条件统计记录数：
例如：统计userid为1003的记录条数

db.comment.count({userid:"1003"})

提示：默认情况下count()方法返回符合条件的全部记录条数。

3.5.2 分页列表查询

可以使用limit()方法来读取指定数量的数据，使用skip()方法来跳过指定数量的数据。
基本语法如下所示：

db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

如果你想返回指定条数的记录，可以在find方法后调用limit来返回结果(TopN)，默认值20，例如：

db.comment.find().limit(3)

skip方法同样接受一个数字参数作为跳过的记录条数。（前N个不要）,默认值是0

db.comment.find().skip(3)

例如
分页查询：需求：每页2个，第二页开始：跳过前两条数据，接着值显示3和4条数据

//第一页
db.comment.find().skip(0).limit(2)
 //第二页
db.comment.find().skip(2).limit(2)
 //第三页
db.comment.find().skip(4).limit(2)
3.5.3 排序查询

sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。
语法如下所示：

db.COLLECTION_NAME.find().sort({KEY:1})
或
db.集合名称.find().sort(排序方式)

例如：
对userid降序排列，并对访问量进行升序排列

db.comment.find().sort({userid:-1,likenum:1})

提示：
skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()，和命令编写顺序无关。

3.6 文档的更多查询

3.6.1 正则的复杂条件查询

MongoDB的模糊查询是通过正则表达式的方式实现的。格式为：

db.collection.find({field:/正则表达式/})
或
db.集合.find({字段:/正则表达式/})

提示：正则表达式是js的语法，直接量的写法。

例如，我要查询评论内容包含“开水”的所有文档，代码如下：

db.comment.find({content:/开水/})

如果要查询评论的内容中以“专家”开头的，代码如下：

db.comment.find({content:/^专家/})
3.6.2 比较查询

<, <=, >, >= 这个操作符也是很常用的，格式如下:

// 大于: field > value
db.集合名称.find({ "field" : { $gt: value }}) 
// 小于: field < value
db.集合名称.find({ "field" : { $lt: value }}) 
// 大于等于: field >= value
db.集合名称.find({ "field" : { $gte: value }}) 
// 小于等于: field <= value
db.集合名称.find({ "field" : { $lte: value }}) 
// 不等于: field != value
db.集合名称.find({ "field" : { $ne: value }})

示例：查询评论点赞数量大于700的记录

db.comment.find({likenum:{$gt:NumberInt(700)}})
3.6.3 包含查询

包含使用$in操作符。 示例：查询评论的集合中userid字段包含1003或1004的文档

db.comment.find({userid:{$in:["1003","1004"]}})

不包含使用$nin操作符。 示例：查询评论集合中userid字段不包含1003和1004的文档

db.comment.find({userid:{$nin:["1003","1004"]}})
3.6.4 条件连接查询

我们如果需要查询同时满足两个以上条件，需要使用$and操作符将条件进行关联。（相 当于SQL的and） 格式为：

$and:[ {  },{  },{ } ]

示例：查询评论集合中likenum大于等于700 并且小于2000的文档：

db.comment.find({
  $and: [
    { likenum: { $gte: NumberInt(700) } },
    { likenum: { $lt: NumberInt(2000) } }
  ]
})

如果两个以上条件之间是或者的关系，我们使用操作符进行关联，与前面 and的使用方式相同 格式为：

$or:[ {  },{  },{   } ]

示例：查询评论集合中userid为1003，或者点赞数小于1000的文档记录

db.comment.find({
	$or:[ 
		{userid:"1003"} ,
		{likenum:{$lt:1000} }
	]
})

3.7 常用命令小结

// 选择切换数据库
use articledb

// 插入数据
db.comment.insertOne({json数据})
db.comment.insertMany([{json数据1}, {json数据2}])

// 查询所有数据
db.comment.find()

// 条件查询数据
db.comment.find({条件})

// 查询符合条件的第一条记录
db.comment.findOne({条件})

// 查询符合条件的前几条记录
db.comment.find({条件}).limit(条数)

// 查询符合条件的跳过的记录
db.comment.find({条件}).skip(条数)

// 修改数据
db.comment.updateOne({条件}, {$set: {要修改部分的字段: 数据}})
db.comment.updateMany({条件}, {$set: {要修改部分的字段: 数据}})

// 修改数据并自增某字段值
db.comment.updateOne({条件}, {$inc: {自增的字段: 步进值}})
db.comment.updateMany({条件}, {$inc: {自增的字段: 步进值}})

// 删除数据
db.comment.deleteOne({条件})
db.comment.deleteMany({条件})

// 统计查询
db.comment.countDocuments({条件})

// 模糊查询
db.comment.find({字段名: /正则表达式/})

// 条件比较运算
db.comment.find({字段名: {$gt: 值}})

// 包含查询
db.comment.find({字段名: {$in: [值1, 值2]}})
db.comment.find({字段名: {$nin: [值1, 值2]}})

// 条件连接查询
db.comment.find({$and: [{条件1}, {条件2}]})
db.comment.find({$or: [{条件1}, {条件2}]})

4.索引-Index

4.1 概述

索引支持在MongoDB中高效地执行查询。如果没有索引，MongoDB必须执行全集合扫描，即扫描集合中的每个文档，以选择与查询语句匹配的文档。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。

如果查询存在适当的索引，MongoDB可以使用该索引限制必须检查的文档数。

索引是特殊的数据结构，它以易于遍历的形式存储集合数据集的一小部分。索引存储特定字段或一组字段的值，按字段值排序。索引项的排序支持有效的相等匹配和基于范围的查询操作。此外，MongoDB还可以使用索引中的排序返回排序结果。

官网文档：
https://docs.mongodb.com/manual/indexes/

了解：
MongoDB索引使用B树数据结构（确切的说是B-Tree，MySQL是B+Tree）

4.2 索引的类型

4.2.1 单字段索引

MongoDB支持在文档的单个字段上创建用户定义的升序/降序索引，称为单字段索引（Single Field Index）。
对于单个字段索引和排序操作，索引键的排序顺序（即升序或降序）并不重要，因为MongoDB可以在任何方向上遍历索引。
请添加图片描述

4.2.2 复合索引

MongoDB还支持多个字段的用户定义索引，即复合索引（Compound Index）。
复合索引中列出的字段顺序具有重要意义。例如，如果复合索引由
{ userid: 1, score: -1 }组成，则索引首先按userid正序排序，然后
在每个userid的值内，再在按score倒序排序。
请添加图片描述

4.2.3 其他索引

地理空间索引（Geospatial Index）、文本索引（Text Indexes）、哈希索引（Hashed Indexes）。

地理空间索引（Geospatial Index）
为了支持对地理空间坐标数据的有效查询，MongoDB提供了两种特殊的索引：返回结果时使用平面几何的二维索引和返回结果时使用球面几何的二维球面索引。

文本索引（Text Indexes）
MongoDB提供了一种文本索引类型，支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的停止词（例如“the”、“a”、“or”），而将集合中的词作为词干，只存储根词。

哈希索引（Hashed Indexes）
为了支持基于散列的分片，MongoDB提供了散列索引类型，它对字段值的散列进行索引。这些索引在其范围内的值分布更加随机，但只支持相等匹配，不支持基于范围的查询。

4.3 索引的管理操作

4.3.1 索引的查看

说明：返回一个集合中的所有索引的数组。
语法：

db.collection.getIndexes()

提示：该语法命令运行要求是MongoDB 3.0+

【示例】
查看comment集合中所有的索引情况

 db.comment.getIndexes()
[
  {
    "v": 2,
    "key": {
      "_id": 1
    },
    "name": "_id_",
    "ns": "articledb.comment"
  }
]

结果中显示的是默认_id索引。

默认_id索引：

MongoDB在创建集合的过程中，在_id字段上创建一个唯一的索引，默认名字为_id_，该索引可防止客户端插入两个具有相同值的文档，您不能在_id字段上删除此索引。

注意：该索引是唯一索引，因此值不能重复，即_id值不能重复的。在分片集群中，通常使用_id作为片键。

4.3.2 索引的创建

说明：
在集合上创建索引。
语法：

db.collection.createIndex(keys, options)

参数：
请添加图片描述
options（更多选项）列表：
请添加图片描述
提示：
注意在 3.0.0 版本前创建索引方法为 db.collection.ensureIndex()，之后的版本使用了 db.collection.createIndex() 方法，ensureIndex()还能用，但只是 createIndex()的别名。

【示例】

（1）单字段索引示例：对userid字段建立索引：

db.comment.createIndex({userid:1})
 {
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
 }

参数1：按升序创建索引
可以查看一下：

 db.comment.getIndexes()
 [
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "articledb.comment"
        },
        {
                "v" : 2,
                "key" : {
                        "userid" : 1
                },
                "name" : "userid_1",
                "ns" : "articledb.comment"
        }
 ]

索引名字为`userid_1请添加图片描述
（2）复合索引：对userid和nickname同时建立复合（Compound）索引：

 db.comment.createIndex({userid:1,nickname:-1})
 {
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "ok" : 1
 }

查看一下索引：

 db.comment.getIndexes()
 [
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "articledb.comment"
        },
        {
                "v" : 2,
                "key" : {
                        "userid" : 1
                },
                "name" : "userid_1",
                "ns" : "articledb.comment"
        },
        {
                "v" : 2,
                "key" : {
                        "userid" : 1,
                        "nickname" : -1
                },
                "name" : "userid_1_nickname_-1",
                "ns" : "articledb.comment"
        }
 ]

请添加图片描述

4.3.3 索引的移除

说明：可以移除指定的索引，或移除所有索引
一、指定索引的移除
语法：

 db.collection.dropIndex(index)

参数：
请添加图片描述
【示例】
删除comment集合中userid字段上的升序索引：

db.comment.dropIndex({userid:1})
 { "nIndexesWas" : 3, "ok" : 1 }

查看已经删除了。

二、所有索引的移除
语法：

db.collection.dropIndexes()

【示例】
删除spit集合中所有索引。

 db.comment.dropIndexes()
 {
        "nIndexesWas" : 2,
        "msg" : "non-_id indexes dropped for collection",
        "ok" : 1
 }

提示：_id的字段的索引是无法删除的，只能删除非_id字段的索引。

4.4 索引的使用

4.4.1 执行计划

分析查询性能（Analyze Query Performance）通常使用执行计划（解释计划、Explain Plan）来查看查询的情况，如查询耗费的时间、是否基于索引查询等。

那么，通常，我们想知道，建立的索引是否有效，效果如何，都需要通过执行计划查看。

语法：

db.collection.find(query,options).explain(options)

【示例】
查看根据userid查询数据的情况：

db.comment.find({userid:"1003"}).explain()
 {
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "articledb.comment",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "userid" : {
                                "$eq" : "1003"
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "userid" : {
                                        "$eq" : "1003"
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "9ef3740277ad",
                "port" : 27017,
                "version" : "4.0.10",
                "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
        },
        "ok" : 1
 }

关键点看：“stage” : “COLLSCAN”,表示全集合扫描
在这里插入图片描述下面对userid建立索引

 db.comment.createIndex({userid:1})
 {
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
 }

再次查看执行计划：

db.comment.find({userid:"1013"}).explain()
 {
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "articledb.comment",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "userid" : {
                                "$eq" : "1013"
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "userid" : 1
                                },
                                "indexName" : "userid_1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "userid" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "userid" : [
                                                "[\"1013\", \"1013\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "9ef3740277ad",
                "port" : 27017,
                "version" : "4.0.10",
                "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
        },
        "ok" : 1
 }

关键点看：“stage” : “IXSCAN”,基于索引的扫描

compass查看：
在这里插入图片描述

4.4.2 涵盖的查询

在这里插入图片描述
更多：
https://docs.mongodb.com/manual/core/query-optimization/#read-operations-covered-query

5.Java应用

5.1 SpringDataMongoDB

SpringData家族成员之一，用于操作MongoDB的持久层框架，封装了底层的mongodb-driver。

官网主页：
https://projects.spring.io/spring-data-mongodb/

我们十次方项目的吐槽微服务就采用SpringDataMongoDB框架。

5.2 微服务模块搭建

在这里插入图片描述
在这里插入图片描述
然后再创建application.yml
在这里插入图片描述

5.3 文章评论实体类的编写

创建实体类 创建包cn.itcast.article，包下建包po用于存放实体类，创建实体类

/**
 * 文章评论实体类
 */
//把一个java类声明为mongodb的文档，可以通过collection参数指定这个类对应的文档。
// @Document(collection="mongodb 对应 collection 名")
// 若未加 @Document ，该 bean save 到 mongo 的 comment collection
// 若添加 @Document ，则 save 到 comment collection
 @Document(collection="comment")//可以省略，如果省略，则默认使用类名小写映射集合
//复合索引
 @CompoundIndex( def = "{'userid': 1, 'nickname': -1}")
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 public class Comment implements Serializable {
    //主键标识，该属性的值会自动对应mongodb的主键字段"_id"，如果该属性名就叫“id”,则该注解可以省略，否则必须写
    @Id
    private String id;//主键
    //该属性对应mongodb的字段的名字，如果一致，则无需该注解
    @Field("content")
    private String content;//吐槽内容
    private Date publishtime;//发布日期
    //添加了一个单字段的索引
    @Indexed
    private String userid;//发布人ID
    private String nickname;//昵称
    private LocalDateTime createdatetime;//评论的日期时间
    private Integer likenum;//点赞数
    private Integer replynum;//回复数
    private String state;//状态
    private String parentid;//上级ID
    private String articleid;
}

说明：
索引可以大大提升查询效率，一般在查询字段上添加索引，索引的添加可以通过Mongo的命令来添加，也可以在Java的实体类中通过注解添
加。

5.4 文章评论的基本增删改查

（1）创建数据访问接口 cn.itcast.article包下创建dao包，包下创建接口

//评论的持久层接口
public interface CommentRepository extends MongoRepository<Comment,String> {
}

（2）创建业务逻辑类 cn.itcast.article包下创建service包，包下创建类

//评论的业务层
@Service
 public class CommentService {
 
    //注入dao
    @Autowired
    private CommentRepository commentRepository;
    @Autowired
    private MongoTemplate mongoTemplate;
    
    /**
     * 保存一个评论
     * @param comment
     */
    public void saveComment(Comment comment){
        //如果需要自定义主键，可以在这里指定主键；如果不指定主键，MongoDB会自动生成主键
        //设置一些默认初始值。。。
        //调用dao
        commentRepository.save(comment);
    }
 
    /**
     * 更新评论
     * @param comment
     */
    public void updateComment(Comment comment){
        //调用dao
        commentRepository.save(comment);
    }
 
    /**
     * 根据id删除评论
     * @param id
     */
    public void deleteCommentById(String id){
        //调用dao
        commentRepository.deleteById(id);
    }
 
    /**
     * 查询所有评论
     * @return
     */
    public List<Comment> findCommentList(){
        //调用dao
        return commentRepository.findAll();
    }
 
    /**
     * 根据id查询评论
     * @param id
     * @return
     */
    public Comment findCommentById(String id){
        //调用dao
        return commentRepository.findById(id).get();
    }

    /**
     * 根据父id查询分页列表
     * @param parentid
     * @param page
     * @param size
     * @return
     */
    public Page<Comment> findCommentListPageByParentid(String parentid,int page, int size){
        return commentRepository.findByParentid(parentid, PageRequest.of(page-1,size));
    }

    public Page<Comment> findCommentListPageByUserid(String userid,int page, int size){
        return commentRepository.findByUserid(userid, PageRequest.of(page-1,size));
    }

    /**
     * 点赞数+1
     * @param id
     */
    public void updateCommentLikenum(String id){
        Query query = Query.query(Criteria.where("_id").is(id));

        Update update = new Update();

        update.inc("likenum");

        mongoTemplate.updateFirst(query,update,"comment");
    }
}

（3）新建Junit测试类，测试保存和查询所有：

@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = Demo1Application.class)
public class CommentServiceTest {

    // 注入Service
    @Autowired
    private CommentService commentService;

    /**
     * 测试保存一个评论
     */
    @Test
    public void testSaveComment() {
        Comment comment = new Comment();
        comment.setArticleid("1000001");
        comment.setContent("测试添加的数据222");
        comment.setCreatedatetime(LocalDateTime.now());
        comment.setUserid("1003");
        comment.setNickname("凯撒大帝");
        comment.setState("1");
        comment.setLikenum(0);
        comment.setReplynum(0);

        commentService.saveComment(comment); // 调用保存方法

        // 可选：添加断言检查保存的评论是否成功
//        assertNotNull(comment.getId());
        System.out.println("保存的评论ID：" + comment.getId());
    }

    /**
     * 测试查询所有数据
     */
    @Test
    public void testFindAll() {
        List<Comment> list = commentService.findCommentList();
        // 可选：添加断言检查是否返回了评论列表
//        assertFalse(list.isEmpty());
        System.out.println(list);
    }

    /**
     * 测试根据ID查询评论
     */
    @Test
    public void testFindCommentById() {
        String commentId = "1"; // 替换为实际ID
        Comment comment = commentService.findCommentById(commentId);
        // 可选：添加断言检查是否成功找到评论
//        assertNotNull(comment);
        System.out.println(comment);
    }

    /**
     * 测试根据父id查询子评论的分页列表
     */
    @Test
    public void testFindCommentListPageByParentid(){
        Page<Comment> pageResponse = commentService.findCommentListPageByParentid("3 ", 1, 1);
        System.out.println("----总记录数："+pageResponse.getTotalElements());
        System.out.println("----当前页数据："+pageResponse.getContent());
    }
    @Test
    public void testFindCommentListPageByUserid(){
        Page<Comment> pageResponse = commentService.findCommentListPageByUserid("1003", 1, 1);
        System.out.println("----总记录数："+pageResponse.getTotalElements());
        System.out.println("----当前页数据："+pageResponse.getContent());
    }

    /**
     * 点赞数+1
     */
    @Test
    public void testUpdateCommentLikenum(){
        //对3号文档的点赞数+1
        commentService.updateCommentLikenum("1");
    }
}

标签：comment,MongoDB,userid,查询,db,索引,id
From： https://blog.csdn.net/m0_74039408/article/details/142860666

相关文章

  • MongoDB安装及配置Navicat MongoDB Tools
    一、下载MongoDB1.下载网址：https://www.mongodb.com/try/download/community注：本文档以Windows和msi安装为例二、安装MongoDB打开.msi文件在硬盘任意位置创建mongo目录，内包含mongo.conf文件内容:#存放数据目录dbpath=D:\mongo\data\db端口port=27017日志......
  • MongoDB常用操作
    MongoDB常用操作的语法格式及其举例如下1、创建数据库语法useDATABASE_NAME例子：usemymongoDB;2、查看数据库语法：showDATABASE_NAME3、删除数据库语法：db.dropDatabase()4、创建集合语法：db.createCollection(name,options)例子：创建普通集合db.createCollection("mytest")创建固......
  • MongoDB新的均衡策略和自动合并
    均衡器的用途均衡器是一个后台线程，运行于配置服务器(configserver)副本集的主节点。它定期检查分片中块(chunks)和数据的分布情况。如果达到某些迁移阈值，均衡器就会决定将块从一个分片迁移到另一个分片。其主要目标是在所有分片中拥有大致相同的数据量。 在繁忙的集群中，迁移......
  • MongoDB集群的启动和关闭顺序
    分片(Shard)环境中的启动和关闭1.启动这个具体的参照分片的配置，启动的顺序是configserver->副本集/分片(shardX)->->mongos2.关闭因为mongos是分片架构最前端的入口，所以关闭顺序：mongos->副本集/分片(shardX)->configserver单实例：直接关闭db.getSiblingDB(“admin”).shutdow......
  • MongoDB
    安装Homebrew:brewtapmongodb/brewbrewupdatebrewinstallmongodb-community相关路径（AppleSilicon）：配置文件路径：/opt/homebrew/etc/mongod.conf日志文件路径：/opt/homebrew/var/log/mongodb数据目录：/opt/homebrew/var/mongodb参考：安装MongoDB|MongoDB手册使用......
  • MongoDB分片键选择指南
    MongoDB分片键选择指南特别是华为Mongodb4.0集群的使用，更能提高查询效率MongoDB是一款高性能的NoSQL数据库，能够处理大量数据并支持水平扩展。为了实现这一点，MongoDB使用了分片技术，而选择合适的分片键对性能和可伸缩性有着至关重要的影响。第一步：理解分片的工作原理MongoDB的......
  • 第二节：基于.Net 链接Mongodb实战
     三. 实操（详见官网：https://www.mongodb.com/zh-cn/docs/drivers/csharp/current/quick-start/）1.相关程序集 【MongoDB.Driver2.17.1】  相关实体：加上如下特性，id值自动生成。publicclassShipInfo{///<summary>///自动生成id/......
  • MongoDB 用户权限管理,复制集,分片集群,备份恢复 rocky使用
    1MongoDB介绍1.4什么时候使用MongoDB1.数据量是有亿万级或者需要不断扩容2.需要2000-3000以上的读写每秒3.新应用，需求会变，数据模型无法确定4.需要整合多个外部数据源5.系统需要99.999%高可用6.系统需要大量的地理位置查询7.系统需要提供最小的latency8.管理的主要数......
  • mongodb(数据库)
    进入mongodb数据库管理系统本地进入mongo远程进入mongo-host=127.0.0.1-p=27017退出exit;查看数据库showdbs-----默认进入test的数据库里面创建数据库/选择数据库usemydb查看你现在使用的是哪个数据库db删除数据库db.dropDatabase()查看集合showcollection......
  • 面向-MongoDB-开发者的-CosmosDB-教程-全-
    面向MongoDB开发者的CosmosDB教程（全）原文：CosmosDBforMongoDBdevelopers协议：CCBY-NC-SA4.0一、为什么是NoSQL？自从上学以来，我们大多数人都被教导要组织信息，这样它就可以用表格的形式来表示。但并不是所有的信息都能遵循这种结构，因此存在NULL值。NULL值表示没有信息......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99