MongoDB for Data Engineers

Ce module présente MongoDB, la base de données NoSQL documentaire la plus populaire.

Prérequis

Niveau	Compétence
✅ Requis	Avoir suivi le module `08_intro_big_data_distributed`
✅ Requis	Comprendre les 5V du Big Data
✅ Requis	Comprendre CAP
✅ Requis	Connaître le format JSON

Objectifs du module

À la fin de ce notebook, tu seras capable de :

Configurer MongoDB Atlas (gratuit, cloud)
Maîtriser le CRUD (Create, Read, Update, Delete)
Utiliser les opérateurs de filtrage et comparaison
Écrire des agrégations
Créer des index pour optimiser les performances

MongoDB dans l’écosystème Big Data

Tu as vu dans le module précédent que MongoDB est une base NoSQL documentaire. Voici comment elle répond aux défis du Big Data :

Rappel : Les 5V

V	Comment MongoDB répond
Volume	Sharding horizontal (données réparties sur plusieurs serveurs)
Velocity	Écritures rapides, réplication temps réel
Variety	Schéma flexible (JSON), pas de structure rigide
Veracity	Validation de schéma optionnelle
Value	Agrégations puissantes, intégration BI

Rappel : CAP & BASE

Concept	MongoDB
CAP	CP (Consistency + Partition tolerance) par défaut
BASE	Cohérence configurable (forte ou éventuelle)

💡 Pas d’installation nécessaire : Tout se fait dans le cloud avec MongoDB Atlas !

📝 Note : Les commandes s’exécutent dans MongoDB Shell ou l’interface web Atlas.

Partie 1 : C’est quoi MongoDB ?

1.1 Explication simple

MongoDB est une base de données qui stocke les données au format JSON (comme des fichiers texte structurés).

Comparaison : SQL vs MongoDB

Base de données SQL (MySQL, PostgreSQL) :

Table : employes
┌────┬──────────┬─────┬───────┬─────────┐
│ id │   nom    │ age │ ville │ salaire │
├────┼──────────┼─────┼───────┼─────────┤
│ 1  │ Alice    │ 25  │ Paris │ 45000   │
│ 2  │ Bob      │ 30  │ Lyon  │ 50000   │
└────┴──────────┴─────┴───────┴─────────┘

-- Requête SQL
SELECT * FROM employes WHERE ville = 'Paris';

MongoDB (NoSQL) :

Collection : employes
[
  {
    "_id": 1,
    "nom": "Alice",
    "age": 25,
    "ville": "Paris",
    "salaire": 45000,
    "competences": ["Python", "SQL"]
  },
  {
    "_id": 2,
    "nom": "Bob",
    "age": 30,
    "ville": "Lyon",
    "salaire": 50000,
    "competences": ["Java", "Docker"]
  }
]

// Requête MongoDB
db.employes.find({ ville: "Paris" })

Différences principales :

Aspect	SQL	MongoDB
Structure	Tableaux avec colonnes fixes	Documents JSON flexibles
Schéma	Rigide (défini à l’avance)	Flexible (peut changer)
Format	Lignes et colonnes	Documents JSON
Tableaux	Difficile (tables séparées)	Facile (intégré)
Langage	SQL	JavaScript/JSON

1.2 Vocabulaire de base

SQL	MongoDB	Explication	Exemple
Database	Database	Conteneur principal	`entreprise`
Table	Collection	Groupe de données similaires	`employes`, `produits`
Row	Document	Une entrée de données	`{nom: "Alice", age: 25}`
Column	Field	Un attribut	`nom`, `age`, `ville`

Structure visuelle :

MongoDB Server
  └── Database: ma_boutique
       ├── Collection: clients
       │    ├── Document 1: { nom: "Alice", email: "alice@email.com" }
       │    └── Document 2: { nom: "Bob", email: "bob@email.com" }
       │
       └── Collection: produits
            ├── Document 1: { nom: "Laptop", prix: 899 }
            └── Document 2: { nom: "Souris", prix: 29 }

1.3 Format des documents

MongoDB stocke les données en BSON (Binary JSON).

Exemple de document complet :

{
  "_id": ObjectId("507f1f77bcf86cd799439011"),  // ID unique automatique
  "nom": "Alice Dupont",                        // String (texte)
  "age": 28,                                     // Number (entier)
  "salaire": 55000.50,                           // Number (décimal)
  "actif": true,                                 // Boolean (vrai/faux)
  "date_embauche": ISODate("2022-01-15"),       // Date
  "competences": ["Python", "SQL", "MongoDB"],  // Array (tableau)
  "adresse": {                                   // Object (objet imbriqué)
    "rue": "123 Main St",
    "ville": "Paris",
    "code_postal": "75001"
  },
  "notes": null                                  // Null (vide)
}

Points importants :

Chaque document a un champ _id unique (créé automatiquement si absent)
On peut imbriquer des objets et des tableaux
Pas besoin que tous les documents aient les mêmes champs
La syntaxe ressemble à JavaScript/JSON

1.4 Pourquoi utiliser MongoDB en Data Engineering ?

Avantages :

1. Flexibilité du schéma

Pas besoin de définir la structure à l’avance
Parfait pour des données qui changent souvent
Chaque document peut être différent

// Document 1 : simple
{ nom: "Alice", age: 25 }

// Document 2 : plus détaillé (dans la même collection !)
{ nom: "Bob", age: 30, ville: "Lyon", competences: ["Python"], manager: "Alice" }

2. Format JSON natif

Les APIs web utilisent JSON
Pas de conversion nécessaire
Facile à lire et manipuler

3. Performance

Lectures et écritures très rapides
Gère facilement des millions de documents
Scalabilité horizontale (ajouter des serveurs)

4. Données imbriquées

Stocke des structures complexes facilement
Pas besoin de multiples tables et jointures

// Tout dans un seul document !
{
  "commande_id": "CMD001",
  "client": { "nom": "Alice", "email": "alice@example.com" },
  "articles": [
    { "produit": "Laptop", "quantite": 1, "prix": 899 },
    { "produit": "Souris", "quantite": 2, "prix": 29 }
  ],
  "total": 957
}

1.5 Quand utiliser MongoDB ?

Utilisez MongoDB pour :

Cas d’usage	Pourquoi
Applications web/mobile	API JSON, scalabilité
Collecte de logs	Volume élevé, structure flexible
E-commerce (catalogues)	Produits avec attributs variables
Données IoT	Millions d’écritures/seconde
CMS (contenu)	Structures diverses
Prototypage rapide	Pas de schéma prédéfini
Données JSON d’APIs	Format natif

N’utilisez PAS MongoDB pour :

Cas d’usage	Préférez SQL
Transactions bancaires	Besoin d’ACID strict
Relations multiples complexes	Nombreuses jointures
Reporting BI traditionnel	Requêtes SQL ad-hoc
Data Warehouse	Schéma en étoile

💡 Règle simple :

Données flexibles, JSON, volume élevé → MongoDB
Données structurées, relations strictes, transactions complexes → SQL (PostgreSQL, MySQL)

Partie 2 : Setup MongoDB Atlas

2.1 Pourquoi MongoDB Atlas ?

MongoDB Atlas = MongoDB hébergé dans le cloud (gratuit)

Avantages :

Gratuit : Tier M0 avec 512 MB de stockage
Pas d’installation : Tout dans le navigateur
Interface graphique : Data Explorer facile
Sécurisé : Backup automatique
MongoDB Shell intégré : Testez vos commandes directement

2.2 Créer votre compte (5 minutes)

▶️ Étape 1 : Inscription

Allez sur 👉 cloud.mongodb.com
Cliquez sur “Try Free”
Inscrivez-vous avec email/mot de passe (ou Google)

▶️ Étape 2 : Créer un cluster gratuit

Choisissez M0 (FREE) 🎉
Provider : AWS (ou Google Cloud/Azure)
Région : Choisissez proche de vous
- Europe : Frankfurt, Paris, London
- Amérique : N. Virginia, Oregon
- Asie : Singapore, Mumbai
Cluster Name : Cluster0 (par défaut, vous pouvez changer)
Cliquez “Create”

⏳ Attendez 2-3 minutes que le cluster se crée

▶️ Étape 3 : Créer un utilisateur

Dans la popup de sécurité :
Authentication Method : Username and Password
Username : admin (ou votre choix)
Password : Créez un mot de passe fort
- ⚠️ NOTEZ-LE BIEN quelque part !
Cliquez “Create User”

▶️ Étape 4 : Autoriser l’accès

Dans la popup : “Where would you like to connect from?”
Choisissez “My Local Environment”
Option 1 (recommandée pour apprendre) :
- Cliquez “Add My Current IP Address”
Option 2 (plus simple mais moins sécurisée) :
- Mettez 0.0.0.0/0 pour autoriser toutes les IPs
Cliquez “Finish and Close”

✅ Votre cluster est prêt !

2.3 Accéder à MongoDB Shell

Méthode 1 : MongoDB Shell Web (le plus simple)

Dans MongoDB Atlas, allez sur “Database” (menu gauche)
Cliquez sur “Browse Collections” sur votre cluster
En bas de page, cliquez sur l’onglet “MongoDB Shell” ou “>_ mongosh”
Une console s’ouvre dans le navigateur

Méthode 2 : Data Explorer (interface graphique)

Cliquez sur “Browse Collections”
Vous pouvez créer des bases de données et collections visuellement
Pratique pour visualiser, mais on va utiliser des commandes

💡 Dans ce tutoriel

Toutes les commandes ci-dessous sont à taper dans : - MongoDB Shell Web (dans Atlas) - Ou mongosh (si vous l’installez localement) - Ou Data Explorer → Insert Document (pour ajouter des données)

On utilise la syntaxe JavaScript/MongoDB, pas Python !

3️⃣ Partie 3 : Commandes MongoDB de base

3.1 Créer une base de données et une collection

Créer/Sélectionner une base de données

// Créer ou utiliser la base de données "ma_premiere_db"
use ma_premiere_db

Note : La base de données n’est créée réellement que quand vous insérez des données.

Voir la base de données actuelle

db

Lister toutes les bases de données

show dbs

Lister les collections

show collections

3.2 CREATE - Insérer des documents

Insérer UN document

// Créer la collection "employes" et insérer un document
db.employes.insertOne({
  nom: "Alice Dupont",
  age: 28,
  poste: "Data Engineer",
  salaire: 55000,
  ville: "Paris"
})

Résultat :

{
  acknowledged: true,
  insertedId: ObjectId("507f1f77bcf86cd799439011")
}

Insérer PLUSIEURS documents

db.employes.insertMany([
  {
    nom: "Bob Martin",
    age: 32,
    poste: "Data Analyst",
    salaire: 48000,
    ville: "Lyon"
  },
  {
    nom: "Charlie Dubois",
    age: 35,
    poste: "Data Scientist",
    salaire: 65000,
    ville: "Paris"
  },
  {
    nom: "David Laurent",
    age: 29,
    poste: "Data Engineer",
    salaire: 58000,
    ville: "Marseille"
  },
  {
    nom: "Eve Bernard",
    age: 26,
    poste: "Data Analyst",
    salaire: 45000,
    ville: "Lyon"
  }
])

Résultat :

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("..."),
    '1': ObjectId("..."),
    '2': ObjectId("..."),
    '3': ObjectId("...")
  }
}

3.3 READ - Lire des documents

Lire TOUS les documents

db.employes.find()

Lire avec un affichage formaté (pretty)

db.employes.find().pretty()

Lire UN seul document

db.employes.findOne()

Filtrer : employés à Paris

db.employes.find({ ville: "Paris" })

Filtrer : salaire supérieur à 50000

db.employes.find({ salaire: { $gt: 50000 } })

Opérateurs de comparaison : - $gt : greater than (>) - $gte : greater than or equal (>=) - $lt : less than (<) - $lte : less than or equal (<=) - $eq : equal (=) - $ne : not equal (!=)

Filtrer avec plusieurs conditions (AND)

// Employés à Paris avec salaire > 50000
db.employes.find({
  ville: "Paris",
  salaire: { $gt: 50000 }
})

Filtrer avec OR

// Employés à Paris OU Lyon
db.employes.find({
  $or: [
    { ville: "Paris" },
    { ville: "Lyon" }
  ]
})

Sélectionner certains champs seulement (projection)

// Afficher seulement nom et salaire (sans _id)
db.employes.find(
  {},
  { nom: 1, salaire: 1, _id: 0 }
)

Note : 1 = inclure, 0 = exclure

3.4 Trier, limiter, compter

Trier par salaire (croissant)

db.employes.find().sort({ salaire: 1 })

Trier par salaire (décroissant)

db.employes.find().sort({ salaire: -1 })

Note : 1 = croissant, -1 = décroissant

Limiter les résultats (top 3)

// Top 3 salaires
db.employes.find().sort({ salaire: -1 }).limit(3)

Sauter des résultats (pagination)

// Sauter les 2 premiers, afficher les 3 suivants
db.employes.find().skip(2).limit(3)

Compter les documents

// Compter tous les employés
db.employes.countDocuments()

// Compter les employés à Paris
db.employes.countDocuments({ ville: "Paris" })

// Compter les employés avec salaire > 50000
db.employes.countDocuments({ salaire: { $gt: 50000 } })

3.5 UPDATE - Modifier des documents

Modifier UN document

// Augmenter le salaire d'Alice
db.employes.updateOne(
  { nom: "Alice Dupont" },           // Condition
  { $set: { salaire: 60000 } }       // Modification
)

Résultat :

{
  acknowledged: true,
  matchedCount: 1,
  modifiedCount: 1
}

Modifier PLUSIEURS documents

// Augmenter tous les salaires de Lyon de 2000€
db.employes.updateMany(
  { ville: "Lyon" },
  { $inc: { salaire: 2000 } }       // $inc = incrémenter
)

Opérateurs de modification

// $set : définir une valeur
{ $set: { ville: "Paris" } }

// $inc : incrémenter
{ $inc: { age: 1 } }

// $mul : multiplier
{ $mul: { salaire: 1.1 } }  // Augmentation de 10%

// $unset : supprimer un champ
{ $unset: { notes: "" } }

// $rename : renommer un champ
{ $rename: { "nom": "nom_complet" } }

Ajouter un champ à tous les documents

db.employes.updateMany(
  {},
  { $set: { actif: true } }
)

3.6 DELETE - Supprimer des documents

Supprimer UN document

db.employes.deleteOne({ nom: "Test User" })

Supprimer PLUSIEURS documents

// Supprimer tous les employés de Test
db.employes.deleteMany({ ville: "Test" })

⚠️ Supprimer TOUS les documents

// ATTENTION : Supprime tout !
db.employes.deleteMany({})

Supprimer une collection entière

db.employes.drop()

Supprimer une base de données

db.dropDatabase()

4️⃣ Partie 4 : Agrégations simples

4.1 Grouper et compter

Compter les employés par ville

db.employes.aggregate([
  {
    $group: {
      _id: "$ville",              // Grouper par ville
      nombre: { $sum: 1 }         // Compter
    }
  }
])

Résultat :

[
  { _id: "Paris", nombre: 2 },
  { _id: "Lyon", nombre: 2 },
  { _id: "Marseille", nombre: 1 }
]

Salaire moyen par ville

db.employes.aggregate([
  {
    $group: {
      _id: "$ville",
      nombre: { $sum: 1 },
      salaire_moyen: { $avg: "$salaire" },
      salaire_max: { $max: "$salaire" },
      salaire_min: { $min: "$salaire" }
    }
  },
  {
    $sort: { salaire_moyen: -1 }   // Trier par salaire moyen décroissant
  }
])

Grouper par poste

db.employes.aggregate([
  {
    $group: {
      _id: "$poste",
      nombre: { $sum: 1 },
      salaire_moyen: { $avg: "$salaire" }
    }
  }
])

4.2 Filtrer avant d’agréger

// Statistiques pour les employés avec salaire > 50000
db.employes.aggregate([
  {
    $match: { salaire: { $gt: 50000 } }   // Filtrer d'abord
  },
  {
    $group: {
      _id: "$ville",
      nombre: { $sum: 1 },
      salaire_moyen: { $avg: "$salaire" }
    }
  }
])

4.3 Statistiques globales

// Statistiques sur tous les salaires
db.employes.aggregate([
  {
    $group: {
      _id: null,                          // null = pas de groupement
      total_employes: { $sum: 1 },
      salaire_moyen: { $avg: "$salaire" },
      salaire_total: { $sum: "$salaire" },
      salaire_max: { $max: "$salaire" },
      salaire_min: { $min: "$salaire" }
    }
  }
])

Résumé

Ce que vous avez appris

Concepts

MongoDB = Base de données NoSQL (documents JSON)
Vocabulaire : Database → Collection → Document → Field
Différence SQL/NoSQL : Structure fixe vs flexible
Quand utiliser MongoDB : APIs, logs, IoT, e-commerce

Commandes essentielles

// BASES
use ma_db                    // Créer/utiliser DB
show dbs                     // Lister les DBs
show collections             // Lister les collections

// CREATE
db.collection.insertOne({...})
db.collection.insertMany([{...}, {...}])

// READ
db.collection.find()                     // Tout
db.collection.find({ ville: "Paris" })   // Filtré
db.collection.findOne()
db.collection.find().sort({ age: -1 })   // Trié
db.collection.find().limit(5)            // Limité
db.collection.countDocuments()

// UPDATE
db.collection.updateOne({ _id: 1 }, { $set: { age: 30 } })
db.collection.updateMany({ ville: "Lyon" }, { $inc: { salaire: 1000 } })

// DELETE
db.collection.deleteOne({ _id: 1 })
db.collection.deleteMany({ ville: "Test" })

// AGGREGATE
db.collection.aggregate([
  { $group: { _id: "$ville", count: { $sum: 1 } } }
])

Opérateurs importants 📝

Comparaison

$gt : > (greater than)
$gte : >= (greater than or equal)
$lt : < (less than)
$lte : <= (less than or equal)
$eq : = (equal)
$ne : != (not equal)

Modification

$set : Définir une valeur
$inc : Incrémenter
$mul : Multiplier
$unset : Supprimer un champ

Agrégation

$sum : Somme
$avg : Moyenne
$max : Maximum
$min : Minimum
$group : Grouper
$match : Filtrer

5️⃣ Partie 5 : Index — Optimiser les performances

5.1 Pourquoi les index ?

Sans index, MongoDB doit scanner tous les documents pour trouver ceux qui correspondent au filtre. Avec un index, la recherche est beaucoup plus rapide.

Sans index	Avec index
Scan complet (lent)	Recherche directe (rapide)
O(n)	O(log n)
1M docs = 1M comparaisons	1M docs = ~20 comparaisons

5.2 Créer un index

Index simple (un champ)

// Index sur le champ "email" (croissant)
db.employes.createIndex({ email: 1 })

// Index sur le champ "salaire" (décroissant)
db.employes.createIndex({ salaire: -1 })

Index composé (plusieurs champs)

// Index sur ville + poste (pour requêtes fréquentes)
db.employes.createIndex({ ville: 1, poste: 1 })

Index unique

// Empêche les doublons sur email
db.employes.createIndex({ email: 1 }, { unique: true })

5.3 Gérer les index

// Lister tous les index
db.employes.getIndexes()

// Supprimer un index
db.employes.dropIndex({ email: 1 })

// Supprimer tous les index (sauf _id)
db.employes.dropIndexes()

5.4 Analyser les performances

// Voir le plan d'exécution
db.employes.find({ ville: "Paris" }).explain("executionStats")

Regarder :

totalDocsExamined : Combien de documents scannés
executionTimeMillis : Temps d’exécution
stage: "IXSCAN" = Index utilisé ✅
stage: "COLLSCAN" = Scan complet ❌

5.5 Bonnes pratiques

Règle	Explication
Indexer les champs de filtrage fréquents	`ville`, `email`, `date`
Indexer les champs de tri	`ORDER BY` = index
Pas trop d’index	Chaque index ralentit les écritures
Index composé : ordre important	Le champ le plus filtrant en premier

6️⃣ Partie 6 : Recherche avancée

6.1 Recherche avec expressions régulières

// Noms commençant par "A"
db.employes.find({ nom: { $regex: "^A" } })

// Noms contenant "dupont" (insensible à la casse)
db.employes.find({ nom: { $regex: "dupont", $options: "i" } })

// Emails Gmail
db.employes.find({ email: { $regex: "@gmail\.com$" } })

6.2 Opérateurs de tableau

// Document avec un tableau
db.employes.insertOne({
  nom: "Alice",
  competences: ["Python", "SQL", "MongoDB"]
})

// Trouver ceux qui ont "Python" dans leurs compétences
db.employes.find({ competences: "Python" })

// Trouver ceux qui ont Python ET SQL
db.employes.find({ competences: { $all: ["Python", "SQL"] } })

// Trouver ceux qui ont au moins 3 compétences
db.employes.find({ competences: { $size: 3 } })

6.3 Recherche dans les objets imbriqués

// Document avec objet imbriqué
db.employes.insertOne({
  nom: "Bob",
  adresse: {
    ville: "Paris",
    code_postal: "75001"
  }
})

// Rechercher par ville imbriquée (notation pointée)
db.employes.find({ "adresse.ville": "Paris" })

// Rechercher par code postal
db.employes.find({ "adresse.code_postal": { $regex: "^75" } })

Cheatsheet : SQL vs MongoDB

Opération	SQL	MongoDB
Tout sélectionner	`SELECT * FROM table`	`db.collection.find()`
Filtrer	`WHERE col = 'val'`	`find({ col: 'val' })`
Supérieur à	`WHERE col > 10`	`find({ col: { $gt: 10 } })`
ET	`WHERE a = 1 AND b = 2`	`find({ a: 1, b: 2 })`
OU	`WHERE a = 1 OR b = 2`	`find({ $or: [{a:1}, {b:2}] })`
IN	`WHERE col IN (1,2,3)`	`find({ col: { $in: [1,2,3] } })`
LIKE	`WHERE col LIKE '%val%'`	`find({ col: { $regex: 'val' } })`
Projection	`SELECT a, b FROM`	`find({}, { a:1, b:1 })`
Trier	`ORDER BY col ASC`	`.sort({ col: 1 })`
Limiter	`LIMIT 10`	`.limit(10)`
Compter	`SELECT COUNT(*)`	`.countDocuments()`
Grouper	`GROUP BY col`	`aggregate([{$group:{_id:'$col'}}])`
Insert	`INSERT INTO ... VALUES`	`insertOne({...})`
Update	`UPDATE ... SET ... WHERE`	`updateOne({filter}, {$set:{...}})`
Delete	`DELETE FROM ... WHERE`	`deleteOne({filter})`

Exercices pratiques — À toi de jouer !

Collection disponible : `employes`

{ nom, age, poste, salaire, ville, competences: [...] }

Exercice 1 — Facile

Trouver tous les employés qui habitent à Lyon.

💡 Solution

db.employes.find({ ville: "Lyon" })

Exercice 2 — Facile

Compter le nombre total d’employés.

💡 Solution

db.employes.countDocuments()

Exercice 3 — Intermédiaire

Trouver les 3 employés les mieux payés (nom et salaire uniquement).

💡 Solution

db.employes.find({}, { nom: 1, salaire: 1, _id: 0 })
  .sort({ salaire: -1 })
  .limit(3)

Exercice 4 — Intermédiaire

Augmenter de 5% le salaire de tous les Data Engineers.

💡 Solution

db.employes.updateMany(
  { poste: "Data Engineer" },
  { $mul: { salaire: 1.05 } }
)

Exercice 5 — Avancé

Calculer le salaire moyen par poste, trié du plus élevé au plus bas.

💡 Solution

db.employes.aggregate([
  { $group: { _id: "$poste", salaire_moyen: { $avg: "$salaire" } } },
  { $sort: { salaire_moyen: -1 } }
])

Exercice 6 — Avancé

Trouver les employés qui ont “Python” dans leurs compétences et gagnent plus de 50000€.

💡 Solution

db.employes.find({
  competences: "Python",
  salaire: { $gt: 50000 }
})

Quiz Final

Testez vos connaissances !

❓ Q1. Quelle est la différence principale entre SQL et MongoDB ?

SQL est gratuit, MongoDB est payant
SQL utilise des tableaux avec un schéma fixe, MongoDB utilise des documents JSON flexibles
SQL est plus rapide que MongoDB
MongoDB ne peut pas stocker de nombres

💡 Voir la réponse

✅ Réponse : b – SQL utilise des tableaux avec colonnes fixes (schéma rigide), tandis que MongoDB utilise des documents JSON flexibles où chaque document peut avoir des champs différents.

❓ Q2. Dans MongoDB, comment appelle-t-on l’équivalent d’une “table” SQL ?

Document
Database
Collection
Field

💡 Voir la réponse

✅ Réponse : c – Une Collection est l’équivalent d’une table SQL. Elle contient plusieurs documents (équivalents des lignes).

❓ Q3. Quelle commande permet d’insérer plusieurs documents à la fois ?

db.collection.insert([...])
db.collection.insertMany([...])
db.collection.addMultiple([...])
db.collection.bulkInsert([...])

💡 Voir la réponse

✅ Réponse : b – La commande insertMany([...]) permet d’insérer plusieurs documents en une seule fois.

❓ Q4. Comment trouver tous les employés avec un salaire supérieur à 50000 ?

db.employes.find({ salaire > 50000 })
db.employes.find({ salaire: { $gt: 50000 } })
db.employes.find({ salaire: 50000+ })
db.employes.search({ salaire: "greater than 50000" })

💡 Voir la réponse

✅ Réponse : b – On utilise l’opérateur $gt (greater than) : { salaire: { $gt: 50000 } }

❓ Q5. Que fait la commande `db.employes.updateMany({}, { $inc: { age: 1 } })` ?

Supprime tous les employés
Augmente l’âge de tous les employés de 1
Définit l’âge de tous les employés à 1
Multiplie l’âge de tous les employés par 1

💡 Voir la réponse

✅ Réponse : b – L’opérateur $inc incrémente la valeur. Ici, il augmente l’âge de chaque employé de 1 (comme pour fêter leurs anniversaires !).

❓ Q6. Quelle est la meilleure utilisation de MongoDB ?

Gestion de transactions bancaires complexes
Collecte de logs et données IoT avec structure flexible
Reporting BI avec jointures multiples
Calculs scientifiques complexes

💡 Voir la réponse

✅ Réponse : b – MongoDB excelle pour la collecte de logs, données IoT, APIs JSON, et toute donnée avec une structure flexible et un volume élevé.

❓ Q7. Comment trier les résultats par salaire décroissant ?

db.employes.find().sort({ salaire: 1 })
db.employes.find().sort({ salaire: -1 })
db.employes.find().orderBy({ salaire: "desc" })
db.employes.find().reverse({ salaire })

💡 Voir la réponse

✅ Réponse : b – On utilise sort({ salaire: -1 }) où -1 signifie décroissant (du plus grand au plus petit) et 1 signifie croissant.

❓ Q8. Que fait la commande `db.employes.aggregate([{ $group: { _id: "$ville", count: { $sum: 1 } } }])` ?

Compte le nombre total d’employés
Groupe les employés par ville et compte combien il y en a dans chaque ville
Supprime les doublons de villes
Calcule le salaire total par ville

💡 Voir la réponse

✅ Réponse : b – Le pipeline d’agrégation groupe les documents par ville ($group: { _id: "$ville" }) et compte combien il y a d’employés dans chaque ville (count: { $sum: 1 }).

❓ Q9. Quel est l’avantage principal de MongoDB Atlas ?

Il est 100 fois plus rapide que MongoDB local
Il offre un tier gratuit (M0) et gère l’infrastructure pour vous
Il ne nécessite pas de mot de passe
Il convertit automatiquement MongoDB en SQL

💡 Voir la réponse

✅ Réponse : b – MongoDB Atlas est la version cloud managée de MongoDB. Le tier M0 est gratuit (512 MB), et Atlas gère automatiquement les backups, la sécurité, et le scaling pour vous.

❓ Q10. Comment supprimer TOUS les documents d’une collection sans supprimer la collection elle-même ?

db.collection.remove()
db.collection.deleteMany({})
db.collection.drop()
db.collection.clear()

💡 Voir la réponse

✅ Réponse : b – La commande deleteMany({}) supprime tous les documents (le filtre vide {} correspond à tous). La commande drop() supprimerait la collection entière.

📊 Votre score

10/10 : 🏆 Expert MongoDB ! Vous êtes prêt pour le niveau intermédiaire
7-9/10 : 🌟 Très bien ! Relisez les sections où vous avez hésité
5-6/10 : 💪 Bon début ! Pratiquez les commandes dans Atlas
< 5/10 : 📚 Relisez le notebook et testez les exemples

➡️ Prochaine étape

Tu maîtrises maintenant MongoDB ! Passons à une autre base NoSQL très utilisée en Data Engineering.

👉 Module suivant : 10_elasticsearch_for_data_engineers — Elasticsearch pour la recherche et l’analytics

📚 Ressources

MongoDB Atlas — Votre compte
MongoDB Documentation — Doc officielle
MongoDB University — Cours gratuits
MongoDB Cheat Sheet

🎉 Félicitations ! Tu maîtrises maintenant les bases de MongoDB.

Retour au sommet