aggregate (database command)（数据库命令）

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

You must use the aggregate command with the cursor option unless the command includes the explain option.除非命令中包含explain选项，否则必须将aggregate命令与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, see:有关聚合管道的更多信息，请参阅：

• Aggregation Pipeline聚合管道
• Aggregation Reference聚合参考
• 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. When the MongoDB server closes the session, it also kills any in-progress operations and open cursors associated with the session. 如果会话空闲时间超过30分钟，MongoDB服务器会将该会话标记为已过期，并可能随时将其关闭。当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阶段的聚合操作：

If the client that issued aggregate disconnects before the operation completes, MongoDB marks aggregate for termination using killOp.如果发出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. These temporary files last for the duration of the pipeline execution and can influence storage space on your instance. 从MongoDB 6.0开始，默认情况下，需要超过100兆字节内存来执行将临时文件写入磁盘的流水线阶段。这些临时文件在管道执行期间持续存在，并可能影响实例上的存储空间。In earlier versions 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 can 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 }禁止将临时文件写入磁盘

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.如果由于内存限制，任何聚合阶段将数据写入临时文件，分析器日志消息和诊断日志消息都会包含一个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. This batch size is useful for quickly returning a cursor or failure message without doing significant server-side work.{ cursor: { batchSize: 0 } }文档指定了初始批大小的大小，表示第一批为空。此批大小对于快速返回游标或失败消息非常有用，而无需进行大量的服务器端工作。

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 }
} )