Mongo学习记录

最新推荐文章于 2022-12-21 15:48:53 发布
最新推荐文章于 2022-12-21 15:48:53 发布
阅读量212 收藏
点赞数
文章标签： Mongo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19006223/article/details/98670951
版权

在这里插入图片描述

引子

最近做项目利用mongo记录的日志做数据统计。着了非关系型数据库的迷，于是乎买了本《MongoDB实战》学习了一番。记录一下学习笔记，共享之。

准备

我在自己的Linux服务器上装了最新版的Mongo。记录一下安装链接还有一个遇到的问题。

Linux安装mongo https://blog.51cto.com/13641879/2141129

我想看数据库状态的时候遇到了一个权限问题

> db.serverStatus()
{
	"ok" : 0,
	"errmsg" : "not authorized on admin to execute command { serverStatus: 1.0, lsid: { id: UUID(\"bbda7ede-9e92-492b-ae2f-f0f641fba261\") }, $db: \"admin\" }",
	"code" : 13,
	"codeName" : "Unauthorized"
}

解决方法：https://www.cnblogs.com/alexzhang92/p/10479105.html

如果看了上面那个解决方法，我们再次进入mongo shell模式（以admin）需要输入一下命令：

mongo -u ‘admin’ -p ‘123’ --authenticationDatabase ‘admin’

基础概念

mysqlmongo解释
databasedatabase数据库
tablecollection集合
rowdocument文档
columnfield域

Mongo储存数据都是以BSON格式的，类似于JSON，如下：

{
	"_id": ObjectId("5d399bb2b52d6dc8a4ff6b42"),
	"name": "pjjlt"
}

如果不指定主键，会默认生成一个_id（长度一共12字节），生成规则：4个字节的时间戳+3个字节的机器Id+2个字节的进程Id+3个字节的随机数

Mongo操作

基础操作

> show dbs #查看所有数据库和使用情况
admin   0.000GB
config  0.000GB
local   0.000GB

> use pjjlt #切换到pjjlt库，发现没有创建之
switched to db pjjlt

> db #查看当前在操作哪个数据库
pjjlt

> db.myCollection.insert({"name":"pjjlt"}) #在pjjlt库的myCollection集合(没有此集合，创建之)插入一条数据
WriteResult({ "nInserted" : 1 })

> show collections #查看本库(pjjlt)下所有集合
myCollection

> db.myCollection.find() #查询某集合数据
{ "_id" : ObjectId("5d399bb2b52d6dc8a4ff6b42"), "name" : "pjjlt" }

#篇幅原因，不演示下面操作了，直接说解释
>db.myCollection.drop() #删除某集合
>db.dropDatabase() #删除某数据库
>db.serverStatus() #查看服务器状态信息（查看引擎就在这边看，可以看到mongo4的默认引擎已经是wiredtiger了）
>db.stats() #当前数据库下简单信息 可以查看本库下有多少集合
>db.myCollection.stats() #查看某集合的基础信息
>db.runCommand() #可以执行某个function()方法
>db.help() #查看数据库层面所有操作
>db.myCollection.help() #查看集合层面所有操作
>db.listCommands() #列举数据库所有命令

数据插入

数据插入，可分为insert和save方法。具体所有方法，可以先输入一段代码，再按两下tab键查看。

#两下TAB键，看下有以下方法。insert可以实现后面两个方法的功能，即插入一条或多条
> db.myCollection.insert 
db.myCollection.insert(      db.myCollection.insertMany(  db.myCollection.insertOne(

#插入一条记录
> db.myCollection.insert({"name":"haha"})
WriteResult({ "nInserted" : 1 })

#插入多条记录，输出的信息会更加详细
> db.myCollection.insert([{"name":"hehe"},{"name":"heihei"}])
BulkWriteResult({
	"writeErrors" : [ ],
	"writeConcernErrors" : [ ],
	"nInserted" : 2,
	"nUpserted" : 0,
	"nMatched" : 0,
	"nModified" : 0,
	"nRemoved" : 0,
	"upserted" : [ ]
})

#看下myCollection集合下有多少数据
> db.myCollection.count()
4

#再看下内容，_id是自动生成的主键。
> db.myCollection.find()
{ "_id" : ObjectId("5d399bb2b52d6dc8a4ff6b42"), "name" : "pjjlt" }
{ "_id" : ObjectId("5d3a6bafd40e94efd747de7b"), "name" : "haha" }
{ "_id" : ObjectId("5d3a6c3fd40e94efd747de7c"), "name" : "hehe" }
{ "_id" : ObjectId("5d3a6c3fd40e94efd747de7d"), "name" : "heihei" }

#看一下save的插入功能，save可以指定_id
#如果有_id存在则更新，没有就是插入，功能类似insert
> db.myCollection.save({"name":"save0"})
WriteResult({ "nInserted" : 1 })

> db.myCollection.save([{"name":"save1"},{"name":"save2"}])
BulkWriteResult({
	"writeErrors" : [ ],
	"writeConcernErrors" : [ ],
	"nInserted" : 2,
	"nUpserted" : 0,
	"nMatched" : 0,
	"nModified" : 0,
	"nRemoved" : 0,
	"upserted" : [ ]
})

> db.myCollection.find()
{ "_id" : ObjectId("5d399bb2b52d6dc8a4ff6b42"), "name" : "pjjlt" }
{ "_id" : ObjectId("5d3a6bafd40e94efd747de7b"), "name" : "haha" }
{ "_id" : ObjectId("5d3a6c3fd40e94efd747de7c"), "name" : "hehe" }
{ "_id" : ObjectId("5d3a6c3fd40e94efd747de7d"), "name" : "heihei" }
{ "_id" : ObjectId("5d3a927fb4d620841817e434"), "name" : "save0" }
{ "_id" : ObjectId("5d3a92a2b4d620841817e436"), "name" : "save1" }
{ "_id" : ObjectId("5d3a92a2b4d620841817e437"), "name" : "save2" }

数据修改

数据修改有命令save和update，其中update有具有局部更新和替换更新的功能

#先看下save方法，指定_id，进行修改
> db.myCollection.save({"_id":ObjectId("5d3a92a2b4d620841817e437"),"name":"save3"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.myCollection.find()
{ "_id" : ObjectId("5d399bb2b52d6dc8a4ff6b42"), "name" : "pjjlt" }
{ "_id" : ObjectId("5d3a6bafd40e94efd747de7b"), "name" : "haha" }
{ "_id" : ObjectId("5d3a6c3fd40e94efd747de7c"), "name" : "hehe" }
{ "_id" : ObjectId("5d3a6c3fd40e94efd747de7d"), "name" : "heihei" }
{ "_id" : ObjectId("5d3a927fb4d620841817e434"), "name" : "save0" }
{ "_id" : ObjectId("5d3a92a2b4d620841817e436"), "name" : "save1" }
{ "_id" : ObjectId("5d3a92a2b4d620841817e437"), "name" : "save3" }

#然后看update方法，同insert一样，update可以实现后面两个方法
> db.myCollection.update
db.myCollection.update(      db.myCollection.updateMany(  db.myCollection.updateOne(

看下update语法

db.collection.update(
   <query>,   #update的查询条件，类似sql update语句where后面的部分
   <update>,  #update的对象和一些更新的操作符等，也可以理解为sql update语句set后面的
   {
     upsert: <boolean>,  #可选，这个参数的意思是，如果不存在update的记录，是否插入objNew，true为插入，默认是false，不插入
     multi: <boolean>,   #可选，mongodb 默认是false，只更新找到的第一条记录，如果这个参数为true，就把按条件查出来多条记录全部更新
     writeConcern: <document>  #可选，抛出异常的级别
   }
)

接着回到例子中，为了说明方便，我们新建一个新的集合user

#给新的集合建一个新的文档
> db.user.insert({"username":"pjjlt","age":25})
WriteResult({ "nInserted" : 1 })
> db.user.find().pretty()
{
	"_id" : ObjectId("5d3aa1fcb4d620841817e438"),
	"username" : "pjjlt",
	"age" : 25
}

# ok，把pjjlt的年龄改成18，使用了关键字$set,待会会演示不使用这个关键字的效果
> db.user.update({"_id" : ObjectId("5d3aa1fcb4d620841817e438")},{$set:{"age":18}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.user.find().pretty()
{
	"_id" : ObjectId("5d3aa1fcb4d620841817e438"),
	"username" : "pjjlt",
	"age" : 18
}

#如果使用了$set是局部更新，如果不使用，就是替换更新，为了区分，我们已跟新新的域city为例
> db.user.update({"_id" : ObjectId("5d3aa1fcb4d620841817e438")},{"city":"SJZ"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.user.find().pretty()
{ "_id" : ObjectId("5d3aa1fcb4d620841817e438"), "city" : "SJZ" }
#发现原始数据也没了，因为被全部替换了

数据删除

数据删除可以使用deleteMany、deleteOne、remove

# 两下Tab
> db.user.delete
db.user.deleteMany(  db.user.deleteOne(

# 删除没数据了
> db.user.deleteOne({"_id" : ObjectId("5d3aa1fcb4d620841817e438")})
{ "acknowledged" : true, "deletedCount" : 1 }
> db.user.find().pretty()
> 

# 再增加几条数据
> db.user.find()
{ "_id" : ObjectId("5d3ab2f8b4d620841817e439"), "username" : "pjjlt", "age" : 25 }
{ "_id" : ObjectId("5d3ab2fdb4d620841817e43a"), "username" : "pjjlt1", "age" : 25 }
{ "_id" : ObjectId("5d3ab302b4d620841817e43b"), "username" : "pjjlt2", "age" : 25 }
{ "_id" : ObjectId("5d3ab322b4d620841817e43c"), "username" : "pjjlt3", "age" : 18 }

remove语法

db.collection.remove(
   <query>,    #可选，查询条件
   {
     justOne: <boolean>,  #可选，设置为true或者1，表示只删除一个文档，设置为false，表示删除所有匹配的文档，默认为false
     writeConcern: <document> #可选，抛出异常的级别
   }
)

再回到例子删除一下。需要手动释放磁盘空间

> db.user.remove({"age" : 25})
WriteResult({ "nRemoved" : 3 })
> db.user.find()
{ "_id" : ObjectId("5d3ab322b4d620841817e43c"), "username" : "pjjlt3", "age" : 18 }
#手动释放磁盘空间
> db.repairDatabase() 
{ "ok" : 1 }

数据查询

几乎大部分的业务都和查询有关。

范围查询运算符
运算符描述
$lt小于
$gt大于
$lte小于等于
$gte大于等于

准备一个大数据集合，往numbers集合里面添加1000个数字

#前面那三个点是自动生成的，对代码没有影响，请忽略
> for(i=0;i<1000;i++){
... db.numbers.save({num:i});
... }
WriteResult({ "nInserted" : 1 })

#测试一个$lt，其他雷同
> db.numbers.find({"num":{$lt:5}})
{ "_id" : ObjectId("5d3ac7b7b4d620841817e43d"), "num" : 0 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e43e"), "num" : 1 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e43f"), "num" : 2 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e440"), "num" : 3 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e441"), "num" : 4 }
集合操作符
运算符描述
$in如果任意参数引用集合里，则匹配
$all如果所有参数再引用集合里且被使用在包含数组的文档中，则匹配
$nin如果没有参数在引用集合里，则匹配
#插入一条记录
> db.tools.insert({tools:["AAA","BBB","CCC","DDD","EEE"]})
WriteResult({ "nInserted" : 1 })
#查看一下
> db.tools.find()
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ] }

#通过$in搜出来了
> db.tools.find({tools:{
... $in:["AAA","FFF","ZZZ"]
... }
... })
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ] }

#$all搜索测试
> db.tools.find({tools:{ $all:["AAA","FFF","ZZZ"] } })
> db.tools.find({tools:{ $all:["AAA","BBB"] } })
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ] }

#$nin搜索测试
> db.tools.find({tools:{ $nin:["AAA","BBB"] } })
> db.tools.find({tools:{ $nin:["ZZZ","YYY"] } })
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ] }
布尔运算符
运算符描述
$ne不匹配参数
$not不匹配结果
$or有一个条件匹配就成立
$nor所有条件都不匹配
$and所有条件都匹配
$exists判断元素是否存在
#接着上面的例子，使用$ne
> db.tools.find({tools:{$ne:"AAA"}})
> db.tools.find({tools:{$ne:"ZZZ"}})
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ] }

#$not 看就就像条件取反
> db.tools.find({tools:{$not:{$in:["AAA"]}}})
> db.tools.find({tools:{$not:{$in:["ZZZ"]}}})
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ] }

#为了演示下面的功能，添加新域给刚才那个文档
> db.tools.update({"_id" : ObjectId("5d3ad78eb4d620841817e825")},{$set:{"city":"SJZ"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.tools.find().pretty()
{
	"_id" : ObjectId("5d3ad78eb4d620841817e825"),
	"tools" : [
		"AAA",
		"BBB",
		"CCC",
		"DDD",
		"EEE"
	],
	"city" : "SJZ"
}

#$or
> db.tools.find( {$or:[ {tools:{$in:["AAA"]}}, {"city":"BJ"} ]} )
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ], "city" : "SJZ" }

#$nor 所有条件都不匹配
> db.tools.find( {$nor:[ {tools:{$in:["ZZZ"]}}, {"city":"BJ"} ]} )
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ], "city" : "SJZ" }

#$and
> db.tools.find( {$and:[ {tools:{$in:["AAA"]}}, {"city":"BJ"} ]} )
> db.tools.find( {$and:[ {tools:{$in:["AAA"]}}, {"city":"SJZ"} ]} )
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ], "city" : "SJZ" }

#$exists
# tools集合是否存在tools域
> db.tools.find({"tools":{$exists:true}})
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ], "city" : "SJZ" }
# tools集合是否不存在tools域
> db.tools.find({"tools":{$exists:false}})
>
数组操作符
运算符描述
$elemMatch如果提供的所有词语在相同的子文档中，则匹配
$size如果子文档数组大小与提供的文本值相同，则匹配
#在新的集合里面插入新的文档
> db.products.insert({addresses:[{name:"home",city:"sjz"},{name:"work",city:"bj"}]})
WriteResult({ "nInserted" : 1 })
> db.products.find().pretty()
{
	"_id" : ObjectId("5d3ae3763d2312bc3a0be84c"),
	"addresses" : [
		{
			"name" : "home",
			"city" : "sjz"
		},
		{
			"name" : "work",
			"city" : "bj"
		}
	]
}

#$elemMatch 需要子文档的哦
> db.products.find({addresses:{$elemMatch:{"name":"home","city":"sjz"}}})
{ "_id" : ObjectId("5d3ae3763d2312bc3a0be84c"), "addresses" : [ { "name" : "home", "city" : "sjz" }, { "name" : "work", "city" : "bj" } ] }

#size
> db.products.find({"addresses":{$size:1}})
> db.products.find({"addresses":{$size:2}})
{ "_id" : ObjectId("5d3ae3763d2312bc3a0be84c"), "addresses" : [ { "name" : "home", "city" : "sjz" }, { "name" : "work", "city" : "bj" } ] }
排序分页分隔符
运算符描述
$sort排序 1 正序；-1 倒叙
$limit显示多少条
$skip跳过多少数据

注意和MySQL一样，skip操作大数的时候会很慢，需要提前缩小范围

#使用numbers这个集合
> db.numbers.find().sort({"num":-1}).skip(33).limit(9)
{ "_id" : ObjectId("5d3ac7b8b4d620841817e803"), "num" : 966 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e802"), "num" : 965 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e801"), "num" : 964 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e800"), "num" : 963 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e7ff"), "num" : 962 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e7fe"), "num" : 961 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e7fd"), "num" : 960 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e7fc"), "num" : 959 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e7fb"), "num" : 958 }
其他操作符
运算符描述
$where执行任意JavaScript来选择文档
$regex匹配正则表达式
$mod[(quatient),(result)]如果元素除以除数符合结果则匹配
$type如果元素的类型符合指定的BSON类型则匹配
$text允许在建立文本索引的字段上执行文本搜索
null不是关键词，不用加$，只是看一下使用
#只演示下 mod 和 regex
#接着用刚才numbers那个集合
> db.numbers.find({"num":{$mod:[200,3]}})
{ "_id" : ObjectId("5d3ac7b8b4d620841817e440"), "num" : 3 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e508"), "num" : 203 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e5d0"), "num" : 403 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e698"), "num" : 603 }
{ "_id" : ObjectId("5d3ac7b8b4d620841817e760"), "num" : 803 }

#使用刚才user集合，搜索所有username以p开头的文档
> db.user.find({"username":{$regex:/^p.*/}})
{ "_id" : ObjectId("5d3ab322b4d620841817e43c"), "username" : "pjjlt3", "age" : 18 }

#null的使用，搜索出没有这个域的文档，或者这个域为null
> db.user.find({"username":null})
> db.user.find({"username111":null})
{ "_id" : ObjectId("5d3ab322b4d620841817e43c"), "username" : "pjjlt3", "age" : 18 }

聚合操作aggregate

可以把聚合框架理解成SQL中的GROUP BY。为了调用聚合框架就要定义一个管道。聚合管道里的每一步输出作为下一步的输入。类似于流的概念。

运算符描述
$project指定输出文档里的字段（项目）
$match选择要处理的字段，与find()类似
$limit限制传递给下一步文档数量
$skip跳过一定数量的文档
$unwind拓展数组，为每一个数组入口生成一个输出文档
$group根据key来分组文档
$skip排序文档
$geoNear选择某个地理位置附近的文档
$out把管道的结果写入某集合
$redact控制特定数据的访问

以上很多命令符与上面查询命令符功能相同，$geoNear（这个貌似很有趣，类似于图论中迪杰斯特拉、弗洛伊德那些算法，可以计算坐标点之间的物理距离）和$redact先不过多的讨论。$limit、$skip、$skip也过于简单，上面演示过了，这里不再重复。看一下这些命令和关系型数据库SQL的类比

SQL命令聚合命令操作符
SELECT$project $group functions : $sum,$min,$avg,etc.
FROMdb.collectionName.aggregate(…)
JOIN$unwind
WHERE$match
GROUP BY$group
HAVING$match

但是集合命令操作符不必按照以上顺序进行书写，比如可以先写$match进行条件筛选，然后进行其他操作（其实，也往往建议这么做，毕竟第一步就把大部分没用的数据过滤了）

#为了方便说明，新建一个集合
> db.score.find()
{ "_id" : ObjectId("5d3bac2d78b22e869eb2fd26"), "name" : "pjjlt", "age" : 25, "city" : "sjz" }
{ "_id" : ObjectId("5d3bac5878b22e869eb2fd27"), "name" : "qex", "age" : 112, "city" : "london" }
{ "_id" : ObjectId("5d3bad9078b22e869eb2fd28"), "name" : "haha", "age" : 24, "city" : "sjz" }
{ "_id" : ObjectId("5d3bada078b22e869eb2fd29"), "name" : "heihei", "age" : 25, "city" : "bj" }

#验证$match和$project
> db.score.aggregate([
... {$match:{age:{$lt:100}}}, //条件过滤
... {$project:{"_id":0}} //不显示主键
... ])
{ "name" : "pjjlt", "age" : 25, "city" : "sjz" }
{ "name" : "haha", "age" : 24, "city" : "sjz" }
{ "name" : "heihei", "age" : 25, "city" : "bj" }

#接下来分组显示每个城市的平均年龄
> db.score.aggregate([ {$group:{_id:"$city",avgAge:{$avg:"$age"}}} ])
{ "_id" : "bj", "avgAge" : 25 }
{ "_id" : "london", "avgAge" : 112 }
{ "_id" : "sjz", "avgAge" : 24.5 }

对于$group,对于原始数据如city、age，进行显示的时候前面也需要加上$，如$city、$age，否则显示为null

另外展示一下$group中可以使用的命令

命令描述
$addToSet为组里唯一的值创建一个数组
$first组里第一个值，只有前缀$sort才有意义
$last组里最后一个值，只有前缀$sort才有意义
$max组里某个字段的最大值
$min组里某个字段的最小值
$avg某个字段的平均值
$push返回组内所有值的数组。不去重复值
$sum求组内所有值的和
#回来接着展示$out字符，并且$out字符类似于Java8中的流收集器，必须放最后执行
> db.score.aggregate([ {$group:{_id:"$city",avgAge:{$avg:"$age"}}} ,{$out:'aResult'}])

#删除一下变量中的数据
> db.aResult.find()
{ "_id" : "bj", "avgAge" : 25 }
{ "_id" : "london", "avgAge" : 112 }
{ "_id" : "sjz", "avgAge" : 24.5 }

#最后是$unwind，接着用上次那个tools集合
> db.tools.find()
{ "_id" : ObjectId("5d3ad78eb4d620841817e825"), "tools" : [ "AAA", "BBB", "CCC", "DDD", "EEE" ], "city" : "SJZ" }

> db.tools.aggregate([
... {$project:{"_id":0}},
... {$unwind:"$tools"}
... ])
{ "tools" : "AAA", "city" : "SJZ" }
{ "tools" : "BBB", "city" : "SJZ" }
{ "tools" : "CCC", "city" : "SJZ" }
{ "tools" : "DDD", "city" : "SJZ" }
{ "tools" : "EEE", "city" : "SJZ" }

同关系型数据库一样，在project的时候，可以对数据进行进一步加工，可选函数有concat、toLower、toUpper这种字符串函数；add、mod、multiply这种算数运算函数；日期运算符；逻辑运算符；集合操作符等。以后有空在总结。

原子性

mongo在事务处理方面不如mysql。比如两个不同线程update的时候（+1操作）可能会出现数据被覆盖的现象。特别介绍一个具有原子性的操作findAndModify(),总找到到修改提交是一个原子事件，期间其他线程查询该数据会被拒绝。
当然为了保护数据，在业务代码层面（比如java）可以考虑加锁。

> db.score.find({"name":"qex"})
{ "_id" : ObjectId("5d3bac5878b22e869eb2fd27"), "name" : "qex", "age" : 112, "city" : "london" }

#修改qex的年龄
> db.score.findAndModify({
... query:{"name":"qex"},
... update:{ $inc:{"age":+3}}
... })
{
	"_id" : ObjectId("5d3bac5878b22e869eb2fd27"),
	"name" : "qex",
	"age" : 112,
	"city" : "london"
}
> db.score.find({"name":"qex"})
{ "_id" : ObjectId("5d3bac5878b22e869eb2fd27"), "name" : "qex", "age" : 115, "city" : "london" }

总结一下更新操作符

操作符描述
$inc根据给定的值更改数字
$set设置字段为给定的值
$unset取消设置字段
$rename重命名字段给定的值
$setOnInsert在upsert中，插入时设置字段
$bit只执行按位更新字段
$根据查询选择器定位要更新的子文档
$push添加值到数组中
$addToSet添加值到数组中，重复了也不处理
$pop从数组中删除第一个或者最后一个值
$pull从数组中删除匹配查询条件的值
$pullAll从数组中删除多个值
$each从push和addToSet一起使用来操作多个值
$slice从push和each一起使用来缩小更新后数组的大小
$sort从push和each、slice一起使用来排序数组中的子文档
$isolated隔离其他操作，不允许其他操作交叉更新多个文档

索引

索引分类

  1. 唯一索引

确保该数据在该集合只有一份，比如说主键，格式：

> db.user.createIndex({username:1},{unique:true})
{
	"createdCollectionAutomatically" : false,
	"numIndexesBefore" : 1,
	"numIndexesAfter" : 2,
	"ok" : 1
}
  1. 稀疏索引

稀疏索引可以保证某些文档不包含这个属性，就不会被筛选出来。例如通过电话号码建索引，但是集合中有的文档电话号码是null，在创建索引的时候就不会把这些文档考虑进来。

> db.user.createIndex({username:1},{sparse:true})
  1. 多键索引

索引字段是个数字，比如tools集合中的tools域，这意味着针对这些数组任意值在索引上的查询都会定位到文档上

  1. 哈希索引

哈希索引的好处是可以让索引上的入口是均匀分布的

db.user.createIndex({username:'hashed'})
  1. 地理位置索引

查询某个地点附近的文档，基于经纬度来储存每个文档。

当然从引用域的数量来说还可以分为单键索引和复合索引，和mysql的行为类似。

索引管理

  1. 建立索引

使用createIndex()。由于建立索引的时候，数据量大会导致系统长时间等待，所以要可以指定后台索引（由于需要大量数据，我没实验），还有离线索引等等。

db.user.createIndex({username:'hashed'}，{background：true})

索引反复操作可能会在内存中产生大量碎片，可以使用命令进行碎片整理（索引新建之）

> db.user.reIndex()
{
	"nIndexesWas" : 2,
	"nIndexes" : 2,
	"indexes" : [
		{
			"v" : 2,
			"key" : {
				"_id" : 1
			},
			"name" : "_id_",
			"ns" : "pjjlt.user"
		},
		{
			"v" : 2,
			"unique" : true,
			"key" : {
				"username" : 1
			},
			"name" : "username_1",
			"ns" : "pjjlt.user"
		}
	],
	"ok" : 1
}
  1. 查看索引

查看某个集合的索引使用getIndexes()

> db.user.getIndexes()
[
	{
		"v" : 2,
		"key" : {
			"_id" : 1
		},
		"name" : "_id_",
		"ns" : "pjjlt.user"
	},
	{
		"v" : 2,
		"unique" : true,
		"key" : {
			"username" : 1
		},
		"name" : "username_1",
		"ns" : "pjjlt.user"
	}
]
  1. 删除索引
> db.user.dropIndex("username_1") #名字可以在查看索引的时候找到
{ "nIndexesWas" : 2, "ok" : 1 }

引擎

主要有两种：MMAPV1和WiredTiger.在2.6版本之前只有MMAPV1，在3.0之后有了WiredTiger，但是默认还是MMAPV1。本篇使用的是4版本，已经默认是WiredTiger引擎了。相对于说MMAPV1，WiredTiger使用磁盘空间小得多，只需要将近7、8分之一的空间。记得从旧版本的mongo升级，导数据，原来20G的数据最后只有个位数（具体几G忘了），吓一跳，还担心会丢数据，原来是引擎变了。同时锁的颗粒度从数据库到文档级别，并发性能提升不少。总之，新的引擎占资源小，性能还高。

图片来自《MongoDB实战》

复制和分片

复制：复制是跨多个Mongo服务器（节点）分布和维护数据的方法。MongoDB可以把数据从一个节点复制到其他节点并在修改时进行同步。这种类型的复制是通过一个叫可复制集的机制提供。集群中的节点配置为自动同步数据，并且在服务器出错十自动容灾。MongDB还有一种旧的复制方法：主从复制。一般复制数据的时候，数据同步到了大部分（大于50%，比如说三台机器中的两台）节点就可以认为复制操作完成。可复制集应该保护至少3个成员，其中一个可以当裁判。

分片：分片是把大型数据集进行分区成更小的可管理的片的过程。简单来说就是一台MongoDB服务器盛不下或处理不了那么多数据（1，2，3，4，5，6）了，就将这些数据分到三台小点的机子上，分别维护（1，4）（2，5）（3，6）

参考

《MongoDB实战》

菜鸟教程 https://www.runoob.com/mongodb/mongodb-tutorial.html

啤酒就辣条
关注
mongo学习笔记.doc
09-20
MongoDB基本知识整理。 Mongodb导出与导入命令、创建分片、创建复制集等。
mongo学习笔记总结
11-16
很好的学习mongo的资源，从好几本书中精挑细选的知识点，适合新手和老手
两个表修改 update
a...Z
09-09 977
update telemarketing_upload_links ,telemarketing_links set telemarketing_upload_links.account = telemarketing_links.account where telemarketing_upload_links.mp = telemarketing_links.mp and telemarketing_upload_links.created_at > ‘2010-01-29 10:30:50’
oracle mongo差异,mongodb 如何实现２个collection差异对比的功能
weixin_34246474的博客
04-04 296
目前MongoDB 还没有提供有效的operator 支持该需求，不过可以通过代码(js、python)来达成。In [12]: def flattern(d):...: def _flattern(src, dst, prefix=''):...: for k, v in src.items():...: key = k if prefix == ...
excel函数公式大全_excel函数公式大全利用if函数and函数sumif函数实现多重条件汇总...
weixin_39952800的博客
11-30 395
excel函数公式大全利用if函数and函数sumif函数实现多重条件汇总，excel函数与公式在工作中使用非常的频繁，会不会使用公式直接决定了我们的工作效率，今天我们来学习一下提高我们工作效率的函数if函数、and函数、sumif函数，利用这三种函数的组合实现对多重条件数值的汇总求和。首先我们来认识一下and函数，只有当所有的条件都满足时，才会返回true，具体如下图：接着我们来认识一下，if函...
两个表比对使用update_详解两个表之间 INNER JOIN, LEFT JOIN, RIGHT JOIN 的使用效果
weixin_39580748的博客
11-28 419
1 概述本文以图文的形式详解 INNER JOIN, LEFT JOIN, RIGHT JOIN 在两个表之间有数据关联和没有数据关联情况下的使用以及返回结果。准备两个有外键关联的表在两个表之间有数据关联情况下 INNER JOIN, LEFT JOIN, RIGHT JOIN 的使用以及返回结果在两个表之间没有数据关联情况下 INNER JOIN, LEFT JOIN, RIGHT JOIN 的...
mongo学习和操作手册
06-07
在本"mongo学习和操作手册"中，我们将深入探讨MongoDB的基本概念、安装、操作、查询以及高级特性。 一、MongoDB基本概念 MongoDB的核心概念包括数据库、集合、文档和键值对。数据库是存储数据的地方，类似关系型...
MongoDB系列教程（五）：mongo语法和mysql语法对比学习
12-16
- MySQL 采用的是表格形式的数据模型，由数据库、表和记录组成，具有固定的列名和数据类型。 - MongoDB 则是基于文档的数据库，由数据库、集合（类似表）和文档（JSON 格式）构成，文档结构灵活，允许动态模式。 ...
Mybatis 一二级缓存实现原理与使用指南
JAVA葵花宝典
07-17 208
Mybatis 与 Hibernate 一样，支持一二级缓存。一级缓存指的是 Session 级别的缓存，即在一个会话中多次执行同一条 SQL 语句并且参数相同，则后面的查询将不会发送到...
两个表比对使用update_SQL中的Update，我帮你整理好了
weixin_39778668的博客
12-05 1026
把你知道的Update语句写下来，大多数人只能写一个至两个。而实际在编写程序的时候，通过BAIDU也能写出来，本文分表分字段总结了常用的Update语句，代码亲测可用，大家放心COPY使用。建表Stud_A，字段为：A_ID，A_NAME，A_SEX表Stud_A单表单字段update Stud_A set A_NAME = 'mike' where A_ID = '1';单表多字段update ...
Oracle数据库比对更新数据
崔钰玺的博客
10-26 1608
SQL UPDATE语句 UPDATE table1 t1 SET (name, desc) = (SELECT t2.name, t2.desc FROM table2 t2 WHERE t1.id = t2.id) WHERE EXISTS ( SELECT 1 FR
python实现对mongodb数据库进行多表联合查询 lookup
yuer_xiao的博客
08-30 6149
最近项目中需要用到对mongodb数据库进行联合查询，百度了一下都只有mongodb语句的联合查询方法，没有通过python来进行查询的。 可能是因为mongodb数据库不是关系型数据库，大家对于它的关系也用不到那么多。 表字段定义 mycol_case_collection = mydb["case_collection"] #表A mycol_ta...
SQL 两表关联更新UPDATE (用一个表更新另一个表)
最新发布
zmt0104的博客
12-21 1万+
SQL两表关联更新UPDATE（用一个表更新另一个表）
mongodb的使用（二）--数据的导入和导出
CLM00_v的博客
11-18 2960
数据的导入和导出 CSV文件的特点是体积较小，但是阅读性比较差。JSON文件的特点是体积比CSV大但是阅读性会比较好。 1.导出集合数据 mongoexport命令可以把一个集合数据导出成JSON或者CSV格式的文件。 mongoexport --host=localhost --port=27017 -u admin -p abc123456 --authenticationDatabase=admin -d school -c student -f "_id,name,sex,age" -o D
Mongodb的update操作总结
ruanhongbiao的专栏
07-08 1529
注：在这篇文章讲的语法介绍都是在mongodb shell环境内的，和真正运用语言编程（如java,php等）使用时，在使用方法上会有一些差别，但语法(如查询条件，$in,$inc等)是一样的。 本文是参考官方文档来介绍的，之所以有官方文档还要在这介绍，一方面是就当翻译，毕竟每次要用时去看英文文档比较累，第二是官方文档讲解比较简单，有时光看官方文档不好理解，我在实际操作的情况下可以做些补充。 好了...
MongoDB之具体使用（二）
Quincy.Coder的博客
01-22 341
MongoDB之具体使用（一）： http://blog.csdn.net/qq_33733970/article/details/79109066 接上回，我们继续： 改： 语法： db.collection.update( ,#查询条件 ,#要更新的内容 { upsert: boolean>,#可选，默认false,设置为true无则添加，
MySql 和 PostgreSQL 根据一张表update另一张表数据
echo666的博客
12-06 828
pgsql关联更新字段
update操作：两表更新（用一个表更新另一个表）的SQL语句
m0_37635053的博客
04-14 1万+
记2020/04/14数据库操作遇到的问题及解决办法。 1.插入数据库，恰遇字段为数据库的关键字怎么办？ mysql的做法是：用``把字段包起来，但是在pgsql需要用""包起来。 2.把一个表查出的数据直接插入另一个表： 保证字段对应即可。 3.两表联查，把一张表的某字段更新到另一张表 不积跬步无以至千里，不积小流无以成江河 ...
MongoDB学习手册：从入门到精通
文档摘要信息:"MongoDB学习手册, 作者李三来, 主要内容包括MongoDB的介绍、特性、工作方式、安装、数据类型、GridFS、索引、主从同步、分片集群、数据库操作、Shell控制台、安全认证及DBA操作和图形化管理工具等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值