Exclua documentos

Parâmetros

Os métodos delete_one() e delete_many() usam um filtro de query como parâmetro. Um filtro de query consiste nos campos e valores que formam critérios para a correspondência de documentos.

Opções

Você pode modificar o comportamento dos métodos da operação de exclusão encadeando os métodos do construtor de opções com delete_one() e delete_many(). Esses métodos de opção definem DeleteOptions campos de estrutura.

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

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

let res = my_coll
    .delete_one(filter)
    .comment(bson!("hello!"))
    .await?;

Valor de retorno

Os métodos delete_one() e delete_many() retornam um tipo DeleteResult . Este tipo contém a propriedade deleted_count , que descreve o número de documentos excluídos. Se nenhum documento corresponder ao filtro de query que você especificou, a operação de exclusão não removerá nenhum documento, e o valor de deleted_count será 0.

Excluir um exemplo

O exemplo a seguir usa o método delete_one() para excluir um documento que tem um valor item de "placemat":

let filter = doc! { "item": "placemat" };
let res = my_coll.delete_one(filter).await?;
println!("Deleted documents: {}", res.deleted_count);

Deleted documents: 1

Exemplo de arquivo completo: excluir um documento

Este exemplo exclui um documento que corresponde a um filtro de query da coleção restaurants no banco de dados sample_restaurants. O método delete_one() exclui o primeiro documento no qual o valor do campo name é "Haagen-Dazs" e o campo borough é "Brooklyn".

Você pode acessar os documentos na coleção restaurants como instâncias do tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, substitua o parâmetro de tipo <T> na linha realçada por um dos seguintes valores:

• <Document>: acessa documentos de coleção como documentos BSON

• <Restaurant>: acessa documentos de coleção como instâncias da estrutura Restaurant, definidas na parte superior do código

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

use mongodb::{ 
    bson::{ Document, doc }, 
    Client, 
    Collection 
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    borough: 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! { "$and": [
           doc! { "name": "Haagen-Dazs" },
           doc! { "borough": "Brooklyn" }
       ]
    };
    let result = my_coll.delete_one(filter).await?;
    println!("Deleted documents: {}", result.deleted_count);
    Ok(())
}

Deleted documents: 1

use mongodb::{ 
    bson::{ Document, doc }, 
    sync::{ Client, Collection } 
};
use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Debug)]
struct Restaurant {
    name: String,
    borough: 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! { "$and": [
           doc! { "name": "Haagen-Dazs" },
           doc! { "borough": "Brooklyn" }
       ]
    };
    let result = my_coll.delete_one(filter).run()?;
    println!("Deleted documents: {}", result.deleted_count);
    Ok(())
}

Deleted documents: 1

Exemplo de exclusão de muitos

Este exemplo executa as seguintes ações:

• Chama o método delete_many()

• Passa um filtro de query para delete_many() que corresponde a documentos onde o valor de category é "garden"

• Encadeia o método hint() para delete_many() para usar o índice _id_ como dica para a operação de exclusão

let filter = doc! { "category": "garden" };
let hint = Hint::Name("_id_".to_string());
let res = my_coll
    .delete_many(filter)
    .hint(hint)
    .await?;
println!("Deleted documents: {}", res.deleted_count);

Deleted documents: 2

Exemplo de arquivo completo: excluir vários documentos

Este exemplo exclui todos os documentos que correspondem a um filtro de query da coleção restaurants no banco de dados sample_restaurants. O método delete_many() exclui documentos nos quais o valor do campo borough é "Manhattan" e o valor do campo address.street é "Broadway".

Você pode acessar os documentos na coleção restaurants como instâncias do tipo Document ou um tipo de dados personalizado. Para especificar qual tipo de dados representa os dados da coleção, substitua o parâmetro de tipo <T> na linha realçada por um dos seguintes valores:

• <Document>: acessa documentos de coleção como documentos BSON

• <Restaurant>: acessa documentos de coleção como instâncias da estrutura Restaurant, definidas na parte superior do código

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

use mongodb::{
    bson::{ Document, doc },
    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,
}
#[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! { "$and": [
           doc! { "borough": "Manhattan" },
           doc! { "address.street": "Broadway" }
       ]
    };
    let result = my_coll.delete_many(filter).await?;
    println!("Deleted documents: {}", result.deleted_count);
    Ok(())
}

// Your values might differ
Deleted documents: 615

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! { "$and": [
           doc! { "borough": "Manhattan" },
           doc! { "address.street": "Broadway" }
       ]
    };
    let result = my_coll.delete_many(filter).run()?;
    println!("Deleted documents: {}", result.deleted_count);
    Ok(())
}

// Your values might differ
Deleted documents: 615

Documentação da API

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

• delete_one()

• delete_many()

• Excluir opções

• Hint

• DeleteResult