MongoDB中的聚合操作

根據MongoDB的文檔描述，在MongoDB的聚合操作中，有以下五個聚合命令。

其中，count、distinct和group會提供很基本的功能，至於其他的高級聚合功能（sum、average、max、min），就需要通過mapReduce來實現了。

在MongoDB2.2版本以后，引入了新的聚合框架（聚合管道，aggregation pipeline ，使用aggregate命令），是一種基於管道概念的數據聚合操作。

Name	Description
count	Counts the number of documents in a collection.
distinct	Displays the distinct values found for a specified key in a collection.
group	Groups documents in a collection by the specified key and performs simple aggregation.
mapReduce	Performs map-reduce aggregation for large data sets.
aggregate	Performs aggregation tasks such as group using the aggregation framework.

下面就開始對這些聚合操作進行介紹，所有的測試數據都是基於上一篇文章。

 

count

首先，我們看下MongoDB文檔中，count命令可以支持的選項：

{ count: <collection>, query: <query>, limit: <limit>, skip: <skip>, hint: <hint> }

• count：要執行count的collection
• query(optional)：過濾條件
• limit(optional)：查詢匹配文檔數量的上限
• skip(optional)：跳過匹配文檔的數量
• hint(optional)：使用那個索引

例子：查看男學生的數量

> db.runCommand({"count":"school.students", "query":{"gender":"Male"}})
{ "n" : 5, "ok" : 1 }
>

在MongoDB中，對count操作有一層包裝，所以也可以通過shell直接運行db."collectionName".count()。

但是為了保持風格一致，我還是傾向於使用db.runCommand()的方式。

 

distinct

接下來看看distinct命令，下面列出可以支持的選項：

{ distinct: "<collection>", key: "<field>", query: <query> }

• distinct：要執行distinct的collection
• key：要執行distinct的鍵
• query(optional)：過濾條件

例子：查看所有學生年齡的不同值

> db.runCommand({"distinct":"school.students","key":"age"})
{
        "values" : [
                20,
                21,
                22,
                23,
                24
        ],
        "stats" : {
                "n" : 10,
                "nscanned" : 10,
                "nscannedObjects" : 0,
                "timems" : 0,
                "cursor" : "BtreeCursor age_1"
        },
        "ok" : 1
}

 

group

group命令相比前兩就稍微復雜了一些。

{
  group:
   {
     ns: <namespace>,
     key: <key>,
     $reduce: <reduce function>,
     initial: 
     $keyf: <key function>,
     cond: <query>,
     finalize: <finalize function>
   }
}

 

• ns：要執行group的collection
• key：要執行group的鍵，可以是多個鍵；和keyf兩者必須有一個
• $reduce：在group操作中要執行的聚合function，該function包括兩個參數，當前文檔和聚合結果文檔
• initial：reduce中使用變量的初始化
• $keyf(optional)：可以接受一個function，用來動態的確定分組文檔的字段
• cond(optional)：過濾條件
• finalize(optional)：在reduce執行完成，結果集返回之前對結果集最終執行的函數

例子：統計不同年齡、性別分組的學生數量

> db.runCommand({
...     "group":{
...         "ns":"school.students",
...         "key":{"age":true, "gender":true},
...         "initial":{"count":0},
...         "$reduce": function(cur, result){ result.count++;},
...         "cond":{"age":{"$lte":22}}
...     }
... })
{
        "retval" : [
                {
                        "age" : 20,
                        "gender" : "Female",
                        "count" : 2
                },
                {
                        "age" : 20,
                        "gender" : "Male",
                        "count" : 1
                },
                {
                        "age" : 21,
                        "gender" : "Male",
                        "count" : 2
                },
                {
                        "age" : 22,
                        "gender" : "Female",
                        "count" : 1
                }
        ],
        "count" : 6,
        "keys" : 4,
        "ok" : 1
}
>

通過finalize選項，可以在結果返回之前進行一些自定義設置。

> db.runCommand({
...     "group":{
...         "ns":"school.students",
...         "key":{"age":true, "gender":true},
...         "initial":{"count":0},
...         "$reduce": function(cur, result){
...                             result.count++;
...                         },
...         "cond":{"age":{"$lte":22}},
...         "finalize": function(result){
...                             result.percentage = result.count/10;
...                             delete result.count;
...                         }
...     }
... })
{
        "retval" : [
                {
                        "age" : 20,
                        "gender" : "Female",
                        "percentage" : 0.2
                },
                {
                        "age" : 20,
                        "gender" : "Male",
                        "percentage" : 0.1
                },
                {
                        "age" : 21,
                        "gender" : "Male",
                        "percentage" : 0.2
                },
                {
                        "age" : 22,
                        "gender" : "Female",
                        "percentage" : 0.1
                }
        ],
        "count" : 6,
        "keys" : 4,
        "ok" : 1
}
>

 

mapReduce

前面三個聚合操作提供了最基本的功能，如果要用到更加復雜的聚合操作，我們就需要自己通過mapReduce來實現了。

mapReduce更重要的用法是實現多個服務器上的聚合操作。

根據MongoDB文檔，得到mapReduce的原型如下：

{
    mapReduce: <collection>,
    map: <function>,
    reduce: <function>,
    out: <output>,
    query(optional): <document>,
    sort(optional): <document>,
    limit(optional): <number>,
    finalize(optional): <function>,
    scope(optional): <document>,
    jsMode(optional): <boolean>,
    verbose(optional): <boolean>
}

• mapReduce：要執行map-reduce操作的collection
• map：map function，生成鍵/值對，可以理解為映射函數
• reduce：reduce function，對map的結果進行統計，可以理解為統計函數
• out：統計結果存放集合 (不指定則使用臨時集合,在客戶端斷開后自動刪除)
• query：過濾條件
• sort：排序條件
• limit：map函數可以接受的文檔數量的最大值
• finalize：在reduce執行完成后，結果集返回之前對結果集最終執行的函數
• scope：向 map、reduce、finalize 導入外部變量
• jsMode：設置是否把map和reduce的中間數據轉換成BSON格式
• verbose：設置是否顯示詳細的時間統計信息

注意：map、reduce和finalize的函數實現都有特定的要求，具體的要求請參考MongoDB文檔

例子：

查詢男生和女生的最大年齡

> db.runCommand({
...     "mapReduce": "school.students",
...     "map": function(){
...                     emit({gender: this.gender}, this.age);
...                 },
...     "reduce": function(key, values){
...                         var max = 0;
...                         for(var i = 0; i < values.length; i++)
...                             max = max>values[i]?max:values[i];
...                         return max;
...                    },
...     "out": {inline: 1},
...
... })
{
        "results" : [
                {
                        "_id" : {
                                "gender" : "Female"
                        },
                        "value" : 24
                },
                {
                        "_id" : {
                                "gender" : "Male"
                        },
                        "value" : 24
                }
        ],
        "timeMillis" : 2,
        "counts" : {
                "input" : 10,
                "emit" : 10,
                "reduce" : 2,
                "output" : 2
        },
        "ok" : 1
}
>

 

分別得到男生和女生的平均年齡

> db.runCommand({
...     "mapReduce": "school.students",
...     "map": function(){
...                     emit({gender: this.gender}, this.age);
...                 },
...     "reduce": function(key, values){
...                         var result = {"total": 0, "count": 0};
...                         for(var i = 0; i < values.length; i++)
...                             result.total += values[i];
...                         result.count = values.length;
...                         return result;
...                    },
...     "out": {inline: 1},
...     "finalize": function(key, reducedValues){
...                         return reducedValues.total/reducedValues.count;
...                    }
... })
{
        "results" : [
                {
                        "_id" : {
                                "gender" : "Female"
                        },
                        "value" : 22
                },
                {
                        "_id" : {
                                "gender" : "Male"
                        },
                        "value" : 21.8
                }
        ],
        "timeMillis" : 55,
        "counts" : {
                "input" : 10,
                "emit" : 10,
                "reduce" : 2,
                "output" : 2
        },
        "ok" : 1
}
>

 

小技巧：關於自定義js函數

在MongoDB中，可以通過db.system.js.save命令（其中system.js是一個存放js函數的collections）來創建並保存JavaScript函數，這樣在就可以在MongoDB shell中重用這些函數。

比如，下面兩個函數是網上網友實現的

SUM	db.system.js.save( { _id : "Sum" , value : function(key,values) { var total = 0; for(var i = 0; i < values.length; i++) total += values[i]; return total; }});
AVERAGE	db.system.js.save( { _id : "Avg" , value : function(key,values) { var total = Sum(key,values); var mean = total/values.length; return mean; }});

 

通過利用上面兩個函數，我們的"分別得到男生和女生的平均年齡"例子就可以通過以下方式實現。

這個例子中，我們還特殊設置了"out"選項，把返回值存入了"average_age"這個collection中。

> db.runCommand({
...     "mapReduce": "school.students",
...     "map": function(){
...                     emit({gender: this.gender}, this.age);
...                 },
...     "reduce": function(key, values){
...                         avg = Avg(key, values);
...                         return avg;
...                    },
...     "out": {"merge": "average_age"}
... })
{
        "result" : "average_age",
        "timeMillis" : 30,
        "counts" : {
                "input" : 10,
                "emit" : 10,
                "reduce" : 2,
                "output" : 2
        },
        "ok" : 1
}
>

 

通過以下命令，我們可以看到新增的collection，並且查看里面的內容。

> show collections
average_age
school.students
system.indexes
system.js
>
> db.average_age.find()
{ "_id" : { "gender" : "Female" }, "value" : 22 }
{ "_id" : { "gender" : "Male" }, "value" : 21.8 }
>
> db.system.js.find()
{ "_id" : "Sum", "value" : function (key,values)
{
    var total = 0;
    for(var i = 0; i < values.length; i++)
        total += values[i];
    return total;
} }
{ "_id" : "Avg", "value" : function (key,values)
{
    var total = Sum(key,values);
    var mean = total/values.length;
    return mean;
} }
>

 

總結

通過這篇文章，介紹了MongoDB中count、distinct、group和mapReduce的基本使用。沒有一次把所有的聚合操作都看完，聚合管道只能放在下一次了。

Ps: 文章中使用的例子可以通過以下鏈接查看

http://files.cnblogs.com/wilber2013/aggregation.js