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密码

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

#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所有聚集索引的状态

#插入、查询、删除
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 --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/

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

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

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

mongorestore --host <hostname> --port <port> --db <database> <path_to_backup>
mongorestore -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 --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的根目录 】

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

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      #根据条件敢出数据

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

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

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.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数据库中

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})

新增：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 字段来建立关系