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会话空闲超时

MongoDB drivers and mongosh associate all operations with a server session, with the exception of unacknowledged write operations. 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()或maxTimeMS()大于30分钟的游标。

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. See Session Idle Timeout for more information.对于返回游标的操作，如果游标空闲时间可能超过30分钟，请使用Mongo.startSession()在显式会话中发出操作，并使用refreshSessions命令定期刷新会话。有关详细信息，请参阅会话空闲超时。

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 aggregate disconnects before the operation completes, MongoDB marks aggregate for termination using killOp.从MongoDB 4.2开始，如果在操作完成之前发出aggregate的客户端断开连接，MongoDB会使用killOp标记aggregate以终止。

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在admin数据库上使用$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 }
)

Interaction with allowDiskUseByDefault与allowDiskUseByDefault的交互

Starting in MongoDB 6.0, pipeline stages that require more than 100 megabytes of memory to execute write temporary files to disk by default. 从MongoDB 6.0开始，需要超过100MB内存才能执行的管道阶段默认情况下会将临时文件写入磁盘。In earlier verisons of MongoDB, you must pass { allowDiskUse: true } to individual find and aggregate commands to enable this behavior.在MongoDB的早期版本中，必须将{ allowDiskUse: true }传递给单个find和aggregate命令才能启用此行为。

Individual find and aggregate commands may override the allowDiskUseByDefault parameter by either:单独的find和aggregate命令可以通过以下方式覆盖allowDiskUseByDefault参数：

• Using { allowDiskUse: true } to allow writing temporary files out to disk when allowDiskUseByDefault is set to false当allowDiskUseByDefault设置为false时，使用{ allowDiskUse: true }允许将临时文件写入磁盘
• Using { allowDiskUse: false } to prohibit writing temporary files out to disk when allowDiskUseByDefault is set to true当allowDiskUseByDefault设置为true时，使用{ allowDiskUse: false }禁止将临时文件写入磁盘

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 { cursor: { batchSize: 0 } } document, which specifies the size of the initial batch size, indicates an empty first batch. 指定初始批大小的{ cursor: { batchSize: 0 } }文档表示第一批为空。This batch size is useful for quickly returning a cursor or failure message without doing significant server-side work.这个批量大小对于快速返回游标或失败消息非常有用，而不需要做大量的服务器端工作。

To specify batch size for subsequent getMore operations (after the initial batch), use the batchSize field when running the getMore command.要为后续的getMore操作指定批处理大小（在初始批处理之后），请在运行getMore命令时使用batchSize字段。

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:以下聚合操作包括collation选项：

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命令使用原始聚合命令中指定的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中被引用为$$targetTotal

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