上一篇文章：MongoDB 指南 —17、MapReduce
下一篇文章：

MongoDB 为在集合上执行基本的聚合任务提供了一些命令。这些命令在聚合框架出现之前就已经存在了，现在（大多数情况下）已经被聚合框架取代。然而，复杂的 group 操作可能仍然需要使用 JavaScript，count 和 distinct 操作可以被简化为普通命令，不需要使用聚合框架。

count

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

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

不论集合有多大，count 都会很快返回总的文档数量。
也可以给 count 传递一个查询文档，Mongo 会计算查询结果的数量：

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

对分页显示来说总数非常必要：“共 439 个，目前显示 0~10 个”。但是，增加查询条件会使 count 变慢。count 可以使用索引，但是索引并没有足够的元数据供 count 使用，所以不如直接使用查询来得快。

distinct

distinct 用来找出给定键的所有不同值。使用时必须指定集合和键。

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

假设集合中有如下文档：

{"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}

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

[{"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”，就能依据各种复杂的条件进行分组了。