文档菜单
文档首页
/
MongoDB 手册
/
聚合操作
/
参考
/
阶段

$replaceWith (聚合)

在本页中

  • 定义
  • 行为
  • 示例

定义

$replaceWith

用指定的文档替换输入文档。该操作替换输入文档中所有现有字段，包括 _id 字段。$replaceWith，可以将嵌入式文档提升到顶层。您还可以指定新的文档作为替换。

$replaceWith 阶段执行的操作与$replaceRoot 阶段相同，但这两个阶段的形式不同。

$replaceWith 阶段具有以下形式

{ $replaceWith: <replacementDocument> }

替换文档可以是任何有效的 表达式，该表达式解析为文档。有关表达式的更多信息，请参阅 表达式运算符。

行为

如果 `<replacementDocument>` 不是一个文档，则 `$replaceWith` 会出错并失败。

如果 `<replacementDocument>` 解析为一个不存在的文档，则 `$replaceWith` 会出错并失败。例如，创建一个包含以下文档的集合

db.collection.insertMany([
   { "_id": 1, "name" : { "first" : "John", "last" : "Backus" } },
   { "_id": 2, "name" : { "first" : "John", "last" : "McCarthy" } },
   { "_id": 3, "name": { "first" : "Grace", "last" : "Hopper" } },
   { "_id": 4, "firstname": "Ole-Johan", "lastname" : "Dahl" },
])

然后以下 `$replaceWith` 操作会失败，因为其中一个文档缺少 `name` 字段

db.collection.aggregate([
   { $replaceWith: "$name" }
])

为了避免错误，您可以使用 `$mergeObjects` 将 `name` 文档与某个默认文档合并；例如

db.collection.aggregate([
   { $replaceWith: { $mergeObjects: [ { _id: "$_id", first: "", last: "" }, "$name" ] } }
])

或者，您可以通过包含一个 $match 阶段来跳过缺少 `name` 字段的文档，以检查文档字段的存在性，然后再将文档传递到 `$replaceWith` 阶段

db.collection.aggregate([
   { $match: { name : { $exists: true, $not: { $type: "array" }, $type: "object" } } },
   { $replaceWith: "$name" }
])

或者，您可以使用 $ifNull 表达式来指定其他文档作为根；例如

db.collection.aggregate([
   { $replaceWith: { $ifNull: [ "$name", { _id: "$_id", missingName: true} ] } }
])

示例

$replaceWith 一个嵌入式文档字段

创建一个名为 people 的集合，包含以下文档

db.people.insertMany([
   { "_id" : 1, "name" : "Arlene", "age" : 34, "pets" : { "dogs" : 2, "cats" : 1 } },
   { "_id" : 2, "name" : "Sam", "age" : 41, "pets" : { "cats" : 1, "fish" : 3 } },
   { "_id" : 3, "name" : "Maria", "age" : 25 }
])

以下操作使用 $replaceWith 阶段将每个输入文档替换为 $mergeObjects 操作的结果。该 $mergeObjects 表达式将指定的默认文档与 pets 文档合并。

db.people.aggregate( [
   { $replaceWith: { $mergeObjects:  [ { dogs: 0, cats: 0, birds: 0, fish: 0 }, "$pets" ] } }
] )

该操作返回以下结果

{ "dogs" : 2, "cats" : 1, "birds" : 0, "fish" : 0 }
{ "dogs" : 0, "cats" : 1, "birds" : 0, "fish" : 3 }
{ "dogs" : 0, "cats" : 0, "birds" : 0, "fish" : 0 }

$replaceWith 一个嵌套在数组中的文档

名为 students 的集合包含以下文档

db.students.insertMany([
   {
      "_id" : 1,
      "grades" : [
         { "test": 1, "grade" : 80, "mean" : 75, "std" : 6 },
         { "test": 2, "grade" : 85, "mean" : 90, "std" : 4 },
         { "test": 3, "grade" : 95, "mean" : 85, "std" : 6 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "test": 1, "grade" : 90, "mean" : 75, "std" : 6 },
         { "test": 2, "grade" : 87, "mean" : 90, "std" : 3 },
         { "test": 3, "grade" : 91, "mean" : 85, "std" : 4 }
      ]
   }
])

以下操作将具有大于或等于 90 的 grade 字段的嵌入式文档提升到顶层

db.students.aggregate( [
   { $unwind: "$grades" },
   { $match: { "grades.grade" : { $gte: 90 } } },
   { $replaceWith: "$grades" }
] )

该操作返回以下结果

{ "test" : 3, "grade" : 95, "mean" : 85, "std" : 6 }
{ "test" : 1, "grade" : 90, "mean" : 75, "std" : 6 }
{ "test" : 3, "grade" : 91, "mean" : 85, "std" : 4 }

$replaceWith 一个新创建的文档

示例 1

一个示例集合 sales 被以下文档填充

db.sales.insertMany([
   { "_id" : 1, "item" : "butter", "price" : 10, "quantity": 2, date: ISODate("2019-03-01T08:00:00Z"), status: "C" },
   { "_id" : 2, "item" : "cream", "price" : 20, "quantity": 1, date: ISODate("2019-03-01T09:00:00Z"), status: "A" },
   { "_id" : 3, "item" : "jam", "price" : 5, "quantity": 10, date: ISODate("2019-03-15T09:00:00Z"), status: "C" },
   { "_id" : 4, "item" : "muffins", "price" : 5, "quantity": 10, date: ISODate("2019-03-15T09:00:00Z"), status: "C" }
])

假设为了报告目的，您希望在每个完成的销售中计算截至当前报告运行时间的总金额。以下操作找到所有状态为 C 的销售，并使用 $replaceWith 阶段创建新文档。$replaceWith 计算总金额，并使用变量 NOW 获取当前时间。

db.sales.aggregate([
   { $match: { status: "C" } },
   { $replaceWith: { _id: "$_id", item: "$item", amount: { $multiply: [ "$price", "$quantity"]}, status: "Complete", asofDate: "$$NOW" } }
])

该操作返回以下文档

{ "_id" : 1, "item" : "butter", "amount" : 20, "status" : "Complete", "asofDate" : ISODate("2019-06-03T22:47:54.812Z") }
{ "_id" : 3, "item" : "jam", "amount" : 50, "status" : "Complete", "asofDate" : ISODate("2019-06-03T22:47:54.812Z") }
{ "_id" : 4, "item" : "muffins", "amount" : 50, "status" : "Complete", "asofDate" : ISODate("2019-06-03T22:47:54.812Z") }

示例 2

一个示例集合 reportedsales 被按季度和地区填充的已报告销售信息

db.reportedsales.insertMany( [
   { _id: 1, quarter: "2019Q1", region: "A", qty: 400 },
   { _id: 2, quarter: "2019Q1", region: "B", qty: 550 },
   { _id: 3, quarter: "2019Q1", region: "C", qty: 1000 },
   { _id: 4, quarter: "2019Q2", region: "A", qty: 660 },
   { _id: 5, quarter: "2019Q2", region: "B", qty: 500 },
   { _id: 6, quarter: "2019Q2", region: "C", qty: 1200 }
] )

假设为了报告目的，您想按季度查看已报告的销售数据；例如

{ "_id" : "2019Q1", "A" : 400, "B" : 550, "C" : 1000 }

要按季度分组查看数据，可以使用以下聚合管道

db.reportedsales.aggregate( [
   { $addFields: { obj:  { k: "$region", v: "$qty" } } },
   { $group: { _id: "$quarter", items: { $push: "$obj" } } },
   { $project: { items2: { $concatArrays: [ [ { "k": "_id", "v": "$_id" } ], "$items" ] } } },
   { $replaceWith: { $arrayToObject: "$items2" } }
] )
第一阶段

$addFields 阶段添加一个新文档字段 obj，该字段定义键 k 为区域值，值 v 为该区域的数量。例如

{ "_id" : 1, "quarter" : "2019Q1", "region" : "A", "qty" : 400, "obj" : { "k" : "A", "v" : 400 } }
第二阶段

$group 阶段按季度分组，并使用 $push 将 obj 字段累积到新的 items 数组字段中。例如

{ "_id" : "2019Q1", "items" : [ { "k" : "A", "v" : 400 }, { "k" : "B", "v" : 550 }, { "k" : "C", "v" : 1000 } ] }
第三阶段

$project 阶段使用 $concatArrays 创建一个新的数组 items2，其中包含 _id 信息和来自 items 数组的元素

{ "_id" : "2019Q1", "items2" : [ { "k" : "_id", "v" : "2019Q1" }, { "k" : "A", "v" : 400 }, { "k" : "B", "v" : 550 }, { "k" : "C", "v" : 1000 } ] }
第四阶段

$replaceWith 使用 $arrayToObject 将 items2 转换为一个文档，使用指定的键 k 和值 v 对，并将该文档输出到下一个阶段。例如

{ "_id" : "2019Q1", "A" : 400, "B" : 550, "C" : 1000 }

聚合返回以下文档

{ "_id" : "2019Q1", "A" : 400, "B" : 550, "C" : 1000 }
{ "_id" : "2019Q2", "A" : 660, "B" : 500, "C" : 1200 }

$replaceWith 从 $$ROOT 和默认文档创建新文档

创建一个名为 contacts 的集合，包含以下文档

db.contacts.insertMany( [
   { "_id" : 1, name: "Fred", email: "fred@example.net" },
   { "_id" : 2, name: "Frank N. Stine", cell: "012-345-9999" },
   { "_id" : 3, name: "Gren Dell", cell: "987-654-3210", email: "beo@example.net" }
] )

以下操作使用 $replaceWith 和 $mergeObjects 将缺失字段的默认值输出到当前文档

db.contacts.aggregate( [
   { $replaceWith:
      { $mergeObjects:
         [
            { _id: "", name: "", email: "", cell: "", home: "" },
            "$$ROOT"
         ]
      }
   }
] )

聚合返回以下文档

{
  _id: 1,
  name: 'Fred',
  email: 'fred@example.net',
  cell: '',
  home: ''
},
{
  _id: 2,
  name: 'Frank N. Stine',
  email: '',
  cell: '012-345-9999',
  home: ''
},
{
  _id: 3,
  name: 'Gren Dell',
  email: 'beo@example.net',
  cell: '',
  home: '987-654-3210'
}

返回

$replaceRoot

下一页

$sample

在本页中