Além do Básico: Comandos Avançados de Consulta MongoDB para Análise de Dados

As consultas MongoDB se tornam mais úteis quando você vai além das chamadas simples find(). Se você precisa filtrar documentos aninhados, remodelar a saída ou calcular resultados agrupados, operadores de consulta avançados e estágios de agregação permitem que você faça esse trabalho próximo aos dados.

Os exemplos abaixo focam em comandos práticos que você pode executar no mongosh para relatórios, solução de problemas e análises pontuais.

Dominando Filtragem Complexa com Operadores de Consulta

Enquanto o método básico find() lida com verificações simples de igualdade, análises avançadas frequentemente exigem combinar múltiplas condições ou consultar estruturas de campo específicas. O MongoDB fornece um conjunto rico de operadores de consulta para construir filtros granulares.

Operadores Lógicos para Consultas Compostas

Operadores lógicos permitem combinar múltiplas condições de consulta, oferecendo controle refinado sobre quais documentos são retornados. Eles são essenciais para estruturar questões analíticas complexas.

• $and / $and Implícito: Usado para especificar múltiplos critérios que devem ser todos verdadeiros. Embora muitas vezes implícito (listando condições sequencialmente no objeto de consulta), $and é necessário ao consultar o mesmo campo várias vezes.

  // $and implícito: Encontrar usuários com mais de 25 anos E que moram em Nova York
  db.users.find({ age: { $gt: 25 }, city: "Nova York" });
  
  // $and explícito: Encontrar documentos onde 'score' é > 90 OU 'level' é 5
  db.results.find({ $and: [ { score: { $gt: 90 } }, { level: 5 } ] });
  

• $or: Seleciona documentos que correspondem a qualquer uma das expressões especificadas no array.

  db.products.find({ $or: [ { category: "Eletrônicos" }, { price: { $lt: 100 } } ] });
  

• $not: Nega os resultados da expressão especificada.

Operadores Geoespaciais e de Array

Para dados baseados em localização ou arrays complexos, operadores especializados fornecem poder analítico:

• $geoWithin / $near: Essencial para encontrar dados dentro de uma área geográfica específica ou proximidade.
• $elemMatch: Crucial para consultar arrays de documentos incorporados, garantindo que um elemento no array corresponda a todos os critérios especificados dentro de $elemMatch.

  // Encontrar pedidos onde pelo menos um item no array 'items' custa mais de 500 E tem quantidade maior que 1
  db.orders.find({ items: { $elemMatch: { price: { $gt: 500 }, qty: { $gt: 1 } } } });
  

Projeção Avançada: Moldando a Saída

A projeção, gerenciada usando o segundo argumento no método find(), determina quais campos são retornados. A projeção avançada vai além da simples inclusão/exclusão para transformar ou moldar os dados retornados.

Exclusão e Inclusão de Campos

• 1 inclui um campo; 0 exclui um campo.
• Nota Importante: Você não pode misturar inclusão (1) e exclusão (0) exceto para o campo _id (que é incluído por padrão e pode ser explicitamente excluído definindo-o como 0).

// Incluir apenas 'name' e 'email', excluir '_id'
db.users.find({}, { name: 1, email: 1, _id: 0 });

Fatiamento e Manipulação de Arrays

A projeção pode limitar o número de elementos do array retornados usando $slice:

• $slice: N: Retorna os primeiros N elementos.
• $slice: -N: Retorna os últimos N elementos.
• $slice: [M, N]: Retorna N elementos a partir do índice M.

// Retornar apenas as últimas 3 entradas do array 'history'
db.logs.find({}, { history: { $slice: -3 } });

Analisando Dados com o Framework de Agregação

O MongoDB Aggregation Framework é a ferramenta mais poderosa para análise de dados complexa, permitindo processar registros de dados através de um pipeline de estágios. Cada estágio realiza uma transformação ou operação específica nos dados passados do estágio anterior.

Estágios Chave de Agregação

A estrutura básica usa db.collection.aggregate([...pipeline]).

1. $match (Filtragem)

Funciona de forma semelhante ao find(), mas é aplicado antes dos estágios subsequentes, otimizando o desempenho ao reduzir o conjunto de dados no início.

2. $group (Agrupamento e Cálculo)

Este estágio agrupa documentos por um identificador especificado (_id) e aplica operadores acumuladores para calcular estatísticas resumidas.

Acumuladores Comuns:

• $sum
• $avg
• $min, $max
• $push (para coletar dados de array do grupo)

// Calcular a pontuação média por departamento
db.scores.aggregate([
  { $group: { 
    _id: "$department", 
    averageScore: { $avg: "$score" },
    totalStudents: { $sum: 1 }
  } }
]);

3. $project (Remodelando Documentos)

Usado dentro da agregação para remodelar os documentos de saída, muito parecido com a projeção do find(), mas frequentemente usado para criar novos campos calculados.

• Campos Calculados: Você pode realizar cálculos dentro do estágio de projeção usando campos existentes.

// Calcular margem de lucro dentro do pipeline
db.sales.aggregate([
  { $project: { 
    _id: 0, 
    productName: 1,
    profit: { $subtract: ["$salePrice", "$cost"] }
  } }
]);

4. $lookup (Juntando Dados)

O estágio $lookup adiciona documentos correspondentes de outra coleção, semelhante a uma junção externa esquerda. É útil quando você precisa enriquecer documentos para relatórios sem fazer a junção no código da aplicação.

// Juntando a coleção 'orders' com a coleção 'customers'
db.orders.aggregate([
  { $match: { status: "Pendente" } },
  { $lookup: {
      from: "customers",         // Coleção para juntar
      localField: "customerId",  // Campo dos documentos de entrada (orders)
      foreignField: "_id",       // Campo dos documentos da coleção "from" (customers)
      as: "customerDetails"      // Nome do campo de array de saída
  } }
]);

5. $unwind (Desconstruindo Arrays)

Se um campo de array contém múltiplos elementos, $unwind cria um documento de saída separado para cada elemento no array, efetivamente desnormalizando os dados para facilitar o agrupamento ou filtragem nos conteúdos do array.

Aviso: $unwind pode aumentar significativamente a contagem de documentos. Use-o com moderação, tipicamente após $match para reduzir o conjunto inicial.

Melhores Práticas para Consultas Analíticas

1. Indexe os Pontos de Entrada: Indexe campos usados por estágios $match iniciais e estágios $sort baseados em índice. $group pode se beneficiar de menos documentos de entrada, mas não se torna automaticamente rápido apenas porque o campo agrupado tem um índice.
2. Filtre Cedo: Coloque estágios $match o mais cedo possível no pipeline de agregação. Reduzir a contagem de documentos no início economiza poder de processamento significativo para estágios posteriores mais caros, como $lookup ou $group.
3. Use Tipos de Dados Apropriados: Garanta que campos de comparação (como datas ou valores numéricos) sejam armazenados de forma consistente. Incompatibilidades de tipo fazem com que operadores $match falhem silenciosamente ou ineficientemente.

Use esses comandos quando a simples recuperação de dados não for suficiente. Comece com filtros seletivos, projete apenas os campos que você precisa e passe para a agregação quando precisar de agrupamento, remodelagem ou enriquecimento entre coleções.