Guía paso a paso para migrar datos relacionales SQL a MongoDB

Migrar datos relacionales SQL a MongoDB no es una copia de tablas. La parte difícil es decidir qué relaciones deben convertirse en documentos incrustados, cuáles deben mantenerse como referencias y cómo su aplicación consultará la nueva forma.

Los esquemas relacionales a menudo están normalizados en varias tablas. El modelo de documentos de MongoDB funciona mejor cuando los datos relacionados que se leen juntos se almacenan juntos. Esta guía explica la planificación, transformación, carga, verificación y cambios en la aplicación sin asumir que cada tabla SQL debe convertirse en una colección de MongoDB.

Comprendiendo las diferencias fundamentales: Modelos relacional vs. de documentos

Antes de sumergirse en el proceso de migración, es esencial comprender las diferencias conceptuales:

• Modelo relacional: Los datos se almacenan en tablas con esquemas predefinidos. Las relaciones se gestionan mediante claves foráneas, requiriendo operaciones JOIN para recuperar datos relacionados. La normalización es un principio clave.
• Modelo de documentos (MongoDB): Los datos se almacenan en documentos flexibles similares a JSON. Los documentos pueden tener estructuras variables. Los datos relacionados pueden incrustarse dentro de un solo documento (desnormalización) o referenciarse mediante uniones a nivel de aplicación o la etapa de agregación $lookup de MongoDB.

Esta diferencia en el modelado de datos impacta directamente en cómo diseña sus colecciones y documentos de MongoDB.

Fase 1: Planificación y diseño del esquema

Esta es la fase más crítica. Un esquema de MongoDB bien diseñado es clave para aprovechar sus beneficios. El objetivo es modelar sus datos basándose en los patrones de acceso de la aplicación, no solo en una traducción directa de sus tablas SQL.

1. Analice los patrones de acceso de su aplicación

• Identifique operaciones de lectura intensiva vs. escritura intensiva: ¿Con qué frecuencia se leen los datos y cómo se consultan típicamente? ¿Qué campos se recuperan juntos con más frecuencia?
• Determine las rutas de consulta comunes: ¿Cuáles son las sentencias SELECT más frecuentes en su aplicación SQL? ¿Qué tablas se unen generalmente?
• Comprenda las relaciones de datos: ¿Cómo se relacionan las entidades? ¿Son relaciones uno a uno, uno a muchos o muchos a muchos?

2. Elija su estrategia de desnormalización

El poder de MongoDB radica en su capacidad para incrustar datos relacionados. Considere estas estrategias:

• Incrustación (Desnormalización): El enfoque más común. Incruste documentos o matrices de documentos dentro de un documento padre cuando la relación sea uno a muchos o cuando los datos se accedan con frecuencia juntos. Esto reduce la necesidad de uniones.
  • Ejemplo: En lugar de tener tablas separadas orders y order_items, puede incrustar order_items como una matriz dentro del documento order.
• Referencias: Úselo cuando la incrustación llevaría a documentos excesivamente grandes, o cuando se accede a los datos de forma independiente. Almacene el _id de un documento relacionado, similar a las claves foráneas, y realice uniones a nivel de aplicación o use $lookup de MongoDB.
  • Ejemplo: Una colección users y una colección posts. Una publicación podría almacenar el user_id de su autor. Luego puede usar $lookup para recuperar los detalles del autor al obtener una publicación.

3. Diseñe sus colecciones y documentos de MongoDB

Basándose en sus patrones de acceso y estrategia de desnormalización, diseñe sus colecciones. Un buen punto de partida es mapear las tablas SQL a colecciones de MongoDB. Luego, decida qué datos relacionados deben incrustarse y cuáles deben referenciarse.

Ejemplo de esquema SQL:

-- Tabla Customers
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    Email VARCHAR(100)
);

-- Tabla Orders
CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    TotalAmount DECIMAL(10, 2),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

-- Tabla OrderItems
CREATE TABLE OrderItems (
    OrderItemID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    Quantity INT,
    Price DECIMAL(10, 2),
    FOREIGN KEY (OrderID) REFERENCES Orders(OrderID)
);

Opciones de diseño de documentos MongoDB:

• Opción A: Cliente con pedidos incrustados, si los clientes tienen un número manejable de pedidos y los pedidos se ven con frecuencia junto con el cliente:

  {
    "_id": ObjectId("..."),
    "customer_id": 1,
    "first_name": "John",
    "last_name": "Doe",
    "email": "[email protected]",
    "orders": [
      {
        "order_id": 101,
        "order_date": ISODate("2023-10-26T00:00:00Z"),
        "total_amount": 50.00,
        "items": [
          { "product_id": 1, "quantity": 2, "price": 25.00 },
          { "product_id": 3, "quantity": 1, "price": 0.00 }
        ]
      }
    ]
  }
  

• Opción B: Colecciones separadas con referencias, si los pedidos son numerosos o se consultan con frecuencia de forma independiente.

  Colección Customers:

  {
    "_id": ObjectId("..."),
    "customer_id": 1,
    "first_name": "John",
    "last_name": "Doe",
    "email": "[email protected]"
  }
  

  Colección Orders:

  {
    "_id": ObjectId("..."),
    "order_id": 101,
    "customer_id": 1,
    "order_date": ISODate("2023-10-26T00:00:00Z"),
    "total_amount": 50.00,
    "items": [
      { "product_id": 1, "quantity": 2, "price": 25.00 },
      { "product_id": 3, "quantity": 1, "price": 0.00 }
    ]
  }
  

Consideraciones sobre el tamaño del documento: MongoDB tiene un límite de tamaño de documento (16MB). Evite incrustar matrices excesivamente grandes que podrían exceder este límite. Si una matriz crece indefinidamente, considere dividirla en una colección separada.

Fase 2: Extracción y transformación de datos

Una vez que su esquema de destino está diseñado, necesita extraer datos de su base de datos SQL y transformarlos al nuevo formato de documento.

1. Extraiga datos de SQL

Use consultas SQL estándar para seleccionar los datos que necesita. Puede exportar estos datos a formatos como CSV o JSON.

• Usando clientes SQL: La mayoría de las herramientas de bases de datos SQL (por ejemplo, DBeaver, SQL Developer, pgAdmin) le permiten exportar resultados de consultas a CSV o JSON.
• Scripting: Escriba scripts (Python, Node.js, etc.) para conectarse a su base de datos SQL, ejecutar consultas y obtener datos.

2. Transforme datos

Aquí es donde implementará su esquema diseñado. Necesitará escribir código o usar una herramienta para:

• Agrupar registros relacionados: Por ejemplo, reunir todos los OrderItems que pertenecen a un Order específico.
• Reestructurar datos: Convertir filas relacionales en documentos JSON anidados.
• Manejar tipos de datos: Asegurarse de que los tipos de datos sean compatibles con MongoDB (por ejemplo, fechas, números, cadenas).

Ejemplo usando Python:

Supongamos que ha exportado Customers, Orders y OrderItems a archivos CSV.

import pandas as pd
import json
from bson import ObjectId

# Cargar datos desde archivos CSV (asumiendo que están en el mismo directorio)
customers_df = pd.read_csv('customers.csv')
orders_df = pd.read_csv('orders.csv')
order_items_df = pd.read_csv('order_items.csv')

# --- Lógica de transformación de datos ---

# Convertir DataFrame a diccionarios para una manipulación más fácil
customers_list = customers_df.to_dict('records')
orders_list = orders_df.to_dict('records')
order_items_list = order_items_df.to_dict('records')

# Crear un mapeo para pedidos y artículos de pedido para búsqueda rápida
orders_by_customer = {}
for order in orders_list:
    customer_id = order['CustomerID']
    if customer_id not in orders_by_customer:
        orders_by_customer[customer_id] = []
    orders_by_customer[customer_id].append(order)

order_items_by_order = {}
for item in order_items_list:
    order_id = item['OrderID']
    if order_id not in order_items_by_order:
        order_items_by_order[order_id] = []
    order_items_by_order[order_id].append(item)

# --- Construyendo documentos MongoDB (Opción A: Cliente con pedidos incrustados) ---
mongo_documents = []

for customer in customers_list:
    mongo_doc = {
        "_id": ObjectId(), # MongoDB genera _id automáticamente, pero puede mapearlo si es necesario
        "customer_id": customer['CustomerID'],
        "first_name": customer['FirstName'],
        "last_name": customer['LastName'],
        "email": customer['Email'],
        "orders": []
    }

    customer_id = customer['CustomerID']
    if customer_id in orders_by_customer:
        for order in orders_by_customer[customer_id]:
            order_doc = {
                "order_id": order['OrderID'],
                "order_date": order['OrderDate'], # Asegurar el formato de fecha correcto
                "total_amount": order['TotalAmount'],
                "items": []
            }

            order_id = order['OrderID']
            if order_id in order_items_by_order:
                for item in order_items_by_order[order_id]:
                    order_doc['items'].append({
                        "product_id": item['ProductID'],
                        "quantity": item['Quantity'],
                        "price": item['Price']
                    })
            mongo_doc['orders'].append(order_doc)

    mongo_documents.append(mongo_doc)

# Ahora 'mongo_documents' es una lista de diccionarios lista para insertarse en MongoDB
# print(json.dumps(mongo_documents[0], indent=2, default=str)) # Imprimir el primer documento como JSON

# Para la Opción B (Colecciones separadas), crearía listas para cada colección:
# customers_mongo = [{'customer_id': c['CustomerID'], ...} for c in customers_list]
# orders_mongo = [{'order_id': o['OrderID'], 'customer_id': o['CustomerID'], ...} for o in orders_list]

# Guardar en JSON para importar (opcional)
# with open('mongo_customer_data.json', 'w') as f:
#     json.dump(mongo_documents, f, indent=2, default=str)

3. Herramientas para la transformación

• Scripts personalizados: Python con Pandas, Node.js con bibliotecas como csv-parser y mysql/pg son potentes para transformaciones complejas.
• Herramientas ETL: Herramientas como Apache NiFi, Talend o AWS Glue pueden orquestar pipelines de datos complejos, incluyendo la migración de SQL a MongoDB.
• Plataformas de migración de bases de datos: Algunas herramientas ETL y CDC comerciales pueden sincronizar fuentes relacionales en MongoDB. Verifique la compatibilidad del conector con su base de datos SQL exacta y el destino MongoDB antes de planificar alrededor de una herramienta.

Fase 3: Carga de datos en MongoDB

Una vez que sus datos están transformados, puede cargarlos en su instancia de MongoDB.

1. Conéctese a MongoDB

Use el Shell de MongoDB (mongosh) o un controlador de MongoDB (para su lenguaje de programación) para conectarse a su base de datos.

2. Importe datos transformados

• Usando mongoimport: Si exportó sus datos transformados a un archivo JSON, puede usar mongoimport:

  # Asumiendo que sus datos están en mongo_customer_data.json y desea importarlos a la colección 'customers'
  mongoimport --db your_database_name --collection customers --file mongo_customer_data.json --jsonArray
  

  • --jsonArray: Use esta bandera si su archivo JSON contiene una matriz de documentos.

• Usando controladores de MongoDB: Si generó sus estructuras de datos en su lenguaje de programación (como la lista mongo_documents en Python), puede insertarlas directamente:

  Ejemplo en Python usando pymongo:

  from pymongo import MongoClient
  
  # Asumiendo que la lista 'mongo_documents' está definida del script Python anterior
  client = MongoClient('mongodb://localhost:27017/')
  db = client['your_database_name']
  customers_collection = db['customers']
  
  # Insertar los documentos transformados
  if mongo_documents:
      insert_result = customers_collection.insert_many(mongo_documents)
      print(f"Insertados {len(insert_result.inserted_ids)} documentos.")
  else:
      print("No hay documentos para insertar.")
  
  client.close()
  

3. Verifique la integridad de los datos

Después de cargar, ejecute consultas en MongoDB para verificar que los datos se hayan importado correctamente y coincidan con sus expectativas.

// Ejemplo: Contar documentos en la colección 'customers'
use your_database_name;
print(db.customers.countDocuments());

// Ejemplo: Encontrar un cliente específico y verificar sus pedidos incrustados
db.customers.findOne({ "customer_id": 1 })

Fase 4: Refactorización de la aplicación

Esta es posiblemente la fase que más tiempo consume. El código de su aplicación debe actualizarse para interactuar con MongoDB en lugar de SQL.

• Actualice las conexiones de base de datos: Cambie las cadenas de conexión y las bibliotecas.
• Reescriba las consultas: Reemplace las consultas SQL con el lenguaje de consulta de MongoDB usando la API de su controlador elegido.
• Ajuste la capa de acceso a datos: Modifique su ORM o capa de acceso a datos para trabajar con documentos de MongoDB.
• Aproveche las características de MongoDB: Adapte su aplicación para aprovechar características como esquemas flexibles, marco de agregación y consultas geoespaciales si corresponde.

Mejores prácticas y consejos

• Empiece pequeño: Si es posible, migre un subconjunto de sus datos o una aplicación menos crítica primero para ganar experiencia.
• Itere sobre el diseño del esquema: Su esquema inicial de MongoDB puede no ser perfecto. Esté preparado para iterar y refinarlo basándose en pruebas de rendimiento y comentarios de la aplicación.
• Indexe sabiamente: Al igual que en SQL, la indexación es crucial para el rendimiento en MongoDB. Identifique sus patrones de consulta y cree índices apropiados.
• Monitoree el rendimiento: Monitoree continuamente su implementación de MongoDB para detectar cuellos de botella de rendimiento y optimice las consultas y el esquema según sea necesario.
• Considere la migración incremental: Para bases de datos grandes, considere una estrategia de migración incremental donde sincronice los cambios de SQL a MongoDB en tiempo casi real antes de realizar un corte final.

Conclusión

La migración más segura de SQL a MongoDB comienza con los patrones de acceso, no con los nombres de las tablas. Modele un flujo de trabajo importante, transforme una pequeña porción de datos, cárguela en MongoDB, verifique los recuentos y documentos de muestra, luego actualice el código de la aplicación alrededor de esa forma antes de escalar la migración.