Menu Docs
Página inicial do Docs
/ / /
Driver Rust
/

Agregação

Nesta página

  • Visão geral
  • Analogia
  • Comparar agregação e encontrar operações
  • Limitações do servidor
  • Exemplos
  • Insights de idade por gênero
  • Agrupar por componente de tempo
  • Calcular gêneros populares
  • Informações adicionais
  • Documentação da API

Neste guia, você pode aprender como realizar operações de agregação no driver Rust.

As operações de agregação processam dados em sua collection MongoDB com base em especificações que você pode definir em um pipeline de agregação. Um aggregation pipeline consiste em um ou mais estágios. Cada estágio executa uma operação com base em seus operadores de expressão. Depois que o acionador executa o pipeline de agregação, ele retorna um resultado agregado.

Este guia inclui as seguintes seções:

  • Comparar agregação e operações de localização descreve as diferenças de funcionalidade entre as operações de agregação e localização

  • Limitações do Servidor MongoDB descreve as limitações do servidor no uso de memória para operações de agregação

  • Exemplos fornece exemplos de agregações para diferentes casos de uso

  • Informações adicionais fornecem links para recursos e documentação da API para os tipos e métodos mencionados neste guia

As operações de agregação funcionam de forma semelhante às fábricas de automóveis com linhas de montagem. As linhas de montagem têm estações com ferramentas especializadas para executar tarefas específicas. Por exemplo, ao construir um carro, a linha de montagem começa com o estrutura. Em seguida, à medida que a estrutura do carro se move pela linha de montagem, cada estação monta uma peça separada. O resultado é um produto final transformado, o carro acabado.

A linha de montagem representa o aggregation pipeline, as estações individuais representam os estágios de aggregation, as ferramentas especializadas representam os operadores de expressão, e o produto finalizado representa o resultado agregado.

A tabela a seguir lista as diferentes tarefas que você pode executar com operações de localização, em comparação com o que você pode obter com operações de agregação. A estrutura de agregação fornece funcionalidade expandida que permite transformar e manipular seus dados.

Encontrar operações
Operações de agregação
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

Ao realizar operações de agregação, considere as seguintes limitações:

  • Os documentos retornados não devem violar o limite de tamanho do documento BSON de 16 megabytes.

  • Os estágios do pipeline têm um limite de memória de 100 megabytes por padrão. Se necessário, você pode exceder esse limite definindo o campo allow_disk_use em seu AggregateOptions.

  • O operador $graphLookup tem um limite de memória rigoroso de 100 megabytes e ignora a configuração do allow_disk_use .

Os exemplos nesta seção usam os seguintes documentos de amostra. Cada documento representa um perfil de usuário em um site de avaliações de livros e contém informações sobre seu nome, idade, interesses de gênero e data em que esteve ativo pela última vez no site:

{ "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" } }

O exemplo abaixo calcula a idade média, mínima e máxima dos usuários interessados em cada gênero.

O pipeline de agregação contém os seguintes estágios:

  • Um estágio $unwind para separar cada entrada de array no campo genre_interests em um novo documento.

  • Um estágio $group para agrupar documentos pelo valor do campo genre_interests . Esse estágio encontra a idade média, mínima e máxima do usuário usando os operadores $avg, $min e $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 }

O exemplo a seguir mostra quantos usuários foram ativos pela última vez em cada mês.

O pipeline de agregação contém os seguintes estágios:

  • $project estágio para extrair o mês do campo last_active como um número para o campo month_last_active

  • $group etapa para agrupar documentos pelo campo month_last_active e contar o número de documentos para cada mês

  • $sort estágio para definir uma classificação crescente no mês

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 }

O exemplo a seguir encontra os três gêneros mais populares com base na frequência com que eles aparecem nos interesses dos usuários.

O pipeline de agregação contém os seguintes estágios:

  • $unwind estágio para separar cada entrada de array no campo genre_interests em um novo documento

  • $group estágio para agrupar documentos pelo campo genre_interests e contar o número de documentos para cada gênero

  • $sort estágio para definir uma classificação descendente na popularidad do gênero

  • $limit palco para mostrar apenas os três primeiros 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 saber mais sobre os conceitos mencionados neste guia, consulte as seguintes entradas manuais do servidor:

Para saber mais sobre o comportamento do método aggregate() , consulte a seção Operações de agregação do guia Recuperar dados.

Para saber mais sobre como classificar resultados em um agregação pipeline, consulte o guia Classificar resultados.

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

Voltar

Validação de esquema