MongoDB Academy · Lección

Conceptos de pipelines: etapas, operadores y expresiones

Comprenderá cómo fluyen los datos por las etapas de un pipeline y distinguirá entre operadores de etapa y operadores de expresión.

Lección 1 de 413 pasos

Conceptos de pipelines: etapas, operadores y expresiones es una lección gratuita de MongoDB Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de MongoDB Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de MongoDB Academy incluye 4 lecciones en total.

¿Qué es el pipeline de agregación?

El pipeline de agregación es el motor de transformación de datos del lado del servidor de MongoDB. En lugar de recuperar documentos sin procesar y procesarlos en el código de la aplicación, usted define una secuencia de etapas que transforman el flujo de datos paso a paso —filtrando, cambiando la estructura, agrupando, calculando y ordenando—, todo dentro del motor de la base de datos. Esto mantiene los cálculos pesados cerca de los datos y reduce drásticamente la cantidad de información que se envía por la red.

// 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
]);

Cómo fluyen los documentos por las etapas

Imagine el pipeline como una cinta transportadora: cada documento entra en la etapa 1, se transforma o se filtra, y los resultados pasan a la etapa 2, luego a la 3 y así sucesivamente. En cada etapa, el conjunto de documentos puede reducirse mediante un filtrado, ampliarse mediante $unwind o sustituirse por completo por resúmenes calculados mediante $group. Los documentos que no cumplen una condición de filtro se eliminan del pipeline y nunca llegan a las etapas 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 etapa frente a operadores de expresiones

El framework de agregación distingue dos tipos de operadores: los operadores de etapa, precedidos por $, que definen qué hace una etapa del pipeline, como $match, $group y $project; y los operadores de expresiones, también precedidos por $, que calculan valores dentro de una etapa, como $sum, $avg y $concat. Las etapas son los componentes básicos; las expresiones son los cálculos que se realizan dentro de ellas.

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'] }
  }}
]);

Referencias a campos con el signo $

Dentro de las expresiones de agregación, una cadena precedida por $ es una referencia a un campo: hace referencia al valor de ese campo en el documento actual. Sin el prefijo, la cadena se trata como un valor literal. Esta distinción es crucial: '$price' significa «el valor del campo price», mientras que 'price' significa la cadena 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'
  }}
]);

Variables del sistema: $$ROOT, $$NOW, $$CURRENT

El pipeline de agregación proporciona variables del sistema precedidas por $$ que permiten acceder a valores especiales: $$ROOT hace referencia al documento actual completo, $$NOW es la fecha y hora actuales, útil en $project para campos calculados, $$CURRENT es el contexto actual de la ruta del campo del documento y $$REMOVE elimina condicionalmente un campo cuando se asigna 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' } }
  }}
]);

Descripción general de las etapas habituales del pipeline

MongoDB proporciona decenas de etapas de pipeline. Las más importantes que debe conocer son: $match (filtrar documentos), $project (cambiar la estructura o calcular campos), $group (agrupar por clave), $sort (ordenar resultados), $limit y $skip (paginación), $lookup (combinar otra colección) y $unwind (aplanar arrays). Si domina estas etapas, podrá expresar casi cualquier 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' }

Optimización del pipeline: el orden de las etapas importa

El optimizador de consultas de MongoDB reordena automáticamente algunas etapas del pipeline para mejorar la eficiencia, por ejemplo, adelantando $match a $sort y $group cuando es posible. Sin embargo, usted debe colocar siempre $match lo antes posible: el filtrado temprano reduce el número de documentos que deben procesar las etapas posteriores y, si $match es la primera etapa, MongoDB puede utilizar un índice.

// 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 expresiones aritméticas

Las expresiones aritméticas permiten calcular nuevos valores a partir de campos existentes dentro de una etapa. Las más habituales son: $add, $subtract, $multiply, $divide, $mod y $abs. Estos operadores funcionan con referencias a campos, literales o el resultado de otras expresiones, lo que permite realizar cálculos complejos que antes requerían procesamiento en la aplicación.

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'] }
  }}
]);

Expresiones condicionales: $cond y $ifNull

Las expresiones condicionales permiten aplicar una lógica if/else dentro de las etapas de agregación. $cond evalúa una expresión booleana y devuelve uno de dos valores, como un operador ternario. $ifNull devuelve un valor alternativo cuando un campo es nulo o no existe. Son esenciales para gestionar campos opcionales y calcular categorías derivadas sin modificar los datos almacenados.

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 expresiones de cadenas

Los operadores de cadenas permiten manipular campos de texto dentro del pipeline: $concat une cadenas, $toUpper/$toLower cambian las mayúsculas y minúsculas, $trim/$ltrim/$rtrim eliminan espacios en blanco, $substr extrae una subcadena y $split divide usando un delimitador. Resultan útiles para normalizar datos durante la agregación sin necesidad de actualizar los documentos almacenados.

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 expresiones de fecha

Los operadores de fecha extraen componentes de los campos de fecha para agrupar y calcular: $year, $month, $dayOfMonth, $hour, $minute, $dayOfWeek y $dateToString. Son indispensables para análisis de series temporales, como «total de pedidos por mes» o «ingresos medios por día de la 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 } }
]);

Comprobación rápida

Compruebe su comprensión de los conceptos del pipeline de agregación de esta lección.

Resumen de la lección

En esta lección ha aprendido que las etapas del pipeline transforman secuencialmente un flujo de documentos, que los operadores de etapa definen lo que hace una etapa, mientras que los operadores de expresiones calculan valores dentro de las etapas, y que $ precede a las referencias a campos, mientras que $$ precede a las variables del sistema. A continuación nos centraremos en $match y $project, las herramientas principales para filtrar y cambiar la estructura de los datos.

Gratis para empezar

Aprende JavaScript con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
30
Lecciones
120

Preguntas frecuentes

¿La lección «Conceptos de pipelines: etapas, operadores y expresiones» es gratis?

Sí — el texto completo de «Conceptos de pipelines: etapas, operadores y expresiones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de MongoDB Academy, actualiza a CoddyKit PRO. El curso de MongoDB Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conceptos de pipelines: etapas, operadores y expresiones»?

Comprenderá cómo fluyen los datos por las etapas de un pipeline y distinguirá entre operadores de etapa y operadores de expresión. Practicas MongoDB Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar MongoDB Academy?

No se requiere experiencia previa. MongoDB Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Conceptos de pipelines: etapas, operadores y expresiones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de MongoDB Academy?

Sí. Cada lección de MongoDB Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conceptos de pipelines: etapas, operadores y expresiones
  2. $match y $project: filtrar y remodelar
  3. $group: agregación y cálculo de totales
  4. $sort, $limit y $skip en el pipeline
← Volver a MongoDB Academy