MongoDB desde Cero

MongoDB es una base de datos NoSQL orientada a documentos, que almacena datos en formato BSON (Binary JSON) flexible y escalable.

Historia:

MongoDB fue creado en 2009 por 10gen (ahora MongoDB Inc.). Su nombre proviene de "humongous" (enorme en inglés), reflejando su capacidad para manejar grandes volúmenes de datos.

Diferencias con SQL:

• Schema-less: No requiere esquema fijo
• Documentos: Datos en formato BSON/JSON
• Escalabilidad: Horizontal con sharding
• Consultas: Basadas en documentos, no JOINs

En Windows:

1. Descarga MongoDB Community Server desde mongodb.com
2. Ejecuta el instalador
3. Selecciona "Install as a Service"
4. Instala MongoDB Compass (GUI)

En Linux (Ubuntu):

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update
sudo apt-get install -y mongodb-org

En macOS:

brew tap mongodb/brew
brew install mongodb-community
brew services start mongodb-community

Jerarquía de Datos:

• Documento: Unidad básica de datos (BSON)
• Colección: Grupo de documentos
• Base de Datos: Grupo de colecciones

CRUD Operations:

// CREATE
db.usuarios.insertOne({ nombre: "Juan", edad: 30 });

// READ
db.usuarios.find({ edad: { $gte: 25 } });

// UPDATE
db.usuarios.updateOne(
    { nombre: "Juan" },
    { $set: { edad: 31 } }
);

// DELETE
db.usuarios.deleteOne({ nombre: "Juan" });

Operadores de Consulta:

// Comparación
db.usuarios.find({ edad: { $gte: 18, $lte: 65 } });

// Lógicos
db.usuarios.find({
    $or: [{ edad: { $lt: 18 } }, { pais: "México" }]
});

// Arrays
db.usuarios.find({ hobbies: { $in: ["leer", "deporte"] } });

Agregaciones:

db.ventas.aggregate([
    { $match: { fecha: { $gte: new Date("2024-01-01") } } },
    { $group: {
        _id: "$categoria",
        total: { $sum: "$monto" },
        promedio: { $avg: "$monto" }
    }},
    { $sort: { total: -1 } }
]);

Índices:

// Crear índice
db.usuarios.createIndex({ email: 1 });

// Índice compuesto
db.usuarios.createIndex({ pais: 1, edad: -1 });

// Ver índices
db.usuarios.getIndexes();

Modelado de Datos:

• Embedding: Datos relacionados en un documento
• Referencing: Documentos separados con referencias
• Usa embedding para relaciones 1:1 y 1:muchos

Replica Set:

Configuración de alta disponibilidad con nodos primarios y secundarios.

Sharding:

Distribución horizontal de datos en múltiples servidores para escalabilidad.

Backup:

mongodump --db mi_base_datos --out /backup
mongorestore /backup/mi_base_datos

Desarrolla una aplicación completa con MongoDB:

1. Diseñar modelo de datos
2. Configurar MongoDB Atlas (cloud)
3. Implementar CRUD con Node.js
4. Crear índices estratégicos
5. Implementar agregaciones
6. Configurar backup automático

Pipeline Stages:

db.ventas.aggregate([
    { $match: { estado: "completada" } },
    { $group: {
        _id: "$producto",
        total_ventas: { $sum: "$cantidad" },
        ingreso_total: { $sum: { $multiply: ["$precio", "$cantidad"] } }
    }},
    { $sort: { ingreso_total: -1 } },
    { $limit: 10 }
]);

Lookup (JOIN en MongoDB):

db.pedidos.aggregate([
    { $lookup: {
        from: "clientes",
        localField: "cliente_id",
        foreignField: "_id",
        as: "cliente_info"
    }},
    { $unwind: "$cliente_info" },
    { $project: {
        "cliente_info.nombre": 1,
        "productos": 1,
        "total": 1
    }}
]);

Cond y Accumulator:

db.empleados.aggregate([
    { $group: {
        _id: "$departamento",
        empleados: { $sum: 1 },
        promedio_salario: { $avg: "$salario" },
        max_salario: { $max: "$salario" },
        categorias: {
            $push: {
                $cond: [
                    { $gte: ["$salario", 5000] },
                    "senior",
                    "junior"
                ]
            }
        }
    }}
]);

Validación de Documentos:

db.createCollection("productos", {
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["nombre", "precio"],
            properties: {
                nombre: { bsonType: "string" },
                precio: { bsonType: "number", minimum: 0 }
            }
        }
    }
});

Transacciones (MongoDB 4.2+):

const session = db.startSession();
session.startTransaction();

try {
    const opts = { session };
    
    db.empleados.updateOne(
        { _id: 1 },
        { $inc: { saldo: -100 } },
        opts
    );
    
    db.empleados.updateOne(
        { _id: 2 },
        { $inc: { saldo: 100 } },
        opts
    );
    
    session.commitTransaction();
} catch (e) {
    session.abortTransaction();
    throw e;
} finally {
    session.endSession();
}

Tipos de Índices:

// Índice simple
db.coleccion.createIndex({ campo: 1 });

// Índice compuesto
db.coleccion.createIndex({ campo1: 1, campo2: -1 });

// Índice de texto
db.articulos.createIndex({ titulo: "text", contenido: "text" });

// Índice único
db.usuarios.createIndex({ email: 1 }, { unique: true });

// Índice TTL (expiración)
db.sesiones.createIndex(
    { "ultimoAcceso": 1 },
    { expireAfterSeconds: 3600 }
);

Text Search:

db.articulos.find(
    { $text: { $search: "mongodb tutorial" } },
    { score: { $meta: "textScore" } }
).sort({ score: { $meta: "textScore" } });

Explain:

db.coleccion.find({ campo: "valor" }).explain("executionStats");

Autenticación:

// Crear usuario admin
db.createUser({
    user: "admin",
    pwd: "password_seguro",
    roles: [
        { role: "userAdminAnyDatabase", db: "admin" },
        { role: "readWriteAnyDatabase", db: "admin" }
    ]
});

// Habilitar auth en mongod.conf
security:
  authorization: enabled

Roles Personalizados:

db.createRole({
    role: "lectura_reportes",
    privileges: [
        { resource: { db: "reportes", collection: "" }, actions: ["find"] }
    ],
    roles: []
});

Backup Seguro:

mongodump --uri="mongodb://user:pass@host:27017/db" --out=/backup

Atlas Cluster:

// Conectar desde aplicación
const mongoose = require('mongoose');
mongoose.connect('mongodb+srv://user:pass@cluster.mongodb.net/mydb');

// MongoDB Shell
mongosh "mongodb+srv://cluster.mongodb.net/mydb" --apiVersion 1

Search Index (Atlas Search):

// Crear índice en Atlas UI o con mongosh
db.coll.createSearchIndex(
    { name: "searchIndex", definition: {
        mappings: { dynamic: true }
    }}
);

Data API (sin driver):

// Llamada HTTP a Data API
fetch('https://data.mongodb-api.com/app/xxx/endpoint/data/v1', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'api-key': 'key' },
    body: JSON.stringify({ dataSource: 'Cluster0', database: 'test', collection: 'items', filter: {} })
});

Triggers en Atlas:

Automatiza funciones cuando hay cambios en los datos (insert, update, replace, delete).