MongoDB 三大利器 TTL, Gridfs, MapRed

一、 Time To Live(TTL) 集合

MongoDB 2.2 引入一个新特性--TTL 集合，TTL集合支持失效时间设置，当超过指定时间后，
集合自动清除超时文档，者用来保存一个诸如session会话信息的时候非常有用。

如果想使用TTL集合，用用到 expireAfterSeconds 选项

  db.ttl.ensureIndex({ "date": new Date() }, { expireAfterSeconds: 3000 })

限制

+ 你不能创建TTL索引，如果要索引的字段已经在其他索引中使用。

+ 索引不能包含多个字段。

+ 索引的字段必须是一个日期的 bson 类型。

如果违反了上述三个规则，那么超时后文档不会被自动清除。

MongoDB 后台进程会实时跟踪过去的文档并删除.

首先我们创建一个索引设置10秒钟后失效：

```
  db.ttl_collection.ensureIndex( { "Date": 1 }, { expireAfterSeconds: 10 } )
```

```
  db.ttl_collection.insert({"Date" : new Date()})
```

因为我们想象该文档会在10秒后删除，但是实际情况并不是如此的。
因为 mongod 后台任务每分钟检查一次过期文档，因此在事件的处理上总是由一定差异，
但这个差异不会超过1分钟，这也取决于 MongoDB 实例当前的负荷情况。

你还可以为已存在的集合设置TTL索引。

能否组织文档白删除？

+ 文档被删除之前更新TTL字段。
+ 为 TTL 字段设置一个非日期类型的值。

二、 Gridfs

GridFS 用于存储和恢复哪些超过16M(BSON文件限制)的文件(如：图片，音频，视频等)
GridFS 也是文件存储的一种方式，但是它是存储在MongoDB的集合中。
GridFS 可以更好的存储大于16M的文件。
GridFS 会将大文件对象分隔成多个小的chunk(文件片段)，一般为256k/个，每个chunk将
作为MongoDB的一个文档(document)被存储在chunks集合中。
GridFS 用两个集合来存储一个文件：fs.files 和 fs.chunks

下面是简单的fs.files集合文档

  {
    "filename": "test.txt",
    "chunkSize": NumberInt(261120),
    "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
    "md5": "7b762939321e146569b07f72c62cca4f",
    "length": NumberInt(646)
  }

以下是简单的fs.chunks集合文档

  {
    "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
    "n": NumberInt(0),
    "data": "Mongo Binary Data"
  }

列出所有文件：

  mongofiles list

上传一个文件：

  mongofiles put xxx.txt

下载一个文件：

  mongofiles get xxx.txt

查找文件：

  mongofiles search xxx  // 会查找所有文件名包含 "xxx"的文件
  mongofiles list xxx    // 会查找所有文件名以 "xxx"为前缀的文件

参数说明：

-d 指定数据库，默认是fs
-u 用户名 -p 密码
-h 指定主机
-port 指定主机端口

上传，检索，下载一个文档

  mongofiles  put high_performance_mysql.pdf
  mongofiles  list high_performance_mysql.pdf
  mongofiles  get high_performance_mysql

三、 MapReduce

MapReduce 使用JavaScript作为“查询语言”。因此它能够表达
任意复杂的逻辑。然而，这种强大是有代价的：MapReduce非常慢，
不应该实时的数据分析中

MapReduce能够在多态服务器之间并行执行。它会将一个大问题分隔为多个小
问题，将各个小问题发送到不同的机器上，每台机器只负责完成一部分工作。
所有机器都完成时，将这些零碎的解决方案合并称为一个完整的解决方案。

MapReduce 需要几个步骤。

• 映射(map)
  将操作映射到集合中的每个文档。这个操作要么“无作为”，要么“产生一些键和X个值”。

• 洗牌(shuffle)
  按照键分组，并将产生的键值组成列表放到对应的键中。

• 化简(reduce)
  把列表中的值化简成一个单值。这个值被返回，然后接着进行洗牌，直到每个键的列表只有
  一个值为止，这个值也就是最终的结果。

** 创造基础数据 **

  for(var i=0; i< 100; i++){
    db.t.insert(
      {
         _id: i,
         "name": "user_"+i,
         "age" : NumberInt(Math.random() * 10)
         })
  }

  > db.t.find()
  { "_id" : 0, "name" : "user_0", "age" : 5 }
  { "_id" : 1, "name" : "user_1", "age" : 9 }
  { "_id" : 2, "name" : "user_2", "age" : 8 }
  { "_id" : 3, "name" : "user_3", "age" : 4 }
  { "_id" : 4, "name" : "user_4", "age" : 0 }
  { "_id" : 5, "name" : "user_5", "age" : 7 }
  { "_id" : 6, "name" : "user_6", "age" : 3 }
  { "_id" : 7, "name" : "user_7", "age" : 8 }
  { "_id" : 8, "name" : "user_8", "age" : 7 }
  { "_id" : 9, "name" : "user_9", "age" : 8 }
  { "_id" : 10, "name" : "user_10", "age" : 9 }
  { "_id" : 11, "name" : "user_11", "age" : 3 }
  { "_id" : 12, "name" : "user_12", "age" : 8 }
  { "_id" : 13, "name" : "user_13", "age" : 0 }
  { "_id" : 14, "name" : "user_14", "age" : 7 }
  { "_id" : 15, "name" : "user_15", "age" : 8 }
  { "_id" : 16, "name" : "user_16", "age" : 4 }
  { "_id" : 17, "name" : "user_17", "age" : 7 }
  { "_id" : 18, "name" : "user_18", "age" : 5 }
  { "_id" : 19, "name" : "user_19", "age" : 2 }
  Type "it" for more

** 统计age相同的名字 **

var map = function(){
  emit(this.age, this.name);
};

var reduce = function(key, values){
  var ret={ age: key, names: values };
  return ret;
};

var finalize = function(key, rval){
  if(key == 0){
    rval.msg = "a new life, baby!";
  }
  return rval;
};

db.runCommand({
  mapreduce: "t",
  map: map,
  reduce: reduce,
  finalize: finalize,
  out: "t_age_names"
});

> db.t_age_names.findOne({ _id: 0 })
{
    "_id" : 0,
    "value" : {
        "age" : 0,
        "names" : [
            "user_4",
            "user_13",
            "user_27",
            "user_30",
            "user_48",
            "user_55",
            "user_59",
            "user_63",
            "user_64",
            "user_67",
            "user_70",
            "user_74",
            "user_75",
            "user_95"
        ],
        "msg" : "a new life, baby!"
    }
};

age为0 的数据个数为14个。

> db.t_age_names.findOne({ _id: 1 })
{
    "_id" : 1,
    "value" : {
        "age" : 1,
        "names" : [
            "user_25",
            "user_28",
            "user_32",
            "user_54",
            "user_61",
            "user_85"
        ]
    }
}

age为1的数据个数为6个。

> db.t_age_names.findOne({ _id: 9 })
{
    "_id" : 9,
    "value" : {
        "age" : 9,
        "names" : [
            "user_1",
            "user_10",
            "user_40",
            "user_78",
            "user_97"
        ]
    }
}

age 为9的数据个数为5个。

** 检测 age 相同的个数 **

  var count_map = function(){
    emit(this.age, 1);
  };

  var count_reduce = function(key, values){
    total = 0;
    for(var i in  values ){
      total += 1;
    }
    return { age: key, total: total }
  };

  db.runCommand({
    mapreduce: "t",
    map: count_map,
    reduce: count_reduce,
    out: "t_age_count"
  });

  {
    "result" : "t_age_count",
    "timeMillis" : 5,
    "counts" : {
        "input" : 100,
        "emit" : 100,
        "reduce" : 10,
        "output" : 10
    },
    "ok" : 1
  }

input 其中input 表示发送到map函数的文档个数。
emit 在map函数中emit 被调用的次数。
output 结果集合中的文档数量。

最终统计结果如下

  > db.t_age_count.find()
  { "_id" : 0, "value" : { "age" : 0, "total" : 14 } }
  { "_id" : 1, "value" : { "age" : 1, "total" : 6 } }
  { "_id" : 2, "value" : { "age" : 2, "total" : 11 } }
  { "_id" : 3, "value" : { "age" : 3, "total" : 7 } }
  { "_id" : 4, "value" : { "age" : 4, "total" : 16 } }
  { "_id" : 5, "value" : { "age" : 5, "total" : 11 } }
  { "_id" : 6, "value" : { "age" : 6, "total" : 10 } }
  { "_id" : 7, "value" : { "age" : 7, "total" : 12 } }
  { "_id" : 8, "value" : { "age" : 8, "total" : 8 } }
  { "_id" : 9, "value" : { "age" : 9, "total" : 5 } }

** MapReduce 可选键 **

• finalize: function

  可以将reduce的结果发送给这个键，这是整个处理过程的最后一步。

• keeptmp：boolean

  如果值为true，那么在连接关闭时会将临时结果集合保存下来，否则不保存。

• out：string

  输出集合的名称。如果设置了这选项，系统会自动设置keeptemp: true

• query: document

  在发往map函数前，先用指定条件过滤文档。

• sort：document

  在发往map前先给文档排序(与Limit 一同使用非常有用)

• limit: integer

  发往map函数的文档数量的上限

• scope: document

  可以在JavaScript代码中使用的变量

• verbose: boolean

  是否记录详细的服务器日志