标签：返回 聚合 MongoDB Aggregation 管道 文档 id 表达式

聚合操作处理数据记录并返回计算结果。将来自多个文档的操作组值聚合在一起，并可以对分组的数据执行各种操作以返回单个结果。MongoDB提供了三种执行聚合的方法:聚合管道、map-reduce函数和单一用途的聚合方法。

一、聚合管道

聚合管道是基于数据处理管道概念建模的数据聚合框架。文档进入一个多阶段的管道，该管道将文档转换为聚合的结果。例如:

例子：

db.orders.aggregate([
   { $match: { status: "A" } },
   { $group: { _id: "$cust_id", total: { $sum: "$amount" } } }
])

第一阶段:$match阶段根据状态字段筛选文档，并将状态等于“A”的文档传递到下一阶段。
第二阶段:$group阶段根据cust_id字段对文档进行分组，以计算每个惟一的cust_id的金额总和。

1.管道

MongoDB聚合管道由阶段组成。每个阶段都在文档通过管道时对其进行转换。流水线阶段不需要为每个输入文档生成一个输出文档;例如，某些阶段可能生成新文档或过滤掉文档。

除了$out、$merge和$geoNear阶段外，管道阶段可以在管道中出现多次。有关所有可用阶段的列表，请参见聚合管道阶段。

MongoDB在mongo shell中提供了db.collection.aggregate()方法，并提供了运行聚合管道的聚合命令。

例如，使用聚合管道时，请考虑使用用户首选项数据进行聚合和使用邮政编码数据集进行聚合。
从MongoDB 4.2开始，你可以使用聚合管道进行更新:

2. 管道表达式

一些管道阶段采用管道表达式作为操作数。管道表达式指定要应用到输入文档的转换。表达式具有文档结构，可以包含其他表达式。
管道表达式只能对管道中的当前文档进行操作，不能引用来自其他文档的数据:表达式操作提供文档在内存中的转换。
通常，表达式是无状态的，只有在聚合过程看到一个例外情况时才进行计算:累加器表达式。

在$group阶段中使用的累加器在文档通过管道时维护它们的状态(例如总计、最大值、最小值和相关数据)。
版本3.2的变化:$project阶段提供了一些累加器;但是，在$project阶段使用时，累加器不会跨文档维护它们的状态。
有关表达式的更多信息，请参见表达式。

3.聚合管道的行为

在MongoDB中，聚合命令操作单个集合，逻辑上将整个集合传递到聚合管道。为了优化操作，尽可能使用以下策略来避免扫描整个集合。

3.1 管道运营商及指标

MongoDB的查询规划器分析聚合管道，以确定是否可以使用索引来提高管道性能。例如，下面的管道阶段可以利用索引:

请注意：
下面的管道阶段并不代表可以使用索引的所有阶段的完整列表。

$match
如果索引出现在管道的开头，则$match阶段可以使用索引来筛选文档。
$sort
$sort阶段可以使用索引，只要索引之前没有$project、$unwind或$group阶段。
$group
$group阶段有时可以使用索引来查找每个组中的第一个文档，前提是满足以下所有条件:

• $group阶段之前是一个$sort阶段，用于对字段进行分组，
• 在分组的字段上有一个与排序顺序和匹配的索引
• $group阶段中惟一使用的累加器是$first。

$geoNear

$geoNear管道操作符利用地理空间索引。在使用$geoNear时，$geoNear管道操作必须作为聚合管道中的第一阶段出现。

3.2版本中的变化:从MongoDB 3.2开始，索引可以覆盖聚合管道。在MongoDB 2.6和3.0中，索引不能覆盖聚合管道，因为即使管道使用索引，聚合仍然需要访问实际的文档。

3.2 早期的过滤

如果聚合操作只需要集合中的一部分数据，那么可以使用$match、$limit和$skip阶段来限制在管道开始时输入的文档。当放置在管道的开头时，$match操作使用合适的索引只扫描集合中匹配的文档。

在管道的开始处放置一个$match管道阶段，然后放置一个$sort阶段，这在逻辑上等同于一个带有sort的查询，并且可以使用索引。如果可能，在管道的开头放置$match操作符。

4. 注意事项

4.1 分片集合

聚合管道支持对切分集合的操作。参见聚合管道和切分集合。

4.2 聚合vs使用映射-规约模式

聚合管道提供了map-reduce之外的另一种选择，并且可能是不需要map-reduce复杂性的聚合任务的首选解决方案。

4.3 局限性

聚合管道对值类型和结果大小有一些限制。有关聚合管道的限制和限制的详细信息，请参阅聚合管道限制。

4.4 流水线优化

聚合管道有一个内部优化阶段，为某些操作符序列提供改进的性能。有关详细信息，请参见聚合管道优化。

二、聚合管道优化

聚合管道操作有一个优化阶段，该阶段尝试重新塑造管道以提高性能。

要查看优化器如何转换特定的聚合管道，请在db. collections .aggregate()方法中包含explain选项。

1. 投影优化

聚合管道可以确定是否只需要文档中的一个字段子集就可以获得结果。如果是这样，管道将只使用那些必需的字段，从而减少通过管道的数据量。

2.管道序列优化

($project或$unset或$addFields或$set) + $match序列优化

对于包含一个投影阶段($project或$unset或$addFields或$set)和一个$match阶段的聚合管道，MongoDB将$match阶段中不需要在投影阶段计算值的任何过滤器移动到一个新的$match阶段，然后再进行投影。

如果聚合管道包含多个投影和/或$match阶段，MongoDB将对每个$match阶段执行此优化，在筛选器不依赖的所有投影阶段之前移动每个$match筛选器。

考虑以下几个阶段的管道:

{ $addFields: {
    maxTime: { $max: "$times" },
    minTime: { $min: "$times" }
} },
{ $project: {
    _id: 1, name: 1, times: 1, maxTime: 1, minTime: 1,
    avgTime: { $avg: ["$maxTime", "$minTime"] }
} },

{ $match: {

    name: "Joe Schmoe",

    maxTime: { $lt: 20 },

    minTime: { $gt: 5 },

    avgTime: { $gt: 7 }

} }

优化器将$match阶段分解为四个单独的过滤器，每个过滤器对应$match查询文档中的每个键。然后优化器在尽可能多的投影阶段之前移动每个筛选器，根据需要创建新的$match阶段。在这个例子中，优化器产生以下优化管道:

{ $match: { name: "Joe Schmoe" } },

{ $addFields: {
    maxTime: { $max: "$times" },
    minTime: { $min: "$times" }
} },

{ $match: { maxTime: { $lt: 20 }, minTime: { $gt: 5 } } },

{ $project: {
    _id: 1, name: 1, times: 1, maxTime: 1, minTime: 1,
    avgTime: { $avg: ["$maxTime", "$minTime"] }
} },

{ $match: { avgTime: { $gt: 7 } } }

$match过滤器{avgTime: {$gt: 7}}依赖于$project阶段来计算avgTime字段。$project阶段是此管道中的最后一个投影阶段，因此无法移动avgTime上的$match过滤器。

maxTime和minTime字段在$addFields阶段计算，但不依赖于$project阶段。优化器为这些字段上的过滤器创建了一个新的$match阶段，并将其置于$project阶段之前。

$match筛选器{name: "Joe Schmoe"}不使用在$project或$addFields阶段中计算的任何值，因此它在两个投影阶段之前被移动到一个新的$match阶段。

请注意：
优化之后，过滤器{name: "Joe Schmoe"}在管道开始处处于$match阶段。这还有一个好处，即允许聚合在最初查询集合时使用name字段上的索引。有关更多信息，请参见管道操作符和索引。

$sort + $match序列优化

当您有一个$sort后面跟着$match的序列时，$match在$sort之前移动，以最小化要排序的对象的数量。例如，如果管道由以下几个阶段组成:

{ $sort: { age : -1 } },
{ $match: { status: 'A' } }

在优化阶段，优化器将序列转换为以下内容:

{ $match: { status: 'A' } },
{ $sort: { age : -1 } }

$redact + $match序列优化

如果可能，当管道中的$redact阶段紧跟在$match阶段之后时，聚合有时可以在$redact阶段之前添加$match阶段的一部分。如果添加的$match阶段位于管道的开头，则聚合可以使用索引和查询集合来限制进入管道的文档数量。有关更多信息，请参见管道操作符和索引。

例如，如果管道由以下几个阶段组成:

{ $redact: { $cond: { if: { $eq: [ "$level", 5 ] }, then: "$$PRUNE", else: "$$DESCEND" } } },
{ $match: { year: 2014, category: { $ne: "Z" } } }

优化器可以在$redact阶段之前添加相同的$match阶段:

{ $match: { year: 2014 } },
{ $redact: { $cond: { if: { $eq: [ "$level", 5 ] }, then: "$$PRUNE", else: "$$DESCEND" } } },
{ $match: { year: 2014, category: { $ne: "Z" } } }

$project/$unset + $skip序列优化

新版本3.2。
当您有一个$project或$unset后面跟着$skip的序列时，$skip在$project之前移动。例如，如果管道由以下几个阶段组成:

{ $sort: { age : -1 } },
{ $project: { status: 1, name: 1 } },
{ $skip: 5 }

在优化阶段，优化器将序列转换为以下内容:

{ $sort: { age : -1 } },
{ $skip: 5 },
{ $project: { status: 1, name: 1 } }

3. 管道联合优化

在可能的情况下，优化阶段将管道阶段合并到其前身。通常，在任何序列重新排序优化之后都会发生合并。

$sort + $limit合并

在4.0版本中进行了更改。
当$sort先于$limit时，如果没有中间阶段修改文档的数量(例如$unwind、$group)，那么优化器可以将$limit合并到$sort中。如果有管道阶段在$sort和$limit阶段之间更改文档数量，MongoDB不会将$limit合并到$sort中。

例如，如果管道由以下几个阶段组成:

{ $sort : { age : -1 } },
{ $project : { age : 1, status : 1, name : 1 } },
{ $limit: 5 }

在优化阶段，优化器合并序列如下:

{
    "$sort" : {
       "sortKey" : {
          "age" : -1
       },
       "limit" : NumberLong(5)
    }
},
{ "$project" : {
         "age" : 1,
         "status" : 1,
         "name" : 1
  }
}

这允许排序操作在进行过程中只维护前n个结果，其中n是指定的限制，MongoDB只需要在内存[1]中存储n个条目。有关更多信息，请参见$sort操作符和内存。

使用$SKIP进行序列优化
如果在$sort和$limit阶段之间存在$skip阶段，MongoDB将把$limit合并到$sort阶段，并将$limit值增加$skip金额。有关示例，请参见$sort + $skip + $limit Sequence。

$limit + $limit合并

当一个$限额紧随另一个$限额之后时，这两个阶段可以合并为一个$限额，其中限额金额是两个初始限额中较小的那个。例如，管道包含以下序列:

{ $limit: 100 },
{ $limit: 10 }

然后，第二个$limit阶段可以合并为第一个$limit阶段，并产生一个$limit阶段，其中限额金额10是两个初始限额100和10的最小值。

{ $limit: 10 }

$skip + $skip合并

当一个$skip紧跟着另一个$skip时，这两个阶段可以合并成一个$skip，其中skip金额是两个初始skip金额的总和。例如，管道包含以下序列:

{ $skip: 5 },
{ $skip: 2 }

然后，第二个$skip阶段可以合并为第一个$skip阶段，并产生一个$skip阶段，其中skip amount 7是两个初始限制5和2的总和。

{ $skip: 7 }

$match + $match合并

当$match紧跟在另一个$match之后时，这两个阶段可以合并为单个$match，将条件与$and组合在一起。例如，管道包含以下序列:

{ $match: { year: 2014 } },
{ $match: { status: "A" } }

然后，第二个$match阶段可以合并为第一个$match阶段，并产生单个$match阶段

{ $match: { $and: [ { "year" : 2014 }, { "status" : "A" } ] } }

$lookup + $unwind合并

新版本3.2。
当$unwind紧跟在另一个$lookup之后，并且$unwind操作在$lookup的as字段上时，优化器可以将$unwind合并到$lookup阶段。这避免了创建大型中间文档。

例如，管道包含以下序列:

{
  $lookup: {
    from: "otherCollection",
    as: "resultingArray",
    localField: "x",
    foreignField: "y"
  }
},
{ $unwind: "$resultingArray"}

优化器可以将$unwind阶段合并为$lookup阶段。如果使用explain选项运行聚合，则explain输出将显示合并阶段:

{
  $lookup: {
    from: "otherCollection",
    as: "resultingArray",
    localField: "x",
    foreignField: "y",
    unwinding: { preserveNullAndEmptyArrays: false }
  }
}

4. 例子

$sort + $skip + $limit序列

管道包含一个$sort序列，后面跟着一个$skip，后面跟着一个$limit:

{ $sort: { age : -1 } },
{ $skip: 10 },
{ $limit: 5 }

优化器执行$sort + $limit合并，将序列转换为以下内容:

{
   "$sort" : {
      "sortKey" : {
         "age" : -1
      },
      "limit" : NumberLong(15)
   }
},
{
   "$skip" : NumberLong(10)
}

MongoDB通过重新排序增加$limit金额。

三、聚合管道极限

使用聚合命令的聚合操作具有以下限制。

1.结果大小限制

版本3.6中的变化:MongoDB 3.6删除了聚合命令以单个文档的形式返回结果的选项。

聚合命令可以返回游标，也可以将结果存储在集合中。当返回游标或将结果存储在集合中时，结果集中的每个文档都受BSON文档大小限制，目前为16兆字节;如果任何单个文档超过了BSON文档大小限制，该命令将产生一个错误。该限制只适用于已退回的文件;在管道处理期间，文档可能超过这个大小。aggregate()方法返回一个游标。

2. 内存限制

流水线阶段的RAM限制为100 MiB(100 * 1024 * 1024字节)。如果一个阶段超过这个限制，MongoDB将产生一个错误。要允许处理大型数据集，可以在aggregate()方法中设置allowDiskUse选项。allowDiskUse选项允许大多数聚合管道操作将数据写入临时文件。allowDiskUse选项的例外是以下聚合操作;这些操作必须保持在内存限制限制:

• $graphLookup阶段
• $group阶段中使用的$addToSet累加器表达式(从版本4.2.3、4.0.14和3.6.17开始)
• $group阶段中使用的$push累加器表达式(从版本4.2.3、4.0.14和3.6.17开始)

如果管道包含其他在aggregate()操作中观察allowDiskUse: true的阶段，则allowDiskUse: true选项对这些其他阶段有效。

从MongoDB 4.2开始，分析器日志消息和诊断日志消息包括一个usedDisk指示器，如果任何聚合阶段由于内存限制将数据写入临时文件。

四、聚合管道和切分集合

聚合管道支持对切分集合的操作。本节描述特定于聚合管道和切分集合的行为。

1. 性能

在3.2版本中进行了更改。
如果管道从切分键上的精确$match开始，则整个管道仅在匹配的切分上运行。在以前，管道会被分割，而合并它的工作必须在主碎片上完成。

对于必须在多个切分上运行的聚合操作，如果这些操作不需要在数据库的主切分上运行，则这些操作将把结果路由到一个随机切分以合并结果，以避免对该数据库的主切分超载。$out阶段和$lookup阶段需要在数据库的主碎片上运行。

2. 优化

当将聚合管道分成两部分时，将管道进行分割，以确保shard执行尽可能多的阶段，同时考虑优化。

要查看如何分割管道，请在db.collection.aggregate()方法中包含explain选项。
优化可能会在不同版本之间发生变化。

五、Aggregation with the Zip Code Data Set

本文档中的示例使用zipcodes集合。这个集合可以在:media.mongodb.org/zips.json中找到。使用mongoimport将这个数据集加载到mongod实例中。

1. 数据模型

邮政编码收集内的每一份文件均有下列表格:

{
  "_id": "10280",
  "city": "NEW YORK",
  "state": "NY",
  "pop": 5574,
  "loc": [
    -74.016323,
    40.710537
  ]
}

• _id字段将邮政编码保存为字符串。
• city字段包含城市名称。一个城市可以有多个与其相关的邮政编码，因为城市的不同部分可以有不同的邮政编码。
• state字段包含两个字母的州缩写。
• pop字段容纳人口。
• loc字段以经纬度对的形式保存位置。

1.1 aggregate()方法

下面的所有示例都使用了mongo shell中的aggregate()帮助器。
aggregate()方法使用聚合管道将文档处理为聚合结果。聚合管道由多个阶段组成，每个阶段在文档通过管道时处理文档。文档依次通过各个阶段。

mongo shell中的aggregate()方法为aggregate数据库命令提供了一个包装器。有关数据聚合操作的更惯用的接口，请参阅驱动程序的文档。

1.2 返回人口超过1000万的州

下面的聚合操作返回总人口大于1000万的所有状态:

db.zipcodes.aggregate( [
   { $group: { _id: "$state", totalPop: { $sum: "$pop" } } },
   { $match: { totalPop: { $gte: 10*1000*1000 } } }
] )

在本例中，聚合管道由$group阶段和$match阶段组成:

• $group stage根据状态字段对zipcode集合的文档进行分组，为每个状态计算totalPop字段，并为每个惟一状态输出一个文档。新的每个状态文档有两个字段:_id字段和totalPop字段。_id字段包含状态值;即按字段分组。totalPop字段是一个计算过的字段，它包含每个状态的总体。为了计算该值，$group使用$sum操作符为每个状态添加人口字段(pop)。

在$group阶段之后，准备中的文档如下:

{
  "_id" : "AK",
  "totalPop" : 550043
}

• $match阶段过滤这些分组文档，只输出totalPop值大于或等于1000万的文档。$match阶段不改变匹配文档，但输出未修改的匹配文档。

这个聚合操作的等效SQL是:

SELECT state, SUM(pop) AS totalPop
FROM zipcodes
GROUP BY state
HAVING totalPop >= (10*1000*1000)

2. 按州返回平均城市人口

下面的汇总操作返回每个州城市的平均人口:

db.zipcodes.aggregate( [
   { $group: { _id: { state: "$state", city: "$city" }, pop: { $sum: "$pop" } } },
   { $group: { _id: "$_id.state", avgCityPop: { $avg: "$pop" } } }
] )

在本例中，聚合管道由$group阶段和另一个$group阶段组成:

• 第一个$group阶段按照城市和州的组合对文档进行分组，使用$sum表达式计算每个组合的人口，并输出每个城市和州组合的文档。[1]

在这个准备阶段之后，文件类似如下:

{
  "_id" : {
    "state" : "CO",
    "city" : "EDGEWATER"
  },
  "pop" : 13154
}

• 第二个$group阶段按_id对管道中的文档进行分组。状态字段(即_id文档中的状态字段)，使用$avg表达式计算每个州的平均城市人口(avgCityPop)，并为每个州输出一个文档。

这种聚合操作产生的文档如下:

{
  "_id" : "MN",
  "avgCityPop" : 5335
}

3. 按州返回最大和最小的城市

下面的聚合操作按人口大小返回每个州的城市:

db.zipcodes.aggregate( [
   { $group:
      {
        _id: { state: "$state", city: "$city" },
        pop: { $sum: "$pop" }
      }
   },
   { $sort: { pop: 1 } },
   { $group:
      {
        _id : "$_id.state",
        biggestCity:  { $last: "$_id.city" },
        biggestPop:   { $last: "$pop" },
        smallestCity: { $first: "$_id.city" },
        smallestPop:  { $first: "$pop" }
      }
   },

  // the following $project is optional, and
  // modifies the output format.

  { $project:
    { _id: 0,
      state: "$_id",
      biggestCity:  { name: "$biggestCity",  pop: "$biggestPop" },
      smallestCity: { name: "$smallestCity", pop: "$smallestPop" }
    }
  }
] )

在本例中，聚合管道包括$group阶段、$sort阶段、另一个$group阶段和$project阶段:

• 第一个$group stage根据城市和州的组合对文档进行分组，计算每个组合的流行值之和，并输出每个城市和州组合的文档。

在筹备阶段，这些文件大致如下:

{
  "_id" : {
    "state" : "CO",
    "city" : "EDGEWATER"
  },
  "pop" : 13154
}

• $sort阶段根据pop字段值(从最小到最大)对管道中的文档进行排序;即通过增加顺序。此操作不更改文档。
• 下一个$group阶段按_id对当前已排序的文档进行分组。状态字段(即_id文档中的状态字段)，并为每个状态输出一个文档。该阶段还为每个状态计算以下四个字段。$group操作符使用$last表达式创建最大城市和最大pop字段，存储人口最多的城市和人口最多的城市。使用$first表达式，$group操作符创建smallestCity和smallestPop字段，它们存储人口最小的城市和该人口。

目前正在拟订的文件如下:

{
  "_id" : "WA",
  "biggestCity" : "SEATTLE",
  "biggestPop" : 520096,
  "smallestCity" : "BENGE",
  "smallestPop" : 2
}

• 最后的$project阶段将_id字段重命名为state，并将最大的city、biggestPop、smallestCity和smallestPop移动到biggestCity和smallestCity嵌入文档中。

该聚合操作的输出文档如下:

{
  "state" : "RI",
  "biggestCity" : {
    "name" : "CRANSTON",
    "pop" : 176404
  },
  "smallestCity" : {
    "name" : "CLAYVILLE",
    "pop" : 45
  }
}

六、与用户首选项数据聚合

1.数据模型

假设一个体育俱乐部拥有一个数据库，其中包含一个用户集合，该集合跟踪用户的加入日期、运动偏好，并将这些数据存储在类似于以下文档的文档中:

{
  _id : "jane",
  joined : ISODate("2011-03-02"),
  likes : ["golf", "racquetball"]
}
{
  _id : "joe",
  joined : ISODate("2012-07-02"),
  likes : ["tennis", "golf", "swimming"]
}

2. 对文档进行规范化和排序

下面的操作以大写字母和字母顺序返回用户名。聚合包括用户集合中所有文档的用户名。您可以这样做来规范化处理的用户名。

db.users.aggregate(
  [
    { $project : { name:{$toUpper:"$_id"} , _id:0 } },
    { $sort : { name : 1 } }
  ]
)

用户集合中的所有文档都要经过流水线，流水线由以下操作组成:

（1）$project操作：

• 创建一个名为name的新字段。
• 使用$toUpper操作符将_id的值转换为大写。然后，$project创建一个名为name的新字段来保存这个值。
• 取消id字段。$project默认情况下会传递_id字段，除非显式禁止。

（2）$sort操作符根据name字段对结果排序。

汇总的结果如下:

{
  "name" : "JANE"
},
{
  "name" : "JILL"
},
{
  "name" : "JOE"
}

3. 返回按加入月排序的用户名

下面的聚合操作将返回按加入月份排序的用户名。这种聚合可以帮助生成会员续订通知。

db.users.aggregate(
  [
    { $project :
       {
         month_joined : { $month : "$joined" },
         name : "$_id",
         _id : 0
       }
    },
    { $sort : { month_joined : 1 } }
  ]
)

管道通过以下操作传递用户集合中的所有文档:

（1）$project操作符:

• 创建两个新字段:month_join和name。
• 从结果中取消id。除非显式禁止，否则聚合()方法包括_id。

（2）$month操作符将联接字段的值转换为月份的整数表示形式。然后，$project操作符将这些值分配给month_joining字段。
（3）$sort操作符根据month_joining字段对结果进行排序。

操作返回类似以下的结果:

{
  "month_joined" : 1,
  "name" : "ruth"
},
{
  "month_joined" : 1,
  "name" : "harold"
},
{
  "month_joined" : 1,
  "name" : "kate"
}
{
  "month_joined" : 2,
  "name" : "jill"
}

4. 返回每个月的连接总数

下面的操作显示每年每个月有多少人加入。您可以将这些聚合数据用于招聘和营销策略。

db.users.aggregate(
  [
    { $project : { month_joined : { $month : "$joined" } } } ,
    { $group : { _id : {month_joined:"$month_joined"} , number : { $sum : 1 } } },
    { $sort : { "_id.month_joined" : 1 } }
  ]
)

管道通过以下操作传递用户集合中的所有文档:

（1）$project操作符创建一个名为month_join的新字段。
（2）$month操作符将联接字段的值转换为月份的整数表示形式。然后，$project操作符将这些值分配给month_joining字段。

（3）$group操作符收集具有给定month_join值的所有文档，并计算该值有多少个文档。具体来说，对于每个惟一的值，$group创建一个新的“每月”文档，其中包含两个字段:

• _id，它包含一个嵌套的文档，其中包含month_join字段及其值。
• number，它是一个生成的字段。对于每个包含给定的month_join值的文档，$sum操作符将该字段增加1。

（4）$sort操作符根据month_joining字段的内容对$group创建的文档进行排序。

此聚合操作的结果将类似于以下内容:

{
  "_id" : {
    "month_joined" : 1
  },
  "number" : 3
},
{
  "_id" : {
    "month_joined" : 2
  },
  "number" : 9
},
{
  "_id" : {
    "month_joined" : 3
  },
  "number" : 5
}

5. 返回五个最常见的“赞”

下面的汇总收集了数据集中最受欢迎的五个活动。这种类型的分析可以帮助规划和未来的发展。

db.users.aggregate(
  [
    { $unwind : "$likes" },
    { $group : { _id : "$likes" , number : { $sum : 1 } } },
    { $sort : { number : -1 } },
    { $limit : 5 }
  ]
)

管道从用户集合中的所有文档开始，通过以下操作传递这些文档:

• $unwind操作符分离like数组中的每个值，并为数组中的每个元素创建源文档的新版本。

例子：
给定用户集合中的以下文档:

{
  _id : "jane",
  joined : ISODate("2011-03-02"),
  likes : ["golf", "racquetball"]
}

$unwind操作符将创建以下文档:

{
  _id : "jane",
  joined : ISODate("2011-03-02"),
  likes : "golf"
}
{
  _id : "jane",
  joined : ISODate("2011-03-02"),
  likes : "racquetball"
}

• $group操作符为likes字段收集具有相同值的所有文档，并对每个分组进行计数。有了这些信息，$group创建了一个带有两个字段的新文档:（1）_id，它包含了like值。（2）number，它是一个生成的字段。$sum操作符对每个包含给定的like值的文档将该字段增加1。
• $sort操作符按数字字段以相反的顺序对这些文档进行排序。
• $limit操作符只包含前5个结果文档。

汇总的结果如下:

{
  "_id" : "golf",
  "number" : 33
},
{
  "_id" : "racquetball",
  "number" : 31
},
{
  "_id" : "swimming",
  "number" : 24
},
{
  "_id" : "handball",
  "number" : 19
},
{
  "_id" : "tennis",
  "number" : 18
}

七、Map-Reduce和Sharded集合

Map-reduce支持对切分集合进行操作，既可以作为输入，也可以作为输出。本节描述特定于切分集合的mapReduce行为。

但是，从4.2版开始，MongoDB就不支持使用map-reduce选项来创建新的切分集合，也不支持使用切分选项来进行map-reduce。要输出到sharded集合，首先创建sharded集合。MongoDB 4.2还反对替换现有的切分集合。

1. 作为输入的切分集合

当使用sharded collection作为map-reduce操作的输入时，mongos将自动并行地将map-reduce作业分派给每个shard。不需要特殊选项。mongos将等待所有碎片上的工作完成。

2. 作为输出的切分集合

如果mapReduce的out字段有分片值，MongoDB使用_id字段作为分片键对输出集合进行分片。

请注意：
从4.2版开始，MongoDB就不支持在mapReduce/db.collection.mapReduce中使用切分选项。

输出到分片集合:

• 如果输出集合不存在，则首先创建切分集合。从4.2版开始，MongoDB就不支持使用map-reduce选项来创建新的sharded集合，也不支持使用sharded选项来进行map-reduce。因此，要输出到sharded集合，首先要创建sharded集合。如果您没有首先创建切分集合，MongoDB将在_id字段上创建并切分集合。但是，建议您首先创建切分集合。
• 从4.2版开始，MongoDB不支持替换现有的切分集合。
• 从4.0版本开始，如果输出集合已经存在但没有分片，则map-reduce失败。
• 对于一个新的或空的切分集合，MongoDB使用map-reduce操作第一阶段的结果来创建分布在切分中的初始块。
• mongos并行地将一个map-reduce后处理作业分派给每个拥有块的碎片。在后期处理期间，每个切分将从其他切分中为自己的块提取结果，运行最后的reduce/finalize，并在本地将结果写入输出集合。

请注意：
在后来的map-reduce作业中，MongoDB根据需要分割块。
为了避免并发性问题，在后处理期间会自动阻止输出集合的块的平衡。

八、使用映射-规约模式并发

map-reduce操作由许多任务组成，包括对输入集合的读取、map函数的执行、reduce函数的执行、在处理期间对临时集合的写入以及对输出集合的写入。

在操作过程中，map-reduce采取以下锁:

• 读阶段采用读锁。它每生成100个文档。
• 临时集合中的插入对单个写操作使用写锁。
• 如果输出集合不存在，则输出集合的创建将使用写锁。
• 如果存在输出集合，则输出操作(即合并、替换、减少)采取写锁。这个写锁是全局的，并阻塞mongod实例上的所有操作。

请注意：
后处理期间的最终写锁使结果自动显示。但是，合并和减少输出操作可能需要几分钟的时间。对于merge和reduce，非原子标记是可用的，它在写入每个输出文档之间释放锁。从MongoDB 4.2开始，显式地设置nonAtomic: false是不赞成的。有关更多信息，请参见db.collection.mapReduce()引用。

九、使用映射-规约模式的例子

在mongo shell中，db.collection.mapReduce()方法是mapReduce命令的包装器。下面的例子使用了db.collection.mapReduce()方法:
考虑以下对包含以下原型文档的集合订单的映射-简化操作:

{
     _id: ObjectId("50a8240b927d5d8b5891743c"),
     cust_id: "abc123",
     ord_date: new Date("Oct 04, 2012"),
     status: 'A',
     price: 25,
     items: [ { sku: "mmm", qty: 5, price: 2.5 },
              { sku: "nnn", qty: 5, price: 2.5 } ]
}

1. 返回每个客户的总价

根据cust_id对订单集合进行map-reduce操作，并计算每个cust_id的价格总和:

（1）定义map函数来处理每个输入文档:

• 在函数中，这指的是map-reduce操作正在处理的文档。
• 该函数将价格映射到每个文档的cust_id，并发出cust_id和价格对。

var mapFunction1 = function() {
                       emit(this.cust_id, this.price);
                   };

（2）定义相应的减少函数有两个参数keyCustId和valuesPrices:

• valuesPrices是一个数组，其元素是map函数发出的price值，并按keyCustId分组。
• 该函数将valuesPrice数组简化为其元素的和。

var reduceFunction1 = function(keyCustId, valuesPrices) {
                          return Array.sum(valuesPrices);
                      };

（3）使用mapFunction1映射函数和reduceFunction1 reduce函数对orders集合中的所有文档执行map-reduce。

db.orders.mapReduce(
                     mapFunction1,
                     reduceFunction1,
                     { out: "map_reduce_example" }
                   )

该操作将结果输出到一个名为map_reduce_example的集合。如果map_reduce_example集合已经存在，这个操作将用这个map-reduce操作的结果来替换内容:

2. 计算订单和总数量，每项平均数量

在本例中，您将对所有ord_date值大于01/01/2012的文档的orders集合执行映射缩减操作。按项目分组。sku字段，并计算每个sku的订单数量和订单总量。通过计算每个sku值的订单平均数量，得出以下结论:

（1）定义map函数来处理每个输入文档:

• 在函数中，这指的是map-reduce操作正在处理的文档。
• 对于每个项目，该函数将sku与一个新对象值相关联，该对象值包含订单的计数1和项目数量，并发出sku和值对。

var mapFunction2 = function() {
                       for (var idx = 0; idx < this.items.length; idx++) {
                           var key = this.items[idx].sku;
                           var value = {
                                         count: 1,
                                         qty: this.items[idx].qty
                                       };
                           emit(key, value);
                       }
                    };

（2）定义相应的reduce函数有两个参数keySKU和countObjVals:

• countObjVals是一个数组，其元素是映射到由map函数传递给减速器函数的分组keySKU值的对象。
• 该函数将countObjVals数组简化为一个包含count和qty字段的reducedValue对象。
• 在reducedVal中，count字段包含来自单个数组元素的计数字段的和，而qty字段包含来自单个数组元素的qty字段的和。

var reduceFunction2 = function(keySKU, countObjVals) {
                     reducedVal = { count: 0, qty: 0 };

                     for (var idx = 0; idx < countObjVals.length; idx++) {
                         reducedVal.count += countObjVals[idx].count;
                         reducedVal.qty += countObjVals[idx].qty;
                     }

                     return reducedVal;
                  };

（3）定义一个带有两个参数key和reducedVal的finalize函数。该函数修改reducedVal对象，添加一个名为avg的计算字段，并返回修改后的对象:

var finalizeFunction2 = function (key, reducedVal) {

                       reducedVal.avg = reducedVal.qty/reducedVal.count;

                       return reducedVal;

                    };

（4）使用mapFunction2、reduceFunction2和finalizeFunction2函数对orders集合执行map-reduce操作。

db.orders.mapReduce( mapFunction2,
                     reduceFunction2,
                     {
                       out: { merge: "map_reduce_example" },
                       query: { ord_date:
                                  { $gt: new Date('01/01/2012') }
                              },
                       finalize: finalizeFunction2
                     }
                   )

该操作使用query字段只选择那些ord_date大于new Date(01/01/2012)的文档。然后将结果输出到集合map_reduce_example。如果map_reduce_example集合已经存在，那么该操作将把现有的内容与这个map-reduce操作的结果合并起来。

八、执行增量使用映射-规约模式

Map-reduce操作可以处理复杂的聚合任务。要执行map-reduce操作，MongoDB提供mapReduce命令，在mongo shell中，提供db.collection.mapReduce()包装器方法。

如果map-reduce数据集不断增长，您可能希望每次对整个数据集执行递增的map-reduce操作，而不是执行map-reduce操作。

要执行增量映射-减少:

1. 在当前集合上运行一个map-reduce作业，并将结果输出到一个单独的集合。
2. 当你有更多的数据要处理，运行后续的map-reduce作业:

• 指定只匹配新文档的条件的查询参数。
• 指定reduce操作的out参数，该操作将新结果合并到现有的输出集合中。

考虑下面的示例，在这个示例中，您计划在每天结束时对一个sessions集合执行一个map-reduce操作。

1. 数据设置

sessions集合包含每天记录用户会话的文档，例如:

db.sessions.save( { userid: "a", ts: ISODate('2011-11-03 14:17:00'), length: 95 } );
db.sessions.save( { userid: "b", ts: ISODate('2011-11-03 14:23:00'), length: 110 } );
db.sessions.save( { userid: "c", ts: ISODate('2011-11-03 15:02:00'), length: 120 } );
db.sessions.save( { userid: "d", ts: ISODate('2011-11-03 16:45:00'), length: 45 } );

db.sessions.save( { userid: "a", ts: ISODate('2011-11-04 11:05:00'), length: 105 } );
db.sessions.save( { userid: "b", ts: ISODate('2011-11-04 13:14:00'), length: 120 } );
db.sessions.save( { userid: "c", ts: ISODate('2011-11-04 17:00:00'), length: 130 } );
db.sessions.save( { userid: "d", ts: ISODate('2011-11-04 15:37:00'), length: 65 } );

2. 当前集合的初始映射缩减

按如下步骤运行第一个map-reduce操作:

（1）定义将userid映射到包含userid、total_time、count和avg_time字段的对象的映射函数:

var mapFunction = function() {
                      var key = this.userid;
                      var value = {
                                    userid: this.userid,
                                    total_time: this.length,
                                    count: 1,
                                    avg_time: 0
                                   };

                      emit( key, value );
                  };

（2）定义相应的reduce函数，使用两个参数键和值来计算总时间和计数。键对应于userid，值是一个数组，其元素对应于映射到mapFunction中的userid的单个对象。

var reduceFunction = function(key, values) {

                        var reducedObject = {
                                              userid: key,
                                              total_time: 0,
                                              count:0,
                                              avg_time:0
                                            };

                        values.forEach( function(value) {
                                              reducedObject.total_time += value.total_time;
                                              reducedObject.count += value.count;
                                        }
                                      );
                        return reducedObject;
                     };

（3）使用两个参数key和reducedValue定义finalize函数。该函数修改reducedValue文档以添加另一个字段平均值并返回修改后的文档。

var finalizeFunction = function (key, reducedValue) {

                          if (reducedValue.count > 0)
                              reducedValue.avg_time = reducedValue.total_time / reducedValue.count;

                          return reducedValue;
                       };

（4） 使用mapFunction、reduceFunction和finalizeFunction函数对会话集合执行map-reduce。将结果输出到集合session_stat。如果session_stat集合已经存在，则操作将替换内容:

db.sessions.mapReduce( mapFunction,
                       reduceFunction,
                       {
                         out: "session_stat",
                         finalize: finalizeFunction
                       }
                     )

3. 后续的增量使用映射-规约模式

稍后，随着sessions集合的增长，您可以运行额外的map-reduce操作。例如，向会话集合添加新文档:

db.sessions.save( { userid: "a", ts: ISODate('2011-11-05 14:17:00'), length: 100 } );
db.sessions.save( { userid: "b", ts: ISODate('2011-11-05 14:23:00'), length: 115 } );
db.sessions.save( { userid: "c", ts: ISODate('2011-11-05 15:02:00'), length: 125 } );
db.sessions.save( { userid: "d", ts: ISODate('2011-11-05 16:45:00'), length: 55 } );

在一天结束时，对sessions集合执行增量的map-reduce，但是使用query字段只选择新文档。将结果输出到集合session_stat，但是使用增量映射-reduce的结果减少内容:

db.sessions.mapReduce( mapFunction,
                       reduceFunction,
                       {
                         query: { ts: { $gt: ISODate('2011-11-05 00:00:00') } },
                         out: { reduce: "session_stat" },
                         finalize: finalizeFunction
                       }
                     );

九、排除映射函数的故障

map函数是一个JavaScript函数，它将值与键关联或“映射”，并在map-reduce操作期间发出键和值对。

请注意：
从4.2.1版开始，MongoDB就不支持在map、reduce和finalize函数中使用带有作用域(即BSON类型15)的JavaScript。要确定变量的作用域，请使用作用域参数。

要验证map函数发出的键和值对，请编写自己的emit函数。
考虑一个包含以下原型文档的集合订单:

{
     _id: ObjectId("50a8240b927d5d8b5891743c"),
     cust_id: "abc123",
     ord_date: new Date("Oct 04, 2012"),
     status: 'A',
     price: 250,
     items: [ { sku: "mmm", qty: 5, price: 2.5 },
              { sku: "nnn", qty: 5, price: 2.5 } ]
}

（1）定义映射函数，将价格映射到每个文档的cust_id，并发出cust_id和价格对:

var map = function() {
    emit(this.cust_id, this.price);
};

（2）定义emit函数来打印key和value:

var emit = function(key, value) {
    print("emit");
    print("key: " + key + "  value: " + tojson(value));
}

（3）使用orders集合中的单个文档调用map函数:

var myDoc = db.orders.findOne( { _id: ObjectId("50a8240b927d5d8b5891743c") } );
map.apply(myDoc);

（4）验证键和值对是否如您所期望的那样。

emit
key: abc123 value:250

（5）使用来自orders集合的多个文档调用map函数:

var myCursor = db.orders.find( { cust_id: "abc123" } );

while (myCursor.hasNext()) {
    var doc = myCursor.next();
    print ("document _id= " + tojson(doc._id));
    map.apply(doc);
    print();
}

（6）验证键和值对是否如预期的那样。

十、对Reduce函数进行故障排除

reduce函数是一个JavaScript函数，它将在map-reduce操作期间与特定键关联的所有值“简化”为一个单一对象。reduce功能必须满足各种需求。本教程帮助验证reduce函数是否满足以下条件:

• reduce函数必须返回一个对象，该对象的类型必须与map函数发出的值的类型相同。
• valuesArray中元素的顺序不应该影响reduce函数的输出。
• reduce函数必须是幂等的。

有关reduce函数的所有要求的列表，请参见mapReduce或mongo shell帮助器方法db.collection.mapReduce()。

请注意：
从4.2.1版开始，MongoDB就不支持在map、reduce和finalize函数中使用带有作用域(即BSON类型15)的JavaScript。要确定变量的作用域，请使用作用域参数。

1. 确认输出类型

您可以测试reduce函数是否返回与map函数发出的值类型相同的值。

（1）定义一个reduceFunction1函数，它接受参数keyCustId和valuesPrices。valuesPrices是一个整数数组:

var reduceFunction1 = function(keyCustId, valuesPrices) {
                          return Array.sum(valuesPrices);
                      };

（2）定义一个整数数组样本:

var myTestValues = [ 5, 5, 10 ];

（3）使用myTestValues调用reduceFunction1:

reduceFunction1('myKey', myTestValues);

（4）验证reduceFunction1返回的是一个整数:

20

（5）定义一个reduceFunction2函数，它接受参数keySKU和valuesCountObjects。valuesCountObjects是一个包含两个字段count和qty的文档数组:

var reduceFunction2 = function(keySKU, valuesCountObjects) {
                          reducedValue = { count: 0, qty: 0 };

                          for (var idx = 0; idx < valuesCountObjects.length; idx++) {
                              reducedValue.count += valuesCountObjects[idx].count;
                              reducedValue.qty += valuesCountObjects[idx].qty;
                          }

                          return reducedValue;
                      };

（6）定义一个文档样本数组:

var myTestObjects = [
                      { count: 1, qty: 5 },
                      { count: 2, qty: 10 },
                      { count: 3, qty: 15 }
                    ];

（7）使用myTestObjects调用reduceFunction2:

reduceFunction2('myKey', myTestObjects);

（8）验证reduceFunction2返回的文档是否包含count和qty字段:

{ "count" : 6, "qty" : 30 }

2. 确保对映射值的顺序不敏感

reduce函数的参数是一个键和一个值数组。您可以测试reduce函数的结果是否依赖于值数组中元素的顺序。

（1）定义一个示例values1数组和一个示例values2数组，它们只在数组元素的顺序上不同:

var values1 = [
                { count: 1, qty: 5 },
                { count: 2, qty: 10 },
                { count: 3, qty: 15 }
              ];

var values2 = [
                { count: 3, qty: 15 },
                { count: 1, qty: 5 },
                { count: 2, qty: 10 }
              ];

（2）定义一个reduceFunction2函数，它接受参数keySKU和valuesCountObjects。valuesCountObjects是一个包含两个字段count和qty的文档数组:

var reduceFunction2 = function(keySKU, valuesCountObjects) {
                          reducedValue = { count: 0, qty: 0 };

                          for (var idx = 0; idx < valuesCountObjects.length; idx++) {
                              reducedValue.count += valuesCountObjects[idx].count;
                              reducedValue.qty += valuesCountObjects[idx].qty;
                          }

                          return reducedValue;
                      };

（3）首先使用values1调用reduceFunction2，然后使用values2:

reduceFunction2('myKey', values1);
reduceFunction2('myKey', values2);

（4）验证reduceFunction2返回相同的结果:

{ "count" : 6, "qty" : 30 }

3. 确保降低函数幂等性

因为map-reduce操作可以对同一个键多次调用reduce，而不会对工作集中键的单个实例调用reduce，所以reduce函数必须返回与map函数发出的值相同类型的值。您可以测试reduce函数处理“简化”的值，而不影响最终的值。

（1）定义一个reduceFunction2函数，它接受参数keySKU和valuesCountObjects。valuesCountObjects是一个包含两个字段count和qty的文档数组:

var reduceFunction2 = function(keySKU, valuesCountObjects) {
                          reducedValue = { count: 0, qty: 0 };

                          for (var idx = 0; idx < valuesCountObjects.length; idx++) {
                              reducedValue.count += valuesCountObjects[idx].count;
                              reducedValue.qty += valuesCountObjects[idx].qty;
                          }

                          return reducedValue;
                      };

（2）定义一个样本密钥:

var myKey = 'myKey';

（3）定义一个示例valuesIdempotent数组，该数组包含一个调用reduceFunction2函数的元素:

var valuesIdempotent = [
                         { count: 1, qty: 5 },
                         { count: 2, qty: 10 },
                         reduceFunction2(myKey, [ { count:3, qty: 15 } ] )
                       ];

（4）定义一个组合传递给reduceFunction2的值的示例values1数组:

var values1 = [
                { count: 1, qty: 5 },
                { count: 2, qty: 10 },
                { count: 3, qty: 15 }
              ];

（5）首先使用myKey和valuesIdempotent调用reduceFunction2，然后使用myKey和values1:

reduceFunction2(myKey, valuesIdempotent);
reduceFunction2(myKey, values1);

（6）验证reduceFunction2返回相同的结果:

{ "count" : 6, "qty" : 30 }

十一、聚合管道快速引用

请注意：
有关特定运算符的详细信息，包括语法和示例，请单击特定运算符进入其参考页面。

1. Stages

1.1 Stages (db.collection.aggregate)

 db.collection.aggregate方法，流水线阶段出现在一个数组中。文档依次通过各个阶段。除了$out、$merge和$geoNear阶段外，其他阶段都可以在管道中多次出现。

db.collection.aggregate( [ { <stage> }, ... ] )

1.2 Stages (db.aggregate)

从3.6版开始，MongoDB也提供了db.aggregate方法:

db.aggregate( [ { <stage> }, ... ] )

以下阶段使用的是db.aggregate()方法，而不是db.collection.aggregate()方法。

1.3 可用于更新的阶段

从MongoDB 4.2开始，你可以使用聚合管道进行更新:

findAndModify

db.collection.findOneAndUpdate()

db.collection.findAndModify()

update

db.collection.updateOne()

db.collection.updateMany()

db.collection.update()

Bulk.find.update()

Bulk.find.updateOne()

Bulk.find.upsert()

对于更新，管道可以包括以下几个阶段:

• $addFields及其别名$set
• $project及其别名$unset
• $replaceRoot及其别名$replaceWith。

2. 表达式

表达式可以包括字段路径、文字、系统变量、表达式对象和表达式操作符。表达式可以嵌套。

2.1 Field Paths

聚合表达式使用字段路径访问输入文档中的字段。要指定字段路径，请在字段名或点字段名(如果字段在嵌入的文档中)前面加上美元符号$。例如，“$user”指定用户字段的字段路径，或者“$user.name”指定“user.name”字段的字段路径。

“$<字段>”等于“$$CURRENT”。<field>"其中，当前是一个系统变量，默认为当前对象的根，除非在特定阶段中另有说明。

2.2 聚合变量

MongoDB为表达式提供了各种聚合系统变量。要访问变量，在变量名前面加上$$。例如:

2.3 Literals

文字可以是任何类型。但是，MongoDB解析以美元符号$作为字段路径开头的字符串，解析表达式对象中的数字/布尔值作为投影标志。要避免解析文字，可以使用$literal表达式。

2.4 表达式对象

表达式对象有以下形式:

{ <field1>: <expression1>, ... }

如果表达式是数值型或布尔型文字，MongoDB将文字作为投影标志(例如1或true来包含字段)，仅在$project阶段有效。为了避免将数字或布尔文字作为投影标志，可以使用$literal表达式来包装数字或布尔文字。

3. 操作符表达式

• Arithmetic Expression Operators
• Array Expression Operators
• Boolean Expression Operators
• Comparison Expression Operators
• Conditional Expression Operators
• Date Expression Operators
• Literal Expression Operator
• Object Expression Operators
• Set Expression Operators
• String Expression Operators
• Text Expression Operator
• Trigonometry Expression Operators
• Type Expression Operators
• Accumulators ($group)
• Accumulators (in Other Stages)
• Variable Expression Operators

操作符表达式类似于接受参数的函数。通常，这些表达式采用参数数组，形式如下:

{ <operator>: [ <argument1>, <argument2> ... ] }

如果操作符接受单个参数，你可以忽略指定参数列表的外部数组:

{ <operator>: <argument> }

如果参数是文字数组，为了避免解析歧义，您必须将文字数组包装在$literal表达式中，或者保留指定参数列表的外部数组。

3.1 算术表达式运算符

算术表达式对数字进行数学运算。一些算术表达式也可以支持日期运算。

3.2 数组表达式运算符

3.3 布尔表达式运算符

布尔表达式将其参数表达式计算为布尔值，并返回一个布尔值作为结果。

除了假布尔值之外，布尔表达式的以下计算结果为假:null、0和未定义的值。布尔表达式计算所有其他值为真，包括非零数值和数组。

3.4 比较表达式操作符

除了$cmp返回一个数字之外，比较表达式返回一个布尔值。
比较表达式采用两个参数表达式，使用指定的BSON比较顺序比较不同类型的值和类型。

3.5 条件表达式运算符

3.6 日期表达运算符

以下操作符返回日期对象或日期对象的组件:

以下算术运算符可以接受日期操作数:

3.7 文字表达式运算符

3.8 对象表达式运算符

3.9 set表达式运算符

Set表达式对数组执行Set操作，将数组视为集合。Set表达式忽略每个输入数组中的重复项和元素的顺序。
如果set操作返回一个set，则该操作过滤掉结果中的重复项，以输出只包含唯一条目的数组。输出数组中元素的顺序是未指定的。

如果集合包含嵌套的数组元素，则集合表达式不会下降到嵌套的数组中，而是在顶层计算数组。

3.10 字符串表达式运算符

除了$concat之外，字符串表达式只有定义良好的ASCII字符字符串行为。

无论使用什么字符，都可以定义$concat行为。

3.11 文本表达式运算符

3.12 三角函数表达式运算符

三角表达式对数字进行三角运算。表示角度的值总是以弧度表示输入或输出。使用$degreesToRadians和$radiansToDegrees在度和弧度度量之间进行转换。

3.13 类型表达式运算符

3.14 Accumulators ($group)

在$group阶段可用，累加器是操作符，当文档在管道中进展时，它们维护自己的状态(例如，总计、最大值、最小值和相关数据)。

在$group阶段中用作累加器时，这些操作符将单个表达式作为输入，对每个输入文档求值一次，并为共享相同组键的文档组维护它们的阶段。

3.15 Accumulators (in Other Stages)

在$group阶段可用作累加器的一些操作符也可用作其他阶段的累加器，但不能用作累加器。当在这些其他阶段使用时，这些操作符不维护它们的状态，可以接受单个参数或多个参数作为输入。有关详细信息，请参阅特定的操作员页面。

在3.2版本中进行了更改。
以下累加器操作符在$project、$addFields和$set stage中也可用。

3.16 变量表达式运算符

表达式运算符索引

十五、聚合的命令

请注意：
有关特定运算符的详细信息，包括语法和示例，请单击特定运算符进入其参考页面。

1. 聚合的命令

2. Aggregation Methods

十六、聚合命令比较

下表简要概述了MongoDB聚合命令的特性。

十七、聚合表达式中的变量

聚合表达式既可以使用用户定义的变量，也可以使用系统变量。
变量可以保存任何BSON类型的数据。要访问变量的值，在变量名前面加上双美元符号($$);即。“$ $ <variable>”。
如果变量引用对象，要访问对象中的特定字段，请使用点符号;即。变量“$ $ <variable >.<field>”。

1. 用户变量

用户变量名可以包含ascii字符[_a-zA-Z0-9]和任何非ascii字符。
用户变量名必须以小写的ascii字母[a-z]或非ascii字符开头。

2.系统变量

MongoDB提供了以下系统变量:

十八、SQL到聚合映射图

聚合管道允许MongoDB提供与SQL中的许多常见数据聚合操作相对应的本地聚合功能。

下表概述了常见的SQL聚合术语、函数和概念，以及相应的MongoDB聚合操作符:

1.实例

下表给出了SQL聚合语句和相应的MongoDB语句的快速引用。表中的例子假设了以下条件:

• SQL示例假设两个表orders和order_lineitem通过order_lineitem连接。order_id和订单。id列。
• MongoDB的例子假设一个收集订单，其中包含以下原型的文档:

{
  cust_id: "abc123",
  ord_date: ISODate("2012-11-02T17:04:11.102Z"),
  status: 'A',
  price: 50,
  items: [ { sku: "xxx", qty: 25, price: 1 },
           { sku: "yyy", qty: 25, price: 1 } ]
}

SELECT COUNT(*) AS count
FROM orders

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

SELECT SUM(price) AS total
FROM orders

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        total: { $sum: "$price" }
     }
   }
] )

SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )

SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id
ORDER BY total

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $sort: { total: 1 } }
] )

SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: { $dateToString: {
              format: "%Y-%m-%d",
              date: "$ord_date"
           }}
        },
        total: { $sum: "$price" }
     }
   }
] )

SELECT cust_id,
       count(*)
FROM orders
GROUP BY cust_id
HAVING count(*) > 1

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        count: { $sum: 1 }
     }
   },
   { $match: { count: { $gt: 1 } } }
] )

SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date
HAVING total > 250

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: { $dateToString: {
              format: "%Y-%m-%d",
              date: "$ord_date"
           }}
        },
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )

SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

SELECT cust_id,
       SUM(li.qty) as qty
FROM orders o,
     order_lineitem li
WHERE li.order_id = o.id
GROUP BY cust_id

db.orders.aggregate( [
   { $unwind: "$items" },
   {
     $group: {
        _id: "$cust_id",
        qty: { $sum: "$items.qty" }
     }
   }
] )

SELECT COUNT(*)
FROM (SELECT cust_id,
             ord_date
      FROM orders
      GROUP BY cust_id,
               ord_date)
      as DerivedTable

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: { $dateToString: {
              format: "%Y-%m-%d",
              date: "$ord_date"
           }}
        }
     }
   },
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

• 点赞
• 收藏
• 分享
• • 文章举报

标签：返回,聚合,MongoDB,Aggregation,管道,文档,id,表达式
来源： https://blog.csdn.net/qq_33642970/article/details/104170035

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。