actualizar (comando de base de datos)

Actualizar instrucciones

Cada elemento del arreglo updates es un documento de instrucción para actualizar. Cada documento contiene los siguientes campos:

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

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

Devuelve

El comando devuelve un documento que contiene el estado de la operación. Por ejemplo:

{
   "ok" : 1,
   "nModified" : 0,
   "n" : 1,
   "upserted" : [
      {
         "index" : 0,
         "_id" : ObjectId("52ccb2118908ccd753d65882")
      }
   ]
}

Para obtener detalles de los campos de salida, se puede consultar Salida.

Limitaciones

Si se configura multi: true, se debe usar el comando update solo para las operaciones idempotentes.

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

El campo de instrucción de actualizar u puede aceptar un documento que solo contenga expresiones de operador de actualizar. Por ejemplo:

updates: [
   {
     q: <query>,
     u: { $set: { status: "D" }, $inc: { quantity: 2 } },
      ...
   },
   ...
]

Luego, el comando update actualiza únicamente los campos correspondientes en el documento.

Actualizar con un documento de reemplazo

El campo de la instrucción de actualizar u puede aceptar un documento de reemplazo, es decir, el documento contiene solo expresiones field:value . Por ejemplo:

updates: [
   {
      q: <query>,
      u: { status: "D", quantity: 4 },
      ...
   },
   ...
]

Luego, el comando update reemplaza el documento coincidente con el documento actualizado. El comando update solo puede sustituir a un único documento coincidente; es decir, el campo multi no puede ser true. El comando update no reemplaza el valor _id.

Errores de actualizaciones múltiples

Si un solo documento no se actualiza en un comando de actualización con el parámetro multi establecido en true, no se actualizarán más documentos como parte de ese comando.

Por ejemplo, la sample_mflix.movies colección contiene películas con imdb.rating campos. Cree un validador de documentos en la movies colección con una regla que establezca que el imdb.rating valor debe ser menor o igual 10 a:

db.runCommand( 
   { 
      update: "movies",
      updates: [
      {
         q: { 
            year: { $gte: 2000, $lte: 2005 },
            "imdb.rating": { $type: "number" }
         }, 
         u: { $inc: { "imdb.rating": 1 } },
         multi: true
      }
      ]
   }
)

Si alguna película ya tiene una calificación de 10, incrementarla infringiría la regla del validador (calificación > 10). En este caso, la actualización se detiene y no se actualizan más documentos, incluso si miles de documentos coinciden con la consulta.

Actualiza con un pipeline de agregación

El campo de instrucción para actualizar u puede aceptar un pipeline de agregación [ <stage1>, <stage2>, ... ] que especifique las modificaciones a realizar. El 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:

updates: [
   {
      q: <query>,
      u: [
        { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
        { $unset: [ "misc1", "misc2" ] }
      ],
      ...
   },
   ...
]

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

Inserción con un índice único

Los upserts pueden crear documentos duplicados, a menos que haya un índice único para evitar duplicados.

Considere un ejemplo en el que no existe ningún documento con el nombre Andy y varios clientes emiten el siguiente comando aproximadamente al mismo tiempo:

db.runCommand(
   {
     update: "people",
     updates: [
       { q: { name: "Andy" }, u: { $inc: { score: 1 } }, multi: true, upsert: true }
     ]
   }
)

Si todas las operaciones update terminan la fase de query antes de que algún cliente inserte correctamente los datos y no hay un índice único en el campo name, cada operación update puede ocasionar una inserción, creando múltiples documentos con name: Andy.

Un índice único en el campo name asegura que solo se cree un documento. Con un índice único en su lugar, las múltiples update operaciones ahora muestran el siguiente comportamiento:

• Exactamente una update operación insertará exitosamente un nuevo documento.

• Otras update operaciones actualizan el documento recién insertado o fallan debido a una colisión de clave única.

  Para que otras operaciones de update actualicen el documento recién insertado, todas las siguientes condiciones deben cumplirse:

  • La colección objetivo tiene un índice único que causaría un error de clave duplicada.

  • La operación de actualización no es updateMany o multi es false.

  • La condición de coincidencia de actualización es:

    • Un único predicado de igualdad. Por ejemplo { "fieldA" : "valueA" }

    • Un AND lógico de predicados de igualdad. Por ejemplo { "fieldA" : "valueA", "fieldB" : "valueB" }

  • Los campos del predicado de igualdad coinciden con los campos del patrón de clave del índice único.

  • La operación de actualización no modifica ningún campo en el patrón de clave de índice único.

La siguiente tabla muestra ejemplos de operaciones de upsert que, cuando ocurre una colisión de clave, se actualizan o fallan.

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

Límites

Para cada elemento de actualización del arreglo updates, la suma de la query y los tamaños de actualización (es decir, q y u ) debe ser menor o igual al tamaño máximo de documento BSON.

El número total de instrucciones de actualización en el arreglo updates debe ser menor o igual al tamaño máximo por lotes.

Validación de esquema

El comando update añade compatibilidad con la opción bypassDocumentValidation, que le permite omitir la validación de esquema al insertar o actualizar documentos en una colección con reglas de validación.

Colecciones fragmentadas

Transacciones

update puede usarse dentro de transacciones distribuidas.

Actualizar campos específicos de un documento

Se deben usar operadores de actualización para actualizar solo los campos especificados de un documento.

Por ejemplo, los documentos de la colección movies de la base de datos sample_mflix contienen campos como title, year y num_mflix_comments.

El siguiente comando utiliza los operadores de actualización $set y $inc para actualizar los campos year y num_mflix_comments de un documento donde title es igual a "The Godfather":

db.runCommand(
   {
      update: "movies",
      updates: [
         {
            q: { title: "The Godfather" }, u: { $set: { year: 1972 }, $inc: { num_mflix_comments: 1 } }
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

Puesto que el documento <update> no especifica el campo multi opcional, la actualización solo modifica un documento, incluso si más de un documento cumple la condición de coincidencia q.

Se puede consultar Salida para obtener más detalles.

Actualizar campos específicos de varios documentos

Se deben usar operadores de actualización para actualizar solo los campos especificados de un documento e incluir el campo multi establecido en true en la instrucción de actualización.

Por ejemplo, los documentos de la colección movies de la base de datos sample_mflix contienen campos como year y num_mflix_comments.

El siguiente comando utiliza el $inc operador de actualización para incrementar el num_mflix_comments campo para todas las películas lanzadas 1924 en:

db.runCommand(
   {
      update: "movies",
      updates: [
         { 
            q: { year: 1924 }, 
            u: { $inc: { num_mflix_comments: 1 }, $set: { classic: true, era: "silent" } }, 
            multi: true 
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

Como el campo multi está establecido en true, la actualización modifica todos los 6 documentos que coinciden con la consulta especificada en el campo q y devuelve el siguiente resultado:

{ n: 6, nModified: 6, ok: 1 }

Se puede consultar Salida para obtener más detalles.

Actualiza con el pipeline de agregación

El comando update puede utilizar un pipeline de agregación para la actualización. El 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.runCommand(
   {
      update: "users",
      updates: [
         { 
            q: { name: "Robert Baratheon" },  
            u: [ 
               { $set: { full_info: { $concat: [ "$name", " - ", "$email" ] } } },
               { $set: { status: "active" } }
            ], 
            multi: false
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

db.runCommand(
   {
      update: "movies",
      updates: [
         { 
            q: { title: "The Great Train Robbery" },  
            u: [ 
                  { $set: { age: { $subtract: [ 2026, "$year" ] } } },
                  { $set: { era: { $switch: { 
                                       branches: [
                                             { case: { $lt: [ "$year", 1960 ] }, then: "Classic" },
                                             { case: { $lt: [ "$year", 1980 ] }, then: "Golden Age" },
                                             { case: { $lt: [ "$year", 2000 ] }, then: "Modern" },                                                   
                                             { case: { $gte: [ "$year", 2000 ] }, then: "Contemporary" }
                                       ],
                                       default: "Unknown" 
                  } } } } 
            ], 
            multi: false
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

Actualización masiva

El siguiente ejemplo realiza varias operaciones de actualización en un solo comando para actualizar documentos existentes e insertar nuevos. La operación:

• marca películas de terror altamente calificadas de 2015 como featured

• clasifica películas cortas de drama y romance de 2012 como melodrama

• Inserta una nueva película de ciencia ficción de 2024 si no existe

db.runCommand(
   {
      update: "movies",
      updates: [
         // Update highly-rated Horror movies from 2015
         { 
            q: { year: 2015, genres: "Horror", "imdb.rating": { $gte: 7 } }, 
            u: { $set: { featured: true } },
            multi: true
         },
         // Update short Drama/Romance movies from 2012
         { 
            q: { year: 2012, genres: { $all: ["Drama", "Romance"] }, runtime: { $lt: 90 } }, 
            u: { $set: { category: "melodrama" } },
            multi: true
         },
         // Upsert a new movie from 2026
         { 
            q: { title: "A New Movie", year: 2026 }, 
            u: { 
               $set: { 
                  genres: ["Sci-Fi", "Adventure"],
                  runtime: 142,
                  "imdb.rating": 8.5,
                  featured: true
               }
            },
            upsert: true
         }
      ],
      ordered: false,
      writeConcern: { w: "majority", wtimeout: 5000 }
   }
)

El documento devuelto muestra que el comando modificó documentos existentes e insertó uno nuevo mediante upsert.Consulte la sección "Salida" para obtener más información.

{
  n: 16,
  upserted: [
    {
      index: 2,
      _id: ObjectId('69861e680e6ea1f51160fe1c')
    }
  ],
  nModified: 15,
  ok: 1,
  '...': '...'
}

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.

Los documentos de la colección movies de la base de datos sample_mflix tienen campos como title y year.

La siguiente operación usará la intercalación para realizar una búsqueda sin distinción entre mayúsculas y minúsculas. La query busca "the godfather" en minúsculas, pero con strength: 1 intercalación, la query coincide con "The Godfather" sin distinción de mayúsculas:

db.runCommand({
  update: "movies",
  updates: [
    {
      q: { title: "the godfather" },
      u: { $set: { featured: true } },
      collation: { locale: "en", strength: 1 }
    }
  ]
})

Especifica arrayFilters para las operaciones de actualización de arreglos

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

db.runCommand( {
   update: "movies",
   updates: [
      { q: { languages: "English" }, u: { $set: { "languages.$[element]" : "EN" } }, arrayFilters: [ { "element": "English" } ], multi: true}
   ]
} )

db.runCommand({
   update: "movies",
   updates: [
      { q: { cast: "Al Pacino" }, u: { $set: { "cast.$[elem]" : "REDACTED" } }, arrayFilters: [ { "elem": "Al Pacino" } ], multi: true }
   ]
})

Especifica hint para las operaciones de actualización

Los documentos de la colección movies de la base de datos sample_mflix tienen campos como year y num_mflix_comments.

Cree los siguientes índices en la colección:

[
   db.movies.createIndex( { year: 1 } ),
   db.movies.createIndex( { num_mflix_comments: 1 } )
]

La siguiente operación de actualización incrementa el campo num_mflix_comments para "El Gran Robo del Tren" y sugiere explícitamente utilizar el índice { year: 1 }:

db.runCommand({
   update: "movies",
   updates: [
      { q: { title: "The Great Train Robbery" }, u: { $inc: { "num_mflix_comments": 1 } }, hint: { year: 1 }, multi: false }
   ]
})

Para ver el índice utilizado, puede ejecutar en una operación de actualización. Por ejemplo, a continuación se explica una actualización que explain incrementa num_mflix_comments para películas con 5 o menos comentarios, estrenadas en 2000 o posteriormente:

db.runCommand(
   {
      explain: {
         update: "movies",
         updates: [ 
         { q: { "num_mflix_comments": { $lte: 5 }, "year": { $gte: 2000 } }, u: { $inc: { "num_mflix_comments": 1 } }, hint: { year: 1 }, multi: true }
         ]
      },
      verbosity: "queryPlanner"
   }
)

El explain no modifica los documentos.

Usa variables en la opción let o en el campo c

Las variables se pueden definir en la opción let o en el campo c y acceder a ellas en el arreglo updates.

Los documentos de la colección movies de la base de datos sample_mflix tienen campos como title y year.

El siguiente ejemplo utiliza la opción let para definir variables para buscar y agregar un nuevo campo a una película.

db.runCommand( {
   update: "movies",
   updates: [
      { q: { $expr: { $eq: [ "$title", "$$movieTitle" ] } },
         u: [ { $set: { franchise: "$$franchiseName" } } ] }
   ],
   let : { movieTitle: "The Godfather", franchiseName: "The Godfather Trilogy" }
} )

El siguiente ejemplo define las variables movieTitle y franchiseName en c y utiliza las variables para agregar un campo franchise.

db.runCommand( {
   update: "movies",
   updates: [
      { q: { $expr: { $eq: [ "$title", "$$movieTitle" ] } },
         u: [ { $set: { franchise: "$$franchiseName" } } ],
         c: { movieTitle: "The Godfather", franchiseName: "The Godfather Trilogy" } }
      ]
} )

Operación de actualización con una ordenación

Los documentos de la colección movies de la base de datos sample_mflix tienen campos como year, title y num_mflix_comments.

El siguiente ejemplo busca todas las películas desde 1972 y actualiza la que tiene más comentarios.

db.runCommand( {
   update: "movies",
   updates: [ {
      // Find movies from 1972
      q: { year: 1972 },
      // Add a classic_status field to the found movie
      u: { $set: { classic_status: "Most Discussed 1972 Film" } },
      // Only update one movie
      multi: false,
      // Sort movies by comment count in descending order
      sort: { num_mflix_comments: -1 }
   } ]
} )

La operación actualiza solo la 1972 película con la mayor cantidad de comentarios.