常用聚合

阶段

$group

$group 阶段根据“组键”将文档分成组。输出是每个唯一组键的一个文档。

组键通常是一个字段或一组字段。组键也可以是表达式的结果。使用 $group 管道阶段中的 _id 字段来设置组键。请参阅下面的使用示例。
在 $group 阶段输出中，_id 字段被设为该文档的组键。
$group 不会对其输出文档进行排序。

$group 阶段具有以下原型形式：

{
 $group:
   {
     _id: <expression>, // Group key
     <field1>: { <accumulator1> : <expression1> },
     ...
   }
 }

字段	说明
`_id`	必需。 `_id`表达式指定群组键。如果指定的`_id` 值为空值或任何其他常量值，`$group` 阶段将返回聚合所有输入文档值的单个文档。请参阅按空值分组示例。
`field`	可选。使用累加器操作符进行计算。

_id 和累加器操作符可以接受任何有效的 expression。

累加器操作符

详见：https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/group/#accumulator-operator

$addToSet：将数据组成集合
$push：将数据组成列表
$avg：平均值，忽略非数值
$sum：数值总和
$bottom/ $top：按指定顺序返回最后一个/第一个
$count：文档数
$max / $min：最大/最小值

$match

根据指定的查询谓词筛选文档。匹配的文档将传递到下一个管道阶段。

{ $match: { <query predicate> } }

$match 查询谓词的语法与 find() 命令的查询参数中使用的语法相同。

尽可能早地将 $match 放在聚合管道中。由于 $match 限制了聚合管道中的文档总数，因此早期的 $match 操作会最大限度地减少管道中的处理量。
如果在管道的开头放置一个 $match，查询可以像使用任何其他 db.collection.find() 或 db.collection.findOne() 那样使用索引。

$count

将文档传递到下一阶段，该阶段包含输入到该阶段的文档数的计数。

{ $count: <string> }

<string> 是以计数为值的输出字段的名称。<string> 必须是非空字符串，不能以 $ 开头，也不能包含 . 字符。

$count 阶段相当于以下 $group 和 $project 序列：

db.collection.aggregate( [
   { $group: { _id: null, myCount: { $sum: 1 } } },
   { $project: { _id: 0 } }
] )

示例

使用以下文档创建名为 scores 的集合：

db.scores.insertMany( [
   { "_id" : 1, "subject" : "History", "score" : 88 },
   { "_id" : 2, "subject" : "History", "score" : 92 },
   { "_id" : 3, "subject" : "History", "score" : 97 },
   { "_id" : 4, "subject" : "History", "score" : 71 },
   { "_id" : 5, "subject" : "History", "score" : 79 },
   { "_id" : 6, "subject" : "History", "score" : 83 }
] )

以下聚合操作有两个阶段：

$match 阶段会排除 score 值小于或等于 80 的文档，以便将 score 大于 80 的文档传递到下一个阶段。
$count 阶段会返回聚合管道中剩余文档的计数，并将该值分配给名为 passing_scores 的字段。

db.scores.aggregate( [
   { $match: { score: { $gt: 80 } } },
   { $count: "passing_scores" }
] )

该操作返回以下结果：

{ "passing_scores" : 4 }

如果输入数据集为空，则 $count 不会返回结果。

$unwind

解构输入文档中的数组字段，以便为每个元素输出文档。每个输出文档都是输入文档，并用该元素替换该数组字段的值。

基础语法：

{ $unwind: <field path> }

可以将文档传递给 $unwind 以指定各种行为选项。

{
  $unwind:
    {
      path: <field path>,
      includeArrayIndex: <string>,
      preserveNullAndEmptyArrays: <boolean>
    }
}

字段	类型	说明
路径	字符串	数组字段的字段路径。如需指定字段路径，请在字段名称前加上美元符号 `$`，并用引号括起来。
includeArrayIndex	字符串	可选。新字段的名称，用于保存该元素的数组索引。名称不能以美元符号 `$` 开头。
preserveNullAndEmptyArrays	布尔	可选。`true`如果为，如果`path` 为 null、缺失或空大量，则`$unwind` 会输出文档。`false`如果为`path` ，如果为 null、缺失或空大量，则`$unwind` 不会输出文档。默认值为 `false`。

示例

展开数组

创建名为 inventory 的示例集合，其中包含以下文档：

db.inventory.insertOne({ "_id" : 1, "item" : "ABC1", sizes: [ "S", "M", "L"] })

以下聚合使用 $unwind 阶段为 sizes 数组中的每个元素输出一个文档：

db.inventory.aggregate( [ { $unwind : "$sizes" } ] )

操作返回以下结果：

{ "_id" : 1, "item" : "ABC1", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "L" }

每个文档都与输入文档完全相同，只是 sizes 字段的值不同，该字段现在采用原始 sizes 数组的值。

缺少或非数组值

考虑 clothing 集合。

db.clothing.insertMany([
  { "_id" : 1, "item" : "Shirt", "sizes": [ "S", "M", "L"] },
  { "_id" : 2, "item" : "Shorts", "sizes" : [ ] },
  { "_id" : 3, "item" : "Hat", "sizes": "M" },
  { "_id" : 4, "item" : "Gloves" },
  { "_id" : 5, "item" : "Scarf", "sizes" : null }
])

如果满足以下条件，则 $unwind 将 sizes 字段视为单元素数组：

该字段存在
该值不为空
该值不是空数组

用 $unwind 展开 sizes 数组：

db.clothing.aggregate( [ { $unwind: { path: "$sizes" } } ] )

$unwind 操作返回：

{ _id: 1, item: 'Shirt', sizes: 'S' },
{ _id: 1, item: 'Shirt', sizes: 'M' },
{ _id: 1, item: 'Shirt', sizes: 'L' },
{ _id: 3, item: 'Hat', sizes: 'M' }

在文档 "_id": 1 中，sizes 是一个填充数组。$unwind 为 sizes 字段中的每个元素返回一个文档。
在文档 "_id": 3 中，sizes 解析为单元素数组。
文档 "_id": 2, "_id": 4 和 "_id": 5 不会返回任何内容，因为 sizes 字段无法还原为单元素数组。

`preserveNullAndEmptyArrays` 和 `includeArrayIndex`

使用了以下集合：

db.inventory2.insertMany([
   { "_id" : 1, "item" : "ABC", price: NumberDecimal("80"), "sizes": [ "S", "M", "L"] },
   { "_id" : 2, "item" : "EFG", price: NumberDecimal("120"), "sizes" : [ ] },
   { "_id" : 3, "item" : "IJK", price: NumberDecimal("160"), "sizes": "M" },
   { "_id" : 4, "item" : "LMN" , price: NumberDecimal("10") },
   { "_id" : 5, "item" : "XYZ", price: NumberDecimal("5.75"), "sizes" : null }
])

使用 preserveNullAndEmptyArrays 选项来纳入 sizes 字段为 null、缺失或空数组的文档。

db.inventory2.aggregate( [
   { $unwind: { path: "$sizes", preserveNullAndEmptyArrays: true } }
] )

输出包括 sizes 字段为 null、缺失或空数组的文档：

{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "S" }
{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "M" }
{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "L" }
{ "_id" : 2, "item" : "EFG", "price" : NumberDecimal("120") }
{ "_id" : 3, "item" : "IJK", "price" : NumberDecimal("160"), "sizes" : "M" }
{ "_id" : 4, "item" : "LMN", "price" : NumberDecimal("10") }
{ "_id" : 5, "item" : "XYZ", "price" : NumberDecimal("5.75"), "sizes" : null }

使用 includeArrayIndex 选项以在输出中纳入数组索引。

db.inventory2.aggregate( [
  {
    $unwind:
      {
        path: "$sizes",
        includeArrayIndex: "arrayIndex"
      }
   }])

该操作展开 sizes 数组并将该数组索引包含在新的 arrayIndex 字段中。如果 sizes 字段未解析为填充数组，但不缺失、不为 null 或空数组，则 arrayIndex 字段为 null。

{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "S", "arrayIndex" : NumberLong(0) }
{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "M", "arrayIndex" : NumberLong(1) }
{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "L", "arrayIndex" : NumberLong(2) }
{ "_id" : 3, "item" : "IJK", "price" : NumberDecimal("160"), "sizes" : "M", "arrayIndex" : null }

按未展开值分组

在 mongosh 中创建名为 inventory2 的示例集合，其中包含以下文档：

db.inventory2.insertMany([
  { "_id" : 1, "item" : "ABC", price: NumberDecimal("80"), "sizes": [ "S", "M", "L"] },
  { "_id" : 2, "item" : "EFG", price: NumberDecimal("120"), "sizes" : [ ] },
  { "_id" : 3, "item" : "IJK", price: NumberDecimal("160"), "sizes": "M" },
  { "_id" : 4, "item" : "LMN" , price: NumberDecimal("10") },
  { "_id" : 5, "item" : "XYZ", price: NumberDecimal("5.75"), "sizes" : null }
])

以下管道会展开 sizes 数组，并按展开的大小值对生成的文档进行分组：

db.inventory2.aggregate( [
   // First Stage
   {
     $unwind: { path: "$sizes", preserveNullAndEmptyArrays: true }
   },
   // Second Stage
   {
     $group:
       {
         _id: "$sizes",
         averagePrice: { $avg: "$price" }
       }
   },
   // Third Stage
   {
     $sort: { "averagePrice": -1 }
   }
] )

第一个阶段：

{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "S" }
{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "M" }
{ "_id" : 1, "item" : "ABC", "price" : NumberDecimal("80"), "sizes" : "L" }
{ "_id" : 2, "item" : "EFG", "price" : NumberDecimal("120") }
{ "_id" : 3, "item" : "IJK", "price" : NumberDecimal("160"), "sizes" : "M" }
{ "_id" : 4, "item" : "LMN", "price" : NumberDecimal("10") }
{ "_id" : 5, "item" : "XYZ", "price" : NumberDecimal("5.75"), "sizes" : null }

第二个阶段：

{ "_id" : "S", "averagePrice" : NumberDecimal("80") }
{ "_id" : "L", "averagePrice" : NumberDecimal("80") }
{ "_id" : "M", "averagePrice" : NumberDecimal("120") }
{ "_id" : null, "averagePrice" : NumberDecimal("45.25") }

第三个阶段：

{ "_id" : "M", "averagePrice" : NumberDecimal("120") }
{ "_id" : "L", "averagePrice" : NumberDecimal("80") }
{ "_id" : "S", "averagePrice" : NumberDecimal("80") }
{ "_id" : null, "averagePrice" : NumberDecimal("45.25") }

展开嵌入式数组

创建名为 sales 的示例集合，其中包含以下文档：

db.sales.insertMany([
  {
    _id: "1",
    "items" : [
     {
      "name" : "pens",
      "tags" : [ "writing", "office", "school", "stationary" ],
      "price" : NumberDecimal("12.00"),
      "quantity" : NumberInt("5")
     },
     {
      "name" : "envelopes",
      "tags" : [ "stationary", "office" ],
      "price" : NumberDecimal("19.95"),
      "quantity" : NumberInt("8")
     }
    ]
  },
  {
    _id: "2",
    "items" : [
     {
      "name" : "laptop",
      "tags" : [ "office", "electronics" ],
      "price" : NumberDecimal("800.00"),
      "quantity" : NumberInt("1")
     },
     {
      "name" : "notepad",
      "tags" : [ "stationary", "school" ],
      "price" : NumberDecimal("14.95"),
      "quantity" : NumberInt("3")
     }
    ]
  }
])

下面的操作按标签对已售出的物品进行分组，然后计算每个标签的总销售额。

db.sales.aggregate([
  // First Stage
  { $unwind: "$items" },

  // Second Stage
  { $unwind: "$items.tags" },

  // Third Stage
  {
    $group:
      {
        _id: "$items.tags",
        totalSalesAmount:
          {
            $sum: { $multiply: [ "$items.price", "$items.quantity" ] }
          }
      }
  }
])

第一个阶段：

{ "_id" : "1", "items" : { "name" : "pens", "tags" : [ "writing", "office", "school", "stationary" ], "price" : NumberDecimal("12.00"), "quantity" : 5 } }
{ "_id" : "1", "items" : { "name" : "envelopes", "tags" : [ "stationary", "office" ], "price" : NumberDecimal("19.95"), "quantity" : 8 } }
{ "_id" : "2", "items" : { "name" : "laptop", "tags" : [ "office", "electronics" ], "price" : NumberDecimal("800.00"), "quantity" : 1 } }
{ "_id" : "2", "items" : { "name" : "notepad", "tags" : [ "stationary", "school" ], "price" : NumberDecimal("14.95"), "quantity" : 3 } }

第二阶段：

{ "_id" : "1", "items" : { "name" : "pens", "tags" : "writing", "price" : NumberDecimal("12.00"), "quantity" : 5 } }
{ "_id" : "1", "items" : { "name" : "pens", "tags" : "office", "price" : NumberDecimal("12.00"), "quantity" : 5 } }
{ "_id" : "1", "items" : { "name" : "pens", "tags" : "school", "price" : NumberDecimal("12.00"), "quantity" : 5 } }
{ "_id" : "1", "items" : { "name" : "pens", "tags" : "stationary", "price" : NumberDecimal("12.00"), "quantity" : 5 } }
{ "_id" : "1", "items" : { "name" : "envelopes", "tags" : "stationary", "price" : NumberDecimal("19.95"), "quantity" : 8 } }
{ "_id" : "1", "items" : { "name" : "envelopes", "tags" : "office", "price" : NumberDecimal("19.95"), "quantity" : 8 } }
{ "_id" : "2", "items" : { "name" : "laptop", "tags" : "office", "price" : NumberDecimal("800.00"), "quantity" : 1 } }
{ "_id" : "2", "items" : { "name" : "laptop", "tags" : "electronics", "price" : NumberDecimal("800.00"), "quantity" : 1 } }
{ "_id" : "2", "items" : { "name" : "notepad", "tags" : "stationary", "price" : NumberDecimal("14.95"), "quantity" : 3 } }
{ "_id" : "2", "items" : { "name" : "notepad", "tags" : "school", "price" : NumberDecimal("14.95"), "quantity" : 3 } }

第三个阶段

{ "_id" : "writing", "totalSalesAmount" : NumberDecimal("60.00") }
{ "_id" : "stationary", "totalSalesAmount" : NumberDecimal("264.45") }
{ "_id" : "electronics", "totalSalesAmount" : NumberDecimal("800.00") }
{ "_id" : "school", "totalSalesAmount" : NumberDecimal("104.85") }
{ "_id" : "office", "totalSalesAmount" : NumberDecimal("1019.60") }

$lookup

对同一数据库中的另一个集合执行左外连接，以过滤“已连接”集合中的文档以便进行处理。$lookup 阶段向每个输入文档添加一个新的数组字段，其包含来自“已连接”集合的匹配文档。

语法

涉及单个条件联接的等值匹配

要在输入文档中的字段与“已连接”集合文档中的字段之间执行等值匹配，$lookup 阶段需具有以下语法：

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}

语法值	解释说明
`from`	同一个数据库下等待被Join的集合。
`localField`	源集合中的 match 值，如果输入的集合中，某文档没有 localField 这个 Key（Field），在处理的过程中，会默认为此文档含有 localField：null 的键值对。
`foreignField`	待 Join 的集合的match值，如果待 Join 的集合中，文档没有 foreignField 值，在处理的过程中，会默认为此文档含有 foreignField：null 的键值对。
`as`	为输出文档的新增值命名。如果输入的集合中已存在该值，则会覆盖掉，

该操作对应于如下伪 SQL 语句：

SELECT *, (
   SELECT ARRAY_AGG(*)
   FROM <collection to join>
   WHERE <foreignField> = <collection.localField>
) AS <output array field>
FROM collection;

示例：使用 $lookup 执行单一等式连接

已联接集合上的联接条件和子查询

要对两个集合执行关联和非关联子查询，并执行除单一等值匹配外的其他联接条件，请使用此 $lookup 语法：

{
   $lookup:
      {
         from: <joined collection>,
         let: { <var_1>: <expression>, …, <var_n>: <expression> },
         pipeline: [ <pipeline to run on joined collection> ],
         as: <output array field>
      }
}

该操作对应于如下伪 SQL 语句：

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (
   SELECT <documents as determined from the pipeline>
   FROM <collection to join>
   WHERE <pipeline>
);

示例：使用多个连接条件和关联子查询

采用简洁语法的关联子查询

从 MongoDB 5.0 开始，聚合管道 $lookup 阶段支持简洁关联子查询语法，该语法改进了集合之间的联接。新的简洁语法取消了在 $match 阶段对 $expr 操作符内的外部和本地字段进行等值匹配的要求。

{
   $lookup:
      {
         from: <foreign collection>,
         localField: <field from local collection's documents>,
         foreignField: <field from foreign collection's documents>,
         let: { <var_1>: <expression>, …, <var_n>: <expression> },
         pipeline: [ <pipeline to run> ],
         as: <output array field>
      }
}

该操作对应于如下伪 SQL 语句：

SELECT *, <output array field>
FROM localCollection
WHERE <output array field> IN (
   SELECT <documents as determined from the pipeline>
   FROM <foreignCollection>
   WHERE <foreignCollection.foreignField> = <localCollection.localField>
   AND <pipeline match condition>
);

示例：使用 $lookup 执行简洁关联子查询

性能考虑因素

$lookup 性能取决于执行的操作类型。请参阅下表了解不同 $lookup 操作的性能注意事项。

`$lookup` 操作	性能考虑因素
涉及单个联接的等值匹配	当外部集合在 `foreignField` 上包含索引时，使用单个联接执行等值匹配的 `$lookup` 操作通常具有较好的性能。
不相关的子查询	在内部管道可以引用外部集合的索引时，包含不相关子查询的 `$lookup` 操作具有较好的性能。MongoDB 只需要在缓存查询之前运行一次 `$lookup` 子查询，因为源和外部集合之间没有关系。子查询不基于源集合中的任何值。此行为可提高后续执行 `$lookup` 操作的性能。
关联子查询	当满足以下条件时，包含相关子查询的 `$lookup` 操作通常具有较好性能：该外部集合包含 `foreignField` 上的一个索引。外部收集包含引用内部管道的索引。如果管道将大量文档传递给 `$lookup` 查询，以下策略可能会提高性能：减少 MongoDB 传递给 `$lookup` 查询的文档数量。例如，在 `$match` 阶段设定更严格的筛选器。将子查询的内部管道作为单独查询运行，并使用`$lookup` `$out`创建临时集合。然后，使用单个联接运行等值匹配。重新考虑数据的模式，以确保它对于使用案例来说是最佳的。

$addFields

为文档添加新字段。$addFields 输出文档包含输入文档中的所有现有字段和新添加的字段。

$addFields 阶段等效于 $project 阶段，后者明确指定输入文档中的所有现有字段并添加新字段。

{ $addFields: { <newField>: <expression>, ... } }

示例

使用两个 `$addFields` 阶段

名为 scores 的集合包含以下文档：

db.scores.insertMany( [
   {
      _id: 1,
      student: "Maya",
      homework: [ 10, 5, 10 ],
      quiz: [ 10, 8 ],
      extraCredit: 0
   },
   {
      _id: 2,
      student: "Ryan",
      homework: [ 5, 6, 5 ],
      quiz: [ 8, 8 ],
      extraCredit: 8
   }
] )

下面的操作使用两个 $addFields 阶段在输出文档中包含三个新字段：

db.scores.aggregate( [
   {
     $addFields: {
       totalHomework: { $sum: "$homework" } ,
       totalQuiz: { $sum: "$quiz" }
     }
   },
   {
     $addFields: { totalScore:
       { $add: [ "$totalHomework", "$totalQuiz", "$extraCredit" ] } }
   }
] )

该操作将返回以下文档：

[
   {
      _id: 1,
      student: "Maya",
      homework: [ 10, 5, 10 ],
      quiz: [ 10, 8 ],
      extraCredit: 0,
      totalHomework: 25,
      totalQuiz: 18,
      totalScore: 43
   },
   {
      _id: 2,
      student: "Ryan",
      homework: [ 5, 6, 5 ],
      quiz: [ 8, 8 ],
      extraCredit: 8,
      totalHomework: 16,
      totalQuiz: 16,
      totalScore: 40
   }
]

为嵌入式文档添加字段

使用点符号为嵌入式文档添加新字段。

例如，创建一个包含以下文档的名为 vehicles 的集合：

db.vehicles.insertMany( [
      { _id: 1, type: "car", specs: { doors: 4, wheels: 4 } },
      { _id: 2, type: "motorcycle", specs: { doors: 0, wheels: 2 } },
      { _id: 3, type: "jet ski" }
] )

以下聚合操作将新字段 fuel_type 添加到嵌入式文档 specs。

db.vehicles.aggregate( [
   { $addFields: { "specs.fuel_type": "unleaded" } }
] )

操作返回以下结果：

[
   { _id: 1, type: "car",
      specs: { doors: 4, wheels: 4, fuel_type: "unleaded" } },
   { _id: 2, type: "motorcycle",
      specs: { doors: 0, wheels: 2, fuel_type: "unleaded" } },
   { _id: 3, type: "jet ski",
      specs: { fuel_type: "unleaded" } }
]

覆盖现有字段

在 $addFields 操作中指定现有字段名称会导致原始字段被替换。

名为 animals 的集合包含以下文档：

db.animals.insertOne(
   { _id: 1, dogs: 10, cats: 15 }
)

以下 $addFields 操作指定 cats 字段。

db.animals.aggregate( [
  {
    $addFields: { cats: 20 }
  }
] )

该操作将返回以下文档：

[ { _id: 1, dogs: 10, cats: 20 } ]

可以用一个字段替换另一个字段。在以下示例中，item 字段替换了 _id 字段。

名为 fruit 的集合包含以下文档：

db.fruit.insertMany( [
   { _id: 1, item: "tangerine", type: "citrus" },
   { _id: 2, item: "lemon", type: "citrus" },
   { _id: 3, item: "grapefruit", type: "citrus" }
] )

以下聚合操作使用 $addFields 将每个文档的 _id 字段替换为 item 字段的值，并将 item 字段替换为静态值。

db.fruit.aggregate( [
  {
    $addFields: {
      _id : "$item",
      item: "fruit"
    }
  }
] )

该操作返回以下内容：

[
   { _id: "tangerine", item: "fruit", type: "citrus" },
   { _id: "lemon", item: "fruit", type: "citrus" },
   { _id: "grapefruit", item: "fruit", type: "citrus" }
]

向数组添加元素

创建一个包含以下内容的示例 scores 集合：

db.scores.insertMany( [
   { _id: 1, student: "Maya", homework: [ 10, 5, 10 ], quiz: [ 10, 8 ], extraCredit: 0 },
   { _id: 2, student: "Ryan", homework: [ 5, 6, 5 ], quiz: [ 8, 8 ], extraCredit: 8 }
] )

您可以使用 $addFields 和 $concatArrays 表达式向现有数组字段添加元素。例如，以下操作使用 $addFields 将 homework 字段替换为一个新数组，该数组的元素是当前 homework 数组与另一个数组的拼接，该数组包含新分数 [ 7 ]。

db.scores.aggregate( [
   { $match: { _id: 1 } },
   { $addFields: { homework: { $concatArrays: [ "$homework", [ 7 ] ] } } }
] )

该操作返回以下内容：

[ { _id: 1, student: "Maya", homework: [ 10, 5, 10, 7 ], quiz: [ 10, 8 ], extraCredit: 0 } ]

removeFields

您可以使用 $addFields 和 $REMOVE 变量来删除文档字段。

例如，创建 labReadings 集合：

db.labReadings.insertMany( [
   {
      date: ISODate("2024-10-09"),
      temperature: 80
   },
   {
      date: null,
      temperature: 83
   },
   {
      date: ISODate("2024-12-09"),
      temperature: 85
   }
] )

要从 labReadings 文档中删除 date 字段，请使用带有 $REMOVE 变量的 $addFields：

db.labReadings.aggregate( [
   {
      $addFields: { date: "$$REMOVE" }
   }
] )

输出：

[
   { _id: ObjectId('671285306fd2c3b24f2e7eaa'), temperature: 80 },
   { _id: ObjectId('671285306fd2c3b24f2e7eab'), temperature: 83 },
   { _id: ObjectId('671285306fd2c3b24f2e7eac'), temperature: 85 }
]

您也可以使用 $REMOVE 有条件地删除字段。例如，以下聚合从 date 为 null 的文档中删除 date 字段：

db.labReadings.aggregate( [
   {
      $addFields:
         {
            date: {
               $ifNull: [ "$date", "$$REMOVE" ]
            }
         }
   }
] )

输出：

[
   {
      _id: ObjectId('671285306fd2c3b24f2e7eaa'),
      date: ISODate('2024-10-09T00:00:00.000Z'),
      temperature: 80
   },
   { _id: ObjectId('671285306fd2c3b24f2e7eab'), temperature: 83 },
   {
      _id: ObjectId('671285306fd2c3b24f2e7eac'),
      date: ISODate('2024-12-09T00:00:00.000Z'),
      temperature: 85
   }
]

操作符

$add：将数字相加或将数字和日期相加

$add: [ 1, 2, 3, '$a', '$b', '$c' ]

$addToSet：返回所有唯一值的数组

返回的数组中元素的顺序未指定

常用聚合

阶段​

$group​

累加器操作符​

$match​

$count​

示例​

$unwind​

示例​

展开数组​

缺少或非数组值​

preserveNullAndEmptyArrays 和 includeArrayIndex​

按未展开值分组​

展开嵌入式数组​

$lookup​

语法​

涉及单个条件联接的等值匹配​

已联接集合上的联接条件和子查询​

采用简洁语法的关联子查询​

性能考虑因素​

$addFields​

示例​

使用两个 $addFields 阶段​

为嵌入式文档添加字段​

覆盖现有字段​

向数组添加元素​

removeFields​

操作符​

阶段

$group

累加器操作符

$match

$count

示例

$unwind

示例

展开数组

缺少或非数组值

`preserveNullAndEmptyArrays` 和 `includeArrayIndex`

按未展开值分组

展开嵌入式数组

$lookup

语法

涉及单个条件联接的等值匹配

已联接集合上的联接条件和子查询

采用简洁语法的关联子查询

性能考虑因素

$addFields

示例

使用两个 `$addFields` 阶段

为嵌入式文档添加字段

覆盖现有字段

向数组添加元素

removeFields

操作符