/ /

Driver Rust

Docs Home

Librerías de clientes

Rust

Driver Rust

Docs Home

Librerías de clientes

Rust

Driver Rust

Limite la cantidad de resultados devueltos

Overview

En esta guía, puede aprender cómo usar el MongoDB Rust Driver para realizar operaciones de límite. Estas operaciones especifican el número de documentos devueltos por una operación de lectura.

Usa el limit() Método para limitar la cantidad de documentos que una operación de lectura puede devolver. La operación devuelve menos documentos si no hay suficientes para alcanzar el límite especificado.

Si utiliza el método limit() con el método skip(), la omisión se aplica primero y el límite solo se aplica a los documentos restantes. Para obtener más información sobre las operaciones de omisión, consulte Guía de Omitir resultados devueltos.

Datos de muestra para ejemplos

Los ejemplos en esta guía usan la siguiente estructura Book como modelo para documentos en la colección books:

#[derive(Debug, Serialize, Deserialize)]
struct Book {
    name: String,
    author: String,
    length: i32,
}

El siguiente código muestra cómo insertar datos de muestra en la colección books:

let uri = "connection string";
let client = Client::with_uri_str(uri).await?;
let my_coll: Collection<Book> = client.database("db").collection("books");
let books = vec![
    Book {
        id: 1,
        name: "The Brothers Karamazov".to_string(),
        author: "Dostoyevsky".to_string(),
        length: 824,
    },
    Book {
        id: 2,
        name: "Atlas Shrugged".to_string(),
        author: "Rand".to_string(),
        length: 1088,
    },
    Book {
        id: 3,
        name: "Les Misérables".to_string(),
        author: "Hugo".to_string(),
        length: 1462,
    },
    Book {
        id: 4,
        name: "A Dance with Dragons".to_string(),
        author: "Martin".to_string(),
        length: 1104,
    },
];
my_coll.insert_many(books).await?;

Limitar documentos

Puede especificar la cantidad máxima de documentos que se devolverán en una consulta o en una secuencia de agregación.

Esta sección describe cómo limitar los resultados de las siguientes maneras:

método limit(): Encadena el método limit() al método find()
Struct FindOptions: Usa la opción limit
pipeline de agregación: Crea una canalización que utiliza la etapa $limit

Ejemplo del método limit()

Para limitar el número de documentos devueltos, se puede encadenar el método limit() al método find().

Este ejemplo ejecuta una operación find() que realiza las siguientes acciones:

Ordena los resultados en orden ascendente de sus valores de campo length
Limita los resultados a los primeros tres documentos

let mut cursor = my_coll
    .find(doc! {})
    .sort(doc! { "length": 1 })
    .limit(3).await?;
while let Some(result) = cursor.try_next().await? {
println!("{:?}", result);
}

Book { name: "The Brothers Karamazov", author: "Dostoyevsky", length: 824 }
Book { name: "Atlas Shrugged", author: "Rand", length: 1088 }
Book { name: "A Dance with Dragons", author: "Martin", length: 1104 }

Ejemplo de opciones

Alternativamente, si estás configurando y reutilizando opciones para tu query, puedes usar FindOptions. Configure el campo limit de la estructura FindOptions utilizando el método de construcción de opciones limit(). Luego, encadena el método with_options() al método find() y pasa tu struct FindOptions como un parámetro al método with_options().

Este ejemplo ejecuta una operación find() que realiza las siguientes acciones:

Filtra los resultados para incluir solo documentos donde el campo length sea mayor que 1000
Ordena los resultados en orden ascendente de sus valores de campo length
Limita los resultados a los dos primeros documentos.

let filter = doc! { "length": { "$gt": 1000 } };
let find_options = FindOptions::builder()
    .sort(doc! { "length": 1 })
    .limit(2)
    .build();
let mut cursor = my_coll.find(filter).with_options(find_options).await?;
while let Some(result) = cursor.try_next().await? {
    println!("{:?}", result);
}

Book { name: "Atlas Shrugged", author: "Rand", length: 1088 }
Book { name: "A Dance with Dragons", author: "Martin", length: 1104 }

Ejemplo de agregación

Puedes usar la etapa $limit en una pipeline de agregación para limitar los resultados devueltos. Para obtener más información sobre las operaciones de agregación, consulta la guía de agregación.

Este ejemplo ejecuta un pipeline de agregación que realiza las siguientes acciones:

Ordena los resultados en orden descendente según los valores del campo length
Limita los resultados devueltos a los dos primeros documentos

let pipeline = vec![
    doc! { "$match": {} },
    doc! { "$sort": { "length": -1 } },
    doc! { "$limit": 2 },
];
let mut cursor = my_coll.aggregate(pipeline).await?;
while let Some(result) = cursor.try_next().await? {
    println!("{:?}", result);
}

Document({"_id": Int32(3), "name": String("Les Misérables"), "author": String("Hugo"), "length": Int32(1462)})
Document({"_id": Int32(4), "name": String("A Dance with Dragons"), "author": String("Martin"), "length": Int32(1104)})

Información Adicional

Para obtener más información sobre las operaciones mencionadas en esta guía, consulta las siguientes guías:

Documentación de la API

Para aprender más sobre cualquiera de los métodos o tipos analizados en esta guía, consulta la siguiente documentación de API:

Volver

Omitir resultados

Insert