Insira documentos

Exemplo

O exemplo a seguir usa o método insert_one() para inserir um documento na collection 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 comportamento do insert_one

Você pode modificar o comportamento do método insert_one() encadeando os métodos do construtor de opções com o insert_one(). Esses métodos de construtor de opções definem InsertOneOptions campos de estrutura.

A tabela a seguir descreve as opções disponíveis em InsertOneOptions:

O código a seguir mostra como definir o campo bypass_document_validation encadeando o método bypass_document_validation() ao método insert_one() :

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

Exemplo de arquivo completo: inserir um documento

Este exemplo insere um documento na coleção restaurants do banco de dados sample_restaurants. O método insert_one() insere um documento que tem valores de campo name, borough e cuisine.

Você pode inserir este documento como uma instância do tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, execute as seguintes ações nas linhas realçadas:

• Para acessar e inserir documentos de coleção como documentos BSON, substitua o parâmetro de tipo <T> por <Document> e o espaço reservado <struct or doc> por insert_doc.

• Para acessar e inserir documentos de coleção como instâncias da estrutura Restaurant, substitua o parâmetro de tipo <T> por <Restaurant> e o espaço reservado <struct or doc> por insert_struct. A estrutura Restaurant é definida no topo do arquivo de código.

Selecione a guia Asynchronous ou Synchronous para ver o código correspondente para cada tempo de execução:

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("...")

Exemplo

O exemplo a seguir usa o método insert_many() para inserir vários documentos na collection 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 comportamento insert_many

Você pode modificar o comportamento do método insert_many() encadeando os métodos do construtor de opções com o insert_many(). Esses métodos de construtor de opções definem InsertManyOptions campos de estrutura.

A tabela a seguir descreve as opções disponíveis em InsertManyOptions:

O código a seguir mostra como definir o campo comment encadeando o método comment() ao método insert_many() :

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

Exemplo de arquivo completo: inserir vários documentos

Este exemplo insere vários documentos na collection restaurants do banco de dados sample_restaurants. O exemplo insere documentos que têm name e cuisine valores de campo passando um vetor de documentos para o método insert_many() .

Você pode inserir estes documentos como instâncias do tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, execute as seguintes ações nas linhas realçadas:

• Para acessar e inserir documentos de coleção como documentos BSON, substitua o parâmetro de tipo <T> por <Document> e o espaço reservado <struct or doc> por insert_docs.

• Para acessar e inserir documentos de coleção como instâncias da estrutura Restaurant, substitua o parâmetro de tipo <T> por <Restaurant> e o espaço reservado <struct or doc> por insert_structs. A estrutura Restaurant é definida no topo do arquivo de código.

Selecione a guia Asynchronous ou Synchronous para ver o código correspondente para cada tempo de execução:

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("...")

Exemplo de comportamento ordenado

Suponha que você queira inserir os seguintes documentos na collection 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" }

Quando você tenta inserir estes documentos, o resultado depende do valor passado para o método construtor de opção ordered() :

• Se você passar um valor de true (o valor padrão), o driver lançará um BulkWriteError quando tentar inserir o documento com o valor _id duplicado. No entanto, o driver ainda insere os documentos antes que o erro ocorra.

• Se você passar um valor de false, o driver ainda lançará um BulkWriteError quando tentar inserir o documento com o valor _id duplicado, mas inserirá todos os outros documento.

O código a seguir mostra como realizar uma operação de gravação não ordenada para inserir os 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?;

Embora essa operação resulte em um BulkWriteError , você ainda poderá encontrar os documentos que não produzem erros na sua coleção:

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

Documentação da API

Para saber mais sobre os métodos e tipos mencionados neste guia, consulte a documentação da API abaixo:

• insert_one()

• InsertOneResult

• InsertOneOptions

• insert_many()

• InsertManyResult

• InsertManyOptions

• BulkWriteError