Conceitos de pipeline: etapas, operadores e expressões
Você entenderá como os dados fluem pelas etapas do pipeline e distinguirá operadores de etapa de operadores de expressão.
Conceitos de pipeline: etapas, operadores e expressões é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.
O que é o fluxo de agregação?
O fluxo de agregação é o mecanismo de transformação de dados no servidor do MongoDB. Em vez de recuperar documentos brutos e processá-los no código da aplicação, você define uma sequência de estágios que transforma o fluxo de dados passo a passo — filtrando, remodelando, agrupando, calculando e ordenando — tudo dentro do mecanismo do banco de dados. Isso mantém os cálculos pesados próximos dos dados e reduz drasticamente o que é enviado pela rede.
// A simple aggregation pipeline
db.orders.aggregate([
{ $match: { status: 'completed' } }, // stage 1: filter
{ $group: { _id: '$userId', total: { $sum: '$amount' } } }, // stage 2: group
{ $sort: { total: -1 } }, // stage 3: sort
{ $limit: 10 } // stage 4: take top 10
]);Como os documentos percorrem os estágios
Pense no fluxo como uma esteira transportadora: cada documento entra no estágio 1, é transformado (ou filtrado), e os resultados seguem para o estágio 2, depois para o estágio 3 e assim por diante. Em cada estágio, o conjunto de documentos pode diminuir (filtragem), aumentar (desmembramento) ou ser completamente substituído por resumos calculados (agrupamento). Os documentos que não atendem a uma condição de filtro são descartados do fluxo e nunca chegam aos estágios posteriores.
// Data flow visualization:
// Input: 10,000 orders
// Stage 1 ($match: status='completed'): 8,000 docs
// Stage 2 ($group by userId): 1,200 docs (one per user)
// Stage 3 ($sort by total DESC): 1,200 docs (reordered)
// Stage 4 ($limit 10): 10 docs
// Output to client: 10 docsOperadores de estágio versus operadores de expressão
O conjunto de recursos de agregação distingue dois tipos de operadores: operadores de estágio (prefixados com $), que definem o que um estágio do fluxo faz — como $match, $group e $project —, e operadores de expressão (também prefixados com $), que calculam valores dentro de um estágio — como $sum, $avg e $concat. Os estágios são os blocos de construção; as expressões são os cálculos realizados dentro deles.
db.sales.aggregate([
// $group is a STAGE operator
{ $group: {
_id: '$region',
// $sum and $avg are EXPRESSION operators (accumulators here)
totalRevenue: { $sum: '$amount' },
avgOrder: { $avg: '$amount' },
// $concat is an expression operator
label: { $concat: ['Region: ', '$region'] }
}}
]);Referências a campos com o sinal $
Dentro das expressões de agregação, uma cadeia de caracteres prefixada com $ é uma referência a um campo — ela se refere ao valor desse campo no documento atual. Sem o prefixo, a cadeia é tratada como um valor literal. Essa distinção é fundamental: '$price' significa “o valor do campo de preço”, enquanto 'price' significa a cadeia literal “price”.
db.products.aggregate([
{ $project: {
name: 1,
// '$price' references the 'price' field value
discountedPrice: { $multiply: ['$price', 0.9] },
// 'price' without $ is a literal string
label: 'price', // all docs get the string 'price', not the field value
// $$ROOT is a special variable for the whole document
original: '$$ROOT'
}}
]);Variáveis do sistema: $$ROOT, $$NOW, $$CURRENT
O fluxo de agregação fornece variáveis do sistema prefixadas com $$, que dão acesso a valores especiais: $$ROOT se refere ao documento atual inteiro, $$NOW é a data e hora atuais (útil em $project para campos calculados), $$CURRENT é o contexto do caminho do campo do documento atual e $$REMOVE remove condicionalmente um campo quando é atribuído como valor.
db.orders.aggregate([
{ $project: {
_id: 1,
orderDate: 1,
daysOld: {
$divide: [
{ $subtract: ['$$NOW', '$orderDate'] }, // $$NOW = current time
1000 * 60 * 60 * 24 // convert ms to days
]
},
// Conditionally remove a field:
sensitiveField: { $cond: { if: '$isAdmin', then: '$secret', else: '$$REMOVE' } }
}}
]);Visão geral dos estágios comuns do fluxo
O MongoDB fornece dezenas de estágios de fluxo. Os mais importantes são: $match (filtrar documentos), $project (remodelar ou calcular campos), $group (agrupar por chave), $sort (ordenar resultados), $limit e $skip (paginação), $lookup (combinar com outra coleção) e $unwind (nivelar matrizes). Dominando esses estágios, você poderá expressar praticamente qualquer consulta analítica.
// Quick reference of the most-used stages:
// $match - { $match: { field: condition } }
// $project - { $project: { keep: 1, drop: 0, computed: expr } }
// $group - { $group: { _id: '$field', agg: { $sum: '$val' } } }
// $sort - { $sort: { field: 1 or -1 } }
// $limit - { $limit: N }
// $skip - { $skip: N }
// $lookup - { $lookup: { from, localField, foreignField, as } }
// $unwind - { $unwind: '$arrayField' }Otimização do fluxo: a ordem dos estágios é importante
O otimizador de consultas do MongoDB reordena automaticamente alguns estágios do fluxo para obter mais eficiência — por exemplo, movendo $match para antes de $sort e $group quando possível. No entanto, você deve sempre colocar $match o mais cedo possível: a filtragem antecipada reduz o número de documentos que os estágios seguintes precisam processar e, se $match for o primeiro estágio, o MongoDB poderá usar um índice para isso.
// BAD: expensive group before filter
db.orders.aggregate([
{ $group: { _id: '$userId', total: { $sum: '$amount' } } },
{ $match: { total: { $gt: 1000 } } } // too late to use index
]);
// GOOD: filter first, then group
db.orders.aggregate([
{ $match: { status: 'completed', createdAt: { $gte: thisYear } } },
{ $group: { _id: '$userId', total: { $sum: '$amount' } } },
{ $match: { total: { $gt: 1000 } } }
]);Operadores de expressão aritmética
As expressões aritméticas permitem calcular novos valores a partir de campos existentes dentro de um estágio. As mais comuns são: $add, $subtract, $multiply, $divide, $mod e $abs. Esses operadores funcionam com referências de campos, literais ou o resultado de outras expressões, permitindo cálculos complexos que anteriormente exigiam processamento no lado da aplicação.
db.invoices.aggregate([
{ $project: {
subtotal: '$subtotal',
taxAmount: { $multiply: ['$subtotal', 0.08] }, // 8% tax
total: { $add: ['$subtotal', { $multiply: ['$subtotal', 0.08] }] },
discount: { $subtract: ['$listPrice', '$salePrice'] },
margin: { $divide: [{ $subtract: ['$price', '$cost'] }, '$price'] }
}}
]);Expressões condicionais: $cond e $ifNull
As expressões condicionais permitem usar uma lógica de if/else dentro dos estágios de agregação. $cond avalia uma expressão booleana e retorna um de dois valores, como um operador ternário. $ifNull retorna um valor alternativo quando um campo é nulo ou está ausente. Elas são essenciais para lidar com campos opcionais e calcular categorias derivadas sem modificar os dados armazenados.
db.products.aggregate([
{ $project: {
name: 1,
price: 1,
// Ternary: label products as budget or premium
tier: {
$cond: {
if: { $lt: ['$price', 100] },
then: 'budget',
else: 'premium'
}
},
// Fallback for missing description
description: { $ifNull: ['$description', 'No description available'] }
}}
]);Operadores de expressão para strings
Os operadores de strings permitem manipular campos de texto dentro do pipeline: $concat une strings, $toUpper/$toLower alteram maiúsculas e minúsculas, $trim/$ltrim/$rtrim removem espaços em branco, $substr extrai uma substring e $split divide pelo delimitador. Eles são úteis para normalizar dados durante a agregação sem precisar atualizar os documentos armazenados.
db.users.aggregate([
{ $project: {
// Combine first and last name
fullName: { $concat: ['$firstName', ' ', '$lastName'] },
// Normalise email to lowercase
emailNorm: { $toLower: '$email' },
// Extract domain from email
domain: {
$arrayElemAt: [{ $split: ['$email', '@'] }, 1]
}
}}
]);Operadores de expressão para datas
Os operadores de datas extraem componentes de campos de data para agrupamento e cálculos: $year, $month, $dayOfMonth, $hour, $minute, $dayOfWeek e $dateToString. Eles são indispensáveis para análises de séries temporais, como “total de pedidos por mês” ou “receita média por dia da semana”.
// Group orders by year and month
db.orders.aggregate([
{ $group: {
_id: {
year: { $year: '$createdAt' },
month: { $month: '$createdAt' }
},
count: { $sum: 1 },
revenue: { $sum: '$amount' }
}},
{ $sort: { '_id.year': 1, '_id.month': 1 } }
]);Verificação rápida
Teste sua compreensão dos conceitos de pipeline de agregação apresentados nesta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: os estágios do pipeline transformam sequencialmente um fluxo de documentos, os operadores de estágio definem o que um estágio faz, enquanto os operadores de expressão calculam valores dentro dos estágios; além disso, $ indica referências de campos, enquanto $$ indica variáveis do sistema. Em seguida, vamos nos concentrar em $match e $project, os principais estágios para filtrar e remodelar dados.
Aprenda JavaScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Conceitos de pipeline: etapas, operadores e expressões” é grátis?
Sim — o texto completo de “Conceitos de pipeline: etapas, operadores e expressões” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.
O que vou aprender em “Conceitos de pipeline: etapas, operadores e expressões”?
Você entenderá como os dados fluem pelas etapas do pipeline e distinguirá operadores de etapa de operadores de expressão. Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar MongoDB Academy?
Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Conceitos de pipeline: etapas, operadores e expressões”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de MongoDB Academy?
Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Conceitos de pipeline: etapas, operadores e expressões
- $match e $project: filtrando e remodelando
- $group: agregando e calculando totais
- $sort, $limit e $skip no pipeline