mirror of
https://github.com/tiennm99/zfoo.git
synced 2026-05-20 05:27:48 +00:00
jaysunxiao
689 lines
26 KiB
Markdown
689 lines
26 KiB
Markdown
# 一、MongoDB常用命令
|
||
|
||
## 1.数据库常用命令
|
||
|
||
```
|
||
show dbs # 查询数据库列表
|
||
use student # 该命令如果数据库不存在，将创建一个新的数据库，否则将返回现有的数据库。
|
||
db.dropDatabase() # 删除新的数据库
|
||
db.repairDatabase() # 整理数据库，不仅能整理碎片还可以回收磁盘空间，但是会产生锁，建议停服的时候做
|
||
db.getName() # 查看当前使用的数据库
|
||
db.version() # 当前db的版本
|
||
db.getMongo() # 查看当前db的链接机器地址
|
||
db.getPrevError() # 查询之前的错误信息
|
||
db.resetError() # 清除错误记录
|
||
db.help() # 查看数据库帮助文档
|
||
```
|
||
|
||
## 2.集合常用命令
|
||
|
||
```
|
||
show collections # 查看所有的集合
|
||
db.createCollection("student") # 创建一个集合
|
||
db.createCollection("log", {size: 20, capped:true, max: 100}); # 或者带参数创建固定集合
|
||
db.student # 使用集合
|
||
db.student.drop() # 删除当前集合
|
||
db.student.validate() # 验证集合是否有问题，验证集合内容
|
||
|
||
|
||
db.student.count() # 查询当前集合的数据条数
|
||
db.student.dataSize() # 查看集合数据大小
|
||
db.student.totalIndexSize() # 查看集合索引大小
|
||
db.student.storageSize() # 集合分配的空间大小,包括未使用的空间
|
||
db.student.totalSize() # 显示集合总大小，包括索引和数据的大小和分配空间的大小
|
||
db.student.getDB() # 显示当前集合所在的db
|
||
db.student.stats() # 显示当前集合的状态
|
||
db.student.getShardVersion() # 集合的分片版本信息
|
||
db.student.renameCollection("students"); # 集合重命名
|
||
db.printCollectionStats() # 显示当前db所有集合的状态信息
|
||
db.student.help() # 查看集合命令帮助文档
|
||
```
|
||
|
||
- 集合内存
|
||
|
||
```
|
||
在MongoDB中并不需要创建集合。 当插入一些文档 MongoDB 会自动创建集合。
|
||
capped: Boolean
|
||
（可选）如果为true，它启用上限集合。上限集合是一个固定大小的集合，当它达到其最大尺寸会自动覆盖最老的条目。
|
||
如果指定true，则还需要指定参数的大小
|
||
size: number （可选）指定的上限集合字节的最大尺寸。如果capped 是true，那么还需要指定这个字段
|
||
autoIndexID Boolean （可选）如果为true，自动创建索引_id字段。默认的值是 false
|
||
max number （可选）指定上限集合允许的最大文件数
|
||
|
||
DB.createCollection("student", { capped : true, size : 6142800, autoIndexId : true, max : 10000 })
|
||
DB.createCollection("student")
|
||
```
|
||
|
||
## 3. 文档常用命令
|
||
|
||
### 增
|
||
|
||
```
|
||
db.student.insert({name:"jay", age: 100})
|
||
|
||
如果我们不指定_id参数插入的文档，那么 MongoDB 将为文档分配一个唯一的ObjectId。_id 是12个字节十六进制数在一个集合的每个文档是唯一的。
|
||
0-3时间戳，4-6机器唯一标识的散列标识，7-8进程号PID，9-11计数器。前三个保证同一个机器不同进程产生的标识唯一，后一个保证同一个进程产生不同的标识。
|
||
简介说就是在分布式系统中可以在本机产生全局唯一id。
|
||
```
|
||
|
||
### 删
|
||
|
||
```
|
||
db.student.remove({name : "jay"},true); # true是只删除一条，默认是false全部删除
|
||
db.student.remove({name : "jay"});
|
||
```
|
||
|
||
### 改
|
||
|
||
```
|
||
db.student.save({name : "jay", age : 20}) # save如果数据库已经有这条数据，则会更新它；如果没有，则写入
|
||
|
||
db.student.update({name:"jay"},{$set:{age : 20, company: "google"}});
|
||
db.student.update({name:"jay"},{$set:{age : 20}},{multi:true}); # $set修改器；multi默认false，只更新找到的第一条记录
|
||
db.student.update({name:"jay"},{$unset:{company:1}}); # $unset用于取消字段，去掉文档中的某个字段
|
||
db.student.update({name:"jay"},{$inc: {age: 50}}); # $inc用于增加或减少数值
|
||
db.student.update({name:"jay"},{$push: {phone: {home:456789}}}); # $push用于把元素追加到数组中，如果字段不存在，会新增
|
||
db.student.update({name:"jay"},{$pushAll: {phone: [{home:456789} # $pushAll用于把元素追加到数组中，多个元素
|
||
db.student.update({name:"jay"},{$pull: {phone:{home: 456789} }}); # $pull删除数组中满足条件的元素
|
||
db.student.update({name:"jay"},{$addToSet: {phone: {home:456789}}}); # $addToSet类似于push，但是只有这个值不在数组中才会增加
|
||
db.student.update({name:"jay"},{$pop: {phone:1}}); # $pop删除数组中最后一个元素
|
||
db.student.update({name:"jay"},{$rename: {phone:"call"}}); # $rename修改字段名称
|
||
```
|
||
|
||
### 查
|
||
|
||
```
|
||
db.student.find()
|
||
db.student.find().pretty(); # 如果需要结构化显示返回的文档可以加上pretty()方法
|
||
db.student.find({name:"jay"},{age:1}) # 查询name伟jay，只显示age
|
||
|
||
db.student.count({$or: [{age: 14}, {age: 28}]}); # 查询满足条件的文档数量
|
||
```
|
||
|
||
## 4.索引
|
||
|
||
### 创建索引
|
||
|
||
```
|
||
db.student.ensureIndex({age: 1}); # 1表示age索引按升序排序
|
||
db.student.ensureIndex({name: 1, age: -1}); # -1表示同组文档按降序排序
|
||
|
||
例如我们有数据:
|
||
{"name":"jay",age:14}
|
||
{"name":"ad",age:14}
|
||
{"name":"ad",age:38}
|
||
{"name":"ad",age:24}
|
||
{"name":"ab",age:14}
|
||
使用db.student.ensureIndex({name: 1, age: -1})建议索引后，索引中的数据组织为:
|
||
{"name":"ab",age:14}
|
||
{"name":"ad",age:38}
|
||
{"name":"ad",age:24}
|
||
{"name":"ad",age:14}
|
||
{"name":"jay",age:14}
|
||
```
|
||
|
||
### 创建唯一索引
|
||
|
||
```
|
||
db.student.ensureIndex({name:1},{unique:true}) # 如果创建唯一索引时已经存在重复项，通过dropDups在创建唯一索引时消除重复文档
|
||
db.student.ensureIndex({name:1},{unique:true,dropDups:true})
|
||
```
|
||
|
||
### 索引操作
|
||
|
||
```
|
||
db.student.getIndexes(); # 查询集合所有索引
|
||
db.student.totalIndexSize(); # 查看集合总索引记录大小
|
||
db.student.reIndex(); # 修复索引
|
||
db.student.dropIndex("name");# 删除指定索引
|
||
```
|
||
|
||
### 索引调优explain
|
||
|
||
```
|
||
db.student.find({name: "jaysunxiao" }).explain();
|
||
```
|
||
|
||
## 5.查询
|
||
|
||
### 单个文档大小
|
||
|
||
```
|
||
Object.bsonsize(db.user.findOne({'account':'xxx'})) # 返回文档的bytes数量
|
||
```
|
||
|
||
### 迭代器，一般用于遍历数据集。通过hasNext()判断是否有下一条数据，next()获取下一条数据
|
||
|
||
```javascript
|
||
var iterator= db.student.find();
|
||
while(iterator.hasNext()){
|
||
let temp=iterator.next();
|
||
print(temp.name);
|
||
}
|
||
|
||
// 迭代器还实现了迭代器接口，所以可以使用forEach。
|
||
var iterator= db.student.find();
|
||
iterator.forEach(function(temp){
|
||
print(temp.name);
|
||
});
|
||
```
|
||
|
||
### find语法
|
||
|
||
```
|
||
find( query, fields)
|
||
query 查询条件，相当于sql的where
|
||
fields 查询的结果，字段映射,0不显示，1显示
|
||
explain("allPlansExecution") 返回查询计划信息和查询计划的执行统计信息
|
||
|
||
db.student.find({}, { "_id":0, "name":1}).limit(9).skip(5).sort({"name":-1}).pretty()
|
||
```
|
||
|
||
### 条件查询
|
||
|
||
```
|
||
db.student.find({name:"jay",age:16}) # 与操作
|
||
db.student.find({$or: [{age: 14}, {age: 28}]}); # 或操作$or
|
||
db.student.find({age: {$gt: 20}}) # 大于$gt
|
||
db.student.find({age: {$lt: 20}}) # 小于$lt
|
||
db.student.find({age: {$gte: 20}}) # 大于等于$gte
|
||
db.student.find({age: {$lte: 20}}) # 小于等于$lte
|
||
db.student.find({name: { $type : "string" }}); # 类型查询$type
|
||
|
||
db.student.find({age: {$exists: true}}) # 是否存在$exists
|
||
db.student.find({age: {$mod : [10, 0]}}); # 取模$mod
|
||
db.student.find({age: { "$ne" : 23}}) # 不等于$ne
|
||
db.student.find({name:{ "$in" : [ "jay" , "ab"]}}) # 包含$in
|
||
db.student.find({name:{$not:{"$in":["jay","ab"]}}})# 取非
|
||
db.student.find({name:{ "$nin":["jay","ab"]}}) # 不包含$nin
|
||
```
|
||
|
||
### null查询
|
||
|
||
```
|
||
db.student.find({company:null}) # 查询company字段为null的文档
|
||
db.student.find({company:{$nin:[null]} }) # 查询company字段不为空的文档\
|
||
```
|
||
|
||
### 正则查询
|
||
|
||
```
|
||
db.student.find({"name":/^j/}) # 以j开头的字符串
|
||
```
|
||
|
||
### 嵌套查询
|
||
|
||
```
|
||
db.student.find({"phone":{"home" : 123321,"mobile" : 15820123123}}) # 指定完整的文档，查询出子文档完全匹配指定文档的文档。
|
||
db.student.find({"phone.home":123321}) # 如果我们不知道子文档的完整文档，只知道子文档中一个字段的值，可以通过点查询。
|
||
```
|
||
|
||
### 数组查询
|
||
|
||
```
|
||
db.student.find({favorite_number :[6, 8]}); # 精确匹配查询
|
||
db.student.find({favorite_number:6}); # 数组单元素查询
|
||
db.student.find({favorite_number : {$all : [6, 8]}}); # 数组多元素查询
|
||
db.student.find({favorite_number: {$size: 3}}); # $size数组长度查询
|
||
db.student.find({},{favorite_number: {$slice: 2}}); # $slice返回数组子集
|
||
db.student.find({},{favorite_number: {$slice: -2}});
|
||
db.student.find({phone.home:123456}); # 点查询用于查询更复杂的数组，例如数组中包含的是子文档的情况
|
||
db.student.find({phone.home:123456,"phone.mobile":13820123123}); # 数组的子文档如果有多个字段，查询出子文档同时满足两个条件的文档有两种方式
|
||
db.student.find( { # 或者，两者等价
|
||
phone: {
|
||
$elemMatch: {
|
||
home :123456,
|
||
mobile: 13820123123
|
||
}}})
|
||
```
|
||
|
||
### 索引查询
|
||
|
||
```
|
||
db.student.find({favorite_number.0:6}); # 数组都有索引，例如[6,8],6是第0个元素，8是第1个元素(数组索引以0开头)。要查找某个元素指定值的文档可以使用点和索引值
|
||
db.student.find({phone.2.home:123456}); # 点查询中只要数组的子文档里有一个home值满足查询值就会返回文档。如果我们要精确到第几个元素也可以用索引查询。
|
||
```
|
||
|
||
### 高级查询$where
|
||
|
||
- Javascript与$where结合使用，下面的全部等价
|
||
|
||
```
|
||
db.student.find({age: {$gt: 18}});
|
||
db.student.find({$where: "this.age > 18"});
|
||
db.student.find("this.age > 18");
|
||
f = function() {return this.age > 18}; db.student.find(f);
|
||
```
|
||
|
||
## 6.聚合查询
|
||
|
||
### count和distinct
|
||
|
||
```
|
||
db.student.count({age: {$gte: 18}}) # 数量查询count
|
||
db.runCommand({"distinct":"student", "key":"age"}) # 不同值distinct
|
||
```
|
||
|
||
### 分组group
|
||
|
||
```
|
||
db.collection.group({
|
||
key:{field:1},
|
||
initial:{count:0},
|
||
cond:{},
|
||
reduce: function ( curr, result ) { },
|
||
keyf：function(doc){},
|
||
finalize:function(result) {}
|
||
})
|
||
|
||
|
||
数据如下:
|
||
{ "_id" : ObjectId("58d9b6afa159504ca6c572e0"), "name" : "jay", "age" : 28, "company" : "google", "name" : "a2" }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313438"), "name" : "jay", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313439"), "name" : "ad", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df631343a"), "name" : "ad", "age" : 38 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df631343b"), "name" : "ad", "age" : 24 }
|
||
{ "_id" : ObjectId("58d9ba2e6097167df631343c"), "name" : "ab", "age" : 14 }
|
||
|
||
|
||
我们这里可以做一个统计:每个年龄有多少人，则使用age字段作为key，在reduce时进行同组的数量计数，finalize中组织结果文档格式。
|
||
使用代码如下:
|
||
db.student.group({
|
||
key:{age:1},
|
||
initial:{count:0},
|
||
cond:{"age":{$gt:13}},
|
||
reduce: function(curr,result) {
|
||
result.count += 1;
|
||
},
|
||
finalize:function(result) {
|
||
result.年龄=result.age;
|
||
result.人数=result.count;
|
||
}
|
||
});
|
||
|
||
|
||
使用MapReduce做一个统计:每个年龄有多少人，this表示当前文档，使用this.age的值作为key。在reduce时进行同组的数量计数，finalize中组织结果文档格式。
|
||
代码如下:
|
||
db.student.mapReduce(
|
||
function () {
|
||
emit(this.age, {age: this.age, count: 1});
|
||
},
|
||
function (key, values) {
|
||
var count = 0;
|
||
values.forEach(function(val) {
|
||
count += val.count;
|
||
});
|
||
return {age: key, count: count};
|
||
},
|
||
{
|
||
out: { inline : 1 },
|
||
finalize: function (key, reduced) {
|
||
return {"年龄": reduced.age, "人数": reduced.count};
|
||
}
|
||
}
|
||
)
|
||
第一个function是map函数，提交两个参数key和value，数据会根据key的值进行分组，把同组的value的值放入values数组中。
|
||
第二个function是reduce函数，key和values是第一个map函数的分组结果。
|
||
第三个out指定结果集生成在什么地方，inline:1，表示结果集放在内存中，仅适用于结果集符合16MB限制的情况
|
||
```
|
||
|
||
### $project
|
||
|
||
```
|
||
数据如下:
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313438"), "name" : { "first" : "adrian", "last" : "jay" }, "age" : 14, "phone" : 111128912345 }
|
||
使用代码:
|
||
db.student.aggregate(
|
||
[
|
||
{ $project: { _id:0, age: 1, phone: "123456789", lastName: "$name.last" } }
|
||
]
|
||
)
|
||
$project映射结果集的文档结构，0表示排除字段，1显示字段，"123456789"直接赋值
|
||
```
|
||
|
||
### $match
|
||
|
||
```
|
||
db.student.aggregate([{$match:{"name.last":"jay"}}])
|
||
```
|
||
|
||
### $limit
|
||
|
||
```
|
||
db.student.aggregate({ $limit : 1 });
|
||
```
|
||
|
||
### $skip
|
||
|
||
```
|
||
db.student.aggregate({ $skip : 2 });
|
||
```
|
||
|
||
### $unwind
|
||
|
||
```
|
||
数据:
|
||
db.product.find()
|
||
{ "_id" : 1, "item" : "ABC1", "sizes" : [ "S", "M", "L" ] }
|
||
|
||
db.product.aggregate( [ { $unwind : "$sizes" } ] )
|
||
```
|
||
|
||
### $group
|
||
|
||
```
|
||
数据:
|
||
db.student.find()
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313438"), "name" : "jay", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313439"), "name" : "ad", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df631343a"), "name" : "ad", "age" : 38 }
|
||
|
||
把数据根据age字段进行分组，使用命令:
|
||
db.student.aggregate([{$group : {_id : "$age"}}])
|
||
```
|
||
|
||
### $sort
|
||
|
||
```
|
||
$sort将输入文档排序后输出，1为按字段升序，-1为降序。
|
||
我们有数据:
|
||
db.student.find()
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313438"), "name" : "jay", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313439"), "name" : "ad", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df631343a"), "name" : "ad", "age" : 38 }
|
||
使用命令:
|
||
db.student.aggregate([{$sort : {age :-1}}])
|
||
```
|
||
|
||
### $lookup
|
||
|
||
```
|
||
数据:
|
||
db.product.insert({"_id":1,"name":"产品1","price":99})
|
||
db.product.insert({"_id":2,"name":"产品2","price":88})
|
||
|
||
db.order.insert({"_id":1,"pid":1,"name":"订单1"})
|
||
db.order.insert({"_id":2,"pid":2,"name":"订单2"})
|
||
db.order.insert({"_id":3,"pid":2,"name":"订单3"})
|
||
db.order.insert({"_id":4,"pid":1,"name":"订单4"})
|
||
db.order.insert({"_id":5,"name":"订单5"})
|
||
db.order.insert({"_id":6,"name":"订单6"})
|
||
|
||
$lookup作左连接组合两个集合的信息使用命令如下:
|
||
db.order.aggregate([
|
||
{
|
||
$lookup:
|
||
{
|
||
from: "product",
|
||
localField: "pid",
|
||
foreignField: "_id",
|
||
as: "orderDetail"
|
||
}
|
||
}
|
||
])
|
||
|
||
```
|
||
|
||
### $geoNear
|
||
|
||
```
|
||
一、平面
|
||
|
||
我们使用lng和lat的命名，新建数据如下:
|
||
db.places.save({name:"肯德基",loc : { lng: 40.739037, lat: 73.992964 },category:"餐饮"})
|
||
db.places.save({name:"麦当劳",loc : { lng : 42.739037, lat: 73.992964 },category:"餐饮"})
|
||
db.places.save({name:"农行",loc : { lng: 41.739037, lat: 73.992964 },category:"银行"})
|
||
db.places.save({name:"地铁站",loc : { lng: 40.639037, lat: 73.992964 },category:"交通"})
|
||
|
||
2d索引创建方式如下:
|
||
db.places.createIndex( { "loc": "2d" } )
|
||
|
||
|
||
我们现在需要查到地铁站附近的文档信息，可以使用:
|
||
db.places.find({loc : {$near : { lng: 40.639037, lat:73.992964 }}})
|
||
|
||
|
||
|
||
aggregate和$geoNear能指定到范围，比如我们要查范围在坐标值相差2度(平面单位)以内的文档:
|
||
db.places.aggregate([
|
||
{
|
||
$geoNear: {
|
||
spherical:false,
|
||
distanceMultiplier:1,
|
||
near: { lng: 40.639037, lat:73.992964 },
|
||
distanceField: "dist.distacnce",
|
||
maxDistance: 2,
|
||
query: { category: "餐饮" },
|
||
includeLocs: "dist.location",
|
||
num: 1
|
||
}
|
||
}
|
||
])
|
||
|
||
二、球面
|
||
新建数据如下:
|
||
db.places.save({name:"肯德基",loc : { type: "Point", coordinates: [ 40.639037, 73.992964 ] },category:"餐饮"})
|
||
db.places.save({name:"麦当劳",loc : { type: "Point", coordinates: [ 42.739037, 73.992964 ] },category:"餐饮"})
|
||
db.places.save({name:"农行",loc : { type: "Point", coordinates: [ 41.739037, 73.992964 ] },category:"银行"})
|
||
db.places.save({name:"地铁站",loc : { type: "Point", coordinates: [ 40.639037, 73.992964 ] },category:"交通"})
|
||
|
||
创建2dsphere 索引使用代码:
|
||
db.places.createIndex( { loc : "2dsphere" } )
|
||
|
||
$geoNear用于输出某一地理位置2公里内的文档代码如下:
|
||
db.places.aggregate([
|
||
{
|
||
$geoNear: {
|
||
spherical: true,
|
||
near: { type: "Point", coordinates: [ 40.639037, 73.992964 ] },
|
||
distanceField: "dist.distacnce",
|
||
maxDistance: 2000,
|
||
query: { category:"餐饮" },
|
||
includeLocs: "dist.location",
|
||
num: 5
|
||
}
|
||
}
|
||
])
|
||
```
|
||
|
||
### $group和管道表达式
|
||
|
||
```
|
||
测试数据准备:
|
||
db.product.insert({"_id":1,"name":"产品1","price":99,"type":"服装"})
|
||
db.product.insert({"_id":2,"name":"产品2","price":88,"type":"服装"})
|
||
db.product.insert({"_id":3,"name":"产品3","price":29,"type":"饰品"})
|
||
db.product.insert({"_id":4,"name":"产品4","price":78,"type":"服装"})
|
||
db.product.insert({"_id":5,"name":"产品5","price":9,"type":"饰品"})
|
||
db.product.insert({"_id":6,"name":"产品6","price":18,"type":"饰品"})
|
||
|
||
|
||
db.product.aggregate([{$group : {_id : "$type", price : {$sum : "$price"}}}]) # 求和$sum
|
||
db.product.aggregate([{$group : {_id : "$type", price : {$avg : "$price"}}}]) # 平均值$avg
|
||
db.product.aggregate([{$group : {_id : "$type", price : {$min : "$price"}}}]) # 最小值$min
|
||
db.product.aggregate([{$group : {_id : "$type", price : {$max : "$price"}}}]) # 最大值$max
|
||
db.product.aggregate([{$group : {_id : "$type", tags : {$push : "$name"}}}]) # 数组添加$push
|
||
db.product.aggregate([{$group : {_id : "$type", tags : {$addToSet : "$name"}}}])# 数组添加$addToSet
|
||
db.product.aggregate([{$group : {_id : "$type", product : {$first : "$name"}}}])# 首元素$first
|
||
db.product.aggregate([{$group : {_id : "$type", product : {$last : "$name"}}}]) # 尾元素$last
|
||
```
|
||
|
||
### 复合使用示例
|
||
|
||
```
|
||
数据如下:
|
||
{ "_id" : ObjectId("58d9b6afa159504ca6c572e0"), "name" : "jay", "age" : 28, "company" : "google", "name" : "a2" }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313438"), "name" : "jay", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df6313439"), "name" : "ad", "age" : 14 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df631343a"), "name" : "ad", "age" : 38 }
|
||
{ "_id" : ObjectId("58d9ba2d6097167df631343b"), "name" : "ad", "age" : 24 }
|
||
{ "_id" : ObjectId("58d9ba2e6097167df631343c"), "name" : "ab", "age" : 14 }
|
||
|
||
使用代码如下:
|
||
db.student.aggregate(
|
||
[
|
||
{ $match: { age:{"$gt":13} } },
|
||
{ $sort: { age: 1 } },
|
||
{ $limit: 2 },
|
||
{ $group: { _id: "$age", "人数": { $sum: 1 } } },
|
||
]
|
||
)
|
||
|
||
aggregate默认返回分组信息_id，如果要去掉，可使用$project。
|
||
因为aggregate是按顺序处理的管道阶段操作器，所以管道的排序也很重要，下面两端代码使用相同的管道阶段操作器，但是不同的顺序，实现的效果也是不同的:
|
||
代码一:
|
||
db.student.aggregate(
|
||
[
|
||
{ $match: { age:{"$gt":13} } },
|
||
{ $sort: { age: 1 } },
|
||
{ $limit: 2 },
|
||
{ $group: { _id: "$age", "人数": { $sum: 1 } } }
|
||
]
|
||
)
|
||
|
||
|
||
代码二:
|
||
db.student.aggregate(
|
||
[
|
||
{ $match: { age:{"$gt":13} } },
|
||
{ $group: { _id: "$age", "人数": { $sum: 1 } } },
|
||
{ $sort: { _id: 1 } },
|
||
{ $limit: 2 }
|
||
]
|
||
)
|
||
```
|
||
|
||
## 7.性能监控
|
||
|
||
- db.stats()，查看当前数据库的状态，可看到数据库的名称，集合（表）数量，索引数量、大小，数据文件大小，存储空间大小和物理文件大小。
|
||
|
||
- db.serverCmdLineOpts()，查看启动参数
|
||
|
||
- db.serverStatus()，查询MongoDB的服务状态，有助于了解诊断和性能分析
|
||
|
||
```
|
||
serverStatus命令是静态的监控，MongoDB提供了动态的监控执行工具mongostat。
|
||
|
||
db.serverStatus().host # 主机名
|
||
db.serverStatus().locks # 锁信息
|
||
db.serverStatus().globalLock # 全局锁信息
|
||
db.serverStatus().mem # 内存信息
|
||
db.serverStatus().connections # 连接数信息
|
||
db.serverStatus().extra_info # 额外信息
|
||
db.serverStatus().indexCounters # 索引统计信息
|
||
db.serverStatus().backgroundFlushing # 后台刷新信息
|
||
db.serverStatus().cursors # 游标信息
|
||
db.serverStatus().network # 网络信息
|
||
db.serverStatus().repl # 副本集信息
|
||
db.serverStatus().opcountersRepl # 副本集的操作计数器
|
||
db.serverStatus().opcounters # 操作计数器
|
||
db.serverStatus().asserts # 断言信息Asserts
|
||
db.serverStatus().writeBacksQueued # writeBacksQueued
|
||
db.serverStatus().dur # 持久化(dur)
|
||
db.serverStatus().recordStats # 记录状态信息
|
||
db.serverStatus( { workingSet: 1 } ).workingSet # 工作集配置
|
||
db.serverStatus().metrics # 指标信息metrics
|
||
```
|
||
|
||
- mongostat，会动态输出一些serverStatus提供的重要信息，每秒输出一次。
|
||
|
||
```
|
||
mongostat会动态输出一些serverStatus提供的重要信息，每秒输出一次。
|
||
|
||
insert query update delete getmore command flushes mapped vsize res faults qrw arw net_in net_out conn time
|
||
*0 *0 *0 *0 0 11|0 0 0B 237M 15.0M 0 0|0 0|0 1.50k 22.7k 1 May 1 14:24:25.425
|
||
*0 *0 *0 *0 0 12|0 0 0B 237M 15.0M 0 0|0 0|0 1.55k 23.5k 1 May 1 14:24:26.405
|
||
*0 *0 *0 *0 0 11|0 0 0B 237M 15.0M 0 0|0 0|0 1.52k 23.0k 1 May 1 14:24:27.405
|
||
*0 *0 *0 *0 0 12|0 0 0B 237M 15.0M 0 0|0 0|0 1.52k 23.1k 1 May 1 14:24:28.404
|
||
*0 *0 *0 *0 0 11|0 0 0B 237M 15.0M 0 0|0 0|0 1.52k 23.0k 1 May 1 14:24:29.404
|
||
*0 *0 *0 *0 0 12|0 0 0B 237M 15.0M 0 0|0 0|0 1.53k 23.2k 1 May 1 14:24:30.396
|
||
|
||
|
||
insert、query、update、delete、getmore、command 每种对应操作的发生次数。
|
||
其中faults表示访问失败数，数据从内存交换出去，放到swap。值越小越好，最好不要大于100。
|
||
|
||
faults：查询从磁盘读取数据，标志服务器未达到最佳，所需的数据并未完全保存找内存中
|
||
qr/qw：队列等待的数目。
|
||
ar/aw：活动客户端的数目。
|
||
conn：打开的连接数。
|
||
flushes：数据刷写到磁盘的数目。
|
||
vsize：使用虚拟内存大小。
|
||
mapped：隐射的内存大小，约等于数据目录大小。
|
||
res：实际使用的内存大小
|
||
netId：表示通过网络传输进来的字节数。
|
||
netou：t表示通过网络传输出的字节数。
|
||
time：表示统计的时间。
|
||
```
|
||
|
||
- mongotop，查看哪个几个最繁忙
|
||
|
||
- db.currentOP()，可看到当前执行的进程，类似MySQL的show processlist
|
||
|
||
- show profile
|
||
|
||
```
|
||
db.setProfilingLevel(2) # enable profiling
|
||
db.system.profile.find() # show raw profile entries
|
||
show profile # 该命令可以查看最近的5条记录
|
||
该命令可以查看最近的5条记录：
|
||
ts:该命令在何时执行。
|
||
millis：执行耗时，以毫秒为单位。
|
||
op：什么操作。
|
||
query：设置的查询条件。
|
||
nReturned：返回的条数。
|
||
docsExamined：文档扫描条数。
|
||
|
||
# 清空还原profile集合使用命令:
|
||
db.setProfilingLevel(0)
|
||
db.system.profile.drop()
|
||
db.createCollection("system.profile", { capped: true, size:4000000 } )
|
||
db.setProfilingLevel(1)
|
||
```
|
||
|
||
## 8.备份和恢复
|
||
|
||
### 1).数据库备份和恢复
|
||
|
||
- mongodump导出数据库中全部的内容，使用-q参数增加查询条件，注意-q参数值的标点符号，否则会报错 too many positional arguments
|
||
|
||
```
|
||
mongodump --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -o /home
|
||
mongodump --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -c user -q "{name:'joe'}" -o /home
|
||
```
|
||
|
||
- mongorestore使用的数据文件就是mongodump备份的数据文件
|
||
|
||
```
|
||
# 使用/home路径下的BSON和JSON文件恢复数据库test，--drop参数表示如果已经存在test数据库则删除原数据库，去掉--drop则与原数据库合并
|
||
mongorestore --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test /home/test --drop
|
||
```
|
||
|
||
### 2).表的备份和恢复
|
||
|
||
- 导出json格式的备份文件，从test数据库中student集合到/home/test.json文件中
|
||
|
||
```
|
||
mongoexport --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -c student -o /home/test.json
|
||
mongoexport --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -c student -q "{name: 'joe'}" -o /home/test.json
|
||
```
|
||
|
||
- 导出csv格式的备份文件
|
||
|
||
```
|
||
# -f参数用于指定只导致id和name以及age字段，因为csv是表格类型的，所以对于内嵌文档太深的数据导出效果不是很好，所以一般来说会指定某些字段导出。
|
||
mongoexport --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -c student --csv -f _id,name,age -o /home/test.csv
|
||
```
|
||
|
||
- json格式导入，使用备份文件/home/test.json导入数据到test数据库的student集合中
|
||
|
||
```
|
||
# --upsert表示更新现有数据，如果不使用—upsert则导入时已经存在的文档会报_id重复，数据不再插入。也可以使用--drop删除原数据。
|
||
mongoimport --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -c student /home/test.json --upsert
|
||
```
|
||
|
||
- csv格式导入，--headerline指明不导入第一行,csv格式的文件第一行为列名
|
||
|
||
```
|
||
mongoimport --port 22400 -u "root" -p "123456" --authenticationDatabase "admin" -d test -c student --type csv --headerline --file /home/test.csv
|
||
```
|