Transformar datos de MongoDB

Introducción

En este laboratorio, aprenderás cómo transformar datos de MongoDB utilizando operaciones básicas de agregación. El laboratorio cubre cinco pasos clave: seleccionar campos de salida, cambiar el nombre de los campos, calcular nuevos campos, dar formato a la salida y filtrar los resultados. A través de estos pasos, adquirirás experiencia práctica en la remodelación y análisis de datos almacenados en colecciones de MongoDB. El laboratorio proporciona un conjunto de datos de muestra de libros y demuestra cómo aprovechar la tubería de agregación (aggregation pipeline) para extraer, manipular y presentar los datos de una manera más significativa.

Skills Graph

Seleccionar campos de salida

En este paso, aprenderemos cómo utilizar la tubería de agregación (aggregation pipeline) de MongoDB para seleccionar y transformar campos de salida. La agregación es una forma poderosa de procesar y analizar datos en MongoDB.

Primero, comencemos lanzando la shell de MongoDB:

mongosh

Ahora, creemos una colección de muestra de libros con la que trabajar:

use bookstore

db.books.insertMany([
    {
        title: "MongoDB Basics",
        author: "Jane Smith",
        price: 29.99,
        pages: 250,
        categories: ["Database", "Programming"]
    },
    {
        title: "Python Deep Dive",
        author: "John Doe",
        price: 39.99,
        pages: 450,
        categories: ["Programming", "Python"]
    },
    {
        title: "Data Science Handbook",
        author: "Alice Johnson",
        price: 49.99,
        pages: 600,
        categories: ["Data Science", "Programming"]
    }
])

Ahora, utilicemos la tubería de agregación para seleccionar campos de salida específicos:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookTitle: "$title",
      bookAuthor: "$author"
    }
  }
]);

Ejemplo de salida:

[
  { bookTitle: 'MongoDB Basics', bookAuthor: 'Jane Smith' },
  { bookTitle: 'Python Deep Dive', bookAuthor: 'John Doe' },
  { bookTitle: 'Data Science Handbook', bookAuthor: 'Alice Johnson' }
]

Analicemos lo que hicimos:

• $project es una etapa de agregación que remodela los documentos.
• _id: 0 excluye el ID de documento predeterminado de MongoDB.
• bookTitle: "$title" cambia el nombre del campo 'title' a 'bookTitle'.
• bookAuthor: "$author" cambia el nombre del campo 'author' a 'bookAuthor'.

El signo $ antes de los nombres de los campos le indica a MongoDB que utilice el valor de ese campo.

Cambiar el nombre de los campos

En este paso, exploraremos técnicas más avanzadas de cambio de nombre de campos utilizando la tubería de agregación (aggregation pipeline) de MongoDB. Nos basaremos en la colección de libros que creamos en el paso anterior.

Continuemos en la shell de MongoDB:

mongosh

Primero, cambiemos a nuestra base de datos de la librería (bookstore):

use bookstore

Ahora, utilizaremos una etapa $project más compleja para cambiar el nombre y transformar múltiples campos:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookInfo: {
        name: "$title",
        writer: "$author",
        bookLength: "$pages",
        pricing: "$price"
      },
      genres: "$categories"
    }
  }
]);

Ejemplo de salida:

[
  {
    bookInfo: {
      name: 'MongoDB Basics',
      writer: 'Jane Smith',
      bookLength: 250,
      pricing: 29.99
    },
    genres: [ 'Database', 'Programming' ]
  },
  //... other book documents
]

Analicemos la técnica de cambio de nombre:

• Creamos un objeto anidado bookInfo con campos renombrados.
• name reemplaza a title.
• writer reemplaza a author.
• bookLength reemplaza a pages.
• pricing reemplaza a price.
• También preservamos categories como genres.

También puedes utilizar la etapa $rename para cambiar el nombre de campos de manera más sencilla:

db.books.aggregate([
  {
    $rename: {
      title: "bookName",
      author: "bookWriter"
    }
  }
]);

Esta etapa cambia directamente el nombre de los campos en los documentos originales.

Calcular nuevos campos

En este paso, aprenderemos cómo crear nuevos campos realizando cálculos utilizando la tubería de agregación (aggregation pipeline) de MongoDB. Continuaremos trabajando con nuestra base de datos de la librería (bookstore).

Comencemos lanzando la shell de MongoDB:

mongosh

Cambiemos a la base de datos de la librería:

use bookstore

Utilizaremos la etapa $addFields para crear nuevos campos calculados:

db.books.aggregate([
  {
    $addFields: {
      totalValue: { $multiply: ["$price", 1.1] },
      discountedPrice: { $multiply: ["$price", 0.9] },
      pageCategories: {
        $concat: [
          { $toString: "$pages" },
          " page ",
          { $arrayElemAt: ["$categories", 0] }
        ]
      }
    }
  }
]);

Ejemplo de salida:

[
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    author: "Jane Smith",
    price: 29.99,
    pages: 250,
    categories: ["Database", "Programming"],
    totalValue: 32.989,
    discountedPrice: 26.991,
    pageCategories: "250 page Database"
  },
  //... other book documents
]

Analicemos los cálculos:

• totalValue: Multiplica el precio por 1.1 (recargo del 10%).
• discountedPrice: Multiplica el precio por 0.9 (descuento del 10%).
• pageCategories: Combina el número de páginas con la primera categoría utilizando $concat.

También podemos realizar cálculos más complejos. Calculemos una calificación de libro basada en el número de páginas:

db.books.aggregate([
  {
    $addFields: {
      bookRating: {
        $switch: {
          branches: [
            { case: { $lt: ["$pages", 300] }, then: "Short Book" },
            { case: { $lt: ["$pages", 500] }, then: "Medium Book" }
          ],
          default: "Long Book"
        }
      }
    }
  }
]);

Este ejemplo utiliza $switch para categorizar los libros según su número de páginas.

Dar formato a la salida

En este paso, exploraremos diversas técnicas para dar formato y transformar la salida utilizando la tubería de agregación (aggregation pipeline) de MongoDB. Continuaremos trabajando con nuestra base de datos de la librería (bookstore).

Comencemos lanzando la shell de MongoDB:

mongosh

Cambiemos a la base de datos de la librería:

use bookstore

Primero, usemos $toUpper y $toLower para dar formato a los campos de texto:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      titleUpperCase: { $toUpper: "$title" },
      authorLowerCase: { $toLower: "$author" }
    }
  }
]);

Ejemplo de salida:

[
  {
    titleUpperCase: 'MONGODB BASICS',
    authorLowerCase: 'jane smith'
  },
  //... other book documents
]

A continuación, demos formato a los valores numéricos utilizando $round y creemos cadenas de precio formateadas:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      roundedPrice: { $round: ["$price", 1] },
      formattedPrice: {
        $concat: ["$", { $toString: { $round: ["$price", 2] } }]
      }
    }
  }
]);

Ejemplo de salida:

[
  {
    title: 'MongoDB Basics',
    roundedPrice: 30,
    formattedPrice: '$29.99'
  },
  //... other book documents
]

También podemos dar formato a las matrices (arrays) y crear representaciones de cadenas complejas:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      categoriesSummary: {
        $reduce: {
          input: "$categories",
          initialValue: "",
          in: {
            $concat: [
              "$$value",
              { $cond: [{ $eq: ["$$value", ""] }, "", ", "] },
              "$$this"
            ]
          }
        }
      }
    }
  }
]);

Ejemplo de salida:

[
  {
    title: 'MongoDB Basics',
    categoriesSummary: 'Database, Programming'
  },
  //... other book documents
]

Este último ejemplo utiliza $reduce para unir los elementos de la matriz en una cadena separada por comas.

Filtrar resultados

En este último paso, exploraremos diversas técnicas de filtrado utilizando la tubería de agregación (aggregation pipeline) de MongoDB. Continuaremos trabajando con nuestra base de datos de la librería (bookstore) para demostrar diferentes formas de filtrar resultados.

Comencemos lanzando la shell de MongoDB:

mongosh

Cambiemos a la base de datos de la librería:

use bookstore

Primero, filtremos los libros utilizando operadores de comparación simples:

db.books.aggregate([
  {
    $match: {
      price: { $gt: 30 },
      pages: { $lt: 500 }
    }
  }
]);

Esta consulta filtra los libros que:

• Tienen un precio mayor a 30
• Tienen menos de 500 páginas

Ejemplo de salida:

[
  {
    _id: ObjectId("..."),
    title: "Python Deep Dive",
    author: "John Doe",
    price: 39.99,
    pages: 450,
    categories: ["Programming", "Python"]
  }
]

A continuación, usemos un filtrado más complejo con operaciones de matrices (arrays):

db.books.aggregate([
  {
    $match: {
      categories: { $in: ["Programming"] }
    }
  }
]);

Esta consulta encuentra todos los libros que tienen "Programming" en sus categorías.

También podemos combinar múltiples técnicas de filtrado:

db.books.aggregate([
  {
    $match: {
      $or: [{ pages: { $gt: 400 } }, { categories: { $in: ["Database"] } }]
    }
  },
  {
    $project: {
      title: 1,
      pages: 1,
      categories: 1
    }
  }
]);

Esta consulta más compleja:

• Encuentra libros con más de 400 páginas O en la categoría "Database"
• Proyecta solo campos específicos en la salida

Ejemplo de salida:

[
  {
    _id: ObjectId("..."),
    title: "Data Science Handbook",
    pages: 600,
    categories: ["Data Science", "Programming"]
  },
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    pages: 250,
    categories: ["Database", "Programming"]
  }
]

Resumen

En este laboratorio (lab), aprendiste cómo utilizar la tubería de agregación (aggregation pipeline) de MongoDB para seleccionar y transformar campos de salida. Comenzaste creando una colección de muestra de libros, luego utilizaste la etapa $project para seleccionar campos específicos y cambiarlos de nombre. También exploraste técnicas más avanzadas de cambio de nombre de campos, incluyendo el uso de expresiones calculadas y campos anidados. Finalmente, aprendiste cómo calcular nuevos campos, dar formato a la salida y filtrar los resultados. Estas habilidades son esenciales para procesar y analizar datos de manera eficiente en MongoDB.