Introdução
Neste laboratório, você aprenderá a realizar operações básicas de agregação no MongoDB. Essas operações permitem processar registros de dados e retornar resultados computados. Você aprenderá a calcular totais, encontrar valores mínimos e máximos, contar documentos e computar médias. O laboratório utiliza uma coleção de amostra bookstore para demonstrar o poder do framework de agregação do MongoDB para extrair insights significativos de seus dados.
Conectando e Populando Dados
Antes de podermos resumir os dados, precisamos nos conectar ao servidor MongoDB e inserir alguns dados de exemplo. Nesta etapa, você iniciará o MongoDB Shell, criará um banco de dados e populará uma coleção com informações de livros.
Primeiro, abra seu terminal e inicie o MongoDB Shell (mongosh):
mongosh
Você está agora dentro do MongoDB Shell, que permite interagir com seus bancos de dados. Vamos mudar para um novo banco de dados chamado bookstore. Se o banco de dados não existir, o MongoDB o criará para você quando você armazenar dados pela primeira vez.
use bookstore
Em seguida, inseriremos vários documentos de livros em uma coleção chamada books usando o método insertMany(). Cada documento é um objeto JSON contendo um title, price e quantity.
db.books.insertMany([
{ title: "Python Basics", price: 29.99, quantity: 50 },
{ title: "MongoDB Essentials", price: 39.99, quantity: 30 },
{ title: "Data Science Guide", price: 45.5, quantity: 25 },
{ title: "Web Development", price: 34.75, quantity: 40 }
]);
Você deverá ver uma saída confirmando que os documentos foram inseridos com sucesso.
Para verificar se os dados foram adicionados, você pode usar o método find() para recuperar e exibir todos os documentos na coleção books.
db.books.find();
A saída listará os quatro documentos que você acabou de inserir, cada um com um _id exclusivo atribuído pelo MongoDB.
[
{
_id: ObjectId("..."),
title: 'Python Basics',
price: 29.99,
quantity: 50
},
{
_id: ObjectId("..."),
title: 'MongoDB Essentials',
price: 39.99,
quantity: 30
},
{
_id: ObjectId("..."),
title: 'Data Science Guide',
price: 45.5,
quantity: 25
},
{
_id: ObjectId("..."),
title: 'Web Development',
price: 34.75,
quantity: 40
}
]
Agora que nossa coleção está configurada, podemos prosseguir com a execução de operações de agregação.
Calcular Totais
Nesta etapa, você aprenderá a calcular valores totais usando o framework de agregação do MongoDB. Pipelines de agregação processam dados através de uma série de estágios. Usaremos o estágio $group para agrupar documentos e o operador $sum para realizar cálculos.
Vamos começar calculando o número total de livros em estoque em todos os títulos. Agruparemos todos os documentos em um único grupo e somaremos seus campos quantity.
db.books.aggregate([
{
$group: {
_id: null,
totalQuantity: { $sum: "$quantity" }
}
}
]);
Aqui está uma descrição do comando:
db.books.aggregate([...]): Inicia um pipeline de agregação na coleçãobooks.$group: O estágio que agrupa os documentos de entrada._id: null: Especifica que todos os documentos na coleção devem ser agrupados em um único documento de saída.totalQuantity: { $sum: "$quantity" }: Define um novo campototalQuantity. O operador$sumcalcula a soma do campoquantity(prefixado com$) para todos os documentos no grupo.
A saída esperada é:
[{ "_id": null, "totalQuantity": 145 }]
Em seguida, vamos calcular o valor total do inventário para todos os livros combinados. Isso requer multiplicar o price pela quantity de cada livro e, em seguida, somar os resultados.
db.books.aggregate([
{
$group: {
_id: null,
totalBookValue: { $sum: { $multiply: ["$price", "$quantity"] } }
}
}
]);
Neste pipeline:
$multiply: ["$price", "$quantity"]: Esta expressão multiplica os campospriceequantitypara cada documento.$sum: Este operador, em seguida, soma os resultados da multiplicação para todos os documentos.
A saída esperada é:
[{ "_id": null, "totalBookValue": 5226.7 }]
Encontrar Valores Mínimo e Máximo
Encontrar os valores mínimo e máximo em um conjunto de dados é uma tarefa comum de análise. Nesta etapa, você usará os operadores de agregação $min e $max para encontrar os livros mais baratos e mais caros em nossa coleção.
Assim como $sum, os operadores $min e $max são usados dentro do estágio $group. Vamos criar um único pipeline de agregação para encontrar os preços mais baixos e mais altos dos livros.
db.books.aggregate([
{
$group: {
_id: null,
lowestPrice: { $min: "$price" },
highestPrice: { $max: "$price" }
}
}
]);
Este pipeline funciona da seguinte forma:
_id: null: Agrupa todos os documentos.lowestPrice: { $min: "$price" }: Cria um campolowestPricee define seu valor como o valor mínimo do campopriceem todos os documentos.highestPrice: { $max: "$price" }: Cria um campohighestPricee define seu valor como o valor máximo do campoprice.
A saída esperada mostrará os preços mínimo e máximo encontrados na coleção:
[{ "_id": null, "lowestPrice": 29.99, "highestPrice": 45.5 }]
Você pode aplicar a mesma lógica a outros campos numéricos. Por exemplo, para encontrar as quantidades mínimas e máximas em estoque, você usaria $min e $max no campo quantity.
db.books.aggregate([
{
$group: {
_id: null,
lowestQuantity: { $min: "$quantity" },
highestQuantity: { $max: "$quantity" }
}
}
]);
A saída esperada para esta consulta é:
[{ "_id": null, "lowestQuantity": 25, "highestQuantity": 50 }]
Contar Documentos e Calcular Médias
Nesta etapa, você aprenderá mais duas técnicas úteis de sumarização: contar documentos e calcular médias. Exploraremos tanto um método simples de contagem quanto o framework de agregação para cenários mais complexos.
Primeiro, vamos contar o número total de documentos em nossa coleção books. O método countDocuments() é a maneira mais simples de fazer isso.
db.books.countDocuments();
A saída será um único número:
4
Você também pode fornecer um filtro de consulta para countDocuments() para contar apenas os documentos que correspondem a critérios específicos. Por exemplo, vamos contar quantos livros têm um preço superior a $35.
db.books.countDocuments({ price: { $gt: 35 } });
O operador $gt significa "maior que" (greater than). A saída será:
2
Em seguida, vamos calcular o preço médio dos livros usando o framework de agregação. O operador $avg, usado dentro de um estágio $group, calcula a média de um campo numérico.
db.books.aggregate([
{
$group: {
_id: null,
averagePrice: { $avg: "$price" }
}
}
]);
Este pipeline agrupa todos os documentos e calcula a média do campo price. A saída será:
[{ "_id": null, "averagePrice": 37.56 }]
O framework de agregação oferece uma maneira poderosa e flexível de realizar cálculos como contagem e cálculo de médias, especialmente quando combinado com outros estágios para lidar com lógica mais complexa.
Gerar Relatório Resumido
Nesta etapa final, você combinará vários estágios de agregação para gerar um relatório de resumo mais complexo. Isso demonstra como você pode encadear operadores para criar visualizações perspicazes de seus dados. Criaremos um relatório que categoriza os livros em faixas de preço "Budget" (Econômico) e "Premium" (Premium) e calcula estatísticas de resumo para cada uma.
Nosso objetivo é agrupar os livros com base em seus preços, em seguida, calcular o número de títulos, a quantidade total, o valor total e o preço médio para cada grupo.
Execute o seguinte pipeline de agregação:
db.books.aggregate([
{
$group: {
_id: {
$cond: {
if: { $lt: ["$price", 35] },
then: "Budget",
else: "Premium"
}
},
totalBooks: { $sum: 1 },
totalQuantity: { $sum: "$quantity" },
totalValue: { $sum: { $multiply: ["$price", "$quantity"] } },
avgPrice: { $avg: "$price" }
}
}
]);
Vamos detalhar este poderoso pipeline:
$group: Este estágio é o núcleo do nosso relatório._id: { $cond: ... }: Em vez denull, usamos o operador$cond(condicional) para determinar dinamicamente o ID do grupo. Se opricede um livro for menor que ($lt) 35, ele é atribuído ao grupo "Budget"; caso contrário, é "Premium".totalBooks: { $sum: 1 }: Esta é uma técnica comum para contar documentos dentro de um grupo. Para cada documento, ele adiciona1ao total.totalQuantity,totalValue,avgPrice: Estes são os mesmos acumuladores que você aprendeu em etapas anteriores, mas agora eles operam dentro de cada categoria de preço.
A saída fornece um resumo limpo para cada categoria. Observe que a ordem dos documentos pode variar.
[
{
"_id": "Premium",
"totalBooks": 2,
"totalQuantity": 55,
"totalValue": 2212.75,
"avgPrice": 42.745
},
{
"_id": "Budget",
"totalBooks": 2,
"totalQuantity": 90,
"totalValue": 2984.5,
"avgPrice": 32.37
}
]
Este exemplo mostra como o framework de agregação pode ser usado para transformar dados brutos em relatórios estruturados e significativos diretamente dentro do banco de dados.
Resumo
Neste laboratório, você aprendeu os fundamentos da agregação de dados no MongoDB. Você começou conectando-se a um banco de dados e populando uma coleção com dados de exemplo. Em seguida, usou o framework de agregação para realizar várias tarefas comuns de sumarização. Você aprendeu a usar o estágio $group com operadores como $sum para calcular totais, $min e $max para encontrar valores limite e $avg para calcular médias. Você também praticou o uso de countDocuments() para contagens simples e viu como construir um relatório de resumo multifacetado combinando vários operadores e estágios. Essas habilidades são essenciais para analisar dados e obter insights valiosos de suas coleções MongoDB.
