db.colección.updateMany() (método mongosh)

Parámetros

El método updateMany() toma los siguientes 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>
}

Devuelve

El método devuelve un documento que contiene:

• Un valor booleano acknowledged en true si la operación se ejecutó con nivel de confirmación de escritura (write concern) o en false si el nivel de confirmación de escritura (write concern) estaba deshabilitado

• matchedCount que contiene el número de documentos coincidentes

• modifiedCount que contiene el número de documentos modificados

• upsertedId que contiene el _id para el documento actualizado o insertado

• upsertedCount que contiene la cantidad de documentos actualizados o insertados

Limitaciones

• updateMany() debería usarse solo para operaciones idempotentes.

Inserción

Si upsert: true y ningún documento coincide con el filter, db.collection.updateMany() crea un nuevo documento basado en los parámetros filter y update.

Si especificas upsert: true en una colección fragmentada, debe incluir la clave de partición completa en la filter. Para obtener información sobre el comportamiento adicional de db.collection.updateMany(), consulta Colecciones fragmentadas.

Consulta Actualizar varios documentos con inserción.

Actualiza con un documento de actualización de expresiones de operador

Para la especificación de modificación, el método db.collection.updateMany() puede aceptar un documento que solo contiene expresiones de Operadores de actualización para ejecutar.

Por ejemplo:

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

Actualiza con un pipeline de agregación

El método db.collection.updateMany() puede aceptar una pipeline de agregación [ <stage1>, <stage2>, ... ] que especifica las modificaciones a realizar. La pipeline puede constar de las siguientes etapas:

• $addFields y su alias $set

• $project y su alias $unset

• $replaceRoot y su alias $replaceWith

El uso de un pipeline de agregación permite una instrucción de actualización más expresiva, como expresar actualizaciones condicionales basadas en los valores actuales de los campos o actualizar un campo con el valor de otros campos.

Por ejemplo:

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

Para ver ejemplos, consulta Actualización con pipeline de agregación.

Colecciones con tamaño fijo

Si una operación de actualización cambia el tamaño del documento, la operación fallará.

Colecciones de series de tiempo

El método updateMany() está disponible para colecciones de series de tiempo a partir de MongoDB 5.1.

Los comandos de actualización deben cumplir con los siguientes requisitos:

• Solo puedes hacer coincidir el valor del campo metaField.

• Solo puedes modificar el valor del campo metaField.

• El documento de actualización solo puede contener expresiones de operador de actualización.

• Su comando para actualizar no debe limitar el número de documentos que se deben actualizar. Establezca multi: true o utilice el método updateMany().

• El comando de actualización no debe establecer inserción: true.

Colecciones fragmentadas

updateMany() presenta los siguientes comportamientos cuando se utiliza con colecciones fragmentadas:

• updateMany() las operaciones que incluyen upsert: true deben incluir la clave de fragmentación completa en el filter.

• Si intentas ejecutar updateMany() durante una migración de rangos o una actualización de valores de la clave de partición, la operación puede omitir documentos en algunos casos. Para asegurarte de que todos los documentos estén actualizados, utiliza actualizaciones idempotentes y vuelve a ejecutar el comando hasta que no se apliquen más actualizaciones. Para obtener más información sobre las actualizaciones idempotentes con updateMany(), consulta Actualizaciones idempotentes.

• Si updateMany() se ejecuta fuera de una transacción, las operaciones que apuntan a más de una partición difunden la operación a todas las particiones del clúster.

• Si updateMany() se ejecuta dentro de una transacción, las operaciones que apuntan a más de una partición solo afectan a las particiones relevantes.

Explicabilidad

updateMany() no es compatible con db.collection.explain().

Transacciones

db.collection.updateMany() puede usarse dentro de transacciones distribuidas.

Entradas de OpLog

updateMany() añade una entrada al oplog (registro de operaciones) por cada documento actualizado con éxito. Si no se actualizan documentos, updateMany() no añade entradas al oplog.

Idempotent Updates

La sample_mflix.movies colección contiene películas con calificaciones de IMDB. Esta actualización idempotente realiza las siguientes operaciones:

• Coincide con todas las películas con una calificación de IMDB inferior a 3.0.

• incrementa esas calificaciones en 0.5

• establece un campo ratingBoosted a true

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

updateMany() modifica individualmente los documentos de película coincidentes. Las actualizaciones de documentos individuales son operaciones atómicas, pero la operación updateMany() en su conjunto no es atómica.

Si la operación no logra actualizar todos los documentos coincidentes, puedes volver a ejecutar de forma segura un comando idempotente hasta que no haya documentos adicionales que coincidan con el filtro especificado. En este caso, el campo imdb.rating de cada documento se actualiza solo una vez, sin importar cuántas veces se reintente, porque el comando es idempotente.

Actualiza varios documentos

La colección sample_mflix.movies contiene películas con un campo num_mflix_comments.

La siguiente operación encuentra todas las películas con más de 100 comentarios y agrega una bandera popular a esas películas:

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

Actualiza con el pipeline de agregación

El db.collection.updateMany() puede utilizar un pipeline de agregación para actualizar. La pipeline puede constar de las siguientes etapas:

• $addFields y su alias $set

• $project y su alias $unset

• $replaceRoot y su alias $replaceWith

El uso de un pipeline de agregación permite una instrucción de actualización más expresiva, como expresar actualizaciones condicionales basadas en los valores actuales de los campos o actualizar un campo con el valor de otros campos.

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

Actualiza múltiples documentos con inserción

La siguiente operación actualiza todas las películas estrenadas después del año 2020 y dirigidas por Christopher Nolan:

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

En este ejemplo, dado que ningún documento coincide con el filtro, y upsert truees, updateMany() inserta un nuevo documento con un generado,_id así como las condiciones de igualdad de filter los update modificadores y.

Actualizar con nivel de confirmación de escritura (Write Concern)

Dado un set de réplicas de tres nodos, la siguiente operación especifica un w de majority y un wtimeout de 100:

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

Si la confirmación tarda más que el límite wtimeout, MongoDB lanza una excepción.

La siguiente tabla explica los posibles valores de errInfo.writeConcern.provenance:

Especificar la intercalación

La intercalación permite a los usuarios especificar reglas propias del lenguaje para la comparación de strings, como reglas para el uso de mayúsculas y minúsculas y marcas de acento.

La siguiente operación utiliza una intercalación que no distingue entre mayúsculas y minúsculas para emparejar películas del género "drama" con cualquier combinación de mayúsculas y minúsculas.

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

Especifica arrayFilters para una operación de actualización de arreglos

Al actualizar el campo de un arreglo, puede especificar arrayFilters que determinen qué elementos del arreglo actualizar.

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

Especifica hint para las operaciones de actualización

Cree el siguiente índice en la colección:

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

La siguiente operación de actualización indica explícitamente que se debe usar el índice { rated: 1 }:

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

Para ver si se utiliza el índice insinuado, ejecuta el pipeline $indexStats :

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

Errores de nivel de confirmación de escritura (write concern) en clústeres particionados

Cuando db.collection.updateMany() se ejecuta en mongos en un clúster fragmentado, siempre se informa de un writeConcernError en la respuesta, incluso cuando se producen uno o más errores adicionales. En versiones anteriores, otros errores a veces causaban que db.collection.updateMany() no reportara errores de nivel de confirmación de escritura.

Por ejemplo, si un documento no supera la validación, activando un error DocumentValidationFailed, y también ocurre un error de nivel de confirmación de escritura, tanto el error DocumentValidationFailed como el writeConcernError se devuelven en el campo de nivel superior de la respuesta.

Roles de usuario y actualizaciones de documentos

A partir de MongoDB 7.0, puedes usar la nueva variable de sistema USER_ROLES para devolver los roles de usuario.

El ejemplo en esta sección muestra actualizaciones de campos en una colección que contiene información médica. El ejemplo lee los roles de usuario actuales de la variable de sistema USER_ROLES y solo realiza las actualizaciones si el usuario tiene un rol específico.

Para usar una variable del sistema, agrega $$ al inicio del nombre de la variable. Especifica la variable del sistema USER_ROLES como $$USER_ROLES.

El ejemplo crea a estos usuarios:

• James con un rol Billing.

• Michelle con un rol Provider.

Realiza los siguientes pasos para crear los roles, los usuarios y la colección:

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

Inicia sesión como Michelle, quien tiene el rol Provider, y realiza una actualización:

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

El ejemplo anterior utiliza $setIntersection para devolver documentos donde la intersección entre la string "Provider" y los roles de usuario de $$USER_ROLES.role no está vacía. Michelle tiene el rol Provider, por lo tanto, se realiza la actualización.

A continuación, inicia sesión como James, que no tiene el rol de Provider, e intenta volver a actualizar:

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

El ejemplo anterior no actualiza ningún documento.