Tutoriel MongoDB : comment configurer et interroger des bases de données MongoDB

Concepts fondamentaux autour de MongoDB

Nous avons parlé encore et encore de bases orientées documents, mais de quoi s’agit‑il concrètement ? Voici les notions principales :

• Documents : les données sont stockées dans des objets appelés documents. En termes simples, ils ressemblent à des objets JSON clé‑valeur. Un document correspond à une ligne dans une table. Si vous programmez en Python, pensez à un document comme à un dictionnaire, et vous serez à l’aise. Gardez juste en tête qu’un document peut contenir des documents imbriqués, l’une des caractéristiques phares des bases de documents.
• Collections : les collections sont l’équivalent des tables dans les bases relationnelles, mais au lieu de contenir des lignes, elles contiennent des documents. Ce sont des structures massives pouvant regrouper des milliers, voire des millions de dictionnaires.
• Sans schéma : c’est là que cela devient intéressant. Une collection peut agréger des documents de tailles variables. Par exemple, le document 1 peut avoir 10 paires clé‑valeur tandis que le document 2 en compte 15 (tant que l’information relève de la même catégorie/sujet, comme des produits, pour que la collection garde du sens).

Voici un excellent tableau qui résume les différences entre bases relationnelles et bases orientées documents :

Passons à la pratique avec des documents dans MongoDB !

Configuration de MongoDB : connexion aux sources de données

Pour interroger des bases orientées documents, nous devons installer le serveur MongoDB. Voici les instructions selon la plateforme :

• Sur Windows, suivez les instructions de ce lien.
• Sur systèmes de type Unix, vous pouvez installer MongoDB depuis le terminal :

$ sudo apt-get install -y mongodb

Ensuite, dans un environnement virtuel, installez les bibliothèques pymongo et requests. pymongo est l’adaptateur Python officiel du serveur MongoDB. Nous aurons besoin de requests pour récupérer des données depuis une API.

$ pip install pymongo
$ pip install requests

Puis, depuis le terminal, démarrez le serveur MongoDB avec la commande suivante :

$ sudo service mongodb start

Nous sommes prêts à charger des données dans une base orientée documents. Deux cas de figure se présentent :

1. Vous disposez localement de données dans des formats adaptés comme JSON, BSON, YAML ou XML.
2. Vous devez récupérer des données depuis des sources externes, généralement des APIs.

Nous allons couvrir les deux. Commençons par charger localement une collection nommée drone_races.json. Voici l’extrait de code :

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)

Les deux objets les plus importants ici sont drones (une base) et races (une collection). La plupart des fonctions et méthodes se rapportent aux collections. Les objets base de données servent surtout à gérer les collections.

Voyons maintenant comment charger les mêmes données via une API. J’ai exposé ces informations sous forme d’API grâce à un service appelé Mockaroo. Voici l’extrait :

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.")

Nous avons chargé des données dans la collection races de la base drones … enfin, en théorie. Vérifions‑le avec des requêtes !

Requêtes MongoDB élémentaires

Compter les documents dans MongoDB

Pour vérifier la présence de données dans une collection, comptons ses documents. Nous allons utiliser la méthode count_documents :

>>> races.count_documents({})
9040

Notez le dictionnaire vide passé à count_documents. Dans MongoDB, on parle de filtre. Au fil du tutoriel, nous apprendrons à le renseigner pour créer différents filtres. Pour l’instant, il est vide. Ce code équivaut à SELECT COUNT(*) FROM table_name en SQL.

Nous avons 9040 documents — parfait ! Jetons un œil aux données.

Extraire un document dans MongoDB

Pour afficher un document avec pymongo, nous pouvons utiliser la méthode 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'}

Remarquez les champs (clés) de ce document. Il stocke les informations d’une course de drones et inclut notamment :

• Le nombre de tours
• Les conditions météo au moment de la course
• Certains pilotes présents lors de la course
• Les sponsors, etc.

Le document comporte aussi un champ obligatoire _id, un hachage unique.

Sélectionner tous les documents dans MongoDB

count_documents renvoie toujours un nombre, mais parfois nous souhaitons voir les données correspondant à notre requête. Pour cela, utilisons le grand frère de find_one, à savoir 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 sans argument (requête vide) renvoie les documents un par un, mais ce n’est pas ce que nous voulons ! Nous voulons poser des questions intéressantes à nos données. C’est là que les documents filtres sont utiles.

Sélectionner selon une condition dans MongoDB

Commençons par les filtres les plus simples : faire correspondre les documents où un champ égalise une valeur. L’équivalent SQL serait :

SELECT *
 FROM table_name
WHERE field = value

Faisons‑le dans MongoDB :

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

fat_shark_races = races.count_documents(criteria)
fat_shark_races

6194

Ici, nous sélectionnons les courses ayant « Fat Shark » parmi leurs sponsors. La syntaxe est simplement un dictionnaire qui mappe le champ sponsors à « Fat Shark ».

Le langage de requête MongoDB ne serait pas un langage sans opérateurs d’inégalité. Voici l’opérateur « inférieur à » :

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

quick_races = races.count_documents(criteria)
quick_races

3061

Cette requête illustre quatre caractéristiques de MQL :

• Vous pouvez accéder à des sous‑champs avec la notation pointée. pilots.qualification_time extrait la valeur imbriquée correspondante.
• Presque tous les opérateurs MQL commencent par un dollar.
• Les opérateurs s’utilisent dans un document imbriqué comme ci‑dessus.
• $lt signifie « less than » (inférieur à).

Résultat : il y a 3061 courses où un pilote a un temps de qualification inférieur à 10 secondes. Voici la fratrie de $lt :

• $lte : inférieur ou égal
• $gt : supérieur
• $gte : supérieur ou égal

Ils s’emploient avec la même syntaxe que $lt.

Sélectionner avec des opérateurs logiques dans MongoDB

MQL inclut également des opérateurs logiques comme $and et $or. Commençons par le second.

Récupérons les courses ayant soit le Royaume‑Uni comme lieu, soit Etisalat parmi les sponsors :

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

>>> races.count_documents(criteria)

6223

Là encore, utilisez le bouton Explain code pour une explication détaillée.

Nous avons 6223 documents correspondant à ces critères. Pour exprimer une logique OR sur plusieurs valeurs d’un même champ, utilisez l’opérateur $in.

Par exemple, pour vérifier des conditions météo défavorables :

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

>>> races.count_documents(criteria)

5508

Cette requête aurait été fastidieuse avec $or. Passons à $and.

Cette fois, nous voulons trouver les courses en Australie ET sponsorisées par Fat Shark. Voici comment faire avec $and :

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

Dans la pratique, vous utiliserez rarement $and, car on peut le remplacer par une écriture plus simple :

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

races.count_documents(criteria)
193

Il suffit d’ajouter plusieurs paires clé‑valeur au document filtre pour réaliser un ET logique.

Enfin, l’opérateur $nin vérifie la non‑appartenance. Par exemple, pour retourner toutes les courses qui ne se sont pas tenues aux États‑Unis, au Royaume‑Uni ou en Australie :

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

>>> races.count_documents(criteria)
126

Ici, il ne reste que les Émirats arabes unis, donc on pourrait tout aussi bien écrire :

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

>>> races.count_documents(criteria)
126

Mais vous avez l’idée.

Requêter des valeurs nulles ou manquantes dans MongoDB

Vérifier les valeurs nulles ou manquantes est une opération universelle en analyse de données. MongoDB propose pour cela l’opérateur $exists. Voici deux exemples pour contrôler l’existence d’un champ :

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

>>> races.count_documents(criteria)

0

Hum, il semble que le champ district n’existe dans aucun document. En revanche, laps devrait être présent partout puisqu’il s’agit d’une information clé d’une course.

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

races.count_documents(criteria)
9040

Comme prévu, tous les documents possèdent le champ laps. Et pour les champs existants mais à valeur nulle ? On peut le vérifier aussi :

criteria = {"pilots.finishing_position": None}

races.count_documents(criteria)
0

En utilisant l’objet Python None, on peut tester l’absence de valeur sur n’importe quel champ.

Certains cas avancés nécessitent aussi des contrôles d’existence ou de nullité. Par exemple, vérifier l’existence d’éléments donnés dans de grands tableaux imbriqués.

Pour cela, on peut utiliser la syntaxe d’indexation de tableau en MQL. Par exemple, pour trouver les courses ayant un seul sponsor, vérifions l’existence du deuxième élément du tableau sponsors :

# Comme toujours, l'indexation commence à 0
criteria = {"sponsors.1": {"$exists": False}}

races.count_documents(criteria)
2929

Il suffit d’ajouter l’index de l’élément à la clé. Dans notre collection, près de 3000 courses n’avaient qu’un seul sponsor.

Cette syntaxe d’indexation fonctionne avec de nombreux autres opérateurs, pas seulement $exists.

Projections (restriction des champs)

Dernier point de ce tutoriel : les projections. Jusqu’ici, nos résultats incluaient tous les champs de chaque document. Ce n’est pas idéal si vos documents comptent des centaines de champs : l’affichage devient illisible.

Afin de choisir les champs à retourner, utilisons des projections. Exemple :

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

Nous définissons le filtre comme d’habitude et, cette fois, un second document avec quatre champs réglés sur 1. Passé en second argument de find (ou de count_documents), ce projection ne renverra que les champs à 1.

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

Même si nous n’avons choisi que quatre champs, l’inévitable champ _id s’est invité. Pour le supprimer, réglez‑le sur 0 dans le dictionnaire 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']}

C’est tout de suite plus lisible.

Enfin, pour retourner tous les champs sauf quelques‑uns, mettez ces champs à 0 :

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

# Critères vides pour cet exemple
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'}

Comme vous le voyez, cette fois nous avons tous les champs sauf _id, league et pilots.

Conclusion

Ce tutoriel ne reflète qu’une petite partie des capacités de MongoDB en tant que système de gestion de base de données. Aujourd’hui, nous n’avons couvert que les requêtes GET (récupération d’informations), mais MongoDB permet aussi d’insérer, de mettre à jour et de supprimer des données. Nous avons également laissé de côté toute une classe de requêtes : les agrégations.

Tous ces sujets dépassent le cadre de cet article et nécessitent des ressources complémentaires. Pourquoi ne pas explorer :

• Introduction to using MongoDB in data science with Python course — un cours complet qui couvre aussi les requêtes avancées comme les agrégations
• Intro to MongoDB in Python — un autre tutoriel MongoDB qui couvre les opérations CRUD (create, read, update, delete) avec pymongo
• NoSQL concepts course — si les bases NoSQL vous intéressent, ce cours est pour vous. Il couvre, en plus des bases orientées documents, d’autres bases non relationnelles.