Tutorial de MongoDB: cómo configurar y consultar bases de datos MongoDB

Conceptos clave sobre MongoDB

He repetido "bases de datos de documentos" varias veces, pero ¿qué son exactamente? Estos son los conceptos principales:

• Documentos: los datos se almacenan en objetos llamados documentos. En pocas palabras, los documentos se parecen a objetos JSON de pares clave-valor. Un documento equivale a una fila en una tabla. Si programas en Python, piensa en un documento como un diccionario y listo. Solo recuerda que los documentos pueden contener documentos anidados, una de las características clave de estas bases de datos.
• Colecciones: las colecciones son como las tablas en las bases de datos relacionales, pero en lugar de filas contienen, lo has adivinado, documentos. Son estructuras de datos masivas que pueden albergar miles o millones de diccionarios.
• Sin esquema: aquí viene lo interesante. Una colección puede tener documentos de tamaños distintos. Por ejemplo, el documento 1 puede tener 10 pares clave-valor mientras que el documento 2 puede tener 15 (siempre que la información trate de la misma categoría/tema, como productos, para que la colección tenga sentido).

Aquí tienes una gran tabla que resume las diferencias entre bases de datos relacionales y de documentos:

¡Vamos a trabajar con documentos en MongoDB!

Configuración de MongoDB: conexión a orígenes de datos

Para consultar bases de datos de documentos, necesitamos instalar el servidor de MongoDB. Aquí tienes las instrucciones por plataforma:

• En Windows, sigue las instrucciones de este enlace.
• En sistemas tipo Unix, puedes instalar MongoDB desde la terminal:

$ sudo apt-get install -y mongodb

Después, dentro de un entorno virtual, instala las librerías pymongo y requests. pymongo es el adaptador oficial de Python para el servidor de MongoDB. Necesitaremos la librería requests para extraer datos de una API.

$ pip install pymongo
$ pip install requests

Luego, desde la terminal, inicia el servidor de MongoDB con este comando:

$ sudo service mongodb start

Ahora ya podemos cargar datos en una base de datos de documentos. Hay dos escenarios:

1. Tienes datos localmente en formatos adecuados como JSON, BSON, YAML o XML.
2. Necesitas extraer los datos de fuentes externas, normalmente APIs.

Veremos ambos. Primero, carguemos localmente una colección llamada drone_races.json. Aquí tienes el fragmento:

import json

from pymongo import MongoClient

# Establish connection to MongoDB
client = MongoClient("localhost", 27017)
# Create a database named "drones"
drones = client["drones"]
# Create a collection named "races"
races = drones["races"]

# Load dataset into MongoDB
with open("data/drone_races.json", "r") as file:
   data = json.load(file)
   races.insert_many(data)

Los dos objetos más importantes para nosotros son drones (una base de datos) y races (una colección). La mayoría de funciones y métodos se relacionan con las colecciones. Los objetos de base de datos se usan sobre todo para gestionar colecciones.

Ahora, veamos cómo cargar los mismos datos usando una API. He publicado la información como API con un servicio llamado Mockaroo. Aquí va el fragmento:

import requests
from pymongo import MongoClient

# Fetch data from the API
api_url = (
   "https://my.api.mockaroo.com/drone_race_matches.json?key=6f5a6b50"
)
response = requests.get(api_url)

if response.status_code == 200:
   data = response.json()  # Get the JSON data from the API

   # Establish a connection to MongoDB
   client = MongoClient()

   # Access or create a specific database
   drones = client["drones"]

   # Access or create a specific collection within the database
   races = drones["races"]

   # Insert the fetched data into the MongoDB collection
   races.insert_many(data)
else:
   print("Failed to fetch data from the API.")

Hemos cargado datos en la colección races de la base de datos de documentos drones, ¿o no? ¡Comprobémoslo con consultas!

Consultas elementales en MongoDB

Contar documentos en MongoDB

Necesitamos contar los documentos para saber si hay datos en una colección. Usaremos el método count_documents para hacerlo:

>>> races.count_documents({})
9040

Fíjate en el diccionario vacío que pasamos a count_documents. Ese diccionario se llama filtro en MongoDB. A lo largo del tutorial aprenderemos a completarlo para crear distintos filtros. Por ahora no tenemos filtro. El código anterior equivale a SELECT COUNT(*) FROM table_name en SQL.

¡Tenemos 9040 documentos, bien! Ahora, echemos un vistazo a algunos datos.

Extraer un documento en MongoDB

Para ver un documento con pymongo, podemos usar find_one:

from pprint import pprint

>>> pprint(races.find_one())
{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

Fíjate en los campos (claves) de este documento. Guarda información sobre una única carrera de drones e incluye, por ejemplo:

• El número de vueltas
• Las condiciones meteorológicas durante la carrera
• Los pilotos (no todos) que participaron
• Los patrocinadores, etc.

El documento también tiene un campo obligatorio _id, que es un hash único.

Seleccionar todos los documentos en MongoDB

count_documents siempre devuelve un número, pero a veces queremos ver los datos que devuelve la consulta. Para ello, podemos usar el hermano mayor de find_one, que es find:

from pprint import pprint

for race in races.find():
   pprint(race)
   break

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'laps': 3,
'league': 'F1 Drones',
'location': {'city': 'Ford',
             'country': 'United Kingdom',
             'date': 'error: invalid date "2024-10-25"',
             'venue': 'Manhattan Seas'},
'name': 'Honorable',
'pilots': {'drone': 'DJI3-old',
           'finishing_position': 66,
           'name': 'Kariotta Cow',
           'qualification_time': 27.39,
           'team': 'Sky Crusaders',
           'telemetry': {'altitude': 34.3,
                         'battery_voltage': 12.1,
                         'speed': 68.3,
                         'timestamp': 'error: invalid date '
                                      '"2024-10-25T14:09:26Z"'}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'weather_conditions': 'snowy'}

find con una consulta vacía (sin argumentos) devuelve documentos uno a uno, pero ¡no es lo que queremos! Queremos realizar consultas para responder preguntas interesantes sobre nuestros datos. Aquí es donde resultarán útiles los documentos de filtro.

Seleccionar según una condición en MongoDB

Empecemos con los filtros más simples: documentos que cumplan que un campo es igual a un valor. Sería lo mismo que:

SELECT *
 FROM table_name
WHERE field = value

Hagámoslo en MongoDB:

criteria = {"sponsors": "Fat Shark"}

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

Arriba estamos eligiendo las carreras con "Fat Shark" como patrocinador. La sintaxis es simplemente un diccionario que mapea el campo sponsors al valor "Fat Shark".

El lenguaje de consultas de MongoDB no sería un lenguaje si no tuviera operadores de desigualdad comunes. Así se usa el operador "menor que":

criteria = {"pilots.qualification_time": {"$lt": 10}}

quick_races = races.count_documents(criteria)
quick_races

3061

Esta consulta introduce cuatro rasgos nuevos de MQL:

• Puedes acceder a subcampos con notación de punto. pilots.qualification_time extrae el tiempo de clasificación anidado dentro de pilots.
• Casi todos los operadores en MQL comienzan con un signo de dólar.
• Los operadores se usan en un documento anidado como arriba.
• $lt es el operador "menor que".

El resultado indica que hubo 3061 carreras en las que un piloto tuvo menos de 10 segundos de tiempo de clasificación. Esta consulta fue posible con $lt. Sus hermanos son:

• $lte: menor o igual que
• $gt: mayor que
• $gte: mayor o igual que

Todos comparten la misma sintaxis que $lt.

Seleccionar con operadores lógicos en MongoDB

MQL también incluye operadores lógicos como $and y $or. Empecemos por este último.

Recuperaremos carreras con Reino Unido como país o Etisalat como patrocinador:

criteria = {
   "$or": [
       {"location.country": "United Kingdom"},
       {"sponsors": "Etisalat"},
   ]
}

>>> races.count_documents(criteria)

6223

De nuevo, usa el botón Explain code para una explicación detallada.

Hay 6223 documentos que cumplen el criterio. Para usar una lógica OR con múltiples valores de un mismo campo, podemos usar el operador $in.

Por ejemplo, podemos comprobar condiciones meteorológicas adversas así:

criteria = {
   "weather_conditions": {"$in": ["rainy", "snowy", "cloudy"]}
}

>>> races.count_documents(criteria)

5508

Con $or esta consulta habría sido un engorro. Ahora, pasemos a $and.

Esta vez queremos encontrar carreras con Australia como país Y Fat Shark como patrocinador. Así se hace con $and:

criteria = {
   "$and": [
       {"location.country": "Australia"},
       {"sponsors": "Fat Shark"},
   ]
}
>>> races.count_documents(criteria)
193

Pero en la práctica, rara vez usarás $and, ya que se puede expresar de forma más simple:

criteria = {
   "location.country": "Australia",
   "sponsors": "Fat Shark",
}

races.count_documents(criteria)
193

Basta con añadir más pares clave-valor al documento de filtro para lograr la lógica AND.

Por último, está el operador $nin, que comprueba no pertenencia. Por ejemplo, podemos devolver todas las carreras que no se celebraron en Estados Unidos, Reino Unido o Australia:

criteria = {
   "location.country": {
       "$nin": ["United States", "United Kingdom", "Australia"]
   }
}

>>> races.count_documents(criteria)
126

Esto deja solo a Emiratos Árabes Unidos como país, así que la consulta anterior podría escribirse como:

criteria = {"location.country": "United Arab Emirates"}

>>> races.count_documents(criteria)
126

Pero ya te haces una idea.

Consultar valores nulos o ausentes en MongoDB

Comprobar valores nulos o ausentes es una operación universal en cualquier análisis de datos. Para ello, MongoDB tiene el operador $exists. Dos ejemplos para verificar si existe un campo:

criteria = {"location.district": {"$exists": True}}

>>> races.count_documents(criteria)

0

Vaya, parece que el campo district no existe en ningún documento. Sin embargo, el campo laps sí debería existir en todos, ya que es clave para describir una carrera.

criteria = {"laps": {"$exists": True}}

races.count_documents(criteria)
9040

Como era de esperar, todos los documentos tienen el campo laps. ¿Y si un campo existe pero su valor es nulo? También podemos comprobarlo:

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

Usando el objeto incorporado None de Python, podemos comprobar la ausencia de valor en cualquier campo.

Hay escenarios más avanzados que también requieren comprobar nulos o existencia. Por ejemplo, quizá quieras verificar si existen ciertos elementos de arrays anidados muy grandes.

Para ello, podemos usar la sintaxis de indexación de arrays en MQL. Por ejemplo, para encontrar carreras con un solo patrocinador, tenemos que comprobar si existe el segundo elemento del array sponsors:

# La cuenta empieza en 0, como siempre
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

Es tan sencillo como añadir el índice del elemento a la clave. En nuestra colección, casi 3000 carreras tuvieron un único patrocinador.

Esta sintaxis de indexación funciona con muchos otros operadores, no solo con $exists.

Proyecciones (restringir campos)

Lo último que veremos son las proyecciones. Hasta ahora, los resultados de nuestras consultas incluían todos los campos de cada documento. No es ideal cuando tus documentos tienen cientos de campos. ¡Imagínate imprimir esas salidas!

Para elegir qué campos devolver, podemos usar proyecciones. Así:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

En este caso, escribimos el filtro como siempre pero definimos otro documento con cuatro campos a 1. Si pasamos este diccionario projection como segundo argumento a find o count_documents, solo obtendremos esos campos en la salida.

{'_id': ObjectId('659d31e9255ec0cf4bab529d'),
'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

Aunque elegimos cuatro campos, el puñetero _id se ha colado. Para evitarlo, ponlo a 0 en el diccionario projection:

criteria = {"pilots.telemetry.speed": {"$gte": 20}}
projection = {
   "sponsors": 1,
   "location.country": 1,
   "pilots.telemetry.speed": 1,
   "pilots.name": 1,
   "_id": 0,
}

fast_pilots = races.find(criteria, projection)

for pilot in fast_pilots:
   pprint(pilot)
   break

{'location': {'country': 'United Kingdom'},
'pilots': {'name': 'Kariotta Cow', 'telemetry': {'speed': 68.3}},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat']}

Ahora sí, mucho mejor.

Por último, para devolver todo salvo unos pocos campos, podemos poner esos campos a 0:

projection = {"_id": 0, "league": 0, "pilots": 0}

# Criterios vacíos en este caso
races.find_one({}, projection)

{'name': 'Honorable',
'location': {'venue': 'Manhattan Seas',
 'city': 'Ford',
 'country': 'United Kingdom',
 'date': 'error: invalid date "2024-10-25"'},
'sponsors': ['Fat Shark', 'DJI', 'Etisalat'],
'laps': 3,
'weather_conditions': 'snowy'}

Como ves, esta vez tenemos todos los campos excepto _id, league y pilots.

Conclusión

Este tutorial no hace justicia a la envergadura de MongoDB como gestor de bases de datos. Hoy solo hemos visto consultas GET (para recuperar información), pero MongoDB también permite insertar, actualizar o eliminar información en bases de datos de documentos. Además, hemos dejado fuera toda una clase de consultas: las agregaciones.

Todos estos temas quedan fuera del alcance del artículo y requieren recursos adicionales. ¿Por qué no echas un vistazo a esto?

• Introduction to using MongoDB in data science with Python course — un curso completo que también cubre consultas avanzadas como agregaciones
• Intro to MongoDB in Python — otro tutorial de MongoDB que cubre operaciones CRUD (crear, leer, actualizar y eliminar) con pymongo
• NoSQL concepts course — si te interesan las bases de datos NoSQL, este curso es para ti. Además de las de documentos, cubre otros tipos no relacionales.