db.collection.updateMany() (método mongosh)

Parâmetros

O método updateMany() utiliza os seguintes parâmetros:

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

// INVALID
[
  { "x.a": { $gt: 85 } },
  { "x.b": { $gt: 80 } }
]

// Example 1
[
  { $or: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 2
[
  { $and: [{"x.a": {$gt: 85}}, {"x.b": {$gt: 80}}] }
]
// Example 3
[
  { "x.a": { $gt: 85 }, "x.b": { $gt: 80 } }
]

{
  <variable_name_1>: <expression_1>,
  ...,
  <variable_name_n>: <expression_n>
}

Devoluções

O método retorna um documento que contém:

• Um valor booleano acknowledged como true se a operação for executada com preocupação de gravaçãorefer ou false se a preocupação de gravação estiver desativada

• matchedCount contendo o número de documentos correspondentes

• modifiedCount contendo o número de documentos modificados

• upsertedId contendo o _id para o documento atualizado

• upsertedCount contendo o número de documentos upserted

Limitações

• updateMany() só deve ser usado para operações idempotentes.

Upsert

Se upsert: true e nenhum documento corresponder a filter, db.collection.updateMany() cria um novo documento com base nos parâmetros filter e update.

Se você especificar upsert: true em uma coleção fragmentada, deverá incluir a chave de fragmento completa em filter. Para comportamento adicional do db.collection.updateMany(), consulte Coleções fragmentadas.

Consulte Atualizar vários documentos com Upsert.

Atualizar com um Documento de Expressões do Operador de Atualização

Para a especificação de modificação, o método db.collection.updateMany() pode aceitar um documento que contém somente expressões de operador de atualização a serem executadas.

Por exemplo:

db.collection.updateMany(
   <query>,
   { $set: { status: "D" }, $inc: { quantity: 2 } },
   ...
)

Atualize com um pipeline de agregação.

O método db.collection.updateMany() pode aceitar um pipeline de agregação [ <stage1>, <stage2>, ... ] que especifica as modificações a serem realizadas. O pipeline pode consistir nas seguintes etapas:

• $addFields e seu alias $set

• $project e seu alias $unset

• $replaceRoot e seu alias $replaceWith

O uso do aggregation pipeline permite uma instrução de atualização mais expressiva, como atualizações condicionais Express com base em valores de campo atuais ou atualização de um campo usando o valor de outro(s) campo(s).

Por exemplo:

db.collection.updateMany(
   <query>,
   [
      { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
      { $unset: [ "misc1", "misc2" ] }
   ]
   ...
)

Para obter exemplos, consulte Atualizar com pipeline de agregação.

Capped collections

Se uma operação de atualização alterar o tamanho do documento, a operação falhará.

Coleções de Time Series

O método updateMany() está disponível para coleções de séries temporais a partir do MongoDB 5.1.

Os comandos de atualização devem atender aos seguintes requisitos:

• Você só pode combinar metaField ao valor do campo.

• Você só pode modificar o valor do campo metaField.

• Seu documento de atualização só pode conter expressões de operador de atualização.

• Seu comando de atualização não deve limitar o número de documentos a serem atualizados. Defina multi: true ou use o método updateMany().

• Seu comando de atualização não deve definir upsert: true.

Coleções fragmentadas

updateMany() exibe os seguintes comportamentos quando usado com coleções fragmentadas:

• updateMany() operações que incluem upsert: true devem incluir a chave de shard completa no filter.

• Se você tentar executar updateMany() durante uma Migração de faixa ou uma atualização de valor da chave de shard, a operação poderá perder documentos em alguns cenários. Para garantir que todos os documentos sejam atualizados, use atualizações idempotentes e execute novamente o comando até que nenhuma atualização seja aplicada. Para obter mais informações sobre atualizações idempotentes updateMany() com, consulte Atualizações idempotentes.

• Se updateMany() for executado fora de uma transação, as operações que visam mais de um fragmento transmitirão a operação para todos os fragmentos no cluster.

• Se updateMany() for executado dentro de uma transação, as operações que têm como alvo mais de um shard terão como alvo apenas os shards relevantes.

Explicabilidade

updateMany() não é compatível com db.collection.explain().

Transações

db.collection.updateMany() pode ser usado dentro de transações distribuídas.

Entradas de oplog

updateMany() adiciona uma entrada ao oplog (log de operações) para cada documento atualizado com êxito. Se nenhum documento for atualizado, o updateMany() não adicionará entradas ao oplog.

Idempotent Updates

A sample_mflix.movies coleção contém filmes com classificações IMDB. Esta atualização idempotente faz as seguintes operações:

• corresponde a todos os filmes com classificações de IMDB inferiores a 3.0

• aumenta essas classificações em 0.5

• definir um campo ratingBoosted como true

db.movies.updateMany(
   { "imdb.rating": { $lt: 3, $type: "number" }, ratingBoosted: { $ne: true } },
   { $inc: { "imdb.rating": 0.5 }, $set: { ratingBoosted: true } }
)

updateMany() modifica os documentos de filme correspondentes individualmente. As atualizações individuais de documento são operações atômicas, mas a operação updateMany() como um todo não é atômica.

Se a operação não atualizar todos os documentos correspondentes, você poderá executar novamente um comando idempotente com segurança até que nenhum documento adicional corresponda ao filtro especificado. Nesse caso, o campo imdb.rating de cada documento é atualizado somente uma vez, independentemente de quantas vezes seja repetido, pois o comando é idempotente.

Atualizar vários documentos

A coleção sample_mflix.movies contém filmes com um campo num_mflix_comments.

A operação a seguir encontra todos os filmes com mais de 100 comentários e adiciona um sinalizador popular a esses filmes:

db.movies.updateMany( 
   { num_mflix_comments: { $gt: 100 } }, 
   { $set: { "popular" : true } } 
)

Atualização com aggregation pipeline

O db.collection.updateMany() pode utilizar um pipeline de agregação para a atualização. O pipeline pode consistir nas seguintes etapas:

• $addFields e seu alias $set

• $project e seu alias $unset

• $replaceRoot e seu alias $replaceWith

O uso do aggregation pipeline permite uma instrução de atualização mais expressiva, como atualizações condicionais Express com base em valores de campo atuais ou atualização de um campo usando o valor de outro(s) campo(s).

db.movies.updateMany(
   { year: { $gte: 2010, $lte: 2019 } },
   [
      { $set: { 
         combinedRatings: [ "$imdb.rating", "$tomatoes.viewer.rating" ], 
         ratingsUpdated: "$$NOW" 
      } },
      { $unset: [ "imdb.rating", "tomatoes.viewer.rating" ] }
   ]
)

db.movies.updateMany(
   { 
      year: { $gte: 2010, $lte: 2019 },
      "imdb.rating": { $exists: true },
      "tomatoes.viewer.rating": { $exists: true }
   },
   [
     { $set: { 
        combinedScore: { $trunc: [ 
           { $avg: [ "$imdb.rating", "$tomatoes.viewer.rating" ] }, 
           1 
        ] },
        scoreUpdated: "$$NOW" 
     } },
     { $set: { 
        ratingGrade: { $switch: {
           branches: [
              { case: { $gte: [ "$combinedScore", 8 ] }, then: "A" },
              { case: { $gte: [ "$combinedScore", 6 ] }, then: "B" },
              { case: { $gte: [ "$combinedScore", 4 ] }, then: "C" },
              { case: { $gte: [ "$combinedScore", 2 ] }, then: "D" }
           ],
           default: "F"
        } } 
     } }
   ]
)

Atualizar Vários Documentos com Inserção

A operação a seguir atualiza todos os filmes lançados após 2020 e dirigidos por Victor Nolan:

db.movies.updateMany(
   { 
      year: { $gt: 2020 }, 
      directors: "Christopher Nolan" 
   },
   { $set: { "upcomingRelease": true } },
   { upsert: true }
)

Neste exemplo, como nenhum documento corresponde ao filtro upsert e true é, updateMany() insere um novo documento com um gerado,_id bem como as condições de igualdade de filter e update modificadores.

Atualize com preocupação de gravação

Dado um conjunto de réplicas de três membros, a operação a seguir especifica um w de majority e wtimeout de 100

db.movies.updateMany(
    { title: "The Godfather" },
    { $inc: { num_mflix_comments: 10 }, $set: { trending: true } },
    { w: "majority", wtimeout: 100 }
)

Se a confirmação demorar mais que o limite wtimeout, o MongoDB lançará uma exceção.

A tabela a seguir explica os possíveis valores de errInfo.writeConcern.provenance:

Especifique o agrupamento

A colocação permite que os usuários especifiquem regras específicas do idioma para comparação de strings, como regras para letras maiúsculas e marcas de acento.

A operação a seguir usa um agrupamento que não diferencia maiúsculas de minúsculas para combinar filmes com o gênero "drum" com qualquer combinação de minúsculas e maiúsculas.

db.movies.updateMany(
   { genres: "drama" },
   { $set: { genreNormalized: true } },
   { collation: { locale: "en", strength: 1 } }
)

Especificar arrayFilters para uma Operação de Atualização de array

Ao atualizar um campo de array, você pode especificar arrayFilters que determinam quais elementos de array atualizar.

db.movies.updateMany(
   { 
      "imdb.rating": { $exists: true },
      "tomatoes.viewer.rating": { $exists: true },
      "tomatoes.critic.rating": { $exists: true },
      year: { $gte: 2010, $lte: 2015 }
   },
   [
      { $set: { 
         ratings: [
            { $multiply: ["$imdb.rating", 10] },
            { $multiply: ["$tomatoes.viewer.rating", 10] },
            { $multiply: ["$tomatoes.critic.rating", 10] }
         ]
      } }
   ]
)

db.movies.updateMany(
   { ratings: { $gte: 100 } },
   { $set: { "ratings.$[element]" : 100 } },
   { arrayFilters: [ { "element": { $gte: 100 } } ] }
)

db.movies.updateMany(
   { 
      "imdb.rating": { $exists: true },
      "tomatoes.viewer.rating": { $exists: true },
      year: { $gte: 2010, $lte: 2012 }
   },
   [
      { $set: { 
         ratingDetails: [
            { source: "imdb", score: "$imdb.rating", weight: 10 },
            { source: "tomatoes_viewer", score: "$tomatoes.viewer.rating", weight: 8 },
            { source: "tomatoes_critic", score: "$tomatoes.critic.rating", weight: 7 }
         ]
      } }
   ]
)

db.movies.updateMany(
   { ratingDetails: { $exists: true } },
   { $set: { "ratingDetails.$[elem].weight" : 10 } },
   { arrayFilters: [ { "elem.score": { $gte: 8 } } ] }
)

Especifique hint para operações de atualização

Crie o seguinte índice na coleção:

db.movies.createIndex( { rated: 1 } )

A seguinte operação de atualização sugere explicitamente o uso do índice { rated: 1 }:

db.movies.updateMany(
   { "num_mflix_comments": { $lte: 5 }, "rated": "G" }, 
   { $set: { "familyFriendly": true } },
   { hint: { rated: 1 } }
)

Para ver se o índice sugerido é usado, execute o pipeline $indexStats:

db.movies.aggregate( [ { $indexStats: { } }, { $sort: { name: 1 } }, { $match: {key: { rated: 1 } } } ] )

Erros de preocupação de gravação em clusters fragmentados

Quando db.collection.updateMany() é executado em mongos em um cluster fragmentado, um writeConcernError é sempre relatado na resposta, mesmo quando ocorre um ou mais erros. Em versões anteriores, outros erros às vezes faziam com que db.collection.updateMany() não relatasse erros de preocupação de gravação.

Por exemplo, se um documento falhar na validação, desencadeando um erro DocumentValidationFailed e também ocorrer um erro de preocupação de gravação , o erro DocumentValidationFailed e o writeConcernError serão retornados no campo de nível superior da resposta.

Roles de usuário e atualizações de documentos

A partir do MongoDB 7.0, você pode usar a nova variável de sistemaUSER_ROLES para retornar funções de usuário .

O exemplo nesta seção mostra atualizações de campos em uma collection que contém informações médicas. O exemplo lê os roles atuais do usuário da variável de sistema USER_ROLES e só executa as atualizações se o usuário tiver um role específico.

Para usar uma variável do sistema, adicione $$ ao início do nome da variável. Especifique a variável de sistema USER_ROLES como $$USER_ROLES.

O exemplo cria estes usuários:

• James com um role Billing.

• Michelle com um role Provider.

Execute as seguintes etapas para criar os roles, os usuários e a collection:

db.createRole( { role: "Billing", privileges: [ { resource: { db: "test",
   collection: "medicalView" }, actions: [ "find" ] } ], roles: [ ] } )
db.createRole( { role: "Provider", privileges: [ { resource: { db: "test",
   collection: "medicalView" }, actions: [ "find" ] } ], roles: [ ] } )

db.createUser( {
   user: "James",
   pwd: "js008",
   roles: [
      { role: "Billing", db: "test" }
   ]
} )
db.createUser( {
   user: "Michelle",
   pwd: "me009",
   roles: [
      { role: "Provider", db: "test" }
   ]
} )

db.medical.insertMany( [
   {
      _id: 0,
      patientName: "Jack Jones",
      diagnosisCode: "CAS 17",
      creditCard: "1234-5678-9012-3456"
   },
   {
      _id: 1,
      patientName: "Mary Smith",
      diagnosisCode: "ACH 01",
      creditCard: "6541-7534-9637-3456"
   }
] )

Faça login como Michelle, que tem o role Provider, e execute uma atualização:

db.auth( "Michelle", "me009" )

// Attempt to update many documents
db.medical.updateMany(
   // User must have the Provider role to perform the update
   { $expr: { $ne: [ {
      $setIntersection: [ [ "Provider" ], "$$USER_ROLES.role" ] }, []
   ] } },
   // Update diagnosisCode
   { $set: { diagnosisCode: "ACH 02"} }
)

O exemplo anterior usa $setIntersection para retornar documentos onde a interseção entre a string "Provider" e os roles de usuário do $$USER_ROLES.role não está vazia. Michelle tem o role Provider, então a atualização é executada.

Em seguida, faça login como James, que não tem o role Provider e tente realizar a mesma atualização:

db.auth( "James", "js008" )

// Attempt to update many documents
db.medical.updateMany(
   // User must have the Provider role to perform the update
   { $expr: { $ne: [ {
      $setIntersection: [ [ "Provider" ], "$$USER_ROLES.role" ] }, []
   ] } },
   // Update diagnosisCode
   { $set: { diagnosisCode: "ACH 02"} }
)

O exemplo anterior não atualiza nenhum documento.