MongoDB Academy · Aula

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.

Aula 1 de 413 etapas

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 docs

Operadores 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.

Grátis para começar

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

  1. Conceitos de pipeline: etapas, operadores e expressões
  2. $match e $project: filtrando e remodelando
  3. $group: agregando e calculando totais
  4. $sort, $limit e $skip no pipeline
← Voltar para MongoDB Academy