Operaciones masivas

Overview

En esta guía, puedes aprender a utilizar el controlador de Rust para realizar operaciones masivas.

Las operaciones masivas realizan múltiples operaciones de escritura en uno o más espacios de nombres. Un namespace es una combinación del nombre de la base de datos y el nombre de la colección, en el formato <database>.<collection>Dado que realiza operaciones masivas en una instancia Client, puede realizar operaciones masivas en cualquier espacio de nombres del clúster al que acceda su cliente.

Puedes realizar operaciones masivas para reducir el número de llamadas al servidor. En lugar de enviar una solicitud para cada operación, las operaciones masivas ejecutan varias operaciones dentro de una sola acción.

Esta guía incluye las siguientes secciones:

• Datos de muestra presenta los datos de muestra que se utilizan en los ejemplos de operaciones masivas

• Tipos de operaciones en bloque describe cómo utilizar los tipos WriteModel para realizar operaciones en bloque de inserción, reemplazo, actualizado y borrado

• Tipo de retorno describe el valor de retorno del método bulk_write() y cómo acceder a la información sobre la operación masiva.

• Modificar comportamiento describe cómo modificar el comportamiento predeterminado del bulk_write() método

• Escribir en espacios de nombres mixtos describe cómo realizar una operación masiva en múltiples espacios de nombres en una llamada de método

• Información adicional proporciona enlaces a recursos y documentación de la API para los tipos y métodos mencionados en esta guía

Datos de muestra

Los ejemplos de esta guía utilizan los siguientes documentos de muestra, que se almacenan en la colección mushrooms de la base de datos db:

let docs = vec![
    doc! {"name" : "portobello", "color" : "brown", "edible" : true },
    doc! {"name" : "chanterelle", "color" : "yellow", "edible" : true },
    doc! {"name" : "oyster", "color" : "white", "edible" : true },
    doc! {"name" : "fly agaric", "color" : "red", "edible" : false },
];

También puedes usar tipos de estructuras personalizadas para representar tus datos de muestras. Para un ejemplo que realiza una operación por lotes usando Mushroom structs para modelar los mismos datos, consulta el Ejemplo de inserción de structs en esta página.

Tipos de operaciones masivas

Para realizar una operación de escritura masiva, pasa un arreglo de instancias del enum WriteModel al método bulk_write().

En esta sección, puedes aprender cómo realizar las siguientes operaciones de guardado masivo definiendo sus respectivos tipos WriteModel:

• Operaciones de inserción masiva

• Operaciones de reemplazo masivo

• Operaciones de actualización masiva

• Borrar operaciones masivas

let mushrooms: Collection<Document> = client.database("db").collection("mushrooms");
let models = vec![
    InsertOneModel::builder()
        .namespace(mushrooms.namespace())
        .document(doc! {
            "name": "lion's mane",
            "color": "white",
            "edible": true
        })
        .build(),
    InsertOneModel::builder()
        .namespace(mushrooms.namespace())
        .document(doc! {
            "name": "angel wing",
            "color": "white",
            "edible": false
        })
        .build(),
];
let result = client.bulk_write(models).await?;
println!("Inserted documents: {}", result.inserted_count);

Inserted documents: 2

#[derive(Serialize)]
struct Mushroom {
    name: String,
    color: String,
    edible: bool,
}

let mushrooms: Collection<Mushroom> = client.database("db").collection("mushrooms");
let lions_mane = Mushroom {
    name: "lion's mane".to_string(),
    color: "white".to_string(),
    edible: true,
};
let angel_wing = Mushroom {
    name: "angel wing".to_string(),
    color: "white".to_string(),
    edible: false,
};
let lions_mane_model = mushrooms.insert_one_model(lions_mane)?;
let angel_wing_model = mushrooms.insert_one_model(angel_wing)?;
let result = client.bulk_write([lions_mane_model, angel_wing_model]).await?;
println!("Inserted documents: {}", result.inserted_count);

Inserted documents: 2

let mushrooms: Collection<Document> = client.database("db").collection("mushrooms");
let models = vec![
    ReplaceOneModel::builder()
        .namespace(mushrooms.namespace())
        .filter(doc! { "name": "portobello" })
        .replacement(doc! {
            "name": "cremini",
            "color": "brown",
            "edible": true
        })
        .build(),
    ReplaceOneModel::builder()
        .namespace(mushrooms.namespace())
        .filter(doc! { "name": "oyster" })
        .replacement(doc! {
            "name": "golden oyster",
            "color": "yellow",
            "edible": true
        })
        .upsert(true)
        .build(),
];
let result = client.bulk_write(models).await?;
println!("Modified documents: {}", result.modified_count);

Modified documents: 2

let mushrooms: Collection<Document> = client.database("db").collection("mushrooms");
let models = vec![
    WriteModel::UpdateOne(
        UpdateOneModel::builder()
            .namespace(mushrooms.namespace())
            .filter(doc! { "name": "fly agaric" })
            .update(doc! { "$set": { "name": "fly amanita" } })
            .upsert(true)
            .build(),
    ),
    WriteModel::UpdateMany(
        UpdateManyModel::builder()
            .namespace(mushrooms.namespace())
            .filter(doc! { "color": "yellow" })
            .update(doc! { "$set": { "color": "yellow/orange" } })
            .build(),
    ),
];
let result = client.bulk_write(models).await?;
println!("Modified documents: {}", result.modified_count);

Modified documents: 2

let mushrooms: Collection<Document> = client.database("db").collection("mushrooms");
let models = vec![
    WriteModel::DeleteOne(
        DeleteOneModel::builder()
            .namespace(mushrooms.namespace())
            .filter(doc! { "color": "red" })
            .build(),
    ),
    WriteModel::DeleteMany(
        DeleteManyModel::builder()
            .namespace(mushrooms.namespace())
            .filter(doc! { "edible": true })
            .build(),
    ),
];
let result = client.bulk_write(models).await?;
println!("Deleted documents: {}", result.deleted_count);

Deleted documents: 4

Tipo de retorno

El método bulk_write() devuelve una instancia de estructura SummaryBulkWriteResult desde la cual puede acceder a información sobre su operación masiva.

El tipo SummaryBulkWriteResult tiene los siguientes campos:

• inserted_count:: el número de documentos insertados

• matched_count: el número de documentos coincididos.

• modified_countla cantidad de documentos actualizados

• upserted_countNúmero de documentos actualizados/insertados

• deleted_count:el número de documentos eliminados

También puede utilizar el método verbose_results() para ver información detallada sobre cada operación. El método verbose_results() devuelve una instancia de la estructura VerboseBulkWriteResult, que tiene los siguientes campos:

• delete_results: los resultados de cada operación de eliminación exitosa

• insert_results:los resultados de cada operación de inserción exitosa

• update_results:los resultados de cada operación de actualización exitosa

• summaryun resumen de los resultados de cada tipo de operación

El siguiente ejemplo encadena el método verbose_results() al método bulk_write() e imprime los resultados de las operaciones de actualización y eliminación:

let models = vec![
    WriteModel::DeleteOne(
        DeleteOneModel::builder()
            .namespace(mushrooms.namespace())
            .filter(doc! { "name": "oyster" })
            .build(),
    ),
    WriteModel::UpdateOne(
        UpdateOneModel::builder()
            .namespace(mushrooms.namespace())
            .filter(doc! { "name": "chanterelle" })
            .update(doc! { "$set": { "season": ["July", "August", "September"] } })
            .build(),
    ),
];
let result = client.bulk_write(models).verbose_results().await?;
println!(
    "Update results: {:?}\nDelete results: {:?}\n",
    result.update_results, result.delete_results
);

Update results: {1: UpdateResult { matched_count: 1, modified_count: 1, upserted_id: None }}
Delete results: {0: DeleteResult { deleted_count: 1 }}

Modificar comportamiento

Puede modificar el comportamiento del método bulk_write() ajustando los valores de los campos BulkWriteOptions. Para establecer estos campos de struct, encadene los métodos correspondientes de los campos al método bulk_write().

La estructura BulkWriteOptions contiene los siguientes campos:

let mushrooms: Collection<Document> = client.database("db").collection("mushrooms");
let models = vec![
    WriteModel::UpdateOne(UpdateOneModel::builder()
        .namespace(mushrooms.namespace())
        .filter(doc! { "name": "portobello" })
        .update(doc! { "$set": { "_id": 123 } })
        .upsert(true)
        .build()),
    WriteModel::InsertOne(InsertOneModel::builder()
        .namespace(mushrooms.namespace())
        .document(doc! {
            "name": "reishi",
            "color": "red/brown",
            "edible": true
        })
        .build()),
];
let result = client.bulk_write(models).ordered(false).await?;
println!(
    "Inserted documents: {}\nDeleted documents: {}",
    result.inserted_count, result.deleted_count
);

Error: Error { kind: BulkWrite(BulkWriteError { write_concern_errors: [], write_errors:
{0: WriteError { code: 66, code_name: None, message: "Plan executor error during update ::
caused by :: Performing an update on the path '_id' would modify the immutable field '_id'",
details: None }}, partial_result: Some(Summary(SummaryBulkWriteResult { inserted_count: 1,
matched_count: 0, modified_count: 0, upserted_count: 0, deleted_count: 0 })) }),
labels: ... }

Guardar en espacios de nombres mixtos

Los ejemplos anteriores en esta página realizan operaciones masivas en el namespace db.mushrooms. Sin embargo, puedes realizar guardados masivos en varios namespace en una sola llamada de método.

El siguiente ejemplo inserta un documento en el namespace ingredients.sweet y uno en el namespace meals.dessert:

let sweet: Collection<Document> = client
    .database("ingredients")
    .collection("sweet");
let dessert: Collection<Document> = client
    .database("meals")
    .collection("dessert");
let models = vec![
    InsertOneModel::builder()
        .namespace(sweet.namespace())
        .document(doc! { "name": "brown sugar", "price": 3.99 })
        .build(),
    InsertOneModel::builder()
        .namespace(dessert.namespace())
        .document(doc! { "name": "banana bread", "cook_time": 75 })
        .build(),
];
let result = client.bulk_write(models).await?;
println!("Inserted documents: {}", result.inserted_count);

Inserted documents: 2

Información Adicional

Para obtener más información sobre las operaciones por lotes, consulta Operaciones de escritura por lotes en el manual del servidor.