美文网首页程序员
MongoDB 三大利器 TTL, Gridfs, MapRed

MongoDB 三大利器 TTL, Gridfs, MapRed

作者: AQ王浩 | 来源:发表于2015-10-12 15:52 被阅读3534次

    一、 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

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

    相关文章

      网友评论

        本文标题:MongoDB 三大利器 TTL, Gridfs, MapRed

        本文链接:https://www.haomeiwen.com/subject/sslocttx.html