Docs Menu
Docs Home
/ /

Agregación

En esta guía, puede aprender cómo realizar operaciones de agregación en el controlador Rust.

Las operaciones de agregación procesan los datos de sus colecciones de MongoDB según las especificaciones que puede establecer en una canalización de agregación. Una canalización de agregación consta de una o más etapas. Cada etapa realiza una operación basada en sus operadores de expresión. Una vez que el controlador ejecuta la canalización de agregación, devuelve un resultado agregado.

Esta guía incluye las siguientes secciones:

  • Comparar operaciones de agregación y búsqueda describe las diferencias de funcionalidad entre las operaciones de agregación y búsqueda.

  • Limitaciones del servidor describe las limitaciones del servidor en el uso de memoria para operaciones de agregación

  • Losejemplos proporcionan ejemplos de agregaciones para diferentes casos de uso.

  • Información adicional proporciona enlaces a recursos y documentación de API para los tipos y métodos mencionados en esta guía.

Tip

Tutoriales completos sobre agregación

Puede encontrar tutoriales que ofrecen explicaciones detalladas de las tareas de agregación más comunes en la sección "Tutoriales completos de canalización de agregación" del manual del servidor. Seleccione un tutorial y, a continuación, seleccione Rust desde el menú desplegable Select your language en la esquina superior derecha de la página.

Las operaciones de agregación funcionan de forma similar a las fábricas de automóviles con líneas de montaje. Estas líneas cuentan con estaciones con herramientas especializadas para realizar tareas específicas. Por ejemplo, al fabricar un automóvil, la línea de montaje comienza con el chasis. A medida que este avanza por la línea, cada estación ensambla una pieza independiente. El resultado es un producto final transformado: el automóvil terminado.

La línea de ensamblaje representa la cadena de agregación, las estaciones individuales representan las etapas de agregación, las herramientas especializadas representan los operadores de expresión y el producto terminado representa el resultado agregado.

La siguiente tabla enumera las diferentes tareas que se pueden realizar con las operaciones de búsqueda, en comparación con las que se pueden lograr con las operaciones de agregación. El marco de agregación ofrece una funcionalidad ampliada que permite transformar y manipular los datos.

Operaciones de búsqueda
Operaciones de agregación
Select certain documents to return
Select which fields to return
Sort the results
Limit the results
Count the results
Select certain documents to return
Select which fields to return
Sort the results
Limit the results
Count the results
Rename fields
Compute new fields
Summarize data
Connect and merge data sets

Al realizar operaciones de agregación, tenga en cuenta las siguientes limitaciones:

  • Los documentos devueltos no deben violar el límite de tamaño de documento BSON de 16 megabytes.

  • Las etapas de pipeline tienen un límite de memoria de 100 megabytes por defecto. Si es necesario, puede superar este límite configurando allow_disk_use. campo en tu AggregateOptions.

  • El operador $graphLookup tiene un límite de memoria estricto de 100 megabytes e ignora la allow_disk_use configuración.

Los ejemplos de esta sección utilizan los siguientes documentos de muestra. Cada documento representa el perfil de un usuario en un sitio web de reseñas de libros y contiene información sobre su nombre, edad, géneros de interés y fecha de su última visita al sitio web:

{ "name": "Sonya Mehta", "age": 23, "genre_interests": ["fiction", "mystery", "memoir"], "last_active": { "$date": "2023-05-13T00:00:00.000Z" } },
{ "name": "Selena Sun", "age": 45, "genre_interests": ["fiction", "literary", "theory"], "last_active": { "$date": "2023-05-25T00:00:00.000Z" } },
{ "name": "Carter Johnson", "age": 56, "genre_interests": ["literary", "self help"], "last_active": { "$date": "2023-05-31T00:00:00.000Z" } },
{ "name": "Rick Cortes", "age": 18, "genre_interests": ["sci-fi", "fantasy", "memoir"], "last_active": { "$date": "2023-07-01T00:00:00.000Z" } },
{ "name": "Belinda James", "age": 76, "genre_interests": ["literary", "nonfiction"], "last_active": { "$date": "2023-06-11T00:00:00.000Z" } },
{ "name": "Corey Saltz", "age": 29, "genre_interests": ["fiction", "sports", "memoir"], "last_active": { "$date": "2023-01-23T00:00:00.000Z" } },
{ "name": "John Soo", "age": 16, "genre_interests": ["fiction", "sports"], "last_active": { "$date": "2023-01-03T00:00:00.000Z" } },
{ "name": "Lisa Ray", "age": 39, "genre_interests": ["poetry", "art", "memoir"], "last_active": { "$date": "2023-05-30T00:00:00.000Z" } },
{ "name": "Kiran Murray", "age": 20, "genre_interests": ["mystery", "fantasy", "memoir"], "last_active": { "$date": "2023-01-30T00:00:00.000Z" } },
{ "name": "Beth Carson", "age": 31, "genre_interests": ["mystery", "nonfiction"], "last_active": { "$date": "2023-08-04T00:00:00.000Z" } },
{ "name": "Thalia Dorn", "age": 21, "genre_interests": ["theory", "literary", "fiction"], "last_active": { "$date": "2023-08-19T00:00:00.000Z" } },
{ "name": "Arthur Ray", "age": 66, "genre_interests": ["sci-fi", "fantasy", "fiction"], "last_active": { "$date": "2023-11-27T00:00:00.000Z" } }

El siguiente ejemplo calcula la edad promedio, mínima y máxima de los usuarios interesados ​​en cada género.

El proceso de agregación contiene las siguientes etapas:

  • Una etapa $unwind para separar cada entrada de la matriz en el campo genre_interests en un nuevo documento.

  • Una etapa $group para agrupar documentos según el valor del campo genre_interests. Esta etapa calcula la edad promedio, mínima y máxima del usuario mediante los operadores $avg, $min y $max.

let age_pipeline = vec![
doc! { "$unwind": doc! { "path": "$genre_interests" } },
doc! { "$group": doc! {
"_id": "$genre_interests",
"avg_age": doc! { "$avg": "$age" },
"min_age": doc! { "$min": "$age" },
"max_age": doc! { "$max": "$age" }
} }
];
let mut results = my_coll.aggregate(age_pipeline).await?;
while let Some(result) = results.try_next().await? {
println!("* {:?}", result);
}
* { "_id": "memoir", "avg_age": 25.8, "min_age": 18, "max_age": 39 }
* { "_id": "sci-fi", "avg_age": 42, "min_age": 18, "max_age": 66 }
* { "_id": "fiction", "avg_age": 33.333333333333336, "min_age": 16, "max_age": 66 }
* { "_id": "nonfiction", "avg_age": 53.5, "min_age": 31, "max_age": 76 }
* { "_id": "self help", "avg_age": 56, "min_age": 56, "max_age": 56 }
* { "_id": "poetry", "avg_age": 39, "min_age": 39, "max_age": 39 }
* { "_id": "literary", "avg_age": 49.5, "min_age": 21, "max_age": 76 }
* { "_id": "fantasy", "avg_age": 34.666666666666664, "min_age": 18, "max_age": 66 }
* { "_id": "mystery", "avg_age": 24.666666666666668, "min_age": 20, "max_age": 31 }
* { "_id": "theory", "avg_age": 33, "min_age": 21, "max_age": 45 }
* { "_id": "art", "avg_age": 39, "min_age": 39, "max_age": 39 }
* { "_id": "sports", "avg_age": 22.5, "min_age": 16, "max_age": 29 }

El siguiente ejemplo busca cuántos usuarios estuvieron activos por última vez en cada mes.

El proceso de agregación contiene las siguientes etapas:

  • $project Etapa para extraer el mes del campo last_active como un número en el campo month_last_active

  • $group Etapa para agrupar documentos por el campo month_last_active y contar el número de documentos para cada mes.

  • $sort Etapa para establecer una ordenación ascendente por mes

let last_active_pipeline = vec![
doc! { "$project": { "month_last_active" : doc! { "$month" : "$last_active" } } },
doc! { "$group": doc! { "_id" : doc! {"month_last_active": "$month_last_active"} ,
"number" : doc! { "$sum" : 1 } } },
doc! { "$sort": { "_id.month_last_active" : 1 } }
];
let mut results = my_coll.aggregate(last_active_pipeline).await?;
while let Some(result) = results.try_next().await? {
println!("* {:?}", result);
}
* { "_id": { "month_last_active": 1 }, "number": 3 }
* { "_id": { "month_last_active": 5 }, "number": 4 }
* { "_id": { "month_last_active": 6 }, "number": 1 }
* { "_id": { "month_last_active": 7 }, "number": 1 }
* { "_id": { "month_last_active": 8 }, "number": 2 }
* { "_id": { "month_last_active": 11 }, "number": 1 }

El siguiente ejemplo encuentra los tres géneros más populares según la frecuencia con la que aparecen en los intereses de los usuarios.

El proceso de agregación contiene las siguientes etapas:

  • $unwind Etapa para separar cada entrada de la matriz en el campo genre_interests en un nuevo documento

  • $group Etapa para agrupar documentos por el campo genre_interests y contar el número de documentos para cada género

  • $sort escenario para establecer una clasificación descendente según la popularidad del género

  • $limit escenario para mostrar solo los tres primeros géneros

let popularity_pipeline = vec![
doc! { "$unwind" : "$genre_interests" },
doc! { "$group" : doc! { "_id" : "$genre_interests" , "number" : doc! { "$sum" : 1 } } },
doc! { "$sort" : doc! { "number" : -1 } },
doc! { "$limit": 3 }
];
let mut results = my_coll.aggregate(popularity_pipeline).await?;
while let Some(result) = results.try_next().await? {
println!("* {:?}", result);
}
* { "_id": "fiction", "number": 6 }
* { "_id": "memoir", "number": 5 }
* { "_id": "literary", "number": 4 }

Para aprender más sobre los conceptos mencionados en esta guía, consulta las siguientes entradas del manual del servidor:

Para obtener más información sobre el comportamiento del método aggregate(), consulte la SecciónOperaciones de agregación de la guía Recuperar datos.

Para obtener más información acerca de cómo ordenar resultados en un pipeline de agregación, consulta la guía Ordenar resultados.

Puede realizar búsquedas de similitud en incrustaciones vectoriales mediante la función de Búsqueda de Vectores de MongoDB. Para obtener más información, consulte la guía de Búsqueda de Vectores de MongoDB.

Para obtener más información sobre los métodos y tipos mencionados en esta guía, consulte la siguiente documentación de API:

Volver

Validación de esquema

En esta página