MongoDB指南---1八、聚合命令

上一篇文章: MongoDB指南---1七、MapReduce
下一篇文章:

MongoDB为在集合上执行基本的聚合任务提供了一些命令。这些命令在聚合框架出现以前就已经存在了,如今(大多数状况下)已经被聚合框架取代。然而,复杂的group操做可能仍然须要使用JavaScript,count和distinct操做能够被简化为普通命令,不须要使用聚合框架。php

 count

count是最简单的聚合工具,用于返回集合中的文档数量:python

> db.foo.count()
0
> db.foo.insert({"x" : 1})
> db.foo.count()
1

不论集合有多大,count都会很快返回总的文档数量。
也能够给count传递一个查询文档,Mongo会计算查询结果的数量:sql

> db.foo.insert({"x" : 2})
> db.foo.count()
2
> db.foo.count({"x" : 1})
1

对分页显示来讲总数很是必要:“共439个,目前显示0~10个”。可是,增长查询条件会使count变慢。count可使用索引,可是索引并无足够的元数据供count使用,因此不如直接使用查询来得快。mongodb

 distinct

distinct用来找出给定键的全部不一样值。使用时必须指定集合和键。数据库

> db.runCommand({"distinct" : "people", "key" : "age"})

假设集合中有以下文档:segmentfault

{"name" : "Ada", "age" : 20}
{"name" : "Fred", "age" : 35}
{"name" : "Susan", "age" : 60}
{"name" : "Andy", "age" : 35}

若是对"age"键使用distinct,会获得全部不一样的年龄:数组

> db.runCommand({"distinct" : "people", "key" : "age"})
{"values" : [20, 35, 60], "ok" : 1}

这里还有一个常见问题:有没有办法得到集合里面全部不一样的键呢?MongoDB并无直接提供这样的功能,可是能够用MapReduce(详见7.3节)本身写一个。服务器

group

使用group能够执行更复杂的聚合。先选定分组所依据的键,然后MongoDB就会将集合依据选定键的不一样值分红若干组。而后能够对每个分组内的文档进行聚合,获得一个结果文档。
若是你熟悉SQL,那么这个group和SQL中的GROUP BY差很少。
假设如今有个跟踪股票价格的站点。从上午10点到下午4点每隔几分钟就会更新某只股票的价格,并保存在MongoDB中。如今报表程序要得到近30天的收盘价。用group就能够轻松办到。
股价集合中包含数以千计以下形式的文档:框架

{"day" : "2010/10/03", "time" : "10/3/2010 03:57:01 GMT-400", "price" : 4.23}
{"day" : "2010/10/04", "time" : "10/4/2010 11:28:39 GMT-400", "price" : 4.27}
{"day" : "2010/10/03", "time" : "10/3/2010 05:00:23 GMT-400", "price" : 4.10}
{"day" : "2010/10/06", "time" : "10/6/2010 05:27:58 GMT-400", "price" : 4.30}
{"day" : "2010/10/04", "time" : "10/4/2010 08:34:50 GMT-400", "price" : 4.01}

注意,因为精度的问题,实际使用中不要将金额以浮点数的方式存储,这个例子只是为了简便才这么作。
咱们须要的结果列表中应该包含天天的最后交易时间和价格,就像下面这样:nosql

[
    {"time" : "10/3/2010 05:00:23 GMT-400", "price" : 4.10},
    {"time" : "10/4/2010 11:28:39 GMT-400", "price" : 4.27},
    {"time" : "10/6/2010 05:27:58 GMT-400", "price" : 4.30}
]

先把集合按照"day"字段进行分组,而后在每一个分组中查找"time"值最大的文档,将其添加到结果集中就完成了。整个过程以下所示:

> db.runCommand({"group" : {
... "ns" : "stocks",
... "key" : "day",
... "initial" : {"time" : 0},
... "$reduce" : function(doc, prev) {
...     if (doc.time > prev.time) {
...         prev.price = doc.price;
...         prev.time = doc.time;
...     }
... }}})

把这个命令分解开看看。

  • "ns" : "stocks"

指定要进行分组的集合。

  • "key" : "day"

指定文档分组依据的键。这里就是"day"键。全部"day"值相同的文档被分到一组。

  • "initial" : {"time" : 0}

每一组reduce函数调用中的初始"time"值,会做为初始文档传递给后续过程。每一组的全部成员都会使用这个累加器,因此它的任何变化均可以保存下来。

  • "$reduce" : function(doc, prev) { ... }

这个函数会在集合内的每一个文档上执行。系统会传递两个参数:当前文档和累加器文档(本组当前的结果)。本例中,想让reduce函数比较当前文档的时间和累加器的时间。若是当前文档的时间更晚一些,则将累加器的日期和价格替换为当前文档的值。别忘了,每一组都有一个独立的累加器,因此没必要担忧不一样日期的命令会使用同一个累加器。

在问题一开始的描述中,就提到只要最近30天的股价。然而,咱们在这里迭代了整个集合。这就是要添加"condition"的缘由,由于这样就能够只对必要的文档进行处理。

> db.runCommand({"group" : {
... "ns" : "stocks",
... "key" : "day",
... "initial" : {"time" : 0},
... "$reduce" : function(doc, prev) {
...     if (doc.time > prev.time) {
...            prev.price = doc.price;
...         prev.time = doc.time;
...     }},
... "condition" : {"day" : {"$gt" : "2010/09/30"}}
... }})

有些参考资料说起"cond"键或者"q"键,其实和"condition"键是彻底同样的(就是表达力不如"condition"好)。
最后就会返回一个包含30个文档的数组,其实每一个文档都是一个分组。每组都包含分组依据的键(这里就是"day" : string)以及这组最终的prev值。若是有的文档不存在指定用于分组的键,这些文档会被单独分为一组,缺失的键会使用"day : null"这样的形式。在"condition"中加入"day" : {"$exists" : true}就能够排除不包含指定用于分组的键的文档。group命令同时返回了用到的文档总数和"key"的不一样值数量:

> db.runCommand({"group" : {...}})
{
    "retval" :
        [
            {
                "day" : "2010/10/04",
                "time" : "Mon Oct 04 2010 11:28:39 GMT-0400 (EST)"
                "price" : 4.27
            },
            ...
        ],
    "count" : 734,
    "keys" : 30,
    "ok" : 1
}

这里每组的"price"都是显式设置的,"time"先由初始化器设置,而后在迭代中进行更新。"day"是默认被加进去的,由于用于分组的键会默认加入到每一个"retval"内嵌文档中。要是不想在结果集中看到这个键,能够用完成器将累加器文档变为任何想要的形态,甚至变换成非文档(例如数字或字符串)。

1. 使用完成器

完成器(finalizer)用于精简从数据库传到用户的数据,这个步骤很是重要,由于group命令的输出结果须要可以经过单次数据库响应返回给用户。为进一步说明,这里举个博客的例子,其中每篇文章都有多个标签(tag)。如今要找出天天最热门的标签。能够(再一次)按天分组,获得每个标签的计数。就像下面这样:

> db.posts.group({
... "key" : {"day" : true},
... "initial" : {"tags" : {}},
... "$reduce" : function(doc, prev) {
...     for (i in doc.tags) {
...         if (doc.tags[i] in prev.tags) {
...             prev.tags[doc.tags[i]]++;
...         } else {
...             prev.tags[doc.tags[i]] = 1;
...         }
...     }
... }})

获得的结果以下所示:

[
    {"day" : "2010/01/12", "tags" : {"nosql" : 4, "winter" : 10, "sledding" : 2}},
    {"day" : "2010/01/13", "tags" : {"soda" : 5, "php" : 2}},
    {"day" : "2010/01/14", "tags" : {"python" : 6, "winter" : 4, "nosql": 15}}
]

接着能够在客户端找出"tags"文档中出现次数最多的标签。然而,向客户端发送天天全部的标签文档须要许多额外的开销——天天全部的键/值对都被传送给用户,而咱们须要的仅仅是一个字符串。这也就是group有一个可选的"finalize"键的缘由。"finalize"能够包含一个函数,在每组结果传递到客户端以前调用一次。可使用"finalize"函数将不须要的内容从结果集中移除:

> db.runCommand({"group" : {
... "ns" : "posts",
... "key" : {"day" : true},
... "initial" : {"tags" : {}},
... "$reduce" : function(doc, prev) {
...     for (i in doc.tags) {
...         if (doc.tags[i] in prev.tags) {
...             prev.tags[doc.tags[i]]++;
...         } else {
...             prev.tags[doc.tags[i]] = 1;
...         }
...     },
... "finalize" : function(prev) {
...     var mostPopular = 0;
...     for (i in prev.tags) {
...         if (prev.tags[i] > mostPopular) {
...             prev.tag = i;
...             mostPopular = prev.tags[i];
...         }
...     }
...     delete prev.tags
... }}})

如今,咱们就获得了想要的信息,服务器返回的内容可能以下:

[
    {"day" : "2010/01/12", "tag" : "winter"},
    {"day" : "2010/01/13", "tag" : "soda"},
    {"day" : "2010/01/14", "tag" : "nosql"}
]

finalize能够对传递进来的参数进行修改,也能够返回一个新值。

2. 将函数做为键使用

有时分组所依据的条件可能会很是复杂,而不是单个键。好比要使用group计算每一个类别有多少篇博客文章(每篇文章只属于一个类别)。因为不一样做者的风格不一样,填写分类名称时可能有人使用大写也有人使用小写。因此,若是要是按类别名来分组,最后“MongoDB”和“mongodb”就是两个彻底不一样的组。为了消除这种大小写的影响,就要定义一个函数来决定文档分组所依据的键。
定义分组函数就要用到$keyf键(注意不是"key"),使用"$keyf"的group命令以下所示:

> db.posts.group({"ns" : "posts",
... "$keyf" : function(x) { return x.category.toLowerCase(); },
... "initializer" : ... })

有了"$keyf",就能依据各类复杂的条件进行分组了。

相关文章
相关标签/搜索