Insertar documentos

Ejemplo

El siguiente ejemplo utiliza el método insert_one() para insertar un documento en la colección books:

let my_coll: Collection<Book> = client.database("db").collection("books");
let doc = Book { _id: 8, title: "Atonement".to_string(), author: "Ian McEwan".to_string() };
let insert_one_result = my_coll.insert_one(doc).await?;
println!("Inserted document with _id: {}", insert_one_result.inserted_id);

Inserted document with _id: 8

Modificar el comportamiento de insert_one

Puede modificar el comportamiento del método insert_one() encadenando métodos del generador de opciones a insert_one(). Estos métodos del generador de opciones establecen los campos de la estructura InsertOneOptions.

La siguiente tabla describe las opciones disponibles en InsertOneOptions:

El siguiente código muestra cómo establecer el campo bypass_document_validation encadenando el método bypass_document_validation() al método insert_one():

let _result = my_coll.insert_one(doc)
    .bypass_document_validation(true)
    .await?;

Ejemplo de archivo completo: Insertar un documento

Este ejemplo inserta un documento en la colección restaurants de la base de datos sample_restaurants. El método insert_one() inserta un documento con los valores de campo name, borough y cuisine.

Puedes insertar este documento como una instancia del tipo Document o de un tipo de dato personalizado. Para especificar qué tipo de dato representa los datos de la colección, realiza las siguientes acciones en las líneas resaltadas:

• Para acceder e insertar documentos en la colección como documentos BSON, reemplaza el parámetro de tipo <T> por <Document> y el marcador de posición <struct or doc> por insert_doc.

• Para acceder e insertar documentos de colección como instancias de la estructura Restaurant, reemplace el parámetro de tipo <T> por <Restaurant> y el marcador de posición <struct or doc> por insert_struct. La estructura Restaurant se define en la parte superior del archivo de 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::{doc, Document},
    Client,
    Collection 
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    borough: String,
    cuisine: String,
    name: 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 insert_doc = doc! { 
        "name": "Sea Stone Tavern",
        "cuisine": "Greek",
        "borough": "Queens",
    };
    let insert_struct = Restaurant {
        name: "Sea Stone Tavern".to_string(),
        cuisine: "Greek".to_string(),
        borough: "Queens".to_string(),
    };
    // Replace <struct or doc> with the insert_struct or insert_doc variable
    let res = my_coll.insert_one(<struct or doc>).await?;
    println!("Inserted a document with _id: {}", res.inserted_id);
    Ok(())
}

Inserted a document with _id: ObjectId("...")

use std::env;
use mongodb::{
    bson::{doc, Document},
    sync::{ Client, Collection }
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    borough: String,
    cuisine: String,
    name: 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 insert_doc = doc! { 
        "name": "Sea Stone Tavern",
        "cuisine": "Greek",
        "borough": "Queens",
    };
    let insert_struct = Restaurant {
        name: "Sea Stone Tavern".to_string(),
        cuisine: "Greek".to_string(),
        borough: "Queens".to_string(),
    };
    // Replace <struct or doc> with the insert_struct or insert_doc variable
    let res = my_coll.insert_one(<struct or doc>).run()?;
    println!("Inserted a document with _id: {}", res.inserted_id);
    Ok(())
}

Inserted a document with _id: ObjectId("...")

Ejemplo

El siguiente ejemplo utiliza el método insert_many() para insertar varios documentos en la colección books:

let docs = vec![
    Book {
        _id: 5,
        title: "Cat's Cradle".to_string(),
        author: "Kurt Vonnegut Jr.".to_string()
    },
    Book {
        _id: 6,
        title: "In Memory of Memory".to_string(),
        author: "Maria Stepanova".to_string()
    },
    Book {
        _id: 7,
        title: "Pride and Prejudice".to_string(),
        author: "Jane Austen".to_string()
    }
];
let insert_many_result = my_coll.insert_many(docs).await?;
println!("Inserted documents with _ids:");
for (_key, value) in &insert_many_result.inserted_ids {
    println!("{:?}", value);
}

Inserted documents with _ids:
Int32(5)
Int32(6)
Int32(7)

Modificar el comportamiento de insert_many

Puede modificar el comportamiento del método insert_many() encadenando métodos del generador de opciones a insert_many(). Estos métodos del generador de opciones establecen los campos de la estructura InsertManyOptions.

La siguiente tabla describe las opciones disponibles en InsertManyOptions:

El siguiente código muestra cómo establecer el campo comment encadenando el método comment() al método insert_many():

let _result = my_coll.insert_many(docs)
    .comment(Some("hello world".into()))
    .await?;

Ejemplo de archivo completo: Insertar varios documentos

Este ejemplo inserta múltiples documentos en la colección restaurants de la base de datos sample_restaurants. El ejemplo inserta documentos que tienen los valores de los campos name y cuisine al pasar un vector de documentos al método insert_many().

Se puede insertar estos documentos como instancias del tipo Document o de un tipo de datos personalizado. Para especificar qué tipo de dato representa los datos de la colección, realiza las siguientes acciones en las líneas resaltadas:

• Para acceder e insertar documentos en la colección como documentos BSON, reemplaza el parámetro de tipo <T> por <Document> y el marcador de posición <struct or doc> por insert_docs.

• Para acceder e insertar documentos de colección como instancias de la estructura Restaurant, reemplace el parámetro de tipo <T> por <Restaurant> y el marcador de posición <struct or doc> por insert_structs. La estructura Restaurant se define en la parte superior del archivo de código.

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

use mongodb::{ 
    bson::{doc, Document},
    Client,
    Collection 
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    cuisine: 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 insert_docs = vec! [
        doc! { 
            "name": "While in Kathmandu",
            "cuisine": "Nepalese",
        },
        doc! { 
            "name": "Cafe Himalaya",
            "cuisine": "Nepalese",
        }
    ];
    let insert_structs = vec! [
        Restaurant {
            name: "While in Kathmandu".to_string(),
            cuisine: "Nepalese".to_string(),
        },
        Restaurant {
            name: "Cafe Himalaya".to_string(),
            cuisine: "Nepalese".to_string(),
        }
    ];
    
    // Replace <structs or docs> with the insert_structs or insert_docs variable
    let insert_many_result = my_coll.insert_many(<structs or docs>).await?;
    println!("Inserted documents with _ids:");
    for (_key, value) in &insert_many_result.inserted_ids {
        println!("{}", value);
    }
        
    Ok(())
}

Inserted documents with _ids:
ObjectId("...")
ObjectId("...")

use mongodb::{
    bson::{doc, Document},
    sync::{Client, Collection}
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    cuisine: 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 insert_docs = vec! [
        doc! { 
            "name": "While in Kathmandu",
            "cuisine": "Nepalese",
        },
        doc! { 
            "name": "Cafe Himalaya",
            "cuisine": "Nepalese",
        }
    ];
    let insert_structs = vec! [
        Restaurant {
            name: "While in Kathmandu".to_string(),
            cuisine: "Nepalese".to_string(),
        },
        Restaurant {
            name: "Cafe Himalaya".to_string(),
            cuisine: "Nepalese".to_string(),
        }
    ];
    
    // Replace <structs or docs> with the insert_structs or insert_docs variable
    let insert_many_result = my_coll.insert_many(<structs or docs>).run()?;
    println!("Inserted documents with _ids:");
    for (_key, value) in &insert_many_result.inserted_ids {
        println!("{}", value);
    }
    Ok(())
}

Inserted documents with _ids:
ObjectId("...")
ObjectId("...")

Ejemplo de comportamiento ordenado

Supón que quieres insertar los siguientes documentos en la colección books:

{ "_id": 1, "title": "Where the Wild Things Are" }
{ "_id": 2, "title": "The Very Hungry Caterpillar" }
{ "_id": 1, "title": "Blueberries for Sal" }
{ "_id": 3, "title": "Goodnight Moon" }

Al intentar insertar estos documentos, el resultado depende del valor que se pase al método de creación de la opción ordered():

• Si se pasa un valor de true (el valor por defecto), el driver lanza un BulkWriteError cuando intenta insertar el documento con el valor duplicado de _id. Sin embargo, el driver sigue introduciendo los documentos antes de que se produzca el error.

• Si pasa un valor de false, el controlador aún arroja un BulkWriteError cuando intenta insertar el documento con el valor duplicado _id, pero inserta todos los demás documentos.

El siguiente código muestra cómo realizar una operación de escritura desordenada para insertar los documentos anteriores:

let docs = vec![
    Book { _id: 1, title: "Where the Wild Things Are".to_string(), author: "".to_string() },
    Book { _id: 2, title: "The Very Hungry Caterpillar".to_string(), author: "".to_string() },
    Book { _id: 1, title: "Blueberries for Sal".to_string(), author: "".to_string() },
    Book { _id: 3, title: "Goodnight Moon".to_string(), author: "".to_string() }
];
my_coll.insert_many(docs).ordered(false).await?;

Aunque esta operación da como resultado un BulkWriteError, aún puedes encontrar los documentos que no producen errores en tu colección:

{ "_id": 1, "title": "Where the Wild Things Are" }
{ "_id": 2, "title": "The Very Hungry Caterpillar" }
{ "_id": 3, "title": "Goodnight Moon" }

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:

• insert_one()

• InsertOneResult

• InsertOneOptions

• insert_many()

• InsertManyResult

• InsertManyOptions

• Error de escritura masiva