Delete Documents

Parámetros

Los métodos delete_one() y delete_many() reciben un filtro de query como parámetro. Un filtro de query está formado por los campos y valores que constituyen los criterios para que los documentos coincidan.

opciones

Puedes modificar el comportamiento de los métodos de operación de borrado encadenando los métodos del desarrollador de opciones a delete_one() y delete_many(). Estos métodos de opciones establecen campos en la estructura DeleteOptions.

La siguiente tabla describe las opciones disponibles en DeleteOptions:

El siguiente código muestra cómo establecer el campo comment mediante el encadenamiento del método comment() al método delete_one():

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

Valor de retorno

Los métodos delete_one() y delete_many() devuelven un tipo DeleteResult. Este tipo contiene la propiedad deleted_count que describe la cantidad de documentos eliminados. Si ningún documento coincide con el filtro de query que especificaste, la operación de borrado no remueve ningún documento y el valor de deleted_count es 0.

Borrar un ejemplo

El siguiente ejemplo utiliza el método delete_one() para borrar un documento que tiene un valor de item igual a "placemat":

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

Deleted documents: 1

Ejemplo de archivo completo: borrar un documento

Este ejemplo borra un documento que coincide con un filtro de query de la colección restaurants en la base de datos sample_restaurants. El método delete_one() elimina el primer documento en el que el valor del campo name es "Haagen-Dazs" y el campo borough es "Brooklyn".

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 la pestaña Asynchronous o Synchronous para ver el código correspondiente para cada runtime:

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

Borrar varios ejemplo

Este ejemplo realiza las siguientes acciones:

• Llama al método delete_many()

• Pasa un filtro de query a delete_many() que coincide con los documentos donde el valor de category es "garden"

• Encadena el método hint() a delete_many() para utilizar el índice _id_ como referencia para la operación de borrado

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

Ejemplo de archivo completo: borrar varios documentos

Este ejemplo elimina todos los documentos que coinciden con un filtro de query de la colección restaurants en la base de datos sample_restaurants. El método delete_many() elimina documentos en los que el valor del campo borough es "Manhattan" y el valor del campo address.street es "Broadway".

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 la pestaña Asynchronous o Synchronous para ver el código correspondiente para cada runtime:

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

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:

• delete_one()

• delete_many()

• DeleteOptions

• Hint

• DeleteResult