Update Documents

Actualizar patrón de documento

En MongoDB, los métodos de actualización siguen el mismo patrón:

Estos métodos toman los siguientes parámetros:

• Filtro de consulta para que coincida con uno o más documentos para actualizar

• Actualice eldocumento que especifica los cambios de campo y valor.

El campo _id

Cada documento en una colección de MongoDB tiene un campo _id único e inmutable. Si intenta cambiar el campo _id mediante una operación de actualización, el controlador genera una excepción WriteError y no realiza ninguna actualización.

Parámetros

Cada método toma un filtro de query y un documento de actualización que incluye al menos un operador de actualización. El operador de actualización especifica el tipo de actualización que se debe realizar e incluye los campos y valores que describen el cambio. Actualiza los documentos utilizando el siguiente formato:

doc! { "<update operator>": doc! { "<field>": <value> } }

Para especificar varias actualizaciones en un solo documento de actualización, utiliza el siguiente formato:

doc! {
    "<update operator>": doc!{"<field>": <value>},
    "<update operator>": doc!{"<field>": <value>},
    ...
}

Consulte el manual del servidor MongoDB para obtener una lista completa de los operadores de actualización y sus descripciones.

Valor de retorno

Los métodos update_one() y update_many() devuelven un tipo UpdateResult si la operación es exitosa. El tipo UpdateResult contiene las siguientes propiedades que describen la operación:

Si varios documentos coinciden con el filtro de query que se pasa a update_one(), el método selecciona y actualiza el primer documento que coincida. Si ningún documento corresponde al filtro de query, la operación de actualización no realiza ningún cambio.

Actualizar ejemplo

Los siguientes documentos describen a los empleados de una empresa:

{
  "_id": ObjectId('4337'),
  "name": "Shelley Olson",
  "department": "Marketing",
  "role": "Director",
  "bonus": 3000
},
{
  "_id": ObjectId('4902'),
  "name": "Remi Ibrahim",
  "department": "Marketing",
  "role": "Consultant",
  "bonus": 1800
}

Este ejemplo realiza una operación de actualización utilizando el método update_many(). El método update_many() toma los siguientes parámetros:

• Filtro de consulta para que coincida con los documentos donde el valor del campo department sea "Marketing".

• Documento de actualización que contiene las siguientes actualizaciones:

  • Un operador $set para cambiar el valor de department a "Business Operations" y de role a "Analytics Specialist"

  • Un operador $inc para aumentar el valor de bonus en 500

let update_doc = doc! {
        "$set": doc! { "department": "Business Operations",
                      "role": "Analytics Specialist" },
        "$inc": doc! { "bonus": 500 }
};
let res = my_coll
    .update_many(doc! { "department": "Marketing" }, update_doc)
    .await?;
println!("Modified documents: {}", res.modified_count);

Modified documents: 2

Los siguientes documentos reflejan los cambios resultantes de la operación de actualización anterior:

{
  "_id": ObjectId('4337'),
  "name": "Shelley Olson",
  "department": "Business Operations",
  "role": "Analytics Specialist",
  "bonus": 3500
},
{
  "_id": ObjectId('4902'),
  "name": "Remi Ibrahim",
  "department": "Business Operations",
  "role": "Analytics Specialist",
  "bonus": 2300
}

actualizar por ObjectId ejemplo

El siguiente documento describe a un empleado de una empresa:

{
  "_id": ObjectId('4274'),
  "name": "Jill Millerton",
  "department": "Marketing",
  "role": "Consultant"
}

Este ejemplo consulta el documento precedente mediante la especificación de un filtro de query para coincidir con el valor único _id del documento. Luego, el código realiza una operación de actualización con el método update_one(). El método update_one() toma los siguientes parámetros:

• Filtro de query que coincide con un documento en el que el valor del campo _id es ObjectId('4274')

• Actualizar el documento que crea instrucciones para establecer el valor de name a "Jill Gillison"

let id = ObjectId::from_str("4274").expect("Could not convert to ObjectId");
let filter_doc = doc! { "_id": id };
let update_doc = doc! {
        "$set": doc! { "name": "Jill Gillison" }
};
let res = my_coll
    .update_one(filter_doc, update_doc)
    .await?;
println!("Modified documents: {}", res.modified_count);

Modified documents: 1

El siguiente documento refleja los cambios resultantes de la operación de actualización anterior:

{
  "_id": ObjectId('4274'),
  "name": "Jill Gillison",
  "department": "Marketing",
  "role": "Consultant"
}

Ejemplo de archivo completo: Actualizar un documento

Este ejemplo actualiza un documento en la colección restaurants de la base de datos sample_restaurants. El método update_one() agrega el campo price al primer documento en el que el valor del campo name es "Spice Market".

Se puede acceder a los documentos en la colección restaurants como instancias del tipo Document o de un tipo de datos personalizado. Para especificar el tipo de dato que representa la colección de datos, reemplaza el parámetro de tipo <T> en la línea resaltada con uno de los siguientes valores:

• <Document>: Accede a documentos de la colección como documentos BSON

• <Restaurant>: Accede a documentos de la colección como instancias de la estructura Restaurant, definida en la parte superior del código

Selecciona el Asynchronous o la pestaña Synchronous para ver el código correspondiente para cada entorno de ejecución:

use std::env;
use mongodb::{
    bson::{ Document, doc },
    Client,
    Collection
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    price: String,
}
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter = doc! { "name": "Spice Market" };
    let update = doc! { "$set": doc! {"price": "$$$"} };
    let res = my_coll.update_one(filter, update).await?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

Updated documents: 1

use std::env;
use mongodb::{
    bson::{ Document, doc },
    sync::{ Client, Collection }
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    price: String,
}
fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri)?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter = doc! { "name": "Spice Market" };
    let update = doc! { "$set": doc! {"price": "$$$"} };
    let res = my_coll.update_one(filter, update).run()?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

Updated documents: 1

Ejemplo de archivo completo: Actualizar varios documentos

Este ejemplo actualiza un documento en la colección restaurants de la base de datos sample_restaurants. El método update_many() agrega el campo near_me a los documentos en los que el valor del campo address.street es "Sullivan Street" y el campo borough es "Manhattan".

Se puede acceder a los documentos en la colección restaurants como instancias del tipo Document o de un tipo de datos personalizado. Para especificar el tipo de dato que representa la colección de datos, reemplaza el parámetro de tipo <T> en la línea resaltada con uno de los siguientes valores:

• <Document>:Accede a los documentos de colección como documentos BSON.

• <Restaurant>: Accede a documentos de la colección como instancias de la estructura Restaurant, definida en la parte superior del código

Seleccione la pestaña Asynchronous o Synchronous para ver el código correspondiente para cada tiempo de ejecución:

use std::env;
use mongodb::{ bson::doc, Client, Collection };
use bson::Document;
use serde::{ Deserialize, Serialize };
#[derive(Debug, Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
}
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    borough: String,
    address: Address,
}
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri).await?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter =
        doc! { 
            "address.street": "Sullivan Street", 
            "borough": "Manhattan" 
        };
    let update = doc! { "$set": doc! { "near_me": true } };
    let res = my_coll.update_many(filter, update).await?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

// Your values might differ
Updated documents: 22

use std::env;
use mongodb::{
    bson::{ Document, doc },
    sync::{ Client, Collection } 
};
use serde::{ Deserialize, Serialize };
#[derive(Debug, Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
}
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    borough: String,
    address: Address,
}
fn main() -> mongodb::error::Result<()> {
    let uri = "<connection string>";
    let client = Client::with_uri_str(uri)?;
    // Replace <T> with the <Document> or <Restaurant> type parameter
    let my_coll: Collection<T> = client
        .database("sample_restaurants")
        .collection("restaurants");
    let filter =
        doc! { 
        "address.street": "Sullivan Street", 
        "borough": "Manhattan" 
    };
    let update = doc! { "$set": doc! { "near_me": true } };
    let res = my_coll.update_many(filter, update).run()?;
    println!("Updated documents: {}", res.modified_count);
    Ok(())
}

// Your values might differ
Updated documents: 22

Documentación de la API

Para obtener más información sobre los métodos y tipos mencionados en esta guía, vea la siguiente documentación de la API:

• update_one()

• update_many()

• UpdateResult

• UpdateOptions

• WriteError