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

Agregação

Nesta página

  • Visão geral
  • Comparar operações
  • Limitações
  • Exemplos
  • Informações adicionais

Neste guia, você pode aprender como usar as operações de agregação no Driver do MongoDB Go.

As operações de agregação processam dados em suas coleções MongoDB com base em suas especificações no pipeline de agregação. Um pipeline de agregação 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.

As operações de agregação funcionam de forma semelhante a uma fábrica de automóveis. As fábricas de automóveis possuem uma linha de montagem. As linhas de montagem têm estações de montagem com ferramentas especializadas para executar uma tarefa específica. Para construir um carro, você envia peças brutas para a fábrica. Em seguida, a linha de montagem transforma e monta as peças num automóvel.

A linha de montagem se assemelha ao pipeline de agregação, as estações de montagem na linha de montagem se assemelham aos estágios de agregação, as ferramentas especializadas representam os operadores de expressão e o produto finalizado se assemelha ao resultado agregado.

A tabela abaixo lista as tarefas que você pode executar usando as operações de localização e agregação.

Encontrar operações
Operações de agregação
Select what documents to return
Select which fields to return
Sort the results
Limit the results
Count the results
Select what documents to return
Select which fields to return
Sort the results
Limit the results
Count the results
Rename fields
Calculate fields
Summarize data
Group values

As operações de agregação têm limitações. Ao realizar operações de agregação, tenha em mente o seguinte:

  • Os documentos devolvidos não devem violar o limite de tamanho de 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 com o método allowDiskUse.

  • O estágio $graphLookup tem um limite de memória rigoroso de 100 megabytes e ignora allowDiskUse.

Os exemplos nesta seção usam o seguinte struct Tea como um modelo para documentos na coleção tea :

type Tea struct {
Type string
Category string
Toppings []string
Price float32
}

Para executar os exemplos nesta seção, carregue os dados de amostra na coleção tea no banco de dados db utilizando o seguinte trecho:

coll := client.Database("db").Collection("tea")
docs := []interface{}{
Tea{Type: "Masala", Category: "black", Toppings: []string{"ginger", "pumpkin spice", "cinnamon"}, Price: 6.75},
Tea{Type: "Gyokuro", Category: "green", Toppings: []string{"berries", "milk foam"}, Price: 5.65},
Tea{Type: "English Breakfast", Category: "black", Toppings: []string{"whipped cream", "honey"}, Price: 5.75},
Tea{Type: "Sencha", Category: "green", Toppings: []string{"lemon", "whipped cream"}, Price: 5.15},
Tea{Type: "Assam", Category: "black", Toppings: []string{"milk foam", "honey", "berries"}, Price: 5.65},
Tea{Type: "Matcha", Category: "green", Toppings: []string{"whipped cream", "honey"}, Price: 6.45},
Tea{Type: "Earl Grey", Category: "black", Toppings: []string{"milk foam", "pumpkin spice"}, Price: 6.15},
Tea{Type: "Hojicha", Category: "green", Toppings: []string{"lemon", "ginger", "milk foam"}, Price: 5.55},
}
result, err := coll.InsertMany(context.TODO(), docs)

Cada documento contém informações sobre o tipo de chá, as coberturas disponíveis e o preço.

O exemplo a seguir calcula e exibe a classificação média e o número de classificações para cada categoria de chá.

O pipeline de agregação usa o estágio $group para agrupar os documentos pelo campo category, calcular a média usando o operador de expressão $avg e contar o número de documentos usando o operador de expressão $sum.

// create group stage
groupStage := bson.D{
{"$group", bson.D{
{"_id", "$category"},
{"average_price", bson.D{{"$avg", "$price"}}},
{"type_total", bson.D{{"$sum", 1}}},
}}}
// pass the pipeline to the Aggregate() method
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{groupStage})
if err != nil {
panic(err)
}
// display the results
var results []bson.M
if err = cursor.All(context.TODO(), &results); err != nil {
panic(err)
}
for _, result := range results {
fmt.Printf("Average price of %v tea options: $%v \n", result["_id"], result["average_price"])
fmt.Printf("Number of %v tea options: %v \n\n", result["_id"], result["type_total"])
}
Average price of black tea options: $6.075
Number of black tea options: 4
Average price of green tea options: $5.70
Number of green tea options: 4

O exemplo a seguir corresponde a documentos onde você pode obter espuma de leite como cobertura e lista as duas opções mais baratas.

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

  • $match estágio para corresponder documentos onde o campo toppings contém "espuma de leite"

  • $unset estágio para omitir os campos _id e category

  • $sort estágio para classificar price e toppings em ordem crescente

  • $limit palco para mostrar os dois primeiros documentos

// create the stages
matchStage := bson.D{{"$match", bson.D{{"toppings", "milk foam"}}}}
unsetStage := bson.D{{"$unset", bson.A{"_id", "category"}}}
sortStage := bson.D{{"$sort", bson.D{{"price", 1}, {"toppings", 1}}}}
limitStage := bson.D{{"$limit", 2}}
// pass the pipeline to the Aggregate() method
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage, unsetStage, sortStage, limitStage})
if err != nil {
panic(err)
}
// display the results
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
panic(err)
}
for _, result := range results {
fmt.Printf("Tea: %v \nToppings: %v \nPrice: $%v \n\n", result.Type, strings.Join(result.Toppings, ", "), result.Price)
}
Tea: Hojicha
Toppings: lemon, ginger, milk foam
Price: $5.55
Tea: Gyokuro
Toppings: berries, milk foam
Price: $5.65

Para saber mais sobre os termos mencionados, consulte os seguintes guias:

Para ver mais exemplos de agregação, consulte os seguintes guias:

  • Contar

  • Limite

  • Ignorar

  • Text

Para saber mais sobre o método Aggregate() e seu comportamento, consulte Recuperar dados.

Para saber mais sobre qualquer um dos métodos ou tipos discutidos neste guia, consulte a seguinte documentação da API:

Voltar

Modificar execução CRUD