db.collection.update()

Substituir operações de documentos em uma coleção fragmentada

As operações de substituição de documentos tentam direcionar um único fragmento, primeiro usando o filtro de query. Se a operação não puder direcionar um único fragmento pelo filtro de query, ela tentará direcionar pelo documento de substituição.

Em versões anteriores, a operação tenta direcionar usando o documento de substituição.

upsert em uma coleção fragmentada

No caso das operações de db.collection.update() que incluam upsert: true e estejam em uma coleção fragmentada, você deve incluir a chave de fragmento completa no filter:

• Para uma operação de atualização.

• Para uma operação de substituição de documento.

No entanto, os documentos em uma coleção fragmentada podem estar faltando os campos de chave de fragmento. Para direcionar um documento que não possui a chave de fragmento, você pode usar a null correspondência de igualdade em conjunto com outra condição de filtro (como no campo _id ). Por exemplo:

{ _id: <value>, <shardkeyfield>: null } // _id of the document missing shard key

Modificação da chave de fragmento

Você pode atualizar o valor da chave de fragmento de um documento, a menos que o campo de chave de fragmento seja o campo de _id imutável.

Para modificar o valor da chave de fragmento existente com db.collection.update():

• Você deve executar em um mongos. Não emita a operação diretamente no fragmento.

• Você deve executar em uma transação ou como uma gravação repetível.

• Você deve especificar multi: false.

• Você deve incluir um filtro de consulta de igualdade na chave de fragmento completa.

Consulte também upsert em uma coleção fragmentada.

Chave de fragmento ausente

Os documentos em coleções fragmentadas podem não ter os campos de chave de fragmento. Para usar db.collection.update() a fim de definir a chave de fragmento ausente do documento, é necessário executar em um mongos. Não emita a operação diretamente no fragmento.

Além disso, os seguintes requisitos também se aplicam:

Veja também:

• upsert em uma coleção fragmentada

• Campos de chave de fragmentação ausentes

Inserção nas Transações

Você pode criar coleção e índices dentro de uma transação distribuída se a transação não for uma transação de gravação cross-fragmento.

db.collection.update() com upsert: true pode ser executado em uma coleção existente ou em uma coleção inexistente. Se for executada em uma coleção inexistente, a operação cria a coleção.

Write concerns e transações

Não defina explicitamente a preocupação de gravação para a operação se for executada em uma transação. Para usar write concern com transações, consulte Transações e write concern.

Upsert com valores duplicados

Os upserts podem criar documentos duplicados, a menos que haja um índice único para evitar duplicatas.

Considere um exemplo em que nenhum documento com o nome Andy existe e vários clientes emitem o seguinte comando ao mesmo tempo:

db.people.update(
   { name: "Andy" },
   { $inc: { score: 1 } },
   {
     upsert: true,
     multi: true
   }
)

Se todas as operações update() terminarem a fase de query antes que qualquer cliente insira dados com êxito e não houver nenhum índice exclusivo no campo name, cada operação update() poderá resultar em uma inserção, criando vários documentos com name: Andy.

Um índice exclusivo no campo name garante que somente um documento seja criado. Com um índice único em vigor, as múltiplas operações update() agora apresentam o seguinte comportamento:

• Exatamente uma operação update() inserirá com êxito um novo documento.

• Outras operações update() atualizam o documento recém-inserido ou falham devido a uma colisão de chave exclusiva.

  Para que outras operações update() atualizem o documento recém-inserido, todas as seguintes condições devem ser atendidas:

  • A collection de destino tem um índice único que causaria um erro de chave duplicado.

  • A operação de atualização não é updateMany ou multi é false.

  • A condição de correspondência de atualização é:

    • Um único predicado de igualdade. Por exemplo { "fieldA" : "valueA" }

    • Um E lógico de predicados de igualdade. Por exemplo { "fieldA" : "valueA", "fieldB" : "valueB" }

  • O campo no predicado de igualdade correspondem ao campo no padrão de chave de índice único.

  • A operação de atualização não modifica nenhum campo no padrão de chave de índice único.

A tabela a seguir mostra exemplos de operações upsert que, quando ocorre uma colisão de chaves, resultam em uma atualização ou falha.

{ name : 1 }

db.people.updateOne(
   { name: "Andy" },
   { $inc: { score: 1 } },
   { upsert: true }
)

{ name : 1 }

db.people.updateOne(
   { name: { $ne: "Joe" } },
   { $set: { name: "Andy" } },
   { upsert: true }
 )

{ name : 1 }

db.people.updateOne(
  { name: "Andy", email: "andy@xyz.com" },
  { $set: { active: false } },
  { upsert: true }
)

Modificar um campo usando os valores dos outros campos no documento

Criar uma coleção students com os seguintes documentos:

db.students.insertMany( [
   { "_id" : 1, "student" : "Skye", "points" : 75, "commentsSemester1" : "great at math", "commentsSemester2" : "loses temper", "lastUpdate" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "students" : "Elizabeth", "points" : 60, "commentsSemester1" : "well behaved", "commentsSemester2" : "needs improvement", "lastUpdate" : ISODate("2019-01-01T00:00:00Z") }
] )

Suponha que, em vez de separar os campos commentsSemester1 e commentsSemester2, você queira reuni-los em um novo campo comments. A seguinte operação de atualização usa um pipeline de agregação para:

• adicione o novo campo comments e defina o campo lastUpdate.

• remova os campos commentsSemester1 e commentsSemester2 de todos os documentos da coleção.

db.members.update(
   { },
   [
      { $set: { comments: [ "$commentsSemester1", "$commentsSemester2" ], lastUpdate: "$$NOW" } },
      { $unset: [ "commentsSemester1", "commentsSemester2" ] }
   ],
   { multi: true }
)

Primeira etapa

O estágio $set:

• cria um novo campo de array comments cujos elementos são o conteúdo atual dos campos commentsSemester1 e commentsSemester2 e

• define o campo lastUpdate para o valor da variável de agregação NOW. A variável de agregação NOW é resolvida para o valor de data e hora atual e permanece a mesma em todo o pipeline. Para acessar variáveis de agregação, prefixe a variável com cifrões duplos $$ e coloque entre aspas.

Segunda etapa

O estágio $unset remove os campos commentsSemester1 e commentsSemester2.

Após o comando, a coleção contém os seguintes documentos:

{ "_id" : 1, "student" : "Skye", "status" : "Modified", "points" : 75, "lastUpdate" : ISODate("2020-01-23T05:11:45.784Z"), "comments" : [ "great at math", "loses temper" ] }
{ "_id" : 2, "student" : "Elizabeth", "status" : "Modified", "points" : 60, "lastUpdate" : ISODate("2020-01-23T05:11:45.784Z"), "comments" : [ "well behaved", "needs improvement" ] }

Executar atualizações condicionais com base nos valores de campo atuais

Criar uma coleção students3 com os seguintes documentos:

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

Usando um aggregation pipeline, você pode atualizar os documentos com a média calculada e a nota por letra.

db.students3.update(
   { },
   [
     { $set: { average : { $trunc: [ { $avg: "$tests" }, 0 ] }, lastUpdate: "$$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"
     } } } }
   ],
   { multi: true }
)

Primeira etapa

O estágio $set:

• calcula um novo campo average com base na média do campo tests. Consulte $avg para obter mais informações sobre o operador de agregação do $avg e $trunc para obter mais informações sobre o operador de agregação truncada $trunc.

• define o campo lastUpdate para o valor da variável de agregação NOW. A variável de agregação NOW é resolvida para o valor de data e hora atual e permanece a mesma em todo o pipeline. Para acessar variáveis de agregação, prefixe a variável com cifrões duplos $$ e coloque entre aspas.

Segunda etapa

O estágio $set calcula um novo campo grade com base no campo average calculado no estágio anterior. Consulte $switch para obter mais informações sobre o operador de aggregation do $switch.

Após o comando, a coleção contém os seguintes documentos:

{ "_id" : 1, "tests" : [ 95, 92, 90 ], "lastUpdate" : ISODate("2020-01-24T17:29:35.340Z"), "average" : 92, "grade" : "A" }
{ "_id" : 2, "tests" : [ 94, 88, 90 ], "lastUpdate" : ISODate("2020-01-24T17:29:35.340Z"), "average" : 90, "grade" : "A" }
{ "_id" : 3, "tests" : [ 70, 75, 82 ], "lastUpdate" : ISODate("2020-01-24T17:29:35.340Z"), "average" : 75, "grade" : "C" }

arrayFilters Atualizar elementos que correspondem aos critérios

Para atualizar todos os elementos de array que correspondem a um critério especificado, utilize o parâmetro arrayFilters.

No mongosh, crie uma coleção students com os seguintes documentos:

db.students.insertMany( [
   { "_id" : 1, "grades" : [ 95, 92, 90 ] },
   { "_id" : 2, "grades" : [ 98, 100, 102 ] },
   { "_id" : 3, "grades" : [ 95, 110, 100 ] }
] )

Para atualizar todos os elementos que são maiores ou iguais a 100 na array grades, utilize o operador posicional filtrado $[<identifier>] com a opção arrayFilters:

db.students.update(
   { grades: { $gte: 100 } },
   { $set: { "grades.$[element]" : 100 } },
   {
     multi: true,
     arrayFilters: [ { "element": { $gte: 100 } } ]
   }
)

Após a operação, a coleção contém os seguintes documentos:

{ "_id" : 1, "grades" : [ 95, 92, 90 ] }
{ "_id" : 2, "grades" : [ 98, 100, 100 ] }
{ "_id" : 3, "grades" : [ 95, 100, 100 ] }

Atualizar elementos específicos de uma array de documentos

Você também pode usar o parâmetro arrayFilters para atualizar campos de documentos específicos em uma array de documentos.

No mongosh, crie uma coleção students2 com os seguintes documentos:

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

Para modificar o valor do campo mean para todos os elementos da array grades onde a nota é maior ou igual a 85, use o operador posicional filtrado com $[<identifier>] o arrayFilters

db.students2.update(
   { },
   { $set: { "grades.$[elem].mean" : 100 } },
   {
     multi: true,
     arrayFilters: [ { "elem.grade": { $gte: 85 } } ]
   }
)

Após a operação, a coleção conta com os seguintes documentos:

{
   "_id" : 1,
   "grades" : [
      { "grade" : 80, "mean" : 75, "std" : 6 },
      { "grade" : 85, "mean" : 100, "std" : 4 },
      { "grade" : 85, "mean" : 100, "std" : 6 }
   ]
}
{
   "_id" : 2,
   "grades" : [
      { "grade" : 90, "mean" : 100, "std" : 6 },
      { "grade" : 87, "mean" : 100, "std" : 3 },
      { "grade" : 85, "mean" : 100, "std" : 4 }
   ]
}