Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/
Referência
/
Operadores
/
Estágios do pipeline de agregação

$replaceRoot (agregação)

Nesta página

  • Definição
  • Comportamento
  • Exemplos

Definição

$replaceRoot

Substitui o documento de entrada pelo documento especificado. A operação substitui todos os campos existentes no documento de entrada, incluindo o campo _id. Você pode promover um documento incorporado existente ao nível superior ou criar um novo documento para promoção (consulte exemplo).

Observação

Você também pode usar o estágio $replaceWith . O estágio $replaceWith executa a mesma ação que o estágio $replaceRoot, mas os estágios têm formas diferentes.

O estágio $replaceRoot tem a seguinte forma:

{ $replaceRoot: { newRoot: <replacementDocument> } }

O documento de substituição pode ser qualquer expressão válida que se resolva a um documento. O estágio apresenta erro e falha se <replacementDocument> não for um documento. Para mais informações sobre expressões, consulte Expressões.

Comportamento

Se o <replacementDocument> não for um documento, $replaceRoot apresenta erros e falha.

Se o <replacementDocument> resultar em um documento ausente (ou seja, o documento não existe), $replaceRoot apresentará erro e falhará. Por exemplo, crie uma coleção com os seguintes documentos:

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" },
])

Então a seguinte operação $replaceRoot falha porque um dos documentos não tem o campo name:

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

Para evitar o erro, você pode usar $mergeObjects para mesclar o documento name em algum documento padrão. Por exemplo:

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

Opcionalmente, você pode ignorar os documentos que não têm o campo name incluindo um estágio $match para verificar a existência do campo do documento antes de passar os documentos para o estágio $replaceRoot:

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

Ou você pode usar a expressão $ifNull para especificar algum outro documento como root. Por exemplo:

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

Exemplos

$replaceRoot com um campo de documento incorporado

Uma coleção chamada people contém os seguintes documentos:

{ "_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 }

A seguinte operação utiliza o estágio $replaceRoot para substituir cada documento de entrada pelo resultado de uma operação $mergeObjects. A expressão $mergeObjects mescla o documento padrão especificado com o documento pets.

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

A operação retorna os seguintes resultados:

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

$replaceRoot com um documento agrupado em uma array

Uma coleção chamada students contém os seguintes documentos:

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

A operação a seguir promove o(s) documento(s) incorporado(s) com o campo grade maior ou igual a 90 ao nível superior:

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

A operação retorna os seguintes resultados:

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

$replaceRoot com um documento recém-criado

Você também pode criar novos documentos como parte do estágio $replaceRoot e usá-los para substituir todos os outros campos.

Uma coleção chamada contacts contém os seguintes documentos:

{ "_id" : 1, "first_name" : "Gary", "last_name" : "Sheffield", "city" : "New York" }
{ "_id" : 2, "first_name" : "Nancy", "last_name" : "Walker", "city" : "Anaheim" }
{ "_id" : 3, "first_name" : "Peter", "last_name" : "Sumner", "city" : "Toledo" }

A operação seguinte cria um novo documento a partir dos campos first_name e last_name.

db.contacts.aggregate( [
   {
      $replaceRoot: {
         newRoot: {
            full_name: {
               $concat : [ "$first_name", " ", "$last_name" ]
            }
         }
      }
   }
] )

A operação retorna os seguintes resultados:

{ "full_name" : "Gary Sheffield" }
{ "full_name" : "Nancy Walker" }
{ "full_name" : "Peter Sumner" }

$replaceRoot com um novo documento criado a partir de e um documento padrão<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path $$ROOT fill=\" \" d=\"\">

Crie uma coleção denominada contacts com os seguintes documentos:

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", home: "987-654-3210", email: "beo@example.net" }
] )

A operação a seguir usa $replaceRoot com $mergeObjects para emitir os documentos atuais com valores padrão para os campos ausentes:

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

A aggregation retorna os seguintes documentos:

{
  _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'
}

Voltar

$redact

Próximo

$replaceWith