MongoDB初级教程

/// https://www.runoob.com/mongodb/mongodb-aggregate.html

//use zxb1
/*
db.dropDatabase()     // { "dropped" : "zxb1", "ok" : 1 }
show dbs
*/
//db.collection.drop()
/*
db.createCollection("tb1")       // 创建表1 也就是collection
db.getCollection('tb1').find({}) // 查询表1

show tables    // tb1
db.tb1.drop()  // 删除表1 
*/

// 创建集合
// 使用 show collections 或 show tables 命令
/*
use zxb1
db.createCollection("tb2")             //创建表
db.tb3.insert({"name" : "菜鸟教程"})  // 创建表并写入数据

show collections  // tb1
show tables       //tb1
// 创建固定集合 mycol，整个集合空间大小 6142800 KB, 文档最大个数为 10000 个
db.createCollection("mytbl", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
capped   如true则创建固定集合，必须指定 size 参数。有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。
autoIndexId 如为 true，自动在 _id 字段创建索引。默认为 false。
size  数值 （可选）为固定集合指定一个最大值，以千字节计（KB）。
max   数值 （可选）指定固定集合中包含文档的最大数量。
*/
// db.collection.drop() //删除表
/*
use zxb1
show collections
show tables
db.mytbl.drop()
*/
//  使用 insert() 或 save() 方法向集合中插入文档
/*
db.COLLECTION_NAME.insert(document) 若插入的数据主键已经存在 提示主键重复，不保存当前数据。
或
db.COLLECTION_NAME.save(document)  // 如果 _id 主键存在则更新数据，如果不存在就插入数据 可以使用 db.collection.insertOne() 或 db.collection.replaceOne() 来代替。
db.collection.insertOne() 
db.collection.insertMany()
db.collection.insertOne()

db.tb3.insert({"name" : "菜鸟教程"})  // 创建表并写入数据
db.tb3.insertOne({"name" : "菜鸟教程"},{ w:1, j: true, wtimeout: 101 }) // writeConcern: document={ w:1, j: true, wtimeout: 101 }
//db.tb3.replaceOne({"name" : "菜鸟教程"})  
db.tb3.insertMany(
   [ {"name" : "菜鸟教程2"} ,{"name" : "菜鸟教程3"}, {"name" : "菜鸟教程4"}],
   {
      writeConcern: { w:1, j: true, wtimeout: 101 },
      ordered: true
   }
)
db.tb3.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
db.tb3.find();
document=({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
});
db.tb3.insert(document);
db.getCollection('tb3').find({})
db.tb3.save(document);

var arr = [];
for(var i=1 ; i<=5 ; i++){
    arr.push({num:i});
}
db.numbers.insert(arr);
*/

// MongoDB 查询文档
/*
db.collection.find(query, projection)
db.tb3.find().pretty();
db.tb3.findOne();
db.tb3.find({"by":"菜鸟教程"}).pretty();
db.tb3.find({"likes":{$lt:50}}).pretty();
db.tb3.find({"likes":{$lte:50}}).pretty();
db.tb3.find({"likes":{$gt:50}}).pretty();
db.tb3.find({"likes":{$gte:50}}).pretty();
db.tb3.find({"likes":{$ne:50}}).pretty();

查询 title 包含"教"字的文档：
db.col.find({title:/教/})
查询 title 字段以"教"字开头的文档：
db.col.find({title:/^教/})
查询 titl e字段以"教"字结尾的文档：
db.col.find({title:/教$/})

// db.col.find({key1:value1, key2:value2}).pretty()
db.tb3.find({"by":"菜鸟教程", "title":"MongoDB 教程"}).pretty()
// db.col.find({$or: [{key1: value1}, {key2:value2}]}).pretty()
db.tb3.find({$or:[{"by":"菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()
// AND 和 OR 联合使用    'where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')'
db.tb3.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()
// 其中projection中，入参格式为{columnA : 0/1,columnB : 0/1}
db.collection.find(query, {title: 1, by: 1}) // inclusion模式 指定返回的键，不返回其他键
db.collection.find(query, {title: 0, by: 0}) // exclusion模式 指定不返回的键,返回其他键
只能全1或全0，除了在inclusion模式时可以指定_id为0
db.collection.find(query, {_id:0, title: 1, by: 1}) // 正确
db.tb3.find({}, {title: 1})
db.tb3.find( {  qty: { $gt: 50 ,$lt: 80}} )    //qty 大于 50 小于 80
*/
// MongoDB 更新文档
/*
db.collection.update(
   ,
   ,
   {
     upsert: ,
     multi: ,
     writeConcern: 
   }
)
db.tb3.insert({
    title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
db.tb3.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
// 以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true
db.tb3.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}},{multi:true})
db.tb3.find().pretty()
db.collection.save(
   ,
   {
     writeConcern: 
   } 
)


db.tb3.save({
    "_id" : ObjectId("5f17d316b6ceaa87d290fc57"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "Runoob",
    "url" : "http://www.runoob.com",
    "tags" : [
            "mongodb",
            "NoSQL"
    ],
    "likes" : 110
})  
db.tb3.find({"_id" : ObjectId("5f17d316b6ceaa87d290fc57")}).pretty()

//只更新第一条记录：
db.col.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } );
//全部更新：
db.col.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true );
//只添加第一条：
db.col.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false );
//全部添加进去:
db.col.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true );
//全部更新：
db.col.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
//只更新第一条记录：
db.col.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

use zxb1
db.test_collection.insert( [
{"name":"abc","age":"25","status":"zxc"},
{"name":"dec","age":"19","status":"qwe"},
{"name":"asd","age":"30","status":"nmn"},
] )
db.test_collection.find().pretty()

db.test_collection.updateOne({"name":"abc"},{$set:{"age":"28"}})
db.test_collection.updateMany({"age":{$gt:"10"}},{$set:{"status":"xyz"}})

如果指定的字段不存在则操作不做任何处理。
db.tb3.update({"_id":"56064f89ade2f21f36b03136"}, {$unset:{ "test2" : "OK"}})
db.tb3.find()

如果数据不存在需要插入，设置 upsert:true 即可：
db.collection.update({'title':'MongoDB 教程'}, {$set: {'title':'MongoDB'}},{upsert:true})
*/

// MongoDB 删除文档
/*
// 在执行remove()函数前先执行find()命令来判断执行的条件是否正确，这是一个比较好的习惯。
db.collection.remove(
   ,
   
)
db.collection.remove(
   ,
   {
     justOne: ,
     writeConcern: 
   }
)
query :（可选）删除的文档的条件。
justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
writeConcern :（可选）抛出异常的级别。

db.tb3.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
db.tb3.remove({'title':'MongoDB 教程'})
只想删除第一条找到的记录可以设置 justOne 为 1，如下所示：
db.tb3.remove({'title':'MongoDB 教程'},1)
想删除所有数据，可以使用以下方式（类似常规 SQL 的 truncate 命令）：
db.tb3.remove({})

// 官方推荐使用 deleteOne() 和 deleteMany() 方法
如删除集合下全部文档：
db.tb3.deleteMany({})

删除 status 等于 A 的全部文档：
db.tb3.deleteMany({ status : "A" })

删除 status 等于 D 的一个文档：
db.tb3.deleteOne( { status: "D" } )

remove() 方法 并不会真正释放空间。
需要继续执行 db.repairDatabase() 来回收磁盘空间。
db.repairDatabase()
或者
db.runCommand({ repairDatabase: 1 })
*/

// $type 操作符
/*
类型                    数字   备注
Double                   1   
String                   2   
Object                   3   
Array                    4   
Binary data              5   
Undefined                6     已废弃。
Object id                7   
Boolean                  8   
Date                     9   
Null                     10  
Regular Expression       11  
JavaScript               13  
Symbol                   14  
JavaScript (with scope)  15  
32-bit integer           16  
Timestamp                17  
64-bit integer           18  
Min key                  255    Query with -1.
Max key                  127    

db.col.insert({
    title: 'PHP 教程', 
    description: 'PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['php'],
    likes: 200
})
db.col.insert({title: 'Java 教程', 
    description: 'Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['java'],
    likes: 150
})
db.col.insert({title: 123, 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb'],
    likes: 100
})
$type 实例
如果想获取 "col" 集合中 title 为 String 的数据，你可以使用以下命令：
db.col.find({"title" : {$type : 2}})
或
db.col.find({"title" : {$type : 'string'}})
/*

// Limit与Skip方法 
/*
db.col.find().limit(NUMBER)
db.col.find().limit(2)

db.col.insert( [
{ "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "php" ], "likes" : 200 }
,{ "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "java" ], "likes" : 150 }
,{ "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "mongodb" ], "likes" : 100 }
])

db.col.find({},{"title":1,_id:0}).limit(2)
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
db.col.find({},{"title":1,_id:0}).limit(1).skip(1)
db.col.find({},{"title":1,_id:0}).limit(1).skip(1)
想要读取从 10 条记录后 100 条记录，相当于 sql 中limit (10,100)
db.COLLECTION_NAME.find().skip(10).limit(100)  // 在集合中跳过前面 10 条返回 100 条数据。

db.test.sort({"amount":1}).skip(100000).limit(10)  //183ms
db.test.find({amount:{$gt:2399927}}).sort({"amount":1}).limit(10)  //53ms

var arr = [];
for(var i=1 ; i<=20000 ; i++){
    arr.push({num:i});
}
db.numbers.insert(arr);
db.numbers.find({$and:[{"num":{$lt:60}},{"num":{$gt:45}}]}).limit(7).skip(5);

*/

// sort() 方法
/*
db.COLLECTION_NAME.find().sort({KEY:1})  //  1:升序; -1:降序
db.col.find({},{"title":1,_id:0}).sort({"likes":-1})
kip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()。
*/

// MongoDB 索引 
/*
索引是对数据库表中一列或多列的值进行排序的一种结构
db.collection.createIndex(keys, options)
db.col.createIndex({"title":1}) /  1:升序; -1:降序
db.col.createIndex({"title":1,"description":-1})

// 在后台创建索引：
db.col.createIndex({open: 1, close: 1}, {background: true})

1、查看集合索引
db.col.getIndexes()

2、查看集合索引大小
db.col.totalIndexSize()

3、删除集合所有索引
db.col.dropIndexes()

4、删除集合指定索引
db.col.dropIndex("索引名称")

例如数据记录中 createDate 为日期类型时：

 设置时间180秒后自动清除。
 设置在创建记录后，180 秒左右删除。
db.col.createIndex({"createDate": 1},{expireAfterSeconds: 180})

由记录中设定日期点清除。
设置 A 记录在 2019 年 1 月 22 日晚上 11 点左右删除，A 记录中需添加 "ClearUpDate": new Date('Jan 22, 2019 23:00:00')，且 Index中expireAfterSeconds 设值为 0。
db.col.createIndex({"ClearUpDate": 1},{expireAfterSeconds: 0})
*/

// MongoDB 聚合
/*
用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。
db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
类似sql语句 
select by_user as _id, count(*) as num_tutorial from mycol group by by_user

按日、按月、按年、按周、按小时、按分钟聚合操作如下：
db.getCollection('m_msg_tb').aggregate(
[
    {$match:{m_id:10001,mark_time:{$gt:new Date(2017,8,0)}}},
    {$group: {
       _id: {$dayOfMonth:'$mark_time'},
        pv: {$sum: 1}
        }
    },
    {$sort: {"_id": 1}}
])

$dayOfYear: 返回该日期是这一年的第几天（全年 366 天）。
 $dayOfMonth: 返回该日期是这一个月的第几天（1到31）。
 $dayOfWeek: 返回的是这个周的星期几（1：星期日，7：星期六）。
 $year: 返回该日期的年份部分。
 $month： 返回该日期的月份部分（ 1 到 12）。
 $week： 返回该日期是所在年的第几个星期（ 0 到 53）。
 $hour： 返回该日期的小时部分。
 $minute: 返回该日期的分钟部分。
 $second: 返回该日期的秒部分（以0到59之间的数字形式返回日期的第二部分，但可以是60来计算闰秒）。
 $millisecond：返回该日期的毫秒部分（ 0 到 999）。
 $dateToString： { $dateToString: { format: , date: } }。
 
 当 match 条件和 group 同时存在时，顺序会影响检索结果，必须先写 match 在前面。
db.articles.aggregate([{$match:{score:{ $gt:70, $lte:90 }}},{$group:{_id: null,count:{$sum: 1 }}}]);
db.articles.aggregate([{$group:{_id: null,count:{$sum: 1 }}},{$match:{score:{ $gt:70,$lte:90 }}}]);

db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])

表达式    实例                                                                                     描述 
$sum      db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])  计算总和。 
$avg      db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])  计算平均值 
$min      db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])  获取集合中所有文档对应值得最小值。 
$max      db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])  获取集合中所有文档对应值得最大值。 
$push     db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])             在结果文档中插入值到一个数组中。  
$addToSet db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])        在结果文档中插入值到一个数组中，但不创建副本。 
$first    db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])     根据资源文档的排序获取第一个文档数据。  
$last     db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])       根据资源文档的排序获取最后一个文档数据  

$project： 修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
$match：   用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
$limit：   用来限制MongoDB聚合管道返回的文档数。
$skip：    在聚合管道中跳过指定数量的文档，并返回余下的文档。
$unwind：  将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
$group：   将集合中的文档分组，可用于统计结果。
$sort：    将输入文档排序后输出。
$geoNear： 输出接近某一地理位置的有序文档。

db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );
结果中就只还有_id,tilte和author三个字段了，默认情况下_id字段是被包含的，如果要想不包含_id话可以这样:
db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

2.$match实例
db.articles.aggregate( [
{ $match : { score : { $gt : 70, $lte : 90 } } },
{ $group: { _id: null, count: { $sum: 1 } } }
] );
$match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段$group管道操作符进行处理。

3.$skip实例
db.article.aggregate({ $skip : 5 });

use zxb1
db.col.aggregate([{$group : {_id : "$title", num_tutorial : {$sum : 1}}}])

按日、按月、按年、按周、按小时、按分钟聚合操作如下：
db.getCollection('m_msg_tb').aggregate(
[
    {$match:{m_id:10001,mark_time:{$gt:new Date(2017,8,0)}}},
    {$group: {
       _id: {$dayOfMonth:'$mark_time'},
        pv: {$sum: 1}
        }
    },
    {$sort: {"_id": 1}}
])

时间关键字如下：

$dayOfYear:     返回该日期是这一年的第几天（全年 366 天）。
$dayOfMonth:    返回该日期是这一个月的第几天（1到31）。
$dayOfWeek:     返回的是这个周的星期几（1：星期日，7：星期六）。
$year:          返回该日期的年份部分。
$month：        返回该日期的月份部分（ 1 到 12）。
$week：         返回该日期是所在年的第几个星期（ 0 到 53）。
$hour：         返回该日期的小时部分。
$minute:        返回该日期的分钟部分。
$second:        返回该日期的秒部分（以0到59之间的数字形式返回日期的第二部分，但可以是60来计算闰秒）。
$millisecond：  返回该日期的毫秒部分（ 0 到 999）。
$dateToString： { $dateToString: { format: , date: } }。

*/

// MongoDB 复制（副本集）
/*
1、关闭正在运行的MongoDB服务器。
现在我们通过指定 --replSet 选项来启动mongoDB。--replSet 基本语法格式如下：
mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

实例
mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0

启动一个名为rs0的MongoDB实例，其端口号为27017。
启动后打开命令提示框并连接上mongoDB服务。
在Mongo客户端使用命令rs.initiate()来启动一个新的副本集。
我们可以使用rs.conf()来查看副本集的配置
查看副本集状态使用 rs.status() 命令

进入Mongo客户端，并使用rs.add()方法来添加副本集的成员
rs.add() 命令基本语法格式如下：
rs.add(HOST_NAME:PORT)
rs.add("mongod1.net:27017")

判断当前运行的Mongo服务是否为主节点可以使用命令db.isMaster() 
*/

// MongoDB 分片
/*
Shard:
用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障

Config Server:
mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。

Query Routers:
前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用可以透明使用。

分片结构端口分布如下：

Shard Server 1：27020
Shard Server 2：27021
Shard Server 3：27022
Shard Server 4：27023
Config Server ：27100
Route Process： 40000

步骤一：启动Shard Server
   [root@100 /]# mkdir -p /www/mongoDB/shard/s0
   [root@100 /]# mkdir -p /www/mongoDB/shard/s1
   [root@100 /]# mkdir -p /www/mongoDB/shard/s2
   [root@100 /]# mkdir -p /www/mongoDB/shard/s3
   [root@100 /]# mkdir -p /www/mongoDB/shard/log
   [root@100 /]# /usr/local/mongoDB/bin/mongod --port 27020 --dbpath=/www/mongoDB/shard/s0 --logpath=/www/mongoDB/shard/log/s0.log --logappend --fork
   ....
   [root@100 /]# /usr/local/mongoDB/bin/mongod --port 27023 --dbpath=/www/mongoDB/shard/s3 --logpath=/www/mongoDB/shard/log/s3.log --logappend --fork

步骤二： 启动Config Server
   [root@100 /]# mkdir -p /www/mongoDB/shard/config
   [root@100 /]# /usr/local/mongoDB/bin/mongod --port 27100 --dbpath=/www/mongoDB/shard/config --logpath=/www/mongoDB/shard/log/config.log --logappend --fork
   可以像启动普通mongodb服务一样启动，不需要添加—shardsvr和configsvr参数。
   因为这两个参数的作用就是改变启动端口的，所以我们自行指定了端口就可以。

步骤三： 启动Route Process
   /usr/local/mongoDB/bin/mongos --port 40000 --configdb localhost:27100 --fork --logpath=/www/mongoDB/shard/log/route.log --chunkSize 500
   mongos启动参数中，chunkSize这一项是用来指定chunk的大小的，单位是MB，默认大小为200MB.
步骤四： 配置Sharding
   使用MongoDB Shell登录到mongos，添加Shard节点
    [root@100 shard]# /usr/local/mongoDB/bin/mongo admin --port 40000
       MongoDB shell version: 2.0.7
       connecting to: 127.0.0.1:40000/admin
    mongos> db.runCommand({ addshard:"localhost:27020" })
    mongos> db.runCommand({ addshard:"localhost:27029" })
    mongos> db.runCommand({ enablesharding:"test" }) #设置分片存储的数据库
    mongos> db.runCommand({ shardcollection: "test.log", key: { id:1,time:1}})


步骤五： 程序代码内无需太大更改，直接按照连接普通的mongo数据库那样，将数据库连接接入接口40000

1. 创建Sharding复制集 rs0
    # mkdir /data/log
    # mkdir /data/db1
    # nohup mongod --port 27020 --dbpath=/data/db1 --logpath=/data/log/rs0-1.log --logappend --fork --shardsvr --replSet=rs0 &

    # mkdir /data/db2
    # nohup mongod --port 27021 --dbpath=/data/db2 --logpath=/data/log/rs0-2.log --logappend --fork --shardsvr --replSet=rs0 &

    1.1 复制集rs0配置
        # mongo localhost:27020 
        # > rs.initiate({_id: 'rs0', members: [{_id: 0, host: 'localhost:27020'}, {_id: 1, host: 'localhost:27021'}]}) 
        # > rs.isMaster() #查看主从关系

2. 创建Sharding复制集 rs1
    # mkdir /data/db3
    # nohup mongod --port 27030 --dbpath=/data/db3 --logpath=/data/log/rs1-1.log --logappend --fork --shardsvr --replSet=rs1 &
    # mkdir /data/db4
    # nohup mongod --port 27031 --dbpath=/data/db4 --logpath=/data/log/rs1-2.log --logappend --fork --shardsvr --replSet=rs1 &

    2.1 复制集rs1配置
       # mongo localhost:27030
       > rs.initiate({_id: 'rs1', members: [{_id: 0, host: 'localhost:27030'}, {_id: 1, host: 'localhost:27031'}]})
       > rs.isMaster() #查看主从关系


3. 创建Config复制集 conf
    # mkdir /data/conf1
    # nohup mongod --port 27100 --dbpath=/data/conf1 --logpath=/data/log/conf-1.log --logappend --fork --configsvr --replSet=conf &
    # mkdir /data/conf2
    # nohup mongod --port 27101 --dbpath=/data/conf2 --logpath=/data/log/conf-2.log --logappend --fork --configsvr --replSet=conf &    
    
    3.1 复制集conf配置       
       # mongo localhost:27100
       > rs.initiate({_id: 'conf', members: [{_id: 0, host: 'localhost:27100'}, {_id: 1, host: 'localhost:27101'}]})
       > rs.isMaster() #查看主从关系

4. 创建Route
    # nohup mongos --port 40000 --configdb conf/localhost:27100,localhost:27101 --fork --logpath=/data/log/route.log --logappend & 

    4.1 设置分片   
       # mongo localhost:40000
       > use admin
       > db.runCommand({ addshard: 'rs0/localhost:27020,localhost:27021'})
       > db.runCommand({ addshard: 'rs1/localhost:27030,localhost:27031'})
       > db.runCommand({ enablesharding: 'test'})
       > db.runCommand({ shardcollection: 'test.user', key: {name: 1}})   

*/
// MongoDB 备份(mongodump)与恢复(mongorestore)

/*
mongodump命令脚本语法如下：
   >mongodump -h dbhost -d dbname -o dbdirectory

    -h：MongDB所在服务器地址，例如：127.0.0.1，当然也可以指定端口号：127.0.0.1:27017
    -d：需要备份的数据库实例，例如：test
    -o：备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，
        系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据。

在本地使用 27017 启动你的mongod服务。打开命令提示符窗口，进入MongoDB安装目录的bin目录输入命令mongodump:
> mongodump
执行以上命令后，客户端会连接到ip为 127.0.0.1 端口号为 27017 的MongoDB服务上，并备份所有数据到 bin/dump/ 目录中

mongodump 命令可选参数列表如下所示：

语法                                                描述                           实例
mongodump --host HOST_NAME --port PORT_NUMBER       该命令将备份所有MongoDB数据    mongodump --host runoob.com --port 27017
mongodump --dbpath DB_PATH --out BACKUP_DIRECTORY                                  mongodump --dbpath /data/db/ --out /data/backup/
mongodump --collection COLLECTION --db DB_NAME      该命令将备份指定数据库的集合。 mongodump --collection mycol --db test

mongodb使用 mongorestore 命令来恢复备份的数据。

mongorestore命令脚本语法如下：
>mongorestore -h <:port> -d dbname 
--host <:port>, -h <:port>： MongoDB所在服务器地址，默认为： localhost:27017
--db , -d ： 需要恢复的数据库实例，例如：test，当然这个名称也可以和备份时候的不一样，比如test2
--drop：恢复的时候，先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！

：mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。
        你不能同时指定  和 --dir 选项，--dir也可以设置备份目录。

--dir：指定备份的目录
       你不能同时指定  和 --dir 选项。

*/

// MongoDB 监控
/*
mongostat 和 mongotop 两个命令来监控MongoDB的运行情况。
如果你发现数据库突然变慢或者有其他问题的话，你第一手的操作就考虑采用mongostat来查看mongo的状态。

进入到你安装的MongoDB目录下的bin目录， 然后输入mongostat命令

> D:\set up\mongodb\bin>mongostat

查看哪些大量的时间花费在读取和写入数据。 
mongotop提供每个集合的水平的统计数据。默认情况下，mongotop返回值的每一秒。
启动你的Mongod服务，进入到你安装的MongoDB目录下的bin目录， 然后输入mongotop命令
> D:\set up\mongodb\bin>mongotop

> E:\mongodb-win32-x86_64-2.2.1\bin>mongotop 10
  后面的10是参数 ，可以不使用，等待的时间长度，以秒为单位，
  mongotop等待调用之间。通过的默认mongotop返回数据的每一秒。 

> E:\mongodb-win32-x86_64-2.2.1\bin>mongotop --locks
  报告每个数据库的锁的使用中，使用mongotop - 锁，这将产生以下输出：

输出结果字段说明：
   ns：   包含数据库命名空间，后者结合了数据库名称和集合。
   db：   包含数据库的名称。名为 . 的数据库针对全局锁定，而非特定数据库。
   total：mongod花费的时间工作在这个命名空间提供总额。
   read： 提供了大量的时间，这mongod花费在执行读操作，在此命名空间。
   write：提供这个命名空间进行写操作，这mongod花了大量的时间。
*/