Mongo工具

1. 查看指令

test:登录时默认存在的库
admin库:系统预留库,MongoDB系统管理库
local库:本地预留库,存储关键日志
config库:MongoDB配置信息库

查看数据库命令
show databases/show dbs
show tables/show collections
use admin
db/select database()

2.插入命令

1.插入单条
db.user_info.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.user_info.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.user_info.insert({"name":"yazhang","age":28,"ad":"北京市朝阳区"})
db.user_info.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区"})
db.user_info.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区","sex":"boy"})


2.插入多条
db.inventory.insertMany( [
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]);

3.查询命令

#输入db.user_info.之后table键可以查看支持的函数
> db.user_info.
db.user_info.addIdIfNeeded(
db.user_info.aggregate(
db.user_info.bulkWrite(
db.user_info.constructor
db.user_info.convertToCapped(
db.user_info.convertToSingleObject(
db.user_info.copyTo(
db.user_info.count(
db.user_info.createIndex(
db.user_info.createIndexes(
db.user_info.dataSize(
db.user_info.deleteMany(
db.user_info.deleteOne(
db.user_info.diskStorageStats(
db.user_info.distinct(
db.user_info.drop(
db.user_info.dropIndex(
db.user_info.dropIndexes(
db.user_info.ensureIndex(
db.user_info.exists(
db.user_info.explain(
db.user_info.find(
db.user_info.findAndModify(
db.user_info.findOne(
db.user_info.findOneAndDelete(
db.user_info.findOneAndReplace(
db.user_info.findOneAndUpdate(
db.user_info.getCollection(
db.user_info.getDB(
db.user_info.getDiskStorageStats(
db.user_info.getFullName(

查询命令总结：

1.查询一条
db.user_info.findOne()

2.查询所有
db.user_info.find()

3.查询符合条件
db.user_info.find({"age":28})
#相当于mysql中的命令
select * from user_info where age = 28;

4.查询嵌套的条件
db.inventory.find( { "size.uom": "in" } )
#json格式如下：
db.inventory.find( 
    { 
        "size.uom": "in" 
    } 
)

5.逻辑查询：and
db.inventory.find( { "size.uom": "cm" ,"status" : "A"} )
#json格式如下：
db.inventory.find( 
    { 
        "size.uom": "cm" ,
        "status" : "A"
    } 
)

6.逻辑查询 或
db.inventory.find(
    {
        $or:[
                {status:"D"},
                {qty:{$lt:30}}
            ]
    }
)

7.逻辑查询+或+and+正则表达式
db.inventory.find({status:"A",$or:[{qty:{$lt:30}},{item:/^p/}]})
#json格式如下：
db.inventory.find( 
    {
        status: "A",
        $or: [ 
                { qty: { $lt: 30 } }, 
                { item: /^p/ } 
             ]
    } 
)

4.更新数据

1.更改匹配条件的单条数据

如：
#查询
> db.inventory.find({ "item" : "paper" })
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8cf"), "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "D" }

#更新
> db.inventory.updateOne(
...     { "item" : "paper" },
...     {
...       $set: {  
... "size.uom" : "cm",  
... "status" : "P" 
... }
...     }
... )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

#再次查询
> db.inventory.find({ "item" : "paper" })
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8cf"), "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "cm" }, "status" : "P" }

---

2.更改匹配条件的多条数据

#查询qty并且值小于50的
> db.inventory.find({ "qty" : { $lt: 50 } })
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8cd"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "m" }, "status" : "A" }
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8d1"), "item" : "postcard", "qty" : 45, "size" : { "h" : 10, "w" : 15.25, "uom" : "m" }, "status" : "A" }

#修改uom 对应的值为mm，status对应的值为P
> db.inventory.updateMany(
...     { "qty" : { $lt: 50 } },
...     {
...        $set: 
... { 
... "size.uom" : "mm", 
... "status": "P" 
... }
...     }
... )
{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 0 }

#再次查询，可以看到改变
> db.inventory.find({ "qty" : { $lt: 50 } })
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8cd"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "mm" }, "status" : "P" }
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8d1"), "item" : "postcard", "qty" : 45, "size" : { "h" : 10, "w" : 15.25, "uom" : "mm" }, "status" : "P" }

3.添加字段

#查询
> db.user_info.find({ "age" : 27})
{ "_id" : ObjectId("5dfa035e90425c3c47b6b8ca"), "name" : "zhangya", "age" : 27, "ad" : "北京市朝阳区"}
#添加字段
> db.user_info.updateMany(
...     { "age" : 27},
...     {
...        $set: 
... { 
... "pet" : "cat"
... }
...     }
... )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 0 }
#再次查询
> db.user_info.find({ "age" : 27})
{ "_id" : ObjectId("5dfa035e90425c3c47b6b8ca"), "name" : "zhangya", "age" : 27, "ad" : "北京市朝阳区", "pet" : "cat" }

5.索引

1.查看执行计划
db.user_info.find({"age":{ $lt: 30 }})
#加上explain查询
db.user_info.find({"age":{ $lt: 30 }}).explain()

2.创建索引（给age创建索引，background:true 意思是放在后台执行这个集合）
> db.user_info.createIndex({ age: 1 },{background: true})
{
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "note" : "all indexes already exist",
    "ok" : 1
}


3.查看索引，会发现多了一个索引
> db.user_info.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test.user_info"
    },
    {
        "v" : 2,
        "key" : {
            "age" : 1
        },
        "name" : "age_1",
        "ns" : "test.user_info",
        "background" : true
    }
]


4.再次查看执行计划
>db.user_info.find({"age":{ $lt: 30 }}).explain()
...
#结果中有出现IXSCAN
    "inputStage" : {
                "stage" : "IXSCAN",
                "keyPattern" : {
                    "age" : 1
                },
                "indexName" : "age_1",
...
关键词
"stage" : "IXSCAN"
"indexName" : "age_1"

其他索引类型
COLLSCAN – Collection scan  （类似于mysql的全表扫描）
IXSCAN – Scan of data in index keys  （走索引）
FETCH – Retrieving documents
SHARD_MERGE – Merging results from shards
SORT – Explicit sort rather than using index orde

5.删除

1.先查找需要删除的数据
> db.inventory.find({"status":"P"})
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8cd"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "mm" }, "status" : "P" }
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8cf"), "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "cm" }, "status" : "P" }
{ "_id" : ObjectId("5dfa03a490425c3c47b6b8d1"), "item" : "postcard", "qty" : 45, "size" : { "h" : 10, "w" : 15.25, "uom" : "mm" }, "status" : "P" }


2.删除单条deleteOne
db.inventory.deleteOne({"status":"P"})

3.删除多个deleteMany
db.inventory.deleteMany({"status":"P"})

4.删除索引
db.user_info.dropIndex("age_1")

4.删除集合
#查看
> show tables
inventory
user_info
#删除集合
> db.inventory.drop()
true
#再次查看
> show tables
user_info

5.删除库
#查看库
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
#当前所在的库
> db
test
#删除当前所在的库
> db.dropDatabase()
{ "dropped" : "test", "ok" : 1 }
#再次查看
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB

6.mongo命令介绍

mongod          #启动命令
mongo           #登录命令         
mongodump       #备份导出，全备压缩
mongorestore    #备份恢复
mongoexport     #备份，数据可读json（适用于单个集合）
mongoimport     #备份恢复
mongostat       #查看mongo运行状态
mongotop        #查看mongo运行状态
mongos          #集群分片命令

.mongostat状态解释

[mongo@db01 ~]$ mongostat
insert query update delete getmore command dirty used flushes vsize   res qrw arw net_in net_out conn                time
    *0    *0     *0     *0       0     1|0  0.0% 0.0%       0  974M 46.0M 0|0 1|0   157b   60.6k    1 Dec 19 00:55:32.632
    *0    *0     *0     *0       0     1|0  0.0% 0.0%       0  974M 46.0M 0|0 1|0   157b   60.5k    1 Dec 19 00:55:33.633


#各字段解释说明：
insert/s : 官方解释是每秒插入数据库的对象数量，如果是slave，则数值前有*,则表示复制集操作
query/s : 每秒的查询操作次数
update/s : 每秒的更新操作次数
delete/s : 每秒的删除操作次数
getmore/s: 每秒查询cursor(游标)时的getmore操作数
command: 每秒执行的命令数，在主从系统中会显示两个值(例如 3|0),分表代表 本地|复制 命令
注： 一秒内执行的命令数比如批量插入，只认为是一条命令（所以意义应该不大）
dirty: 仅仅针对WiredTiger引擎，官网解释是脏数据字节的缓存百分比
used:仅仅针对WiredTiger引擎，官网解释是正在使用中的缓存百分比

flushes:
For WiredTiger引擎：指checkpoint的触发次数在一个轮询间隔期间
For MMAPv1 引擎：每秒执行fsync将数据写入硬盘的次数
注：一般都是0，间断性会是1， 通过计算两个1之间的间隔时间，可以大致了解多长时间flush一次。flush开销是很大的，如果频繁的flush，可能就要找找原因了
vsize： 虚拟内存使用量，单位MB （这是 在mongostat 最后一次调用的总数据）
res:  物理内存使用量，单位MB （这是 在mongostat 最后一次调用的总数据）
注：这个和你用top看到的一样, vsize一般不会有大的变动， res会慢慢的上升，如果res经常突然下降，去查查是否有别的程序狂吃内存。

qr: 客户端等待从MongoDB实例读数据的队列长度
qw：客户端等待从MongoDB实例写入数据的队列长度
ar: 执行读操作的活跃客户端数量
aw: 执行写操作的活客户端数量
注：如果这两个数值很大，那么就是DB被堵住了，DB的处理速度不及请求速度。看看是否有开销很大的慢查询。如果查询一切正常，确实是负载很大，就需要加机器了
netIn:MongoDB实例的网络进流量
netOut：MongoDB实例的网络出流量
注：此两项字段表名网络带宽压力，一般情况下，不会成为瓶颈
conn: 打开连接的总数，是qr,qw,ar,aw的总和
注：MongoDB为每一个连接创建一个线程，线程的创建与释放也会有开销，所以尽量要适当配置连接数的启动参数，maxIncomingConnections，阿里工程师建议在5000以下，基本满足多数场景

7.创建用户和角色

#与用户相关的命令
db.auth() 将用户验证到数据库。
db.changeUserPassword() 更改现有用户的密码。
db.createUser() 创建一个新用户。
db.dropUser() 删除单个用户。
db.dropAllUsers() 删除与数据库关联的所有用户。
db.getUser() 返回有关指定用户的信息。
db.getUsers() 返回有关与数据库关联的所有用户的信息。
db.grantRolesToUser() 授予用户角色及其特权。
db.removeUser() 已过时。从数据库中删除用户。
db.revokeRolesFromUser() 从用户中删除角色。
db.updateUser() 更新用户数据。

1.创建管理用户

mongo db01:27017
#先进到admin库
use admin 
#先查看用户（当前没有用户）
> db.getUsers()
[ ]
#创建用户
db.createUser(
    {
        user: "admin",
        pwd: "123456",
        roles:[ 
                { 
                    role: "root", 
                    db:"admin"
                }
              ]
    }   
)

2.查看创建的用户

> db.getUsers()
[
    {
        "_id" : "admin.admin",
        "userId" : UUID("b056b2c5-705b-49bc-9b5f-c6d7d295501d"),
        "user" : "admin",
        "db" : "admin",
        "roles" : [
            {
                "role" : "root",
                "db" : "admin"
            }
        ]
    }
]

3.退出，配置文件添加权限认证参数

[mongo@db01 ~]$ tail -2 /opt/mongo_27017/conf/mongodb.conf 
security:     
  authorization: enabled

4.重启mongo

[mongo@db01 ~]$  mongod -f /opt/mongo_27017/conf/mongodb.conf --shutdown
[mongo@db01 ~]$  mongod -f /opt/mongo_27017/conf/mongodb.conf

5.使用admin用户登录

[mongo@db01 ~]$  mongo db01:27017 -uadmin -p --authenticationDatabase admin

6.创建其他用户

>use test
>db.createUser(
  {
    user: "mysun",
    pwd: "123456",
    roles: [ { role: "readWrite", db: "write" },
             { role: "read", db: "read" } ]
  }
)

7.创建测试数据

>use write
>db.write.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.write.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.write.insert({"name":"yazhang","age":28,"ad":"北京市朝阳区"})
db.write.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区"})
db.write.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区","sex":"boy"})

>use read
>db.read.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.read.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})
db.read.insert({"name":"yazhang","age":28,"ad":"北京市朝阳区"})
db.read.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区"})
db.read.insert({"name":"xiaozhang","age":28,"ad":"北京市朝阳区","sex":"boy"})

8.退出admin，使用mysun用户登录

[mongo@db01 ~]$ mongo db01:27017 -umysun -p --authenticationDatabase test

#普通mysun用户登录，write库，可读可写
>use write
> db.write.find()
> db.write.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})

#read库，只可读，写的话会报错
> use read
switched to db read
> db.read.find()
> db.read.insert({"name":"zhangya","age":27,"ad":"北京市朝阳区"})

9.修改用户权限，必须以admin的用户登录，普通用户修改不了

use test
db.updateUser(
  'mysun',
  { 
    pwd: "123456",
    roles: [ { role: "readWrite", db: "write" },
             { role: "readWrite", db: "read" } ,
             { role: "readWrite", db: "test" }
             ]
             
  }
)

10.删除用户，也必须以admin的用户登录

db.getUsers()
db.dropUser('mysun')

原文地址：https://www.cnblogs.com/gongjingyun123--/p/12088297.html