还记得MySQL、Redis、PostgreSQL、ClickHouse常用命令及操作吗？如果忘记可以到这里重新温习： MySQL常用命令，Redis常用命令，PostgreSQL常用命令，ClickHouse常用命令，启动、关闭、连接、备份、导入导出。本文重点讲述MongoDB常用命令。

一、MongoDB简介

MongoDB是一款流行的NoSQL数据库，以其灵活的文档模型、高可用性、易于扩展等特性而受到广泛关注。

• MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统；在高负载的情况下，添加更多的节点，可以保证服务器性能；MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案；MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成；MongoDB 文档类似于 JSON 对象。
• 特点：高性能、高可用、高扩展、丰富的查询支持、动态模式和灵活的文档模型
• 应用场景：网站实时数据处理；缓存；高伸缩性的场景

MongoDB中的记录是一个文档，它是由字段和值对组成的数据结构。多个键及其关联的值有序地放在一起就构成了文档。MongoDB文档类似于JSON对象。字段的值可以包括其他文档，数组和文档数组。{“greeting”:“hello,world”, “foo”: 3}

在MongoDB中基本的概念是文档、集合、数据库。

SQL术语/概念	MongoDB术语/概念	解释/说明
database	database	数据库
table	collection	数据库表/集合
row	document(集合中的数据)	数据记录行/文档
column	field	数据字段/域
index	index	索引
table joins		表连接，MongoDB不支持
primary key	primary key	主键，MongoDB自动将_id字段设置为主键

数据库服务和对应的客户端

数据库服务	客户端
Mysqld/Oracle	mysql/sqlplus
mongodb	mongo

在MongoDB中，常用命令包括数据库操作、集合操作、文档操作等几个方面。以下是MongoDB的一些常用命令及其说明

二、服务启动停止、连接

#windows cmd   或   Linux 终端
mongo --version

#启动
#Windows启动与停止    命令行指令、任务管理器手动启动停止
#以管理员方式运行cmd，输入以下命令
net start mongodb
net stop mongodb    #停止mongodb服务
netstat -aon | findstr 27017

#Linux启动与停止
/xxx/mongodb-server/bin/mongod -f /xxx/mongodb-server/conf/mongodb.conf     #启动
ps -ef | grep mongodb-server
netstat -tunlp | grep 27017
ps -aef | grep mongodb-server | grep -v grep | awk '{print $2}' | xargs -t kill -9           #停止


#连接mongodb
#配置了环境变量的前提下 在任意目录可通过mongo进入数据库；否则需要在mongodb安装目录下操作
mongo        #无密码
mongo 10.169.215.xx:27017/admin  -uroot  -p1234    #有密码
mongo localhost:27017/admin -uroot -p密码     
mongo admin -uroot -p密码

已开启认证的，除了mongo 10.169.215.xx:27017/admin -uroot -p1234连接；还可以通过 mongo进入命令行，使用use admin通过db.auth(‘root’,‘密码’) 输出1就是验证成功。

windows下启动、停止、查看mongodb

linux下启动、停止、查看mongodb

三、数据库相关

1. 连接数据库
   • 使用MongoDB Shell连接：mongo [host]:[port]/[dbname]，其中[host]是数据库服务器地址，[port]是端口号（默认为27017），[dbname]是数据库名。如果连接本地数据库，可以简化为mongo或mongo localhost；有密码则需要加上对应的参数 -u、-p
   • 使用完整连接字符串：mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]。
2. 查询所有数据库
   • 命令：show dbs 或 show databases
3. 创建/切换数据库
   • 命令：use database_name。如果数据库不存在，则创建并切换到该数据库；如果数据库已存在，则直接切换到该数据库。
4. 删除数据库
   • 先切换到要删除的数据库，然后执行命令：db.dropDatabase()。
5. 查看当前使用的数据库
   • 命令：db 或 db.getName()
6. 显示数据库中的用户： show users

#mongodb命令行
show dbs                 #查询所有数据库
use database_name        #创建/切换数据库
db.dropDatabase()        #删除数据库
db 或 db.getName()       #查看当前使用的数据库
show users               #显示数据库中的用户

四、集合操作

1. 创建集合
   • 命令：db.createCollection(name, options)。其中name是集合名称，options是可选参数，用于指定集合的特性，如固定集合（capped collection）的大小和最大文档数。
   • 集合的隐式创建：当向一个集合中插入一个文档的时候，如果集合不存在，则会自动创建集合。 提示：通常我们使用隐式创建文档即可
2. 查看所有集合
   • 命令：show collections 或 show tables
3. 删除集合
   • 命令：db.collection_name.drop()。成功删除集合将返回true，否则返回false
4. 查询当前集合的数据条数：db.yourCollec.count()

#mongodb命令行
use wjTemp                    #如果wjTemp数据库不存在，则创建并切换到该数据库；如果数据库已存在，则直接切换到该数据库
db.createCollection("myCollec")    #创建myCollec集合
db.createCollection("myCollec2")
db.createCollection(“collName”, {size: 20, capped: 5, max: 100});
show tables                        #查看所有集合
db.myCollec2.drop()                #删除myCollec2集合
show collections

db.getCollection("account")        #得到指定名称的聚集集合（table）
db.getCollectionNames()            #得到当前db的所有聚集集合
db.printCollectionStats()          #显示当前db所有聚集索引的状态

五、文档操作

1. 插入文档：使用 insert 或 save 方法插入文档（‌在较新的 MongoDB 版本中，‌save 方法已被弃用，‌推荐使用 insertOne 或 insertMany）‌
   • 单条插入：db.collection_name.insert(document) 或 db.collection.insertOne(document)
   • 多条插入：db.collection_name.insert([document1, document2, ...]) 或 db.collection.insertMany([document1, document2, ...])
2. 查询文档
   • 查询所有文档：db.collection_name.find()。相当于 select * from collection_name
   • 查询满足条件的文档：db.collection_name.find(query)，其中query是查询条件。
   • 格式化显示查询结果：db.collection_name.find().pretty()
   • 查询并返回第一个匹配的文档：db.collection_name.findOne(query)
3. 更新文档：update、updateOne、updateMany
   • 使用update方法：db.collection.update(<query>, <update>, {upsert: <boolean>, multi: <boolean>})。其中query是查询条件，类似sql update查询内where后面的；update是更新内容，也可以理解为sql update查询内set后面的；upsert 可选，表示如果不存在满足条件的文档，是否插入新文档（默认为false）；multi 可选，表示是否更新所有满足条件的文档（默认为false，只更新第一个）。
   • 使用$set操作符更新字段：db.collection.update(query, {$set: {field: value}})
4. 删除文档：remove、deleteOne、deleteMany
   • 删除满足条件的文档：db.collection.remove(query, {justOne: <boolean>})。其中query是删除条件，justOne表示是否只删除第一个匹配的文档（默认为false，删除所有匹配的文档）。
   • 使用deleteOne或deleteMany方法（MongoDB 3.2+）：db.collection.deleteOne(query) 或 db.collection.deleteMany(query)

#插入、查询、删除
db.myCollec.insert({title: 'MongoDB', 
    description: 'MongoDB NOSQL',
    by: 'test',
    url: 'https:',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
db.myCollec.find()
db.myCollec.update({'title':'MongoDB'},{$set:{'title':'MongoDB-test'}})
db.myCollec.remove({'title':'MongoDB-test'})



#查询
db.userInfo.find()                    #查询所有记录
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)   #分页列表查询。使用limit()方法来读取指定数量的数据，使用skip()方法来跳过指定数量的数据
db.userInfo.distinct("name")          #查询去掉后的当前聚集集合中的某列的重复数据。会过滤掉name中的相同数据，相当于：select distict name from userInfo
db.userInfo.find({"age": 23})         #查询age = 23的记录，相当于 select * from userInfo where age = 23
db.userInfo.find({age: {$gt: 23}})    #查询age > 23的记录
db.userInfo.find({age: {$gte: 25}})   #查询age >= 25的记录
db.userInfo.find({name: /mongo/})     #查询name中包含 mongo的数据，//相当于%%，相当于 select * from userInfo where name like ‘%mongo%’
db.userInfo.find({name: /^mongo/})    #查询name中以mongo开头的，select * from userInfo where name like ‘mongo%’
db.userInfo.find({}, {name: 1, age: 1})   #查询指定列name、age数据，相当于：select name, age from userInfo
db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1})   #查询指定列name、age数据, age > 25。相当于：select name, age from userInfo where age >25
#按照年龄排序
db.userInfo.find().sort({age: 1})    #升序
db.userInfo.find().sort({age: -1})   #降序
db.userInfo.find({name: 'zhangsan', age: 22})   #查询name = zhangsan, age = 22的数据。相当于：select * from userInfo where name = ‘zhangsan’ and age = ‘22’;
db.userInfo.find().limit(5)    #查询前5条数据。相当于：selecttop 5 * from userInfo;
db.userInfo.find().skip(10)    #查询10条以后的数据。相当于：select * from userInfo where id not in (selecttop 10 * from userInfo)
db.userInfo.find().limit(10).skip(5)  #查询在5-10之间的数据。可用于分页，limit是pageSize，skip是第几页*pageSize
db.userInfo.find({sex: {$exists: true}}).count()   #按照某列进行排序。相当于：select count(sex) from userInfo

六、数据备份与恢复/导入导出数据

• 定时备份/全量备份

  • 备份 mongodump，还原 mongorestore

  • 备份格式： bson/gzip

• 分析数据/迁移数据

  • 备份 mongoexport，还原 mongoimport

  • 备份格式：json csv

常见备份恢复方法

1）备份全库、单个库：

mongodump --host mongodb1.example.net --port 27017 -u用户名 -p密码 --db mydbname --out /path/to/backup/
mongorestore --host mongodb2.example.net --port 27017 -u用户名 -p密码 --db mydbname /path/to/backup/mydbname/


mongodump -h ip:端口 -uroot -p密码 -d 数据库 -o 路径             #备份数据库
mongodump -uroot -p密码 -d 数据库 -c 集合名 -o 路径    #备份数据库某个集合
mongorestore -h 127.0.0.1:27017 -u用户名 -p密码 -d 数据库 --dir /路径/数据库名/

#加密后备份
mongodump -h ip:port -uroot -p密码 -d 数据库 --authenticationDatabase admin -o 路径         
mongodump -uroot -p密码 -d 数据库 -c 集合名 --authenticationDatabase admin -o 路径   

mongorestore -uroot -p密码 -d wjTemp2 --authenticationDatabase admin --dir /root/mon_wjTemp/wjTemp/

2）备份某个库的某张表：

mongoexport备份

mongoexport备份某个表语法格式：mongoexport --port 端口号 -d 库名 -c 表名 -o 备份文件路径.json

mongoexport备份某个表csv格式：mongoexport --port 端口号 -d 库名 -c 表名 --type=csv -f 备份的字段 -o 备份文件路径.csv

mongoimport还原

mongoimport还原某个表json格式：mongoimport --port 26017 -d 要还原的库名-c 表名 备份文件路径.json

mongoimport还原某个表csv格式： mongoimport --port 26017 -d 库名 -c 表名–type=csv --headerline 备份文件路径.csv

（mongoimport还原csv格式表时要加上–headerline参数，否则会将字段名也作为一条数据插入；–headerline和-f不能同时使用）

mongodump备份

mongodump备份库：mongodump --port 26017 -d 库名 -o 备份文件路径

mongorestore还原

mongorestore还原：mongorestore --port 26017 -d 库名 备份文件路径 --drop

6.1 mongodump备份数据库

常用命令格式如下：

mongodump -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -o 文件存在路径
mongodump -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 集合名 -o 文件存在路径

• 如果没有用户，可以去掉-u和-p。
• 如果导出本机的数据库，可以去掉-h。
• 如果是默认端口，可以去掉–port。
• 如果想导出所有数据库，可以去掉-d

mongodump -h 127.0.0.1 -u用户名 -p密码 -o /home/dev/mongodb/      #备份所有数据库
mongodump -h ip --port 端口 -u用户名 -p密码 -d tank -o /home/dev/mongodb/   #备份指定数据库

mongodump -uroot -p密码 -d wjTemp -o /root/mon_wjTemp
mongodump -uroot -p密码 -d wjTemp --authenticationDatabase admin -o /root/mon_wjTemp

如果报错 Failed: error connecting to db server: server returned error on SASL authentication step: Authentication failed.，可以添加--authenticationDatabase admin。

示例：

mongodump -h 192.168.31.251:27017 -d my_db -u test_user -p test_user -o c:\mongoBackup
mongodump -h 192.168.31.251 -port:27017 -d my_db -u test_user -p test_user -o c:\mongoBackup

mongodump -uroot -p密码 -d wjTemp --authenticationDatabase admin -o /root/mon_wjTemp

6.2 mongorestore还原数据库

mongorestore --host <hostname> --port <port> --db <database> <path_to_backup>
mongorestore -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 --drop 文件存在路径

–drop的意思是，先删除所有的记录，然后恢复。

mongorestore -h ip:port -u 用户名 -p 密码 /home/dev/mongodb/  #恢复所有数据库到mongodb中。这里的路径是所有库的备份路径
mongorestore -d tank /home/dev/mongodb/tank/  #还原指定的数据库

# 使用新建用户恢复demodb数据库
mongorestore -u 用户名 -p 密码 -d db_name c:\mongoBackup\my_db --authenticationDatabase admin -u admin -p password

# 或使用admin用户恢复数据到 yuandb 数据库中
mongorestore -u admin -p admin123 -d yuandb c:\mongoBackup\my_db --authenticationDatabase admin -u admin -p admin123
#【注意：备份的数据库文件路径(c:\mongoBackup\my_db)一定要指定到xxx.bson的根目录 】

恢复前先要使用use 命令切换到要导入的数据库
在切换后的数据库下新建用户，并设置角色及所属数据库
使用新建用户或admin用户导入
使用新建的用户连接数据库
【注意：先用admin用户导入，然后再创建普通用户并设置角色及指定所属数据库，最终新建用户是无法连接数据库的】

通过以上步骤虽然能导入数据库，但是在连接时会提示授权错误，暂时就用admin一个用户就行

6.3 mongoexport导出表 或 表中部分字段

常用命令格式

mongoexport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 -f 字段 -q 条件导出 --csv -o 文件名

上面的参数好理解，重点说一下：

• -f 导出指定字段，以字号分割，-f name,email,age 导出name,email,age这三个字段
• -q 可以根查询条件导出，-q ‘{ “uid” : “100” }’ 导出uid为100的数据
• –csv 表示导出的文件格式为csv的，这个比较有用，因为大部分的关系型数据库都是支持csv，在这里有共同点

mongoexport -d tank -c users -o /home/dev/mongodb/tank/users.dat     #导出整张表
mongoexport -d tank -c users --csv -f uid,name,sex -o tank/users.csv       #导出表中部分字段
mongoexport -d tank -c users -q '{uid:{$gt:1}}' -o tank/users.json      #根据条件敢出数据

6.4 mongoimport导入表 或 表中部分字段

常用命令格式：

1）还原整表导出的非csv文件

mongoimport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 --upsert --drop 文件名 

重点说一下–upsert，其他参数上面的命令已有提到，–upsert 插入或者更新现有数据

2）还原部分字段的导出文件

mongoimport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 --upsertFields 字段 --drop 文件名

–upsertFields根–upsert一样

3）还原导出的csv文件

mongoimport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 --type 类型 --headerline --upsert --drop 文件名

上面三种情况，还可以有其他排列组合的。

示例：

mongoimport -d tank -c users --upsert tank/users.dat       #还原导出的表数据
mongoimport -d tank -c users  --upsertFields uid,name,sex  tank/users.dat    #部分字段的表数据导入 
mongoimport -d tank -c users --type csv --headerline --file tank/users.csv    #还原csv文件

七、其他常用命令

• 查看帮助：db.help() 或 db.yourCollec.help()或db.yourCollec.find().help()
• 显示当前db状态：db.stats()； 当前db版本：db.version()； 查看当前db的链接机器地址：db.getMongo()
• 查看集合状态：db.collection.stats()
• 修复数据库：db.repairDatabase()
• 复制/克隆数据库：db.cloneDatabase("hostname") 或 db.copyDatabase("fromdb", "todb", "hostname")。
• 查询之前的错误信息：db.getPrevError()； 清除错误记录： db.resetError()
• 用户操作

#添加一个用户
db.addUser("name");
db.addUser("userName", "pwd123", true); 添加用户、设置密码、是否只读

#数据库认证、安全模式
db.auth("userName", "123123")
show users                      #显示当前所有用户
db.removeUser("userName")       #删除用户


#添加用户、安全认证
#首先必须使用admin数据库，进行新用户授权；授权成功后，关闭mongo服务
use admin
db.createUser({user:"root",pwd:"123456",roles:[{role:"root",db:"admin"}]})
db.shutdownServer()
#验证：使用use admin通过db.auth(‘root’,‘密码’) 输出1就是验证成功
use admin
db.auth('root','123456')

db.cloneDatabase(“127.0.0.1”); 将指定机器上的数据库的数据克隆到当前数据库
db.copyDatabase("mydb", "temp", "127.0.0.1");将本机的mydb的数据复制到temp数据库中

八、补充

Navicat操作MongoDB，增删改查的完整代码

use DATABASE_NAME     #如果数据库不存在，则创建数据库，否则切换到指定数据库
show dbs              #查看所有数据库
db.dropDatabase()     #删除当前数据库(默认为test，可通过use db_name切换)


#创建集合
db.createCollection(name[, options])
db.createCollection("runoob")      
db.createCollection("mycol", {capped:true, autoIndexId:true, size:6142800, max:10000})       #创建固定集合 mycol，整个集合空间大小 6142800B, 文档最大个数为 10000个
show collections     show tables     #查看已有集合
#在 MongoDB 中，你不需要创建集合。当你插入一些文档时，MongoDB会自动创建集合
db.mycol2.insert({"name" : "菜鸟教程"})
db.collection.drop()           #删除集合。(use db1,show tb1)


#插入文档
db.COLLECTION_NAME.insert(document)   或 db.COLLECTION_NAME.save(document)
    save()：如果_id主键存在则更新数据，如果不存在就插入数据(类似于insert方法)。该方法新版本中(3.2版本之后)已废弃，可以使用db.collection. insertOne()或db.collection.replaceOne()来代替。
	insert(): 若插入的数据主键已经存在，则会抛 org.springframework. dao.DuplicateKeyException 异常，提示主键重复，不保存当前数据。
	
#db.collection.insertOne() 用于向集合插入一个新文档
db.collection.insertOne(
   <document>,
   {
      writeConcern: <document>
   }
)
#db.collection.insertMany() 用于向集合插入一个多个文档
db.collection.insertMany(
   [ <document 1> , <document 2>, ... ],
   {
      writeConcern: <document>,
      ordered: <boolean>
   }
)
#document：要写入的文档；writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求；ordered：指定是否按顺序写入，默认 true，按顺序写入。

db.col.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})    或
document=({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
});
db.col.insert(document)


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

db.col.update({'title':'MongoDB教程'},{$set:{'title':'MongoDB'}})
   #以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true
db.col.update({'title':'MongoDB教程'},{$set:{'title':'MongoDB'}},{multi:true})

#save()方法通过传入的文档来替换已有文档，_id 主键存在就更新，不存在就插入
db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)          
#两个参数同update对应参数


#删除文档
db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)
query :（可选）删除的文档的条件；justOne : （可选）如果设为true或1，则只删除一个文档，如果不设置该参数，或使用默认值false，则删除所有匹配条件的文档；writeConcern :（可选）抛出异常的级别。
db.users.remove({status:"D"},true)
#删除满足年龄小于20的所有文档
db.users.remove(        
	{ age: { $lt: 20 } },
    { writeConcern: { w: "majority", wtimeout: 5000 } }
)
#删除满足匹配条件的最多一个文档。filter为查询的过滤条件
db.collection.deleteOne(
	<filter>,                   
   	{
    	writeConcern: <document>   #用于控制写入何时应答及超时
    }
)
#删除满足匹配条件的所有文档，语法、参数同deleteOne
db.collection.deleteMany(
	<filter>,                
   	{
    	writeConcern: <document> 
    }
)
#删除所有数据
db.col.remove({})
#MongoDB remove()函数是用来移除集合中的数据。在执行remove()函数前先执行 find()命令来判断执行的条件是否正确，这是一个比较好的习惯。



#查询文档    and,or
db.collection.find(query, projection)
#projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。
#如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，pretty() 方法以格式化的方式来显示所有文档，格式如下：
db.col.find().pretty()    #以易读的方式来读取数据
#findOne() 方法，只返回一个文档
#MongoDB的find()方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规SQL 的AND条件。WHERE key1=value1 AND key2=value2
db.col.find({key1:value1, key2:value2}).pretty()
db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()
db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()            # 类似常规SQL语句为  'where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')'
db.member.find({_id :{$gt: 2}, age:18});
db.member.find({_id :{$gt: 2}}).sort({_id:-1});
#返回指定字段,注：_id默认是显示的,只有_id不显示是设置0,其他字段都不可以设置0
find({查询条件，可以空},{显示的字段:1})

MongoDB 与 RDBMS Where 语句比较

操作	格式	范例	RDBMS中的类似语句
等于	{<key>:<value>}	db.col.find({"by":"菜鸟教程"}).pretty()	where by = '菜鸟教程'
小于	{<key>:{$lt:<value>}}	db.col.find({"likes":{$lt:50}}).pretty()	where likes < 50
小于或等于	{<key>:{$lte:<value>}}	db.col.find({"likes":{$lte:50}}).pretty()	where likes <= 50
大于	{<key>:{$gt:<value>}}	db.col.find({"likes":{$gt:50}}).pretty()	where likes > 50
大于或等于	{<key>:{$gte:<value>}}	db.col.find({"likes":{$gte:50}}).pretty()	where likes >= 50
不等于	{<key>:{$ne:<value>}}	db.col.find({"likes":{$ne:50}}).pretty()	where likes != 50

mongo查询操符:$eq,$ne,$in,$nin,$gt,$get,$lt,$lte,$and,$or,$not,$nor,$all, $eleMatch,$size,$slice,$exists

mongo操作符	描述	对比mysql
$e	等值比较，find({_id :{ $eq: 1}}) 等价于 find({id : 1})	id=1
$ne	不等于指定值,find({_id:{$ne:1}})	id!=1或id<>1
$in	数组中包含 ，find( { _id :{ $in: [ 1,2 ] } } )	id in (1,2)
$nin	数组中不包含，find( { _id :{ $nin: [ 1,2 ] } } )	id not in (1,2)
$gt,$get,$lt,$lte
$and	与（并且）查询，find({$and:[ { _id:{ $gt:1} },{ _id:{ $lt:4} } ]})	id>1 and id<4
$or	或查询，find({$or:[ { _id:1 },{ _id: 3} ]})	id=1 or id=3
$not	非查询，非小于3的数据 find({_id :{$not :{ $lt: 3 } } })	id>=3
$nor	即非查询，find( { $nor: [ { _id: 1 }, { _id: 2 }, { _id: 3 }] } )	(id!=1 and id!=2 and id!=3)
$all	同时包含，查询tag同时包含3和9的数据，tag是一个数组，find({tag:{$all:[3,9]}})，可查看下面示例	无
$elemMatch	有一个元素匹配即可，find({job:{$elemMatch:{city:‘beijing’,company:‘xiaomi’}}})，可查看下面示例	无
$size	匹配数组大小，find({tag:{$size:3}})，可查看下面示例	无
$slice	返回数组中第几个元素，find({job:{KaTeX parse error: Expected ‘EOF’, got ‘}’ at position 43: …ompany:‘baidu’}}̲},{name:1,job:{slice:1}})，可查看下面示例	无
$exists	匹配是否包含查询字段的文档，find({name:{$exists:true}})	无

新增：db.集合名称.insert/save/insertOne(文档)
修改：db.集合名称.update(条件,{操作种类:{文档}})
删除：db.集合名称.remove(条件)
#查询所有数据2种写法
db.book.find()
db.getCollection("book").find() 
db.book.find({type:"工具书"})      #条件查询

db.book.remove({type:"工具书"})    #条件删除
db.book.remove({})                #删除所有

#新增数据2种方式   
db.book.save({"name":"springboot"});
db.book.insert({"name":"mango good"});
db.book.save({"name":"springboot",type:"工具书"});
 
#修改"name":"springboot"的数据为"name","springboot2"
# update:遇到满足条件的第一条数据修改；updateOne:修改满足条件的第一条数据；updateMany:修改所有满足条件的
db.book.update({"name":"springboot"},{$set:{"name":"springboot2"}})
db.book.updateOne({"name":"springboot2"},{$set:{"name":"springboot3"}})
db.book.updateMany({"name":"springboot"},{$set:{"name":"springboot2"}})

$type 操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果(Double 1;String 2;Object 3)
db.col.find({"title" : {$type : 2}})     或
db.col.find({"title" : {$type : 'string'}})

limit(number) 在MongoDB中读取指定数量的数据记录
db.COLLECTION_NAME.find().limit(NUMBER)
skip(number) 跳过指定数量的数据，默认参数为0
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
db.col.find({},{"title":1,_id:0}).limit(1).skip(1) //显示第二条数据


使用sort()方法对数据进行排序，sort()方法可以通过参数指定排序的字段，并使用1和 -1来指定排序的方式，其中1为升序排列，而-1是用于降序排列.
db.COLLECTION_NAME.find().sort({KEY:1})
skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先sort(), 然后是skip()，最后是显示的limit()

扫描全集合的查询效率是非常低，索引通常能够极大的提高查询的效率。索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。
db.collection.createIndex(keys, options)      //创建索引，Key值为你要创建的索引字段，1为指定按升序创建索引，如果你想按降序来创建索引指定为-1即可
db.col.createIndex({"title":1,"description":-1})  //多字段创建索引
db.col.getIndexes()    //查看集合索引
db.col.totalIndexSize()   //查看集合索引大小
db.col.dropIndexes()      //删除集合所有索引
db.col.dropIndex("索引名称")    //删除集合指定索引

聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果。有点类似 SQL 语句中的 count(*)。$sum,$avg,$min/max,$push,$addToSet,$first/last
db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])        类似于sql语句
select by_user, count(*) from mycol group by by_user
 
MongoDB复制是将数据同步在多个服务器的过程.
MongoDB备份(mongodump，可以导出所有数据到指定目录中)与恢复(mongorestore,恢复备份的数据)
mongodump -h dbhost -d dbname -o dbdirectory
-o:备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据
mongorestore -h <hostname><:port> -d dbname <path>
<path>：mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。你不能同时指定 <path> 和 --dir 选项，--dir也可以设置备份目录。

mongostat和mongotop 两个命令来监控MongoDB的运行情况。
mongostat是mongodb自带的状态检测工具，在命令行下使用(安装目录下的bin目录 输入mongostat)。它会间隔固定时间获取mongodb的当前运行状态，并输出。
mongotop也是mongodb下的一个内置工具，mongotop提供了一个方法，用来跟踪一个MongoDB的实例，查看哪些大量的时间花费在读取和写入数据。 mongotop提供每个集合的水平的统计数据。默认情况下，mongotop返回值的每一秒。(用法同mongostat)
mongotop number  //<sleeptime>参数，可不使用，等待的时间长度，以秒为单位

MongoDB关系： 1:1,1:N,N:1,N:N
嵌入式方法/关系
引用式方法/关系：把用户数据文档和用户地址数据文档分开，通过引用文档的 id 字段来建立关系

参考 MongoDB常用命令详细讲解（最全）、Mongo基本命令