Guía de MongoDB Nivel Medio: Consultas, Agregación, Índices y Modelado por Santiago Soñora

“Hola, mundo” en MongoDB

El 'Hola, mundo' en MongoDB: insertar un documento simple en una colección y consultarlo utilizando la Mongo Shell.

📋 Copiar

// Conectarse a la base de datos (si no existe, se crea al insertar el primer documento)
use hola_mundo_db;

// Insertar un documento simple
db.saludos.insertOne({ mensaje: "Hola, mundo" });

// Consultar el documento insertado
db.saludos.find();

Resultado:

Output

{ _id: ObjectId("..."), mensaje: "Hola, mundo" }

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con MongoDB:

Conectarse a MongoDB Shell
📋 Copiar
```
mongosh
```
Inicia el cliente interactivo de línea de comandos para MongoDB (o `mongo` en versiones anteriores).
Listar bases de datos
📋 Copiar
```
show dbs
```
Muestra todas las bases de datos disponibles en el servidor MongoDB.
Usar una base de datos
📋 Copiar
```
use nombreDB
```
Cambia al contexto de la base de datos especificada. Si no existe, se crea implícitamente al insertar el primer documento.
Mostrar colecciones en la base de datos actual
📋 Copiar
```
show collections
```
Lista todas las colecciones en la base de datos seleccionada actualmente.
Crear una colección (explícito)
📋 Copiar
```
db.createCollection("miColeccion")
```
Crea una nueva colección explícitamente (aunque las colecciones se crean automáticamente al insertar el primer documento).
Insertar un documento
📋 Copiar
```
db.miColeccion.insertOne({ nombre: "Juan", edad: 30, ciudad: "Madrid" })
```
Agrega un solo documento a la colección `miColeccion`.

Insertar varios documentos

📋 Copiar

db.productos.insertMany([
  { nombre: "Laptop", precio: 1200, stock: 50 },
  { nombre: "Teclado", precio: 75, stock: 150 }
]);

Agrega múltiples documentos a la colección `productos` en una sola operación.

Buscar todos los documentos
📋 Copiar
```
db.nombreColeccion.find()
```
Devuelve todos los documentos de la colección.
Buscar documentos con filtro (query)
📋 Copiar
```
db.usuarios.find({ edad: { $gt: 18 }, ciudad: "Barcelona" })
```
Devuelve documentos de la colección `usuarios` donde la `edad` es mayor que 18 Y la `ciudad` es 'Barcelona'.
Buscar con Proyección (seleccionar campos)
📋 Copiar
```
db.productos.find({ stock: { $lt: 100 } }, { nombre: 1, precio: 1, _id: 0 })
```
Busca productos con stock menor a 100 y muestra solo los campos `nombre` y `precio` (excluyendo `_id`).
Ordenar resultados
📋 Copiar
```
db.pedidos.find().sort({ fecha_pedido: -1, total: 1 })
```
Devuelve todos los pedidos ordenados por `fecha_pedido` descendente (-1) y `total` ascendente (1).
Limitar resultados (Paginación)
📋 Copiar
```
db.logs.find().sort({ timestamp: -1 }).limit(100)
```
Devuelve solo los últimos 100 logs, ordenados por timestamp descendente.
Saltar resultados (Paginación)
📋 Copiar
```
db.logs.find().sort({ timestamp: -1 }).skip(100).limit(100)
```
Devuelve los siguientes 100 logs después de saltar los primeros 100.
Actualizar un documento ($set)
📋 Copiar
```
db.usuarios.updateOne({ nombre: "Juan" }, { $set: { edad: 32, profesion: "Ingeniero" } })
```
Actualiza el primer documento donde el nombre es 'Juan', estableciendo/modificando los campos `edad` y `profesion`.
Actualizar varios documentos ($inc)
📋 Copiar
```
db.productos.updateMany({ stock: { $lt: 20 } }, { $inc: { stock: 10 } })
```
Incrementa el campo `stock` en 10 para todos los productos con stock menor a 20.
Añadir a un array ($push)
📋 Copiar
```
db.usuarios.updateOne({ nombre: "Ana" }, { $push: { tags: "nodejs" } })
```
Añade el valor 'nodejs' al final del array `tags` del usuario 'Ana'.
Eliminar de un array ($pull)
📋 Copiar
```
db.usuarios.updateOne({ nombre: "Ana" }, { $pull: { tags: "javascript" } })
```
Elimina el valor 'javascript' del array `tags` del usuario 'Ana'.
Eliminar un documento
📋 Copiar
```
db.miColeccion.deleteOne({ nombre: "Juan" })
```
Elimina el primer documento que coincida con el filtro.
Eliminar varios documentos
📋 Copiar
```
db.pedidos.deleteMany({ estado: "cancelado" })
```
Elimina todos los documentos que coincidan con el filtro.
Eliminar una colección
📋 Copiar
```
db.nombreColeccion.drop()
```
Elimina la colección y todos los documentos que contiene.
Crear un índice en un campo
📋 Copiar
```
db.productos.createIndex({ nombre: 1 })
```
Crea un índice ascendente (1) en el campo `nombre` de la colección `productos`.
Crear un índice compuesto
📋 Copiar
```
db.pedidos.createIndex({ cliente_id: 1, fecha_pedido: -1 })
```
Crea un índice que incluye múltiples campos, útil para consultas que filtran o ordenan por esta combinación.
Ejemplo básico de Agregación ($match, $group)
📋 Copiar
```
db.productos.aggregate([
  { $match: { categoria: 'electronica' } },
  { $group: { _id: '$categoria', total_stock: { $sum: '$stock' }, num_productos: { $count: {} } } }
])
```
Pipeline de agregación: filtra productos por categoría 'electronica' y luego los agrupa por categoría para sumar el stock y contar cuántos productos hay.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar MongoDB de forma más organizada y eficiente:

Estructura del Documento y Modelado de Datos (BSON):

MongoDB almacena datos en documentos flexibles en formato BSON (similar a JSON). El modelado de datos implica decidir cómo estructurar los documentos y cómo representar las relaciones entre ellos, típicamente mediante incrustación (embedding) de documentos relacionados o referenciando (_id) documentos en otras colecciones. La elección depende de los patrones de acceso a los datos.
MongoDB Query Language (Lenguaje de Consulta):

El lenguaje utilizado para leer datos. Va más allá de los filtros simples, incluyendo operadores de comparación (`$gt`, `$lt`), lógicos (`$and`, `$or`), de elementos (`$exists`, `$type`), de array (`$in`, `$all`), etc. También cubre la `projection` (seleccionar campos), `sort` (ordenar), `limit` y `skip` (paginación).
Operaciones de Actualización y Operadores:

Modificar documentos existentes de forma eficiente sin tener que reemplazarlos completamente. Se utilizan operadores de actualización como `$set` (modificar/añadir campo), `$unset` (eliminar campo), `$inc` (incrementar valor numérico), `$rename` (renombrar campo), y operadores específicos para arrays como `$push`, `$addToSet`, `$pop`, `$pull`.
Aggregation Framework:

Un potente pipeline de procesamiento de datos utilizado para análisis, transformaciones y agregaciones complejas. Consiste en una secuencia de etapas (`stages`) que los documentos pasan (`$match`, `$group`, `$project`, `$sort`, `$limit`, `$skip`, `$lookup` - similar a JOIN). Es esencial para generar informes o realizar ETL.
Índices:

Mejorar significativamente la velocidad de las operaciones de lectura creando índices en los campos más utilizados en consultas (`find`), ordenaciones (`sort`) o etapas de agregación (`$match`, `$sort`, `$lookup`). Tipos de índices incluyen de campo único, compuestos, multikey (para arrays), texto y geoespacial.
Transacciones Multi-Documento:

Asegurar la propiedad ACID (Atomicidad, Consistencia, Aislamiento, Durabilidad) para operaciones que involucran múltiples documentos, incluso si están en diferentes colecciones. Disponibles en replica sets y sharded clusters, permiten garantizar que un conjunto de operaciones se completa completamente o se revierte.
Tipos de Datos BSON:

Familiarizarse con los tipos de datos que BSON soporta además de JSON, siendo `ObjectId` el más común (usado como clave primaria por defecto), `Date`, `Timestamp`, `BinData` y otros. Entender cuándo y cómo utilizarlos.
Gestión de Usuarios y Roles:

Crear y gestionar usuarios de base de datos, asignándoles roles que definen sus permisos (ej: leer, escribir, administrar) sobre bases de datos o colecciones específicas. Fundamental para la seguridad de la base de datos.
Geospatial Queries (Básico):

Introducción a las capacidades de MongoDB para almacenar datos de ubicación (puntos, líneas, polígonos) y realizar consultas basadas en la proximidad, intersección o contención geométrica utilizando índices geoespaciales.

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza MongoDB:

Modelado de datos flexible para aplicaciones web o móviles con esquemas cambiantes:

Diseñar la estructura de colecciones considerando la flexibilidad del esquema NoSQL y decidiendo la mejor forma de representar relaciones entre datos (incrustados vs referenciados) basándose en los patrones de acceso de la aplicación.
Consultar y actualizar datos complejos dentro de documentos con estructuras anidadas y arrays:

Utilizar el Query Language y los operadores de actualización de array para interactuar eficientemente con datos dentro de documentos complejos (ej: gestionar ítems en un carrito de compra, actualizar elementos en una lista de tags).
Generación de informes y análisis de datos complejos con el Aggregation Framework:

Construir pipelines de agregación para procesar datos, calcular métricas (sumas, promedios, recuentos), agrupar resultados y reformar los datos para informes o visualizaciones.
Optimización del rendimiento de consultas en aplicaciones con grandes volúmenes de datos:

Analizar consultas lentas utilizando `explain()` y crear índices adecuados (simples, compuestos, multikey, geoespacial) para acelerar la recuperación de datos y reducir la carga en el servidor.
Implementación de funcionalidades de búsqueda de texto o búsqueda basada en ubicación:

Utilizar los índices de texto o geoespaciales de MongoDB para añadir capacidades de búsqueda eficiente a tu aplicación (ej: buscar productos por descripción, encontrar negocios cercanos).
Asegurar la integridad de datos en operaciones críticas que afectan múltiples documentos:

Utilizar transacciones multi-documento en replica sets o sharded clusters para garantizar que operaciones que involucran cambios en varios documentos se completan completamente o se revierten en caso de fallo.
Configuración de seguridad básica y gestión de acceso a la base de datos:

Crear usuarios con roles específicos para limitar los permisos (lectura, escritura, etc.) a bases de datos o colecciones determinadas, mejorando la seguridad.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en MongoDB:

Entiende el Modelado de Datos en NoSQL (No es Relacional):

No intentes aplicar las reglas de normalización de bases de datos relacionales directamente. Piensa en cómo se usarán los datos y si tiene más sentido incrustar (para acceso frecuente con el padre y tamaño pequeño) o referenciar (para relaciones muchos-a-muchos o muchos-a-pocos con muchos 'muchos') documentos.
Domina el Lenguaje de Consulta (Query Language):

Practica a fondo cómo filtrar documentos utilizando todos los operadores de consulta relevantes (`$gt`, `$lt`, `$in`, `$and`, `$or`, etc.), cómo seleccionar campos específicos con proyección, y cómo ordenar, limitar y saltar resultados para la paginación.
Familiarízate con los Operadores de Actualización:

Aprende a usar operadores como `$set`, `$inc`, `$push`, `$pull` para modificar partes de un documento o arrays sin tener que leer el documento completo, modificarlo en memoria y volver a escribirlo. Esto es más eficiente.
Comienza a Usar el Aggregation Framework para Análisis:

Es muy potente para transformar y agregar datos. Empieza con las etapas básicas (`$match`, `$group`, `$project`, `$sort`) y luego explora otras como `$lookup` para 'unir' datos entre colecciones (aunque no es un JOIN relacional exacto).
Usa Índices Estratégicamente para Optimizar:

Identifica las consultas lentas utilizando `explain()` en la Mongo Shell. Crea índices (simples, compuestos, multikey) en los campos que usas para filtrar, ordenar o unir datos. Los índices son cruciales para el rendimiento en colecciones grandes.
Practica en la Mongo Shell:

La shell interactiva es una herramienta poderosa para aprender y experimentar con el lenguaje de consulta, el Aggregation Framework y los comandos administrativos directamente en la base de datos.
Utiliza Herramientas GUI como MongoDB Compass:

MongoDB Compass (o DBeaver, Robo 3T) proporciona una interfaz visual para explorar tus datos, construir y probar consultas y pipelines de agregación, y administrar índices y usuarios. Es muy útil, especialmente al principio.
Comprende los Tipos de Datos BSON, especialmente `ObjectId`:

Entiende que `ObjectId` es el tipo de dato por defecto para las claves primarias y cómo se genera. Familiarízate con otros tipos como `Date` y cómo manejarlos en las consultas.
Lee la Documentación Oficial de MongoDB:

La documentación es extensa y la mejor fuente de información para entender a fondo el Query Language, el Aggregation Framework, la indexación, el modelado de datos y las características de administración.

Herramientas relacionadas

Si te interesa MongoDB, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: