常用基本操作

mongodb常用基本操作

mongodb 默认存在的库

test:登录时，默认连接存在的库
# 管理MongoDB有关的系统库
> db	#查看当前所在哪个库
test
> show collections; show tables;
> 
> show databases; show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
>


# admin库:系统预留库,MongoDB系统日常管理库

> use admin
switched to db admin
> show collections; show tables;
system.version
> 

# local库:本地预留库,存储关键日志，比如binlog
> 
> use local
switched to db local
> 
> show collections; show tables;
startup_log
> 
>

# config库:MongoDB配置信息库,主要是存储集群配置信息
> 
> use config
switched to db config
> 
> show collections; show tables;
system.sessions
> 

show databases/show dbs
show tables/show collections
use admin 
db/select database()

命令种类

db 库相关命令

# 库级别
db.[TAB][TAB]
db.help()		# 查看库db帮助的简易信息
db.runCommand( { listCommands: 1 } )

# 查看库
show dbs


# 建库
> use simon
switched to db simon
> 

# 查看当前正在使用的库
db

# 删除库
use db_name
db.runCommand( { dropDatabase: 1 } )

use db_name
>db.dropDatabase()   
{ "dropped" : "test", "ok" : 1 }

> 
> db.drop[Tab][Tab]
db.dropAllRoles(  db.dropDatabase(  db.dropUser(
db.dropAllUsers(  db.dropRole(
> db.dropDatabase()
{ "ok" : 1 }
> 

# 修复当前数据库
db.repairDatabase()

# 查看数据库大小
db.adminCommand( { dbstats:1 , scale:1024 } )

mongodb对象操作

mongo         mysql
库    ----->  库
集合  ----->  表
文档  ----->  数据行

集合的操作

# 表和文档
db.collection.[TAB][TAB]
db.collection.help()

# 具体信息查看，查官方文档
# https://docs.mongodb.com/v3.6/

# 在MongoDB中，db 和 collection 是不需要提前创建好的，只要通过语句告诉MongoDB，数据要往哪里录入，MongoDB会自动生成

# 查看表
show collections
show tables
db.getCollectionNames()


# 建集合/表
# 方式1：
> db.createCollection('a')
{ "ok" : 1 }

> db.createCollection('tb_name',{ 'capped':true,'size':10240,'max':204800 })


# 方法2：当插入一个文档的时候，一个集合就会自动创建。
use oldboy
db.test.insert({name:"zhangsan"})
db.stu.insert({id:101,name:"zhangsan",age:20,gender:"m"})

show tables;
db.stu.insert({id:102,name:"lisi"})
db.stu.insert({a:"b",c:"d"})
db.stu.insert({a:1,c:2})

# 删除集合
db.tb_name.drop()

# 查询指定数据库的集合分配的存储空间
use db_name
db.baseSe.totalSize()

db.log.totalSize() //集合中索引+数据压缩存储之后的大小   
   
# 查看集合大小
> db.log.totalSize()
696320
>

# 查询指定数据库的集合当前可用的存储空间
use db_name
db.baseSe.storageSize()

# 判断集合是否为固定集合
db.cappedLogCollection.isCapped()

# 根据条件删除某个集合的数据
db.tb_name.deleteOne( { "user_name" : "hukey" } )	//删除单条

# 表重命名
use db_name
db.orders.renameCollection( "orders2014" )

db.adminCommand( { renameCollection: "test.orders", to: "test.orders2014" } )

#向指定集合中插入一条文档数据
> db.collection.insertOne()

#向指定集合中插入多条文档数据
> db.collection.insertMany()

文档操作

# 插入一条记录
> db.info.insert({"id":1,"score":88,"address":"金川校区","hobby":["game","talk","sport"]})

# 通过循环批量插入数据
> for(var i=1;i<100;i++)db.info.insert({"id":i,"name":"jack"+i})

# 数据的批量录入：
for(i=1;i<100000;i++){db.log.insert({"uid":i,"name":"mongodb","age":6,"date":new Date()})}

# 查询数据行数：
> db.log.count()
    
# 全表查询：
> db.log.find()		# 等同 select *

# 查询log集合uid为1的文档
> db.log.findOne({uid:1})

# 每页显示50条记录：
> DBQuery.shellBatchSize=50; 

# 按照条件查询
> db.log.find({uid:999})	# 等同 select * from tb where...

# 以标准的json格式显示数据
> db.log.find({uid:999}).pretty()
{
    "_id" : ObjectId("5cc516e60d13144c89dead33"),
    "uid" : 999,
    "name" : "mongodb",
    "age" : 6,
    "date" : ISODate("2019-04-28T02:58:46.109Z")
}

# 删除集合中所有记录,就是清空
app> db.log.remove({})

> db.log.remove({})
WriteResult({ "nRemoved" : 9999 })
>
# 按条件删除
> db.log.remove({uid:999})
WriteResult({ "nRemoved" : 1 })
>

修改文档

#修改info集合id=1的name值为"zhangsan"文档
db.info.update({"id":"1"},{$set:{"name":"zhangsan"}})

进程管理

1. 查看当前正在运行的进程的命令：
db.currentOp() ------> 获取opid进程号

2. 终止正在运行的高消耗资源的进程命令:
db.killOP(opid)

索引

# 创建索引
注： mongodb使用 createIndex() 和 ensureIndex() 方法来创建索引，牵着用于3.0及以上版本，后者用于3.0以下版本

# 索引排序 数据1表示升序，-1表示降序

# 单字段索引
db.collection_name.createIndex(
	{ "name" : "idx_name" },
    { "age" : 1 , "sex" : 1 },
    { "background" : true },
    { "unique" : false }
)

# 数据库命令，创建索引
#

# 复合索引
db.collection_name.createIndex({ "id" : 1,"name" : 1,"age" : -1 })
db.collection_name.find().sort({"id":1,"name":1,"age":-1})	//可以走索引
db.collection_name.find().sort({"id":1,"name":1,"age":1})	//不走索引

# hash 索引
use simon_data
db.collection_name.createIndex({ "name" : "hashed" })

# 过期索引 (索引过期后，索引对应的数据会被删除)
# expireAfterSecondes , 值是秒数，用来设置过期索引的过期时间
use db_name
db.collection_name.createIndex({time:1},{expireAfterSeconds:30})

# 查询索引
use db_name
db.collection_name.getIndexes()
db.runCommand (
	{
        listIndexes : "collection_name"
    }
)


# 删除索引
db.collection_name.dropIndex("idx_name")
db.runCommand (
    { dropIndexes: "collection", index:"*" }	# 删除所有索引
    { dropIndexes: "collection", index:"idx_name" }	# 删除指定索引
)

# 索引重建
db.collection_name.reIndex()
db.runCommand (
    { reIndex : "collection_name" }
)

状态信息

# 查询指定数据库统计信息
use db_name
db.stats()


# 查询数据库服务器的状态
db.serverStatus()

# 查看当前数据库实例的链接数情况
db.serverStatus().connections

# 查看内存使用
# 其中resident代表物理内存使用情况，单位为M
# virtual 为虚拟内存使用情况
# mapped 是映射到内存的数据大小
# 虚拟内存是mapped的两倍，是开启了Journal日志，需要再内存中多映射一次，大概就是它的两倍。如果关闭Journal日志，虚拟内存大小将和mapped大小相当
db.serverStatus().mem

db.serverStatus().wiredTiger.cache
"maximum bytes configured" : 3872165513

# 查看当前执行的事务
db.currentOp()

# 重点需要关注的字段：
client 发起请求的客户端地址
opid 识别当前操作的标识符。如果需要终止当前操作，可以通过执行db.killOp(opid)终止。
secs_running	当前操作已经执行的时间，单位：秒。如果已经执行的时间较长，建议查看请求是否合理
microsecs_running	当前操作已经执行的时间，单位：微妙。如果已经执行的时间较长，建议查看请求是否合理
ns	当前操作的目标集合
op	当前操作的类型，通常是查询、插入、更新和删除中的一种
locks	跟锁相关的信息

# 查看当前所有链接数据库的IP地址
db.getMongo()

# 查看当前节点的IP地址
db.isMaster().me

# 获取配置参数
use admin
db.runCommand( { getParameter:"*" } )

# 自mongod实例上次启动以来，按类型查看数据库复制操作的文档
db.serverStatus().opcountersRepl
db.serverStatus().opcounters
db.serverStatus().repl

# 锁库(hidden节点执行，备份场景使用)
db.fsyncLock()

# 解锁
db.fsyncUnlock()

# 查看是否有锁
db.adminCommand({ lockInfo: 1 })
db.serverStatus().fsyncLock
db.currentOp()
db.runCommand({"currentOp":1,"$ownOps":1})

# 查找 fsyncLock
lockcount: longNumber(3)

# 动态 设置日志级别参数
db.adminCommand({"getParameter":1,"logLevel":1})

# 设置和查看慢查询
# 设置慢查询
db.setProfilingLevel(1,200)

# 查看慢查询级别
db.getProfilingLevel()

# 查询慢查询日志，此命令是针对某一库进行设置
db.system.profile.find(
	{ ns : 'dbName.collection_name' }
).limit(10).sort( { ts : -1 } ).pretty()


# 问题说明： 千万级别集合，为优化业务，直接执行新建索引命令，导致整个库被锁，应用服务出现不可用
# 解决方案： 找出此操作进程，并且杀死。改为后台新建索引，速度会很慢，但是不会影响业务，该索引只会在新建完成后，才会生效
# 查询运行时间超过200ms操作
db.currentOp({"active":true,"secs_running":{ "gt" : 2000 }})
# 杀死执行时间过长的操作
db.killOp(opid)
# 后台新建索引
db.collection_name.createIndex({filedName:1},{background:true})

rs 复制集有关(replication set):

rs.[TAB][TAB]
rs.help()
> 
> rs.
rs.add(                        rs.printReplicationInfo(
rs.addArb(                     rs.printSlaveReplicationInfo(
rs.apply(                      rs.propertyIsEnumerable(
rs.bind(                       rs.prototype
rs.call(                       rs.reconfig(
rs.compareOpTimes(             rs.remove(
rs.conf(                       rs.secondaryOk(
rs.config(                     rs.slaveOk(
rs.constructor                 rs.status(
rs.debug                       rs.stepDown(
rs.freeze(                     rs.syncFrom(
rs.hasOwnProperty(             rs.toLocaleString(
rs.help(                       rs.toString(
rs.initiate(                   rs.valueOf(
rs.isMaster(
> 
        


# 获取副本集状态
db.runCommand({ replSetGetConfig: 1 })
rs.status()

self: 只会出现在执行rs.status()命令的成员里
uptime: 从本节点 网络科大到当前所经历的时间
lastHeartbeat: 当前服务器最后一次收到其心跳的时间
Optime & optimeDate : 命令发出时oplog所记录的操作时间戳
pingMs: 网络延迟
syncingTo: 复制源
stateStr:

可提供服务的状态： primary，secondary，arbiter
即将提供服务的状态： startup，startup2，recovering
不可提供服务状态： down,unknow，removed，rollback,fatal


# 初始化为默认配置
rs.initiate()

# 使用配置好的cfg信息，初始化
rs.initiate(cfg)
db.adminCommand({ replSetInitiate : <config_document> })

# 从local.system.repset获取当前配置对象
rs.conf()

use admin
db.runCommand({ replSetGetConfig: 1 })

# 更新正在运行的副本集的配置
# 对于复杂的操作，比如更改成员配置或者一次性添加/删除多个成员，rs.reconfig() 通常比rs.add() 和rs.remove()更有用
rs.reconfig(cfg)
db.adminCommand({ replSetReconfig: <new_config_document>, force: false })

#######################################################

# 添加节点
rs.add(host.port.str)
rs.add(member.conf.obj)

cfg=rs.conf()
cfg.version++
cfg.members[3]={"_id" : 3 , "host" : "192.168.0.1:27017" , "priority" : 0, "votes" : 0 }
cfg.members[4]={"_id" : 3 , "host" : "192.168.0.2:27017" , "priority" : 0, "votes" : 0 }
rs.reconfig(cfg,{"force":false})


# 修改节点属性
cfg=rs.conf()
cfg.version++
cfg.members[1].priority=1
cfg.members[1].votes=1
cfg.members[2].priority=0
cfg.members[2].votes=1
cfg.members[2].hidden=true
rs.reconfig(cfg,{"force":false})

# 删除节点
rs.remove(host.port.str)

cfg=rs.conf()
cfg.version++
host=["192.168.0.3:27017","192.168.0.4:27017"]
for (var h in host) {
  for ( var m in cfg.members ) {
    if (cfg.members[m] == host[h]) {
      cfg.members.splice(m, 1);
}}}
printjson(cfg.members)
rs.reconfig(cfg,{"force":false})

#######################################################

# 添加一个arbiter仲裁节点
rs.addArb(host,port.str)

# 主节点降为备节点
# 会让primary降级为secondary节点，并维持60s，如果这段时间内没有新的primary被选举出来，这个节点可以要求重新进行选举
rs.stepDown([stepdownSecs, catchUpSecs])
db.adminCommand({ replSetStepDown : 1, force : true })

# 从指定成员进行数据同步
rs.syncFrom(host.port.str)
db.adminCommand( { replSetSyncFrom : "192.168.0.4:27017" } )

# 使节点在指定的时间内没有资格成为primary
rs.freeze(secs)
db.adminCommand({ replSetFreeze: 0 })


# 允许在副主节点上查询
# 从节点可能会落后于primary而缺少最新的数据，所以默认情况下secondary节点会拒绝读请求，以防止有应用程序以外读取过期数据，因此需要设置一下才能读

rs.slaveOk()
db.setSlaveOk()

# 4.2 版本以前使用此命令
db.setSlaveOk()

# 4.2 版本以后 db.setSlaveOk() 已被遗弃
db.setSecondaryOk()


# 查看oplog信息
rs.printReplicationInfo()
db.getReplicationInfo()

rs.printSlaveReplicationInfo()

# 查看Oplog的配置Size
use local
db.oplog.rs.stats().maxSize


# 查看是否为主节点
db.isMaster()
db.runCommand({ isMaster: 1 })


#######################################################

# tags 属性
# tag是针对每个节点的属性
# 通过tags，可以指定从哪个secondary上读取数据
# 设置tags
cfg = rs.conf()
cfg.version++
cfg.members[n].tags = { "dc" : "poll" , "usage" : "data_pool" }
rs.reconfig(cfg)

# 查询语句，需要通过readPref 指定tags
db.collection_name.find({}).readPref(
	"secondary", [
		{
			"dc" : "poll",
			"usage" : "data_pool"
		}
	]
)


#######################################################

sh 分片集群(sharding cluster)

sh.[TAB][TAB]
sh.help()
> 
> sh.
sh.addShard(               sh.getBalancerState(       sh.removeTagRange(
sh.addShardTag(            sh.getBalancerWindow(      sh.setBalancerState(
sh.addShardToZone(         sh.getRecentFailedRounds(  sh.shardCollection(
sh.addTagRange(            sh.getRecentMigrations(    sh.splitAt(
sh.apply(                  sh.getShouldAutoSplit(     sh.splitFind(
sh.bind(                   sh.hasOwnProperty(         sh.startBalancer(
sh.call(                   sh.help(                   sh.status(
sh.constructor             sh.isBalancerRunning(      sh.stopBalancer(
sh.disableAutoSplit(       sh.moveChunk(              sh.toLocaleString(
sh.disableBalancing(       sh.propertyIsEnumerable(   sh.toString(
sh.enableAutoSplit(        sh.prototype               sh.updateZoneKeyRange(
sh.enableBalancing(        sh.removeRangeFromZone(    sh.valueOf(
sh.enableSharding(         sh.removeShardFromZone(    sh.waitForPingChange(
sh.getActiveMigrations(    sh.removeShardTag(
> 
>