Maîtrise de MongoDB : De la modélisation NoSQL au Framework d'Agrégation

3.1. Les composants clés

• MongoDB Server (`mongod`) : Le processus principal de la base de données. C'est le démon qui gère les données, les requêtes et les accès.
• MongoDB Shell (`mongosh`) : Une interface en ligne de commande interactive pour administrer la base et exécuter des requêtes en JavaScript.
• MongoDB Compass : Une interface graphique (GUI) qui permet de visualiser, d'interroger et d'analyser vos données de manière intuitive.
• Database Tools : Une suite d'outils en ligne de commande pour l'import/export de données (`mongoimport`, `mongoexport`) et la sauvegarde/restauration (`mongodump`, `mongorestore`).

4.1. Insérer un seul document (`insertOne`)

Pour insérer un unique document dans une collection, on utilise la méthode `insertOne()`. Si la collection n'existe pas, MongoDB la crée automatiquement.

db.Sportif.insertOne({
    _id: "sp11",
    nom: "Ziyech",
    prenom: "Hakim",
    genre: "homme",
    sport: { description: "football", olympique: true }
})

4.2. Insérer plusieurs documents (`insertMany`)

Pour insérer une liste de documents en une seule opération, on utilise `insertMany()`, ce qui est beaucoup plus performant que d'appeler `insertOne()` en boucle. La méthode prend un tableau de documents en argument.

db.Sportif.insertMany([
    { _id: "sp12", nom: "Hakimi", prenom: "Achraf", genre: "homme", sport: { description: "football", olympique: true } },
    { _id: "sp13", nom: "Bounou", prenom: "Yassine", genre: "homme", sport: { description: "football", olympique: true } }
])

4.3. Opérations en masse (`bulkWrite`)

La méthode `bulkWrite()` est l'outil le plus puissant pour les opérations d'écriture. Elle permet de combiner des insertions, des mises à jour et des suppressions en une seule requête envoyée au serveur, réduisant ainsi la latence réseau et améliorant considérablement les performances.

Elle prend en argument un tableau d'opérations. Chaque opération est un objet spécifiant le type d'action (`insertOne`, `updateOne`, `updateMany`, `deleteOne`, `deleteMany`, `replaceOne`) et ses paramètres.

db.Sportif.bulkWrite([
    { 
        insertOne: { 
            document: { _id: "sp14", nom: "Amrabat", prenom: "Sofyan", genre: "homme" } 
        } 
    },
    { 
        updateOne: {
            filter: { nom: "Ziyech" },
            update: { $set: { "sport.description": "football pro" } }
        }
    },
    {
        deleteOne: {
            filter: { _id: "sp9" } // On supprime le sportif "Belafrikh"
        }
    }
])

Exercice 1 : Créer une base et une collection

En utilisant `mongosh`, basculez sur une nouvelle base de données `DBSportifs`. La commande `use` suffit, la base sera créée physiquement lors de la première insertion.

// 1. Se connecter à une base de données (la crée si elle n'existe pas)
use DBSportifs

// 2. Vérifier la base de données actuelle
db

Exercice 2 : Insérer le jeu de données initial

Téléchargez le fichier de données des sportifs : dbs/sportif.json.
Utilisez la commande `insertMany()` pour insérer tous les sportifs de ce fichier dans votre collection `Sportif`.

db.Sportif.insertMany([
  {
    "_id": "sp1", "nom": "Radi", "prenom": "Abdessalam", "genre": "homme",
    "sport": { "description": "marathon", "olympique": true }
  },
  {
    "_id": "sp2", "nom": "Larbi", "prenom": "Benmbarek", "genre": "homme",
    "sport": { "description": "football", "olympique": true }
  },
  {
    "_id": "sp3", "nom": "ELGourch", "prenom": "Mohamed", "genre": "homme",
    "sport": { "description": "cyclisme", "olympique": true }
  },
  {
    "_id": "sp4", "nom": "Bidouane", "prenom": "Nezha", "genre": "femme",
    "sport": { "description": "athletisme", "olympique": true }
  },
  {
    "_id": "sp5", "nom": "ELGaraa", "prenom": "Najat", "genre": "femme",
    "sport": { "description": "athletisme", "olympique": true }
  },
  {
    "_id": "sp6", "nom": "Rabii", "prenom": "Mohamed", "genre": "homme",
    "sport": { "description": "box", "olympique": true }
  },
  {
    "_id": "sp7", "nom": "El Guerrouj", "prenom": "Hicham", "genre": "homme",
    "sport": { "description": "athletisme", "olympique": true }, "nbMedailles": 3
  },
  {
    "_id": "sp8", "nom": "Abissourour", "prenom": "Sara", "genre": "femme",
    "sport": { "description": "volley ball", "olympique": true }
  },
  {
    "_id": "sp9", "nom": "Belafrikh", "prenom": "Amine", "genre": "homme",
    "sport": { "description": "Muay Thai", "olympique": false }
  },
  {
    "_id": "sp10", "nom": "Moutawakil", "prenom": "Naoual", "genre": "femme",
    "nbMedailles": 4, "sport": { "description": "athletisme", "olympique": true }
  }
])

Exercice 3 : Pratiquer `bulkWrite`

Exécutez les opérations suivantes en une seule commande `bulkWrite` :
1. Insérer un nouveau sportif : `_id: "sp15", nom: "Saibari", prenom: "Ismael", genre: "homme"`.
2. Mettre à jour Hicham El Guerrouj (`sp7`) pour corriger son sport en "athletisme" (il était noté "box" par erreur).
3. Augmenter le nombre de médailles de Nezha Bidouane (`sp4`) de 1 (elle n'en avait pas, il faut donc lui en mettre 1).
4. Supprimer le sportif `sp2` (Larbi Benmbarek).

db.Sportif.bulkWrite([
    {
        insertOne: {
            document: { _id: "sp15", nom: "Saibari", prenom: "Ismael", genre: "homme", sport: { description: "football", olympique: true } }
        }
    },
    {
        updateOne: {
            filter: { _id: "sp7" },
            update: { $set: { "sport.description": "athletisme" } }
        }
    },
    {
        updateOne: {
            filter: { _id: "sp4" },
            update: { $set: { nbMedailles: 1 } }
        }
    },
    {
        deleteOne: {
            filter: { _id: "sp2" }
        }
    }
])

Exercice 1 : Vérification des données

Après avoir exécuté tous les exercices précédents, combien de documents votre collection `Sportif` contient-elle ? Utilisez une commande pour le vérifier.

// Compte le nombre total de documents dans la collection.
db.Sportif.countDocuments()

// Ou, une méthode plus ancienne mais toujours fonctionnelle :
db.Sportif.find().count()

Exercice 2 : Opération d'écriture complexe

Créez une nouvelle collection `Equipements`. En une seule commande `bulkWrite`, effectuez les actions suivantes :
1. Insérez 3 équipements : `{ _id: "eq1", type: "Velo", marque: "B-Twin" }`, `{ _id: "eq2", type: "Gants de Box", marque: "Everlast" }`, `{ _id: "eq3", type: "Chaussures de course", marque: "Nike" }`.
2. Immédiatement après, modifiez l'équipement `eq1` pour ajouter un champ `modele: "Rockrider"`.

db.Equipements.bulkWrite([
    { insertOne: { document: { _id: "eq1", type: "Velo", marque: "B-Twin" } } },
    { insertOne: { document: { _id: "eq2", type: "Gants de Box", marque: "Everlast" } } },
    { insertOne: { document: { _id: "eq3", type: "Chaussures de course", marque: "Nike" } } },
    { updateOne: {
        filter: { _id: "eq1" },
        update: { $set: { modele: "Rockrider" } }
    }}
])

Exercice 1

Quels sont les sportifs de genre « femme » ?

db.Sportif.find({genre: "femme"})

Exercice 2

Quel(s) sont les sportifs qui pratiquent le cyclisme ?

db.Sportif.find({"sport.description": "cyclisme"})

6.1. Opérateurs de comparaison

Ils permettent de filtrer les documents en comparant la valeur d'un champ.

• `$eq` : égal à (souvent implicite).
• `$ne` : non égal à.
• `$gt` : supérieur à (greater than).
• `$gte` : supérieur ou égal à.
• `$lt` : inférieur à (less than).
• `$lte` : inférieur ou égal à.
• `$in` : la valeur est dans un tableau de possibilités.
• `$nin` : la valeur n'est dans aucun élément du tableau.

// Sportifs ayant plus de 2 médailles
db.Sportif.find({ "nbMedailles": { $gt: 2 } })

// Sportifs pratiquant le 'box' ou le 'cyclisme'
db.Sportif.find({ "sport.description": { $in: [ "box", "cyclisme" ] } })

6.2. Opérateurs logiques

Ils combinent plusieurs conditions.

• `$and` : ET logique (souvent implicite en séparant les champs par une virgule).
• `$or` : OU logique.
• `$not` : Inverse une condition.

// Sportifs de genre "femme" OU qui ont plus de 3 médailles
db.Sportif.find({
    $or: [
        { "genre": "femme" },
        { "nbMedailles": { $gt: 3 } }
    ]
})

6.3. Opérateur d'élément (`$exists`)

Cet opérateur permet de sélectionner les documents en fonction de la présence ou de l'absence d'un champ. C'est très utile dans un schéma flexible où tous les documents n'ont pas forcément les mêmes champs.

// Trouver les sportifs qui ont un champ "nbMedailles"
db.Sportif.find({ "nbMedailles": { $exists: true } })

// Trouver les sportifs qui N'ONT PAS de champ "nbMedailles"
db.Sportif.find({ "nbMedailles": { $exists: false } })

Exercice 1

Afficher les sportifs qui ont exactement 4 médailles.

db.Sportif.find({nbMedailles: 4})

Exercice 2

Afficher les sportifs qui pratiquent les sports suivants : box, athletisme et cyclisme.

db.Sportif.find({"sport.description": {$in: ["box", "athletisme", "cyclisme"]}})

Exercice 3

Afficher les sportifs qui n'ont pas de médailles (champ `nbMedailles` manquant).

db.Sportif.find({nbMedailles: {$exists: false}})

7.1. Projection : Choisir les champs à afficher

La projection est le second argument de la méthode `find()`. C'est un document où l'on spécifie les champs à inclure (avec la valeur `1`) ou à exclure (avec la valeur `0`). Par défaut, le champ `_id` est toujours inclus, sauf si on l'exclut explicitement.

// Afficher uniquement le nom et prénom des sportifs, sans leur _id
db.Sportif.find(
    {}, // Filtre vide pour tout sélectionner
    { "nom": 1, "prenom": 1, "_id": 0 } // Document de projection
)

7.2. Tri (`sort`) et Pagination (`limit`, `skip`)

Les méthodes `sort()`, `limit()` et `skip()` se "chaînent" après un `find()` pour manipuler le curseur de résultat.

// Afficher les 3 sportifs ayant le plus de médailles, triés par ordre décroissant
db.Sportif.find({ "nbMedailles": { $exists: true } })
    .sort({ "nbMedailles": -1 }) // -1 pour décroissant, 1 pour croissant
    .limit(3) // Ne retourner que 3 documents

Exercice 1

Afficher les sportifs (nom et prenom) triés par ordre alphabétique des noms.

db.Sportif.find({}, {nom:1, prenom:1, _id:0}).sort({nom:1})

Exercice 2

Afficher les deux premières femmes sportives de la base de données (tous les champs).

db.Sportif.find({genre: "femme"}).limit(2)

Exercice 3

Afficher les noms et prénoms des sportifs qui ont plus que deux médailles.

db.Sportif.find({nbMedailles: {$gt: 2}}, {nom:1, prenom:1, _id:0})

Requête 1

db.restaurants.find( { "borough" : "Brooklyn" } ).count()

Requête 2

db.restaurants.find(
    { "borough" : "Brooklyn",
      "cuisine" : "Italian",
      "name" : /pizza/i }
)

Requête 3 (Projection)

db.restaurants.find(
    {"borough":"Manhattan",
     "grades.score":{$lt : 10}
    },
    {"name":1,"grades.score":1, "_id":0})

Requête 4 (elemMatch)

db.restaurants.find({
    "grades" : {
           $elemMatch : {
               "grade" : "C",
               "score" : {$lt :40}
           }
    }
})

Requête 5 (Index de tableau)

db.restaurants.find(
    {"grades.0.grade":"C"},
    {"name":1, "borough":1, "_id":0}
)

Requête 6 (Distinct)

db.restaurants.distinct("grades.grade")

8.1. Mise à jour de champs (`updateOne`, `updateMany`)

Pour modifier des champs spécifiques sans toucher au reste du document, on utilise `updateOne()` (modifie le premier document trouvé) ou `updateMany()` (modifie tous les documents correspondants). Ces méthodes utilisent des opérateurs de mise à jour comme `$set` pour modifier une valeur, `$inc` pour l'incrémenter, ou `$unset` pour supprimer un champ.

// Mettre à jour le nbMedailles du sportif "Rabii Mohamed"
db.Sportif.updateOne(
   { "nom" : "Rabii", "prenom": "Mohamed" },
   { $set: { "nbMedailles" : 2 } }
)

// Ajouter un champ "nationalite" à TOUS les sportifs
db.Sportif.updateMany(
   {}, // Un filtre vide cible tous les documents
   { $set: { "nationalite": "marocaine" } }
)

8.2. Remplacement de document (`replaceOne`)

Contrairement à `updateOne` qui modifie des champs, `replaceOne` supprime le document existant (correspondant au filtre) et le remplace par un nouveau, tout en conservant l'`_id` d'origine. Tous les anciens champs qui ne sont pas dans le nouveau document sont perdus.

// Remplacer entièrement les données de "Radi Abdessalam"
db.Sportif.replaceOne(
    { _id: "sp1" },
    { nom: "Radi", prenom: "Abdessalam", genre: "homme", sport: "Marathon Pro", retraité: true }
)
// Le champ "sport" n'est plus un objet, et le champ "olympique" a disparu.

8.3. Suppression de documents (`deleteOne`, `deleteMany`)

La suppression suit une logique similaire avec `deleteOne()` (supprime le premier document trouvé) et `deleteMany()` (supprime tous les documents correspondants).

// Supprimer le sportif qui pratique le "Muay Thai"
db.Sportif.deleteOne({ "sport.description": "Muay Thai" })

// Supprimer tous les sportifs dont le nom est "ELGourch"
db.Sportif.deleteMany({ "nom": "ELGourch" })

Exercice 1

Mettre à jour le champ nbMedailles du sportif « Rabii Mohamed » pour y mettre la valeur 2.

db.Sportif.updateOne(
  {nom: "Rabii", prenom: "Mohamed"},
  {$set: {nbMedailles: 2}}
)

Exercice 2

Pour tous les sportifs, ajouter un champ « nationalité » avec la valeur « marocaine ».

db.Sportif.updateMany(
  {},
  {$set: {nationalite: "marocaine"}}
)

Exercice 3

Supprimer le sportif qui s'appelle `Belafrikh`.

db.Sportif.deleteOne({nom: "Belafrikh"})

10.1. `$match` : Filtrer les documents

L'étape `$match` filtre les documents pour ne passer que ceux qui correspondent à la condition. Sa syntaxe est identique à celle d'une requête `find()`. Il est recommandé de placer `$match` le plus tôt possible dans le pipeline pour réduire le volume de données à traiter.

10.2. `$group` : Regrouper et calculer

L'étape `$group` regroupe les documents en fonction d'une clé (`_id`) et permet d'appliquer des accumulateurs sur chaque groupe pour calculer des sommes (`$sum`), des moyennes (`$avg`), des maximums (`$max`), des minimums (`$min`), etc.

// Calculer le nombre total de médailles par genre
db.Sportif.aggregate([
    // Étape 1: Filtrer pour ne garder que les sportifs ayant des médailles
    { $match: { "nbMedailles": { $exists: true } } },
    
    // Étape 2: Regrouper par genre et calculer la somme des médailles
    { $group: {
        _id: "$genre", // La clé de regroupement est le champ 'genre'
        "totalMedailles": { $sum: "$nbMedailles" } 
    }}
])

Exercice 1

Calculer la somme des médailles par sport.

db.Sportif.aggregate([
  {$group: {_id: "$sport.description", totalMedailles: {$sum: "$nbMedailles"}}}
])

Exercice 2

Afficher le maximum de médailles par sport.

db.Sportif.aggregate([
  {$group: {_id: "$sport.description", maxMedailles: {$max: "$nbMedailles"}}}
])

Exercice 1 : Modification de données

Dans la collection `movies`, ajoutez un nouveau film, puis modifiez son année et enfin, supprimez-le.

// 1. Ajouter un nouveau film
db.movies.insertOne({
    title: "Mon Film Test",
    year: 2023,
    cast: ["Acteur Inconnu"]
})

// 2. Modifier l'année du film ajouté
db.movies.updateOne(
    { title: "Mon Film Test" },
    { $set: { year: 2024 } }
)

// 3. Supprimer le film
db.movies.deleteOne({ title: "Mon Film Test" })

Exercice 2 : Agrégation simple

Dans la collection `movies`, affichez le nombre de films produits par pays, trié par ordre décroissant du nombre de films.

db.movies.aggregate([
   { $unwind : '$countries' },
   { $group : { '_id' : '$countries', count : { $sum : 1 } } },
   { $sort: { count: -1 } }
])

Agrégation 1

varMatch = { $match : { "grades.0.grade":"C"} };
varProject = { $project : {"name":1, "borough":1, "_id":0}};
varSort = { $sort : {"name":1} };

db.restaurants.aggregate( [ varMatch, varProject, varSort ] );

Agrégation 2

db.restaurants.aggregate([
  {   $group: { _id: { cuisine: "$cuisine", borough: "$borough" } }  },
  {   $project: { _id: 0, cuisine: "$_id.cuisine", borough: "$_id.borough" } },
  {   $sort:  {  borough: 1, cuisine: 1 }  }
])

Agrégation 3

varMatch = { $match : { "grades.0.grade":"C"} };
varGroup = { $group : {"_id" : "$borough", "total" : {$sum : 1} } };

db.restaurants.aggregate( [ varMatch, varGroup ] );

Agrégation 4

varUnwind = {$unwind : "$grades"};
varGroup = { $group : {"_id" : "$borough", "moyenne" : {$avg : "$grades.score"} } };
varSort = { $sort : { "moyenne" : -1 } };

db.restaurants.aggregate( [ varUnwind, varGroup, varSort ] );

12.1. Sauvegarder (`mongodump`)

La commande `mongodump` crée une sauvegarde binaire (BSON) de votre base de données. Elle s'exécute depuis le terminal de votre système d'exploitation, et non depuis `mongosh`.

# Sauvegarde simple d'une base de données spécifique
mongodump --db DBSportifs --out=/chemin/vers/backup/

# Sauvegarde avec authentification
mongodump --authenticationDatabase admin --username root --password VOTRE_PASS --db DBSportifs --out=/chemin/vers/backup/

12.2. Restaurer (`mongorestore`)

La commande `mongorestore` permet de restaurer une base de données à partir d'un répertoire de sauvegarde créé par `mongodump`. L'option `--drop` est utile pour supprimer les collections existantes avant de les restaurer.

# Restauration simple (le nom de la DB est déduit du nom du dossier)
mongorestore --drop /chemin/vers/backup/DBSportifs

# Restauration avec authentification
mongorestore --authenticationDatabase admin --username root --password VOTRE_PASS --drop /chemin/vers/backup/DBSportifs

13.1. Activer l'authentification

L'authentification doit être activée dans le fichier de configuration de MongoDB (`mongod.cfg`).

security:
  authorization: "enabled"

Après avoir modifié ce fichier, le service MongoDB doit être redémarré.

13.2. Créer un utilisateur

La commande `db.createUser()` permet de créer un utilisateur en lui assignant un nom, un mot de passe et un ou plusieurs rôles sur une base de données spécifique.

// Se connecter à la base 'admin' pour créer un super-utilisateur
use admin
db.createUser({
    user: "superAdmin",
    pwd: passwordPrompt(), // Pour une saisie sécurisée du mot de passe
    roles: [ { role: "root", db: "admin" } ]
})

// Créer un utilisateur avec des droits de lecture seule sur la base 'DBSportifs'
use DBSportifs
db.createUser({
    user: "guest",
    pwd: "guest123",
    roles: [ { role: "read", db: "DBSportifs" } ]
})

14.1. Installation et Connexion

L'installation se fait via `pip`. La connexion est établie en instanciant la classe `MongoClient`.

# 1. Installation
pip install pymongo

# 2. Connexion et récupération d'une collection
from pymongo import MongoClient

# Créer une connexion au serveur MongoDB
client = MongoClient('mongodb://localhost:27017/')

# Sélectionner la base de données
db = client['DBSportifs']

# Sélectionner la collection
collection = db['Sportif']

14.2. Exécuter une requête

La méthode `find()` de PyMongo retourne un objet `Cursor`, qui est un itérable. Il suffit de boucler dessus pour accéder aux documents.

# Rechercher tous les sportifs de genre "femme" et n'afficher que leur nom
filtre = { "genre": "femme" }
projection = { "nom": 1, "prenom": 1, "_id": 0 }

cursor = collection.find(filtre, projection)

# Itérer sur les résultats et les afficher
for sportif in cursor:
    print(sportif)

Exercice : Mettre en place la sécurité

1. Activez l'authentification sur votre serveur MongoDB.
2. Créez un utilisateur `root` sur la base `admin`.
3. Créez un utilisateur `guest` sur la base `DBSportifs` avec uniquement les droits de lecture.
4. Connectez-vous avec `guest` et vérifiez que vous ne pouvez pas insérer de document dans la collection `Sportif`.

// -- Étape 1 : Modifier le fichier mongod.cfg et redémarrer le service --

// -- Étape 2 : Créer l'utilisateur root (connecté sans authentification pour la première fois) --
use admin
db.createUser({ 
    user: "root", 
    pwd: "123456", 
    roles: [ { role: "root", db: "admin" } ] 
});

// -- Étape 3 : Se reconnecter avec l'utilisateur root et créer le guest --
// > mongosh --authenticationDatabase "admin" -u "root" -p "123456"
use DBSportifs
db.createUser({ 
    user: "guest", 
    pwd: "123456", 
    roles: [ { role: "read", db: "DBSportifs" } ] 
});

// -- Étape 4 : Se reconnecter avec guest et tester --
// > mongosh --authenticationDatabase "DBSportifs" -u "guest" -p "123456"
use DBSportifs
db.Sportif.find({}).limit(1) // Devrait fonctionner
db.Sportif.insertOne({ title: "Test" }) // Devrait échouer avec une erreur d'autorisation