Transformar Datos de MongoDB

Introducción

En este laboratorio, aprenderá a transformar datos en MongoDB utilizando su potente pipeline de agregación. El pipeline de agregación le permite procesar datos a través de una serie de etapas, permitiendo transformaciones complejas, análisis e informes. Comenzará configurando un conjunto de datos de ejemplo y luego pasará por varias técnicas de transformación clave, que incluyen la selección y el cambio de nombre de campos, el cálculo de nuevos campos a partir de datos existentes, el formato de la salida y el filtrado de documentos según criterios específicos. Al final de este laboratorio, tendrá una base sólida para manipular datos dentro de MongoDB.

Configuración y Selección Básica de Campos

En este primer paso, se conectará al servidor MongoDB, creará una base de datos y una colección, e insertará algunos datos de ejemplo. Luego, realizará su primera transformación de datos seleccionando y renombrando campos específicos de los documentos.

Primero, abra su terminal y ejecute el Shell de MongoDB (mongosh). Este shell interactivo es la forma principal de interactuar con su instancia de MongoDB. Realizará todas las operaciones de base de datos dentro de este shell durante el resto del laboratorio.

mongosh

Una vez que esté dentro del Shell de MongoDB, su prompt cambiará. Ahora, cree y cambie a una nueva base de datos llamada bookstore. Si la base de datos no existe, este comando la creará.

use bookstore

A continuación, cree una colección llamada books e inserte tres documentos de ejemplo en ella utilizando el comando insertMany. Una colección es un grupo de documentos, similar a una tabla en una base de datos SQL.

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 que tiene datos, usemos el pipeline de agregación para transformarlos. El método aggregate toma una matriz de etapas, donde cada etapa realiza una operación sobre los datos. Nuestra primera etapa será $project, que remodela los documentos.

Ejecute el siguiente comando para seleccionar solo los campos title y author, renombrándolos a bookTitle y bookAuthor respectivamente.

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

Debería ver la siguiente salida:

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

Analicemos la etapa $project:

• _id: 0 excluye el campo _id predeterminado de la salida. Por defecto, siempre se incluye.
• bookTitle: "$title" crea un nuevo campo llamado bookTitle y le asigna el valor del campo original title. El prefijo $ indica que está haciendo referencia al valor de un campo.
• bookAuthor: "$author" renombra de manera similar el campo author a bookAuthor.

Cálculo de Nuevos Campos

En el paso anterior, seleccionó y renombró campos existentes. Ahora, aprenderá a crear campos completamente nuevos realizando cálculos sobre los datos existentes. Para ello, utilizará la etapa $addFields, que agrega nuevos campos a los documentos sin eliminar los originales.

Agreguemos un nuevo campo llamado priceWithTax, que calcula el precio del libro incluyendo un impuesto del 10%.

db.books.aggregate([
  {
    $addFields: {
      priceWithTax: { $multiply: ["$price", 1.1] }
    }
  }
]);

La salida incluirá todos los campos originales más el nuevo campo priceWithTax para cada documento:

[
  {
    _id: ObjectId("..."),
    title: 'MongoDB Basics',
    author: 'Jane Smith',
    price: 29.99,
    pages: 250,
    categories: [ 'Database', 'Programming' ],
    priceWithTax: 32.989
  },
  {
    _id: ObjectId("..."),
    title: 'Python Deep Dive',
    author: 'John Doe',
    price: 39.99,
    pages: 450,
    categories: [ 'Programming', 'Python' ],
    priceWithTax: 43.989
  },
  {
    _id: ObjectId("..."),
    title: 'Data Science Handbook',
    author: 'Alice Johnson',
    price: 49.99,
    pages: 600,
    categories: [ 'Data Science', 'Programming' ],
    priceWithTax: 54.989
  }
]

En este pipeline:

• $addFields es la etapa utilizada para agregar nuevos campos.
• priceWithTax es el nombre del nuevo campo que está creando.
• $multiply es un operador de agregación que toma una matriz de dos números y los multiplica. Aquí, multiplica el valor del campo price por 1.1.

Formateo de Datos de Salida

Los datos son a menudo más útiles cuando están formateados correctamente. En este paso, aprenderá a formatear datos de cadena y numéricos utilizando varios operadores de agregación dentro de una etapa $project. Esto es útil para preparar datos para su visualización en aplicaciones o informes.

Creemos una salida más legible convirtiendo el título del libro a mayúsculas y formateando el precio como una cadena de moneda.

db.books.aggregate([
  {
    $project: {
      _id: 0,
      titleUpperCase: { $toUpper: "$title" },
      formattedPrice: {
        $concat: [{ $literal: "$" }, { $toString: "$price" }]
      }
    }
  }
]);

La salida esperada mostrará los datos transformados:

[
  {
    "titleUpperCase": "MONGODB BASICS",
    "formattedPrice": "$29.99"
  },
  {
    "titleUpperCase": "PYTHON DEEP DIVE",
    "formattedPrice": "$39.99"
  },
  {
    "titleUpperCase": "DATA SCIENCE HANDBOOK",
    "formattedPrice": "$49.99"
  }
]

Examinemos los operadores utilizados en esta etapa $project:

• $toUpper: Este operador convierte una cadena a mayúsculas. Lo aplicamos al campo title.
• $concat: Este operador concatena una matriz de cadenas. Lo usamos para agregar un prefijo de signo de dólar $ al precio.
• $literal: Este operador se utiliza para representar valores literales que de otro modo se interpretarían como expresiones. Aquí usamos { $literal: "$" } para representar un carácter literal de signo de dólar.
• $toString: Dado que $concat solo funciona con cadenas, primero tuvimos que convertir el campo numérico price en una cadena utilizando el operador $toString.

Filtrar Resultados con $match

La última técnica fundamental que aprenderá es el filtrado. La etapa $match le permite seleccionar solo los documentos que cumplen criterios específicos, similar a la cláusula WHERE en SQL. Es una de las etapas más comunes en un pipeline de agregación.

Busquemos todos los libros que cuestan más de $35.

db.books.aggregate([
  {
    $match: {
      price: { $gt: 35 }
    }
  }
]);

La salida solo contendrá los dos libros que coinciden con el filtro:

[
  {
    _id: ObjectId("..."),
    title: 'Python Deep Dive',
    author: 'John Doe',
    price: 39.99,
    pages: 450,
    categories: [ 'Programming', 'Python' ]
  },
  {
    _id: ObjectId("..."),
    title: 'Data Science Handbook',
    author: 'Alice Johnson',
    price: 49.99,
    pages: 600,
    categories: [ 'Data Science', 'Programming' ]
  }
]

La etapa $match utiliza la sintaxis de consulta estándar de MongoDB.

• price: { $gt: 35 } especifica la condición del filtro. Selecciona documentos donde el campo price sea mayor que ($gt) 35.

También puede encadenar etapas para crear pipelines más complejos. Por ejemplo, puede filtrar los documentos primero y luego proyectar una salida personalizada a partir de los resultados.

db.books.aggregate([
  {
    $match: {
      price: { $gt: 35 }
    }
  },
  {
    $project: {
      _id: 0,
      title: 1,
      price: 1
    }
  }
]);

Este pipeline primero filtra los libros caros usando $match y luego, para esos resultados, utiliza $project para mostrar solo el title y el price. La sintaxis title: 1 en $project es una forma abreviada de incluir un campo.

La salida final está tanto filtrada como proyectada:

[
  { "title": "Python Deep Dive", "price": 39.99 },
  { "title": "Data Science Handbook", "price": 49.99 }
]

Para salir del shell de MongoDB, puede escribir exit o presionar Ctrl+D.

Resumen

En este laboratorio, ha aprendido las operaciones fundamentales del pipeline de agregación de MongoDB. Comenzó insertando datos y luego utilizó una serie de etapas para transformarlos. Practicó la selección y el cambio de nombre de campos con $project, la creación de nuevos campos calculados con $addFields, la modificación de la apariencia de los datos con operadores de formato como $toUpper y $concat, y el filtrado de documentos con $match. Al combinar estas etapas, puede crear pipelines de procesamiento de datos sofisticados para analizar y remodelar sus datos directamente dentro de la base de datos, lo que constituye un enfoque potente y eficiente para la manipulación de datos.