aggregate

Command Fields命令字段

The aggregate command takes the following fields as arguments:aggregate命令将以下字段作为参数：

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

{ <variable_name_1>: <expression_1>,
  ...,
  <variable_name_n>: <expression_n> }

MongoDB 3.6 removes the use of aggregate command without the cursor option unless the command includes the explain option. MongoDB 3.6删除了不带cursor选项的aggregate命令，除非该命令包含explain选项。Unless you include the explain option, you must specify the cursor option.除非包含explain选项，否则必须指定cursor选项。

• To indicate a cursor with the default batch size, specify cursor: {}.要使用默认批处理大小指示游标，请指定cursor: {}。
• To indicate a cursor with a non-default batch size, use cursor: {batchSize: <num> }.要使用非默认批次大小指示游标，请使用cursor: {batchSize: <num> }。

For more information about the aggregation pipeline Aggregation Pipeline, Aggregation Reference, and Aggregation Pipeline Limits.有关聚合管道聚合管道、聚合引用和聚合管道限制的详细信息。

Session Idle Timeout会话空闲超时

Starting in MongoDB 3.6, MongoDB drivers and mongosh associate all operations with a server session, with the exception of unacknowledged write operations. 从MongoDB 3.6开始，MongoDB驱动程序和mongosh将所有操作与服务器会话相关联，但未确认的写入操作除外。For operations not explicitly associated with a session (i.e. using Mongo.startSession()), MongoDB drivers and mongosh create an implicit session and associate it with the operation.对于未显式与会话关联的操作（即使用Mongo.startSession()），MongoDB驱动程序和mongosh创建一个隐式会话并将其与操作关联。

If a session is idle for longer than 30 minutes, the MongoDB server marks that session as expired and may close it at any time. 如果会话空闲时间超过30分钟，MongoDB服务器会将该会话标记为已过期，并可随时将其关闭。When the MongoDB server closes the session, it also kills any in-progress operations and open cursors associated with the session. 当MongoDB服务器关闭会话时，它还会终止与会话相关联的任何正在进行的操作和打开的游标。This includes cursors configured with noCursorTimeout() or a maxTimeMS() greater than 30 minutes.这包括配置了noCursorTimeout()或大于30分钟的maxTimeMS()的游标。

For operations that return a cursor, if the cursor may be idle for longer than 30 minutes, issue the operation within an explicit session using Mongo.startSession() and periodically refresh the session using the refreshSessions command. 对于返回游标的操作，如果游标空闲时间可能超过30分钟，请使用Mongo.startSession()在显式会话中发出操作，并使用refreshSessions命令定期刷新会话。See Session Idle Timeout for more information.有关详细信息，请参阅会话空闲超时。

Client Disconnection客户端断开连接

For aggregate operation that do not include the $out or $merge stages:对于不包括$out或$merge阶段的aggregate操作：

Starting in MongoDB 4.2, if the client that issued the aggregate disconnects before the operation completes, MongoDB marks the aggregate for termination (i.e. killOp on the operation).从MongoDB 4.2开始，如果发出aggregate的客户端在操作完成之前断开连接，MongoDB会将aggregate标记为终止（即操作上的killOp）。

Aggregate Data with Multi-Stage Pipeline使用多级管道聚合数据

A collection articles contains documents such as the following:集合articles包含以下文档：

{
   _id: ObjectId("52769ea0f3dc6ead47c9a1b2"),
   author: "abc123",
   title: "zzz",
   tags: [ "programming", "database", "mongodb" ]
}

The following example performs an aggregate operation on the articles collection to calculate the count of each distinct element in the tags array that appears in the collection.以下示例对articles集合执行aggregate操作，以计算出现在集合中的tags数组中的每个不同元素的计数。

db.runCommand( {
   aggregate: "articles",
   pipeline: [
      { $project: { tags: 1 } },
      { $unwind: "$tags" },
      { $group: { _id: "$tags", count: { $sum : 1 } } }
   ],
   cursor: { }
} )

In mongosh, this operation can use the db.collection.aggregate() helper as in the following:在mongosh中，此操作可以使用db.collection.aggregate()助手，如下所示：

db.articles.aggregate( [
   { $project: { tags: 1 } },
   { $unwind: "$tags" },
   { $group: { _id: "$tags", count: { $sum : 1 } } }
] )

Use $currentOp on an Admin Database在管理数据库上使用$currentOp

The following example runs a pipeline with two stages on the admin database. 以下示例在管理数据库上运行具有两个阶段的管道。The first stage runs the $currentOp operation and the second stage filters the results of that operation.第一阶段运行$currentOp操作，第二阶段筛选该操作的结果。

db.adminCommand( {
   aggregate : 1,
   pipeline : [ {
      $currentOp : { allUsers : true, idleConnections : true } }, {
      $match : { shard : "shard01" }
      }
   ],
   cursor : { }
} )

Return Information on the Aggregation Operation返回聚合操作的信息

The following aggregation operation sets the optional field explain to true to return information about the aggregation operation.以下聚合操作将可选字段explain设置为true，以返回有关聚合操作的信息。

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

Aggregate Data using External Sort使用外部排序聚合数据

Each individual pipeline stage has a limit of 100 megabytes of RAM. 每个管道级的RAM限制为100 MB。By default, if a stage exceeds this limit, MongoDB produces an error. 默认情况下，如果阶段超过此限制，MongoDB将生成错误。To allow pipeline processing to take up more space, set the allowDiskUse option to true to enable writing data to temporary files, as in the following example:要允许管道处理占用更多空间，请将allowDiskUse选项设置为true，以允许将数据写入临时文件，如下例所示：

db.stocks.aggregate( [
      { $sort : { cusip : 1, date: 1 } }
   ],
   { allowDiskUse: true }
)

Starting in MongoDB 4.2, the profiler log messages and diagnostic log messages includes a usedDisk indicator if any aggregation stage wrote data to temporary files due to memory restrictions.从MongoDB 4.2开始，如果任何聚合阶段由于内存限制将数据写入临时文件，探查器日志消息和诊断日志消息都包含usedDisk指示符。

Aggregate Data Specifying Batch Size指定批次大小的聚合数据

To specify an initial batch size, specify the batchSize in the cursor field, as in the following example:要指定初始批次大小，请在cursor字段中指定batchSize，如下例所示：

db.orders.aggregate( [
      { $match: { status: "A" } },
      { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },
      { $sort: { total: -1 } },
      { $limit: 2 }
   ],
   { cursor: { batchSize: 0 } }
)

The {batchSize: 0 } document specifies the size of the initialbatch size only. {batchSize:0}文档仅指定初始批大小的大小。Specify subsequent batch sizes to OP_GET_MORE operations as with other MongoDB cursors. 与其他MongoDB游标一样，为OP_GET_MORE操作指定后续批次大小。A batchSize of 0 means an empty first batch and is useful if you want to quickly get back a cursor or failure message, without doing significant server-side work.batchSize为0表示第一批为空，如果您想快速返回游标或失败消息，而不需要做大量的服务器端工作，那么它非常有用。

Specify a Collation指定排序规则

Collation排序规则 allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。

A collection myColl has the following documents:集合myColl包含以下文档：

{ _id: 1, category: "café", status: "A" }
{ _id: 2, category: "cafe", status: "a" }
{ _id: 3, category: "cafE", status: "a" }

The following aggregation operation includes the Collation option:以下聚合操作包括排序规则选项：

db.myColl.aggregate(
   [ { $match: { status: "A" } }, { $group: { _id: "$category", count: { $sum: 1 } } } ],
   { collation: { locale: "fr", strength: 1 } }
);

For descriptions on the collation fields, see Collation Document.有关排序字段的描述，请参阅排序文档。

Hint an Index提示索引

Create a collection foodColl with the following documents:使用以下文档创建集合foodColl：

db.foodColl.insertMany( [
   { _id: 1, category: "cake", type: "chocolate", qty: 10 },
   { _id: 2, category: "cake", type: "ice cream", qty: 25 },
   { _id: 3, category: "pie", type: "boston cream", qty: 20 },
   { _id: 4, category: "pie", type: "blueberry", qty: 15 }
] )

Create the following indexes:创建以下索引：

db.foodColl.createIndex( { qty: 1, type: 1 } );
db.foodColl.createIndex( { qty: 1, category: 1 } );

The following aggregation operation includes the hint option to force the usage of the specified index:以下聚合操作包含用于强制使用指定索引的hint选项：

db.foodColl.aggregate(
   [ { $sort: { qty: 1 }}, { $match: { category: "cake", qty: 10  } }, { $sort: { type: -1 } } ],
   { hint: { qty: 1, category: 1 } }
)

Override Default Read Concern覆盖默认读取问题

To override the default read concern level, use the readConcern option. 要覆盖默认的读取关注级别，请使用readConcern选项。The getMore command uses the readConcern level specified in the originating aggregate command.getMore命令使用原始aggregate命令中指定的readConcern级别。

You cannot use the $out or the $merge stage in conjunction with read concern "linearizable". 您不能将$out或$merge阶段与读取关注点"linearizable"结合使用。That is, if you specify "linearizable" read concern for db.collection.aggregate(), you cannot include either stages in the pipeline.也就是说，如果为db.collection.aggregate()指定"linearizable"读取关注点，则不能在管道中包含这两个阶段。

The following operation on a replica set specifies a read concern of "majority" to read the most recent copy of the data confirmed as having been written to a majority of the nodes.以下对副本集的操作将读取关注指定为"majority"，以读取确认已写入大多数节点的数据的最新副本。

db.restaurants.aggregate(
   [ { $match: { rating: { $lt: 5 } } } ],
   { readConcern: { level: "majority" } }
)

To ensure that a single thread can read its own writes, use "majority" read concern and "majority" write concern against the primary of the replica set.要确保单个线程可以读取自己的写入，请对副本集的主线程使用"majority"读取关注点和"majority"写入关注点。

Use Variables in let在let中使用变量

To define variables that you can access elsewhere in the command, use the let option.要定义可以在命令中其他位置访问的变量，请使用let选项。

Create a collection cakeSales containing sales for cake flavors:创建包含蛋糕口味销售的集合cakeSales：

db.cakeSales.insertMany( [
   { _id: 1, flavor: "chocolate", salesTotal: 1580 },
   { _id: 2, flavor: "strawberry", salesTotal: 4350 },
   { _id: 3, flavor: "cherry", salesTotal: 2150 }
] )

The following example:以下示例：

• retrieves the cake that has a salesTotal greater than 3000, which is the cake with an _id of 2检索salesTotal大于3000的蛋糕，即_id为2的蛋糕
• defines a targetTotal variable in let, which is referenced in $gt as $$targetTotal在let中定义targetTotal变量，该变量在$gt中被引用为$$targetToll

db.runCommand( {
   aggregate: db.cakeSales.getName(),
   pipeline: [
      { $match: {
           $expr: { $gt: [ "$salesTotal", "$$targetTotal" ] }
      } },
    ],
    cursor: {},
    let: { targetTotal: 3000 }
} )