/ /

Métodos mongosh

Colecciones

Docs Home

Manual de base de datos

Referencia

Métodos mongosh

Colecciones

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

Esta versión de la documentación está archivada y ya no recibe soporte. Para actualizar su implementación 6.0, consulte Procedimientos de actualización de MongoDB.7.0

MongoDB con controladores

Esta página documenta una mongosh . Para ver el método equivalente en un driver de MongoDB, se debe consultar la página correspondiente al lenguaje de programación:

C#Java Sync Node.js PyMongo C C++Go Java RS Kotlin Coroutine Kotlin Sync PHP Mongoid Rust Scala

Definición

db.collection.updateOne(filter, update, options): Actualiza un único documento dentro de la colección según el filtro.

Compatibilidad

Este método está disponible en implementaciones alojadas en los siguientes entornos:

MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

Nota

Este comando es compatible con todos los clústeres de MongoDB Atlas. Para obtener información sobre el soporte de Atlas para todos los comandos, consulte Comandos no compatibles.

MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB
MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

El método updateOne() tiene la siguiente sintaxis:

db.collection.updateOne(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>,
     let: <document>
   }
)

Parámetros

El método db.collection.updateOne() toma los siguientes parámetros:

Parameter

Tipo

Descripción

filtro

Documento

Los criterios de selección para actualizar. Los mismos selectores query que en el método find() están disponibles.

Especifica un documento vacío { } para actualizar el primer documento devuelto en la colección.

update

documento o pipeline

Las modificaciones que se deben aplicar puede ser una de las siguientes:

Update document	Contiene solo expresiones de operadores de actualización. Para obtener más información, consulta Actualizar con un documento de expresiones del operador de actualizaciones
Aggregation Pipeline	Contiene únicamente las siguientes etapas de agregación: `$addFields` y su alias `$set` `$project` y su alias `$unset` `$replaceRoot` y su alias `$replaceWith` Para obtener más información, consulta Actualizar con una pipeline de agregación.

Para actualizar con un documento de reemplazo, consulta db.collection.replaceOne().

upsert

booleano

Opcional. Cuando true, updateOne() puede:

Crea un nuevo documento si no hay documentos que coincidan con filter. Para más detalles, consulta comportamiento de inserción.
Actualiza un solo documento que coincida con filter.

Para evitar múltiples upserts, asegúrate de que el/los campo(s) filter estén indexados de forma única.

Se establece por defecto en false, lo que no inserta un nuevo documento cuando no se encuentra ninguna coincidencia.

writeConcern

Documento

Opcional. Un documento que expresa el nivel de confirmación de escritura. Omite el uso del nivel de confirmación de escritura por defecto.

No establezcas explícitamente el nivel de confirmación de escritura para la operación si se ejecuta en una transacción. Para usar el nivel de confirmación de escritura con transacciones, consulta Transacciones y nivel de confirmación de escritura.

collation

Documento

Opcional.

Especifica la intercalación a utilizar para la operació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 opción de intercalación tiene la siguiente sintaxis:

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

Al especificar la intercalación, el campo locale es obligatorio; todos los demás campos de intercalación son opcionales. Para las descripciones de los campos, consulta Documento de intercalación.

Si no se especifica la intercalación, pero la colección tiene una intercalación por defecto (ver db.createCollection()), la operación utiliza la intercalación especificada para la colección.

Si no se especifica ninguna intercalación para la colección o para las operaciones, MongoDB utiliza la comparación binaria simple usada en versiones anteriores para las comparaciones de strings.

No puedes especificar varias intercalaciones para una operación. Por ejemplo, no puedes especificar diferentes intercalaciones por campo, o si realizas una búsqueda con un ordenamiento, no puedes usar una intercalación para la búsqueda y otra para el ordenamiento.

arrayFilters

arreglo

Opcional. Un arreglo de documentos de filtro que determinan qué elementos del arreglo modificar para una operación de actualización en un campo de arreglo.

En el documento de actualización, usa el operador posicional filtrado $[<identifier>] para definir un identificador, al que luego puedes hacer referencia en los documentos de filtro de arreglo. No puedes tener un documento de filtro de arreglo para un identificador si dicho identificador no está incluido en el documento de actualización.

El <identifier> debe comenzar con una letra minúscula y contener solo caracteres alfanuméricos.

Puedes incluir el mismo identificador varias veces en el documento de actualización; sin embargo, para cada identificador distinto ($[identifier]) en el documento de actualización, debes especificar exactamente un documento de filtro de arreglo correspondiente. Es decir, no puedes especificar múltiples documentos de filtro de arreglo para el mismo identificador. Por ejemplo, si la instrucción de actualizar incluye el identificador x (posiblemente varias veces), no puedes especificar lo siguiente para arrayFilters que incluya dos documentos de filtro separados para x:

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

Sin embargo, se pueden especificar condiciones compuestas sobre el mismo identificador en un único documento de filtro, como en los siguientes ejemplos:

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

Para obtener ejemplos, consulta Especificar arrayFilters para operaciones de actualización de arreglos.

hint

Documento o string

Opcional. Un documento o string que especifica el índice que se utilizará para respaldar el predicado de query.

La opción puede tomar un documento de especificación de índice o la string de nombre de índice.

Si especifica un índice que no existe, la operación genera un error.

Para un ejemplo, consulta Especificar hint para las operaciones de actualización.

let

Documento

Opcional.

Especifica un documento que contiene una lista de variables. Esto le permite mejorar la legibilidad de los comandos al separar las variables del texto de la query.

La sintaxis del documento es:

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

La variable se establece en el valor devuelto por la expresión y no puede modificarse posteriormente.

Para acceder al valor de una variable en el comando, se debe usar el prefijo de doble signo de dólar ($$) junto con el nombre de la variable en la forma $$<variable_name>. Por ejemplo: $$targetTotal.

Para usar una variable para los resultados del filtro, debes acceder a la variable dentro del operador $expr.

Para un ejemplo completo usando let y variables, ve Actualizar con variables let.

Devuelve

El método devuelve un documento que contiene:

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

Control de acceso

En las implementaciones que se ejecutan con authorization, el usuario debe tener acceso que incluya los siguientes privilegios:

update acción en las colecciones especificadas.
find acción en las colecciones especificadas.
insert acción en las colecciones especificadas si la operación produce una inserción.

El rol con funcionalidad incorporada readWrite proporciona los privilegios necesarios.

Comportamiento

Actualiza un solo documento

db.collection.updateOne() encuentra el primer documento que coincide con el filtro y aplica las modificaciones de actualización especificadas.

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

Para las especificaciones de actualización, el método db.collection.updateOne() puede aceptar un documento que solo contenga expresiones del operador de actualización.

Por ejemplo:

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

Actualiza con un pipeline de agregación

El método db.collection.updateOne() 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.updateOne(
   <query>,
   [
      { $set: { status: "Modified", comments: [ "$misc1", "$misc2" ] } },
      { $unset: [ "misc1", "misc2" ] }
   ]
   ...
)

Nota

La $set y $unset utilizadas en la pipeline se refieren a las etapas de agregación $set y $unset respectivamente, y no a los operadores de actualización $set y $unset.

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

Inserción

Si upsert: true y ningún documento coincide con el filter, db.collection.updateOne() crea un nuevo documento basado en los criterios de filter y las modificaciones de update. Consulta Actualización con inserción.

Si especificas upsert: true en una colección particionada, debes incluir la clave de partición completa en el filtro. Para un comportamiento adicional de db.collection.updateOne() en una colección particionada, consulta Colecciones particionadas.

Colección con tamaño fijo

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

Colecciones fragmentadas

`upsert` en una colección fragmentada

Para usar db.collection.updateOne() en una colección fragmentada:

Si no especifica upsert: true, debe incluir una coincidencia exacta en el campo _id o apuntar a una única partición (por ejemplo, incluyendo la clave de partición en el filtro).
Si upsert: true especifica, el filtro debe incluir la clave del fragmento.

Sin embargo, a los documentos de una colección fragmentada pueden faltarles los campos de clave de fragmento. Para identificar un documento que no tenga la clave de fragmento, puede usar la null coincidencia de igualdad. Junto con otra condición de filtro (como en el _id campo). Por ejemplo:

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

Modificación de la clave de fragmentación

Puede actualizarse el valor de clave de partición de un documento a menos que el campo de clave de partición sea el campo _id inmutable.

Advertencia

Los documentos en colecciones particionadas pueden no tener los campos de clave de partición. Toma precauciones para evitar remover accidentalmente la clave de partición al cambiar el valor de clave de partición de un documento.

Para modificar el valor de clave de fragmentación existente con db.collection.updateOne():

Debes ejecutar en un mongos. No emitas la operación directamente en la partición.
Usted debe ejecutar ya sea en una transacción o como una escritura reintentable.
Debes incluir un filtro de igualdad en la clave de partición completa.

Véase también upsert en una colección particionada.

Clave de fragmentación faltante

Los documentos en una colección particionada pueden carecer de los campos de clave de partición. Para usar db.collection.updateOne() para establecer la clave de partición faltante del documento, se debe ejecutar en un mongos. No realizar la operación directamente en la partición.

Además, se aplican los siguientes requisitos:

Tarea	Requisitos
Para configurar en `null`	Requiere un filtro de igualdad en la clave de partición completa si `upsert: true`.
Para establecer en un valor que no sea `null`	Debe realizarse dentro de una transacción o como una escritura reintentable. Requiere un filtro de igualdad en la clave de partición completa si `upsert: true`.

Tip

Dado que un valor de clave faltante se devuelve como parte de una coincidencia exacta nula, para evitar actualizar una clave con valor nulo, incluya condiciones de query adicionales (como en el campo _id) según corresponda.

Véase también:

Explicabilidad

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

Transacciones

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

Importante

En la mayoría de los casos, una transacción distribuida incurre en un costo de rendimiento mayor que las escrituras de documentos individuales, y la disponibilidad de transacciones distribuidas no debería ser un sustituto para un diseño de esquema efectivo. Para muchos casos, el modelo de datos desnormalizado (documento incrustado y matrices) seguirá siendo óptimo para tus datos y casos de uso. Es decir, en muchos casos, modelar tus datos de forma adecuada minimizará la necesidad de transacciones distribuidas.

Para consideraciones adicionales sobre el uso de transacciones (como el límite de tiempo de ejecución y el límite de tamaño del oplog), consulta también las consideraciones de producción.

Inserta dentro de transacciones

Puedes crear colecciones e índices dentro de una transacción distribuida si la transacción no es una transacción de escritura entre particiones.

db.collection.updateOne() con upsert: true puede ejecutarse en una colección existente o en una colección inexistente. Si se ejecuta en una colección que es inexistente, la operación crea la colección.

Tip

Crear colecciones e índices en una transacción

Nivel de confirmación de escritura y transacciones

Entradas de OpLog

Si una operación db.collection.updateOne() actualiza con éxito un documento, la operación añade una entrada en el OpLog (registro de operaciones). Si la operación falla o no encuentra un documento para actualizar, no se agrega una entrada en el oplog.

Ejemplos

Actualiza utilizando Update Operator Expressions

La colección restaurant contiene los siguientes documentos:

db.restaurant.insertMany( [
   { _id: 1, name: "Central Perk Cafe", Borough: "Manhattan" },
   { _id: 2, name: "Rock A Feller Bar and Grill", Borough: "Queens", violations: 2 },
   { _id: 3, name: "Empire State Pub", Borough: "Brooklyn", violations: 0 }
] )

La siguiente operación actualiza un único documento name: "Central Perk Cafe" con el campo violations:

try {
   db.restaurant.updateOne(
      { "name" : "Central Perk Cafe" },
      { $set: { "violations" : 3 } }
   );
} catch (e) {
   print(e);
}

La operación arroja:

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Si no se encuentra ninguna coincidencia, la operación arroja lo siguiente:

{ "acknowledged" : true, "matchedCount" : 0, "modifiedCount" : 0 }

Al establecer upsert: true se insertaría el documento si no se encontrara ninguna coincidencia. Consulta Actualización con inserción

Actualiza con el pipeline de agregación

El db.collection.updateOne() 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

Ejemplo 1

Los siguientes ejemplos utilizan el pipeline de agregación para modificar un campo mediante los valores de los otros campos del documento.

Crea una colección students con los siguientes 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, student: "Elizabeth", points: 60, commentsSemester1: "well behaved", commentsSemester2: "needs improvement", lastUpdate: ISODate("2019-01-01T00:00:00Z") }
] )

Imagina que, en lugar de tener campos separados commentsSemester1 y commentsSemester2 en el primer documento, deseas reunirlos en un campo comments, como en el segundo documento. La siguiente operación para actualizar utiliza un pipeline de agregación para:

añade el nuevo campo comments y establece el campo lastUpdate.
eliminar los campos commentsSemester1 y commentsSemester2 de todos los documentos en la colección.

Asegúrate de que el filtro en el comando de actualización apunte a un documento único. El campo id en el código a continuación es un ejemplo de tal filtro:

db.students.updateOne(
   { _id: 1 },
   [
      { $set: { status: "Modified", comments: [ "$commentsSemester1", "$commentsSemester2" ], lastUpdate: "$$NOW" } },
      { $unset: [ "commentsSemester1", "commentsSemester2" ] }
   ]
)

Nota

La $set y $unset utilizadas en la pipeline se refieren a las etapas de agregación $set y $unset respectivamente, y no a los operadores de actualización $set y $unset.

Primera etapa

La etapa $set:

crea un nuevo campo de arreglo comments cuyos elementos son el contenido actual de los campos misc1 y misc2 y
establece el campo lastUpdate al valor de la variable de agregación NOW. La variable de agregación NOW se resuelve al valor actual de la fecha y hora y permanece igual a lo largo de toda la pipeline de agregación. Para acceder a las variables de agregación, prefija la variable con signos double de dólar $$ y enciérrela entre comillas.

Segunda etapa

La etapa $unset remueve los campos commentsSemester1 y commentsSemester2.

Después del comando, la colección contiene los siguientes documentos:

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

Ten en cuenta que, después de introducir un orden, solo se modifica el primer documento encontrado en el orden y los documentos restantes permanecen intactos.

Ejemplo 2

La pipeline de agregación permite que la actualización realice actualizaciones condicionales basadas en los valores actuales de los campos y también utilice estos valores para calcular un valor diferente para otro campo.

Por ejemplo, crea una colección students3 con los siguientes documentos:

db.students3.insertMany( [
   { _id: 1, tests: [ 95, 92, 90 ], average: 92, grade: "A", lastUpdate: ISODate("2020-01-23T05:18:40.013Z") },
   { _id: 2, tests: [ 94, 88, 90 ], average: 91, grade: "A", lastUpdate: ISODate("2020-01-23T05:18:40.013Z") },
   { _id: 3, tests: [ 70, 75, 82 ], lastUpdate: ISODate("2019-01-01T00:00:00Z") }
] )

El tercer documento _id: 3 no tiene los campos average y grade. Usando un pipeline de agregación puedes actualizar el documento con el promedio de calificaciones calculado y la calificación en letra.

db.students3.updateOne(
   { _id: 3 },
   [
     { $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"
     } } } }
   ]
)

Nota

El $set utilizado en la pipeline se refiere a la etapa de agregación $set, y no a los operadores de actualizar $set.

Primera etapa

La etapa $set:

calcula un nuevo campo average basado en el promedio del campo tests. Consulta $avg para obtener más información sobre el operador de agregación $avg y $trunc para obtener más información sobre el operador de agregación de truncamiento $trunc.
establece el campo lastUpdate al valor de la variable de agregación NOW. La variable de agregación NOW se resuelve al valor actual de la fecha y hora y permanece igual a lo largo de toda la pipeline de agregación. Para acceder a las variables de agregación, prefija la variable con signos double de dólar $$ y enciérrela entre comillas.

Segunda etapa

La etapa $set calcula un nuevo campo grade basado en el campo average calculado en la etapa anterior. Consulta $switch para obtener más información sobre el operador de agregación $switch.

Después del comando, la colección contiene los siguientes documentos:

{ _id: 1, tests: [ 95, 92, 90 ], average: 92, grade: "A", lastUpdate: ISODate("2020-01-23T05:18:40.013Z") }
{ _id: 2, tests: [ 94, 88, 90 ], average: 91, grade: "A", lastUpdate: ISODate("2020-01-23T05:18:40.013Z") }
{ _id: 3, tests: [ 70, 75, 82 ], lastUpdate: ISODate("2020-01-24T17:33:30.674Z"), average: 75, grade: "C" }

Tip

Actualizaciones con el pipeline de agregación

Actualizar con inserción

La colección restaurant contiene los siguientes documentos:

db.restaurant.insertMany( [
   { _id: 1, name: "Central Perk Cafe", Borough: "Manhattan", violations: 3 },
   { _id: 2, name: "Rock A Feller Bar and Grill", Borough: "Queens", violations: 2 },
   { _id: 3, name: "Empire State Pub", Borough: "Brooklyn", violations: "0" }
] )

La siguiente operación intenta actualizar el documento con name : "Pizza Rat's Pizzaria", mientras upsert: true :

try {
   db.restaurant.updateOne(
      { "name" : "Pizza Rat's Pizzaria" },
      { $set: {"_id" : 4, "violations" : 7, "borough" : "Manhattan" } },
      { upsert: true }
   );
} catch (e) {
   print(e);
}

Desde upsert:true, el documento es inserted basado en los criterios filter y update. La operación devuelve:

{
   "acknowledged" : true,
   "matchedCount" : 0,
   "modifiedCount" : 0,
   "upsertedId" : 4,
   "upsertedCount": 1
}

La colección ahora contiene los siguientes documentos:

{ _id: 1, name: "Central Perk Cafe", Borough: "Manhattan", violations: 3 },
{ _id: 2, name: "Rock A Feller Bar and Grill", Borough: "Queens", violations: 2 },
{ _id: 3, name: "Empire State Pub", Borough: "Brooklyn", violations: 4 },
{ _id: 4, name: "Pizza Rat's Pizzaria", Borough: "Manhattan", violations: 7 }

El campo name se rellenó utilizando los criterios filter, mientras que los operadores update se emplearon para crear el resto del documento.

La siguiente operación actualiza el primer documento con violations que sean mayores que 10:

try {
   db.restaurant.updateOne(
      { "violations" : { $gt: 10} },
      { $set: { "Closed" : true } },
      { upsert: true }
   );
} catch (e) {
   print(e);
}

La operación arroja:

{
   "acknowledged" : true,
   "matchedCount" : 0,
   "modifiedCount" : 0,
   "upsertedId" : ObjectId("56310c3c0c5cbb6031cafaea")
}

La colección ahora contiene los siguientes documentos:

{ _id: 1, name: "Central Perk Cafe", Borough: "Manhattan", violations: 3 },
{ _id: 2, name: "Rock A Feller Bar and Grill", Borough: "Queens", violations: 2 },
{ _id: 3, name: "Empire State Pub", Borough: "Brooklyn", violations: 4 },
{ _id: 4, name: "Pizza Rat's Pizzaria", Borough: "Manhattan", grade: 7 }
{ _id: ObjectId("56310c3c0c5cbb6031cafaea"), Closed: true }

Dado que ningún documento coincidió con el filtro y upsert era true, updateOne() insertó el documento con un _id generado y solamente el criterio update.

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, wtimeout de 100:

try {
   db.restaurant.updateOne(
       { "name" : "Pizza Rat's Pizzaria" },
       { $inc: { "violations" : 3}, $set: { "Closed" : true } },
       { w: "majority", wtimeout: 100 }
   );
} catch (e) {
   print(e);
}

Si el primario y al menos un secundario reconocen cada operación de guardado en un plazo de 100 milisegundos, devuelve:

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Si el reconocimiento tarda más que el límite de wtimeout, se obtiene la siguiente excepción:

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})

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

Origen	Descripción
`clientSupplied`	El nivel de confirmación de escritura se especificó en la aplicación.
`customDefault`	El nivel de confirmación de escritura se originó a partir de un valor por defecto personalizado. Vea `setDefaultRWConcern`.
`getLastErrorDefaults`	El nivel de confirmación de escritura se originó en el campo `settings.getLastErrorDefaults` del set de réplicas.
`implicitDefault`	El nivel de confirmación de escritura (write concern) se originó en el servidor en ausencia de todas las demás especificaciones de nivel de confirmación de escritura (write concern).

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.

Una colección myColl tiene los siguientes documentos:

db.myColl.insertMany( [
   { _id: 1, category: "café", status: "A" },
   { _id: 2, category: "cafe", status: "a" },
   { _id: 3, category: "cafE", status: "a" }
] )

La siguiente operación incluye la opción de intercalación:

db.myColl.updateOne(
   { category: "cafe" },
   { $set: { status: "Updated" } },
   { collation: { locale: "fr", strength: 1 } }
);

Especifique `arrayFilters` para una operación de actualización de matriz

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

Se deben actualizar los elementos que coinciden con los criterios `arrayFilters`

Cree una colección students con los siguientes documentos:

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

Para modificar todos los elementos que sean mayores o iguales que 100 en el arreglo grades, utilizar el operador posicional filtrado $[<identifier>] con la opción arrayFilters en el método db.collection.updateOne():

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

La operación actualiza el campo grades de un solo documento y, después de la operación, la colección contiene los siguientes documentos:

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

Actualiza elementos específicos de un arreglo de documentos

Cree una colección students2 con los siguientes 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 el valor del campo mean para todos los elementos en el arreglo grades en que la calificación es mayor o igual que 85, utiliza el operador posicional filtrado $[<identifier>] con los arrayFilters en el método db.collection.updateOne():

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

La operación actualiza el arreglo de un solo documento, y después de la operación, la colección contiene los siguientes 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: 75, std: 6 },
      { grade: 87, mean: 90, std: 3 },
      { grade: 85, mean: 85, std: 4 }
   ]
}

Especifica `hint` para las operaciones de actualización

Crea una colección de ejemplo students con los siguientes documentos:

db.students.insertMany( [
   { _id: 1, student: "Richard", grade: "F", points:  0,  comments1: null, comments2: null },
   { _id: 2, student: "Jane", grade: "A", points: 60,  comments1: "well behaved", comments2: "fantastic student" },
   { _id: 3, student: "Ronan", grade: "F", points:  0,  comments1: null, comments2: null },
   { _id: 4, student: "Noah", grade: "D", points: 20,  comments1: "needs improvement", comments2: null },
   { _id: 5, student: "Adam", grade: "F", points:  0,  comments1: null, comments2: null },
   { _id: 6, student: "Henry", grade: "A", points: 86,  comments1: "fantastic student", comments2: "well behaved" }
] )

Cree los siguientes índices en la colección:

db.students.createIndex( { grade: 1 } )
db.students.createIndex( { points: 1 } )

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

Nota

Si especifica un índice que no existe, la operación genera un error.

db.students.updateOne(
   { "points": { $lte: 20 }, "grade": "F" },
   { $set: { "comments1": "failed class" } },
   { hint: { grade: 1 } }
)

El comando de actualización devuelve lo siguiente:

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Nota

Aunque 3 documentos cumplen con los criterios de la actualización, updateOne solo modifica el primer documento que encuentra. Por lo tanto, aunque los estudiantes Richard, Ronan y Adam cumplen con todos los criterios, solo se actualizará Richard.

Para ver el índice utilizado, ejecuta explain en la operación:

db.students.explain().update(
   { "points": { $lte: 20 }, "grade": "F" },
   { $set: { "comments1": "failed class" } },
   { multi: true, hint: { grade: 1 } }
)

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

Cambiado en la versión 8.1.2.

Cuando db.collection.updateOne() 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.updateOne() 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.

Tip

Para actualizar varios documentos, consulta db.collection.updateMany().

Volver

db.collection.updateMany

db.collection.validate

Definición

Compatibilidad

Nota

Sintaxis

Parámetros

Devuelve

Control de acceso

Comportamiento

Actualiza un solo documento

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

Actualiza con un pipeline de agregación

Nota

Inserción

Colección con tamaño fijo

Colecciones fragmentadas

upsert en una colección fragmentada

Modificación de la clave de fragmentación

Advertencia

Clave de fragmentación faltante

Tip

Explicabilidad

Transacciones

Importante

Inserta dentro de transacciones

Tip

Nivel de confirmación de escritura y transacciones

Entradas de OpLog

Ejemplos

Actualiza utilizando Update Operator Expressions

Actualiza con el pipeline de agregación

Ejemplo 1

Nota

Ejemplo 2

Nota

Tip

Actualizar con inserción

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

Especificar la intercalación

Especifique arrayFilters para una operación de actualización de matriz

Se deben actualizar los elementos que coinciden con los criterios arrayFilters

Actualiza elementos específicos de un arreglo de documentos

Especifica hint para las operaciones de actualización

Nota

Nota

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

Tip

`upsert` en una colección fragmentada

Especifique `arrayFilters` para una operación de actualización de matriz

Se deben actualizar los elementos que coinciden con los criterios `arrayFilters`

Especifica `hint` para las operaciones de actualización