Atualizações com pipeline de agregação

updateOne com $set

Criar uma coleção de exemplo students (se a coleção não existir atualmente, inserir operações criará a coleção):

db.students.insertMany( [
   { _id: 1, test1: 95, test2: 92, test3: 90, modified: new Date("01/05/2020") },
   { _id: 2, test1: 98, test2: 100, test3: 102, modified: new Date("01/05/2020") },
   { _id: 3, test1: 95, test2: 110, modified: new Date("01/04/2020") }
] )

Para verificar, faça a query da coleção:

db.students.find()

A seguinte operação do db.collection.updateOne() utiliza um aggregation pipeline para atualizar o documento com _id: 3:

db.students.updateOne( { _id: 3 }, [ { $set: { "test3": 98, modified: "$$NOW"} } ] )

Especificamente, o pipeline consiste em um estágio $set que adiciona o campo test3 (e define seu valor para 98) ao documento e define o campo modified para o período atual. A operação utiliza a variável de agregação NOW para o período atual. Para acessar a variável, prefixo com $$ e entre aspas.

Para verificar a atualização, você pode fazer a query da coleção:

db.students.find().pretty()

updateMany com $replaceRoot e $set

Criar uma coleção de exemplo students2 (se a coleção não existir atualmente, inserir operações criará a coleção):

db.students2.insertMany( [
   { "_id" : 1, quiz1: 8, test2: 100, quiz2: 9, modified: new Date("01/05/2020") },
   { "_id" : 2, quiz2: 5, test1: 80, test2: 89, modified: new Date("01/05/2020") },
] )

Para verificar, faça a query da coleção:

db.students2.find()

A operação db.collection.updateMany() a seguir usa um aggregation pipeline para padronizar os campos dos documentos (ou seja documentos na coleção devem ter os mesmos campos) e atualizar o campo modified:

db.students2.updateMany( {},
  [
    { $replaceRoot: { newRoot:
       { $mergeObjects: [ { quiz1: 0, quiz2: 0, test1: 0, test2: 0 }, "$$ROOT" ] }
    } },
    { $set: { modified: "$$NOW"}  }
  ]
)

Especificamente, o pipeline consiste em:

• um estágio $replaceRoot com uma expressão $mergeObjects para definir valores padrão para os campos quiz1, quiz2, test1 e test2. A variável de agregação ROOT refere-se ao documento atual que está sendo modificado. Para acessar a variável, prefixo com $$ e entre aspas. Os campos do documento atual substituirão os valores padrão.

• um estágio $set para atualizar o campo modified para a data e hora atual. A operação usa a variável de agregação NOW para a data e hora atual. Para acessar a variável, prefixo com $$ e entre aspas.

Para verificar a atualização, você pode fazer a query da coleção:

db.students2.find()

updateMany com $set

Criar uma coleção de exemplo students3 (se a coleção não existir atualmente, inserir operações criará a coleção):

db.students3.insertMany( [
   { "_id" : 1, "tests" : [ 95, 92, 90 ], "modified" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "tests" : [ 94, 88, 90 ], "modified" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 3, "tests" : [ 70, 75, 82 ], "modified" : ISODate("2019-01-01T00:00:00Z") }
] );

Para verificar, faça a query da coleção:

db.students3.find()

A operação db.collection.updateMany() a seguir usa um aggregation pipeline para atualizar os documentos com a média de nota calculada e a nota de letra.

db.students3.updateMany(
   { },
   [
     { $set: { average : { $trunc: [ { $avg: "$tests" }, 0 ] }, modified: "$$NOW" } },
     { $set: { grade: { $switch: {
                           branches: [
                               { case: { $gte: [ "$average", 90 ] }, then: "A" },
                               { case: { $gte: [ "$average", 80 ] }, then: "B" },
                               { case: { $gte: [ "$average", 70 ] }, then: "C" },
                               { case: { $gte: [ "$average", 60 ] }, then: "D" }
                           ],
                           default: "F"
     } } } }
   ]
)

Especificamente, o pipeline consiste em:

• um estágio $set para calcular o valor médio truncado dos elementos da array tests e atualizar o campo modified para a data e hora atual. Para calcular a média truncada, o estágio utiliza as expressões $avg e $trunc. A operação usa a variável de agregação NOW para a data/hora atual. Para acessar a variável, prefixo com $$ e entre aspas.

• um estágio $set para adicionar o campo grade baseado no average utilizando a expressão $switch.

Para verificar a atualização, você pode fazer a query da coleção:

db.students3.find()

updateOne com $set

Criar uma coleção de exemplo students4 (se a coleção não existir atualmente, inserir operações criará a coleção):

db.students4.insertMany( [
  { "_id" : 1, "quizzes" : [ 4, 6, 7 ] },
  { "_id" : 2, "quizzes" : [ 5 ] },
  { "_id" : 3, "quizzes" : [ 10, 10, 10 ] }
] )

Para verificar, faça a query da coleção:

db.students4.find()

A operação db.collection.updateOne() a seguir usa um aggregation pipeline para adicionar pontuações de questionário ao documento com _id: 2:

db.students4.updateOne( { _id: 2 },
  [ { $set: { quizzes: { $concatArrays: [ "$quizzes", [ 8, 6 ]  ] } } } ]
)

Para verificar a atualização, faça a query da coleção:

db.students4.find()

updateMany com $addFields

Crie uma coleção de exemplo temperatures que contenha temperaturas em Celsius (se a coleção não existir no momento, as operações de inserção criarão a coleção):

db.temperatures.insertMany( [
  { "_id" : 1, "date" : ISODate("2019-06-23"), "tempsC" : [ 4, 12, 17 ] },
  { "_id" : 2, "date" : ISODate("2019-07-07"), "tempsC" : [ 14, 24, 11 ] },
  { "_id" : 3, "date" : ISODate("2019-10-30"), "tempsC" : [ 18, 6, 8 ] }
] )

Para verificar, faça a query da coleção:

db.temperatures.find()

A seguinte operação do db.collection.updateMany() utiliza um aggregation pipeline para atualizar os documentos com as temperaturas correspondentes em Fahrenheit:

db.temperatures.updateMany( { },
  [
    { $addFields: { "tempsF": {
          $map: {
             input: "$tempsC",
             as: "celsius",
             in: { $add: [ { $multiply: ["$$celsius", 9/5 ] }, 32 ] }
          }
    } } }
  ]
)

Especificamente, o pipeline consiste em um estágio $addFields para adicionar um novo campo de array tempsF que contém as temperaturas em Fahrenheit. Para converter cada temperatura celsius na array tempsC para Fahrenheit, o estágio utiliza a expressão $map com expressões $add e $multiply.

Para verificar a atualização, você pode fazer a query da coleção:

db.temperatures.find()

Atualize com variáveis let

Para definir variáveis que você possa acessar em outro lugar no comando, use a opção let.

Criar uma coleção cakeFlavors:

db.cakeFlavors.insertMany( [
   { _id: 1, flavor: "chocolate" },
   { _id: 2, flavor: "strawberry" },
   { _id: 3, flavor: "cherry" }
] )

O seguinte comando do updateOne utiliza variáveis configuradas com a opção let :

• A variável targetFlavor está definida como cherry. Essa variável é usada na expressão $eq para especificar o filtro de correspondência.

• A variável newFlavor está definida como orange. Essa variável é usada no operador $set para especificar o valor flavor atualizado para o documento correspondente.

db.cakeFlavors.updateOne(
   {
      $expr: { $eq: [ "$flavor", "$$targetFlavor" ] }
   },
   [
      {
         $set: { flavor: "$$newFlavor" }
      }
   ],
   {
      let: { targetFlavor: "cherry", newFlavor: "orange" }
   }
)

Depois de executar a operação de atualização anterior, a coleção cakeFlavors contém estes documentos:

[
   { _id: 1, flavor: 'chocolate' },
   { _id: 2, flavor: 'strawberry' },
   { _id: 3, flavor: 'orange' }
]

Exemplos adicionais

Consulte também as várias páginas do método de atualização para exemplos adicionais:

• db.collection.updateOne

• db.collection.updateMany

• db.collection.findOneAndUpdate()

• db.collection.findAndModify()

• Bulk.find.update()

• Bulk.find.updateOne()

• Bulk.find.upsert()