MongoDB 65 termes

Stage d'aggregation qui ajoute de nouveaux champs aux documents sans supprimer les champs existants. Alias de $set dans le contexte d'aggregation.

Coller un post-it supplémentaire sur une fiche sans rien effacer de ce qui est déjà écrit.

{ $addFields: {
  totalPrice: {
    $multiply: ['$price', '$quantity']
  },
  isExpensive: {
    $gt: ['$price', 100]
  }
}}

Cas d'usage : Enrichir les documents avec des champs calcules sans perdre les données originales.

Stage d'aggregation qui distribue les documents dans des intervalles (buckets) définis par des bornes. Utile pour créer des histogrammes ou des tranches.

Trier des élèves par tranche d'âge : 6-10, 11-14, 15-18 ans.

{ $bucket: {
  groupBy: '$age',
  boundaries: [0, 18, 30, 50, 100],
  default: 'Other',
  output: { count: { $sum: 1 } }
}}

Cas d'usage : Créer des rapports avec des tranches de prix, d'ages ou de scores.

Stage d'aggregation qui exécute plusieurs sous-pipelines en parallèle sur le même jeu de documents. Chaque sous-pipeline produit un résultat indépendant dans un seul document de sortie.

Un journaliste qui écrit trois angles différents du même evenement en même temps.

{ $facet: {
  byCategory: [
    { $group: { _id: '$cat', n: { $sum: 1 } } }
  ],
  priceStats: [
    { $group: { _id: null, avg: { $avg: '$price' } } }
  ],
  total: [{ $count: 'count' }]
}}

Cas d'usage : Générer un dashboard avec des statistiques multiples en un seul appel a la base.

Stage d'aggregation qui regroupe les documents par une clé (_id) et applique des accumulateurs ($sum, $avg, $max, $min, $push, $first). Équivalent du GROUP BY en SQL.

Trier des billes par couleur dans des bols différents, puis compter combien il y en a dans chaque bol.

{ $group: {
  _id: '$category',
  count: { $sum: 1 },
  avgPrice: { $avg: '$price' },
  items: { $push: '$name' }
}}

Cas d'usage : Calculer des métriques agrégées par catégorie, utilisateur, période ou tout autre critère de regroupement.

Stage d'aggregation qui réalise une jointure gauche (LEFT JOIN) entre deux collections. Ajoute un tableau de documents correspondants depuis la collection jointe.

Appeler le service comptabilité pour joindre les factures de chaque client a leur fiche.

{ $lookup: {
  from: 'orders',
  localField: '_id',
  foreignField: 'userId',
  as: 'userOrders'
}}

Cas d'usage : Combiner des données de collections séparées quand l'embedding n'est pas adapte.

Stage d'aggregation qui filtre les documents, équivalent du WHERE en SQL. Place en début de pipeline, il utilise les index pour optimiser les performances.

Le vigile a l'entrée de la boite de nuit : seuls ceux qui remplissent les critères passent.

{ $match: {
  status: 'active',
  createdAt: { $gte: new Date('2024-01-01') }
}}

Cas d'usage : Filtrer les documents en amont du pipeline pour réduire le volume de données traite par les stages suivants.

Stage d'aggregation qui restructure les documents en incluant, excluant ou créant de nouveaux champs calcules. Permet de renommer des champs et d'appliquer des expressions.

Un monteur vidéo qui sélectionne les scènes a garder et ajoute des effets spéciaux.

{ $project: {
  fullName: { $concat: ['$first', ' ', '$last'] },
  year: { $year: '$createdAt' },
  _id: 0
}}

Cas d'usage : Formater la sortie de l'aggregation pour qu'elle corresponde exactement au format attendu par le frontend.

Stage d'aggregation, généralement disponible (GA) depuis MongoDB 8.0, qui combine les classements de plusieurs sous-pipelines (par exemple recherche vectorielle et recherche full-text) en un seul classement hybride pondéré.

Comme un jury qui fusionne les notes de plusieurs juges (recherche vectorielle, recherche texte) en un classement final unique.

db.products.aggregate([
  { $rankFusion: {
    input: { pipelines: {
      vector: [{ $vectorSearch: {
        index: 'v_idx', path: 'emb',
        queryVector: [0.1, 0.2], limit: 20
      }}],
      text: [{ $search: {
        text: { query: 'chaussures', path: 'name' }
      }}]
    }}
  }}
]);

Cas d'usage : Combiner recherche sémantique et recherche full-text pour un classement de résultats plus pertinent (hybrid search).

Stage d'aggregation, généralement disponible (GA) depuis MongoDB 8.3 (4 mai 2026), qui combine les scores de plusieurs sous-pipelines selon une formule explicite plutôt que par simple fusion de rangs comme $rankFusion.

La ou $rankFusion fusionne des classements, $scoreFusion fusionne des notes chiffrées selon une formule choisie.

db.articles.aggregate([
  { $scoreFusion: {
    input: {
      pipelines: {
        recent: [{ $addFields: {
          score: { $divide: [1, '$ageInDays'] }
        }}],
        relevance: [{ $search: {
          text: { query: 'ia', path: 'title' }
        }}]
      },
      normalization: 'minMaxScaler'
    }
  }}
]);

Cas d'usage : Construire un score composite (fraîcheur + pertinence textuelle) pour trier un fil d'actualité.

Stage d'aggregation qui decompacte un champ tableau en créant un document par élément. Transforme un document avec un tableau de N éléments en N documents.

Ouvrir un paquet de bonbons et poser chaque bonbon sur la table individuellement.

// { tags: ['js', 'mongo'] } devient :
// { tags: 'js' }
// { tags: 'mongo' }
{ $unwind: '$tags' }

Cas d'usage : Préparer les données d'un tableau pour un $group ou un $sort sur les éléments individuels.

Stage d'aggregation qui effectue une recherche sémantique par similarité vectorielle sur un index Atlas Vector Search. Disponible sur Atlas 6.0.11+ et sur MongoDB Enterprise/Community 8.2+ ; chaque document retourne inclut un score de similarité entre 0 et 1.

Comme chercher une chanson en fredonnant l'air plutôt qu'en tapant son titre exact : on cherche par proximité de sens, pas par égalité de texte.

db.movies.aggregate([
  { $vectorSearch: {
    index: 'vector_index',
    path: 'plotEmbedding',
    queryVector: [0.12, -0.45, 0.88],
    numCandidates: 150,
    limit: 10
  }}
]);

Cas d'usage : Recherche sémantique (RAG, recommandation) sur des embeddings générés par un modèle IA.

Depuis la version 4.0, MongoDB supporte les propriétés ACID (Atomicité, Cohérence, Isolation, Durabilite) au niveau multi-documents. Un seul document est toujours ACID nativement.

MongoDB a passe son permis ACID : avant il ne conduisait qu'un document, maintenant il gère tout un convoi.

// ACID single doc : toujours garanti
db.accounts.updateOne(
  { _id: 'A' },
  { $inc: { balance: -100 }, $push: { log: 'debit' } }
);

Cas d'usage : Justifier le choix de MongoDB pour des applications nécessitant des garanties transactionnelles.

Framework de transformation de données ou les documents passent par une séquence d'étapes (stages). Chaque stage transforme les documents et les passe au suivant, comme un pipeline Unix. Depuis MongoDB 8.0, le stage $rankFusion combine les classements de plusieurs sous-pipelines (recherche hybride) ; $scoreFusion, généralement disponible depuis MongoDB 8.3, fait de même a partir d'une formule de score explicite.

Une chaîne de montage en usine : chaque poste (stage) effectue une opération sur la pièce avant de la passer au suivant.

db.orders.aggregate([
  { $match: { status: 'completed' } },
  { $group: {
    _id: '$customerId',
    total: { $sum: '$amount' }
  }},
  { $sort: { total: -1 } }
]);

Cas d'usage : Calculer des statistiques, générer des rapports ou transformer des données complexes directement dans MongoDB.

Moteur de recherche full-text base sur Apache Lucene, intégré a MongoDB Atlas et interroge via le stage $search. Contrairement aux text index natifs de MongoDB, il offre des analyseurs linguistiques avances, l'autocompletion, le facettage et un scoring de pertinence configurable.

La différence entre chercher un mot exact avec Ctrl+F (text index natif) et utiliser un vrai moteur de recherche comme celui d'un site e-commerce (Atlas Search).

db.products.aggregate([
  { $search: {
    text: { query: 'chausure', path: 'name', fuzzy: {} }
  }}
]);

Cas d'usage : Offrir une recherche produit tolérante aux fautes de frappe avec autocompletion et facettes.

Mécanismes d'authentification de MongoDB. SCRAM (Salted Challenge Response Authentication Mechanism) est le défaut, x509 utilise des certificats TLS pour une authentification sans mot de passe.

SCRAM = badge avec code PIN. x509 = empreinte digitale, impossible a falsifier.

// Creer un utilisateur SCRAM
db.createUser({
  user: 'admin',
  pwd: 'secret',
  roles: [{ role: 'readWrite', db: 'mydb' }]
});

Cas d'usage : Sécuriser l'accès a la base en production, SCRAM pour les humains, x509 pour les services.

Binary JSON, format de sérialisation binaire utilise par MongoDB pour stocker les documents. BSON étend JSON avec des types supplémentaires comme Date, ObjectId, Décimal128 et BinData.

JSON en tenue de sport : même structure mais plus rapide a parcourir et capable de porter des types de données plus lourds.

// BSON supporte des types absents en JSON
{
  _id: ObjectId("507f1f77bcf86cd799439011"),
  created: ISODate("2024-01-15"),
  price: NumberDecimal("19.99")
}

Cas d'usage : Comprendre pourquoi MongoDB peut stocker des dates et des nombres décimaux précis, contrairement au JSON brut.

Exécuté un ensemble d'opérations d'écriture (insert, update, delete) en un seul appel réseau. Supporte les modes ordonne et non-ordonne pour optimiser les performances.

Envoyer un colis contenant plusieurs courriers au lieu de poster chaque lettre séparément.

await db.collection('users').bulkWrite([
  { insertOne: { document: { name: 'New' } } },
  { updateOne: {
    filter: { name: 'Old' },
    update: { $set: { status: 'archived' } }
  }},
  { deleteOne: { filter: { name: 'Gone' } } }
]);

Cas d'usage : Exécuter des migrations complexes mélangeant insertions, mises a jour et suppressions en une seule opération atomique.

API qui permet a une application de s'abonner en temps réel aux modifications d'une collection, d'une base ou d'un déploiement entier via watch(), sans lire l'oplog manuellement. Un résume token permet de reprendre le flux exactement ou il s'est arrêté après une coupure.

Comme s'abonner aux notifications d'une application plutôt que de rafraîchir la page toutes les secondes pour vérifier s'il y a du nouveau.

const cursor = db.collection('orders').watch([], {
  fullDocument: 'updateLookup'
});
cursor.on('change', (event) => {
  console.log(event.operationType, event._id);
});

Cas d'usage : Synchroniser des données en temps réel vers un autre système (ETL, cache, notification) sans polling.

Regroupement de documents dans MongoDB, équivalent d'une table en SQL. Les collections n'imposent pas de schema par défaut, chaque document peut avoir une structure différente.

Un dossier dans une armoire : tu y ranges des fiches, mais rien ne t'oblige a ce qu'elles aient toutes le même format.

// Creer implicitement
db.products.insertOne({ name: "Laptop" });
// Lister les collections
show collections;

Cas d'usage : Organiser les documents par domaine métier : users, orders, products.

Index créé sur plusieurs champs. L'ordre des champs est crucial : il suit la règle ESR (Equality, Sort, Range) pour des performances optimales.

Un annuaire trie d'abord par ville, puis par nom : chercher 'Paris + Dupont' est rapide, mais 'Dupont' seul ne profite pas de l'index.

db.orders.createIndex(
  { status: 1, createdAt: -1, amount: 1 }
);
// Suit la regle ESR

Cas d'usage : Optimiser des requêtes qui filtrent et trient sur plusieurs champs simultanément.

Depuis MongoDB 8.3, le multi-planning avec le Cost-Based Ranker devient la stratégie par défaut pour les requêtes éligibles : plutôt que d'exécuter plusieurs plans candidats en compétition (multi-planner historique), le CBR estime un coût par plan et choisit directement le moins coûteux, avec de nouvelles métriques exposées dans serverStatus.

Comme choisir son trajet en regardant une estimation de durée sur une carte plutôt que de tester physiquement plusieurs itinéraires avant de partir.

db.orders.find({ status: 'paid', region: 'EU' })
  .explain('queryPlanner');
// Le plan choisi provient du CBR quand
// la requete est eligible

Cas d'usage : Améliorer la stabilité et la latence du choix de plan sur des requêtes complexes a index multiples.

Pointeur iterable vers les résultats d'une requête. Le curseur ne charge pas tous les documents en mémoire mais les récupère par batches depuis le serveur.

Un marque-page dans un gros livre : tu lis page par page au lieu de photocopier tout le livre d'un coup.

const cursor = db.users.find({});
while (await cursor.hasNext()) {
  const doc = await cursor.next();
  process(doc);
}

Cas d'usage : Iterer sur de grands résultats sans saturer la mémoire de l'application.

Conteneur logique de collections dans MongoDB. Une instance MongoDB peut héberger plusieurs databases, chacune avec ses propres fichiers sur disque.

Une armoire entière dans un bureau : chaque armoire (database) contient ses propres dossiers (collections).

use myApp;
db.stats();
show dbs;

Cas d'usage : Isoler les données de différentes applications ou environnements sur un même serveur.

Supprime tous les documents correspondant au filtre. Avec un filtre vide {}, supprime tous les documents de la collection.

Vider tout un tiroir du classeur d'un coup.

await db.collection('logs').deleteMany({
  createdAt: { $lt: new Date('2023-01-01') }
});

Cas d'usage : Purger des données obsolètes comme des logs ou des sessions expirées.

Supprime le premier document correspondant au filtre. Retourne deletedCount indiquant si un document a été supprime.

Retirer une seule fiche du classeur et la mettre a la poubelle.

const result = await db.collection('users')
  .deleteOne({ _id: userId });
console.log(result.deletedCount); // 1

Cas d'usage : Supprimer un document précis comme un compte utilisateur après demande RGPD.

Stratégie de design qui duplique volontairement des données entre documents pour éviter les jointures coûteuses. Optimise la lecture au prix de la complexité en écriture.

Écrire le nom du client directement sur chaque facture au lieu de ne mettre qu'un numéro client.

// Denormalise : nom duplique
{
  orderId: 1,
  customerName: 'Alice',
  customerId: ObjectId('...')
}

Cas d'usage : Quand les lectures sont beaucoup plus fréquentes que les écritures et que les données dupliquees changent rarement.

Unité de base de stockage dans MongoDB, équivalent d'une ligne en SQL. C'est un objet BSON (JSON binaire) compose de paires clé-valeur, pouvant contenir des sous-documents et des tableaux.

Une fiche client dans un classeur : chaque fiche peut avoir des champs différents, contrairement aux lignes figées d'un tableur.

db.users.insertOne({
  name: "Alice",
  age: 30,
  address: { city: "Paris" },
  hobbies: ["code", "cafe"]
});

Cas d'usage : Stocker des données semi-structurées ou le schema peut varier d'un enregistrement a l'autre.

Choix de design fondamental en MongoDB : embarquer les données liées dans le même document (denormalisation) ou stocker une référence (ObjectId) vers un autre document (normalisation).

Coller la photo dans le passeport (embedding) ou noter un numéro de dossier renvoyant a la photo (referencing).

// Embedding
{ name: 'Alice', address: { city: 'Paris' } }
// Referencing
{ name: 'Alice', addressId: ObjectId('...') }

Cas d'usage : Embedding pour les relations 1:1 et 1:few lues ensemble. Referencing pour les relations 1:many ou many:many.

Méthode qui retourne le plan d'exécution d'une requête, montrant quels index sont utilises, le nombre de documents scannes et le temps d'exécution.

Le GPS qui te montre l'itinéraire prévu avant de partir, pour que tu choisisses le plus rapide.

db.users.find({ age: { $gt: 25 } })
  .explain('executionStats');
// Verifier totalDocsExamined
// vs totalKeysExamined

Cas d'usage : Diagnostiquer les requêtes lentes et vérifier que les index sont correctement utilises.

Chiffrement cote client de champs individuels avant envoi au serveur. Le serveur ne voit jamais les données en clair, même un admin DB ne peut pas les lire.

Envoyer une lettre dans une enveloppe scellée : le facteur (le serveur) la transporte sans pouvoir la lire.

const client = new MongoClient(uri, {
  autoEncryption: {
    keyVaultNamespace: 'enc.__keys',
    kmsProviders: { local: { key: masterKey } },
    schemaMap: encryptedFieldsMap
  }
});

Cas d'usage : Protéger les données sensibles (PII, données médicales) même en cas de compromission du serveur.

Méthode de lecture qui retourne un curseur sur les documents correspondant au filtre. Sans filtre, retourne tous les documents de la collection.

Chercher tous les livres d'un rayon qui correspondent a tes critères, tu obtiens un panier a parcourir.

const cursor = db.collection('users')
  .find({ age: { $gte: 18 } })
  .sort({ name: 1 })
  .limit(10);
const users = await cursor.toArray();

Cas d'usage : Récupérer une liste filtrée de documents pour un affichage pagine ou un export.

Méthode qui retourne le premier document correspondant au filtre, ou null si aucun résultat. Plus efficace que find().limit(1) car elle ne crée pas de curseur.

Demander au bibliothécaire de te trouver UN livre précis au lieu de parcourir tout le rayon.

const user = await db.collection('users')
  .findOne({ email: '[email protected]' });

Cas d'usage : Récupérer un document unique par son identifiant ou un champ unique comme l'email.

Index 2dsphere ou 2d pour les requêtes géographiques. Permet de chercher des points proches, dans un polygone ou dans un rayon donne.

Un GPS intégré a ta base de données : 'Trouve-moi tous les restaurants a moins de 2 km.'

db.stores.createIndex({ location: '2dsphere' });
db.stores.find({
  location: {
    $near: {
      $geometry: { type: 'Point', coordinates: [2.35, 48.86] },
      $maxDistance: 2000
    }
  }
});

Cas d'usage : Applications de geolocalisation : trouver les magasins, restaurants ou livreurs les plus proches.

Méthode qui insère plusieurs documents en une seule opération. Par défaut, l'insertion est ordonnée et s'arrête a la première erreur.

Déposer un paquet de lettres d'un coup au lieu de faire des allers-retours un par un.

await db.collection('logs').insertMany(
  [
    { level: 'info', msg: 'start' },
    { level: 'error', msg: 'fail' }
  ],
  { ordered: false }
);

Cas d'usage : Importer des données en masse ou insérer des logs par batch pour réduire les allers-retours réseau.

Méthode qui insère un seul document dans une collection. Retourne un objet contenant l'insertedId du document créé.

Déposer une seule lettre dans la boite aux lettres.

const result = await db.collection('users')
  .insertOne({ name: 'Bob', age: 25 });
console.log(result.insertedId);

Cas d'usage : Créer un nouvel enregistrement unique comme un utilisateur après inscription.

limit(n) restreint le nombre de documents retournes. skip(n) saute les n premiers résultats. Ensemble, ils permettent la pagination.

Dans un livre de 500 pages, skip(100) te place page 101 et limit(10) te fait lire 10 pages.

// Page 3, 20 items par page
const page = 3, size = 20;
db.users.find({})
  .sort({ _id: 1 })
  .skip((page - 1) * size)
  .limit(size);

Cas d'usage : Implémenter la pagination dans une API REST ou une interface utilisateur.

Service cloud manage de MongoDB qui gère automatiquement le déploiement, le scaling, les backups et la sécurité. Disponible sur AWS, Azuré et GCP. Atlas intégré nativement la recherche full-text Lucene (Atlas Search, stage $search) et la recherche vectorielle (Atlas Vector Search, stage $vectorSearch) sans base ou service tiers a provisionner.

Un hôtel pour ta base de données : tu arrives, ta chambre est prêté, le ménage et la sécurité sont inclus.

// Connection string Atlas
mongoose.connect(
  'mongodb+srv://user:[email protected]/mydb'
);

Cas d'usage : Déployer une base MongoDB en production sans gérer l'infrastructure serveur.

Interface graphique officielle de MongoDB pour explorer les données, construire des requêtes visuellement et analyser les performances via les plans d'exécution.

L'équivalent de phpMyAdmin mais pour MongoDB, avec des graphiques en bonus.

// Pas de code : outil GUI
// Lancer depuis le terminal :
// mongodb-compass

Cas d'usage : Visualiser la structure des documents et debugger les requêtes sans écrire de code.

Routeur de requêtes dans une architecture shardee. Il reçoit les requêtes des clients et les redirigé vers le(s) shard(s) concerne(s) en consultant les config servers.

Le standard téléphonique d'une grande entreprise : il redirigé chaque appel vers le bon département.

// Se connecter via mongos
mongosh 'mongodb://mongos-host:27017/mydb'

Cas d'usage : Point d'entrée unique pour les applications dans une architecture MongoDB shardee.

Shell interactif moderne de MongoDB qui remplace l'ancien mongo shell. Il offre la coloration syntaxique, l'auto-completion et un support complet de JavaScript/Node.js.

Le terminal de commande de ta base de données, comme psql pour PostgreSQL mais avec du JavaScript sous le capot.

mongosh "mongodb://localhost:27017/mydb"
db.users.find({ age: { $gt: 25 } });

Cas d'usage : Explorer et administrer rapidement une base MongoDB en ligne de commande.

Transaction ACID qui garantit l'atomicité sur plusieurs documents et collections. Introduite en MongoDB 4.0 pour les replica sets et 4.2 pour les clusters shardes. MongoDB 8.0, disponible en production depuis le 2 octobre 2024, amélioré le throughput général du moteur de stockage sans changer l'API des transactions (startSession/startTransaction/commitTransaction).

Un virement bancaire : le débit ET le crédit doivent réussir ensemble, sinon rien ne se passe.

const session = client.startSession();
session.startTransaction();
await accounts.updateOne(
  { _id: 'A' }, { $inc: { bal: -100 } }, { session }
);
await accounts.updateOne(
  { _id: 'B' }, { $inc: { bal: 100 } }, { session }
);
await session.commitTransaction();

Cas d'usage : Opérations financières ou tout scénario ou plusieurs documents doivent être modifies de façon atomique.

Identifiant unique de 12 octets génère automatiquement par MongoDB pour le champ _id. Il encode un timestamp, un identifiant machine, un PID et un compteur incremental.

Un numéro de série sur un produit : unique au monde, et en le lisant tu peux deviner quand et ou il a été fabrique.

const id = new ObjectId();
console.log(id.getTimestamp());
// 2024-01-15T10:30:00.000Z

Cas d'usage : Identifier de manière unique chaque document sans compteur central, idéal pour les systèmes distribues.

Opérations Log, collection cappee spéciale qui enregistre chronologiquement toutes les opérations de modification. Les secondaries la répliquent pour rester synchronises avec le primary.

Un journal de bord du capitaine : chaque manoeuvre est notée pour que l'équipage suivant puisse reproduire le trajet.

// Consulter l'oplog
use local;
db.oplog.rs.find().sort({ $natural: -1 }).limit(5);

Cas d'usage : Implémenter des Change Streams, debugger la réplication ou faire du point-in-time recovery.

Mécanisme pour sélectionner les champs a inclure ou exclure dans les résultats d'une requête. Réduit la quantité de données transférées du serveur au client.

Demander au serveur de ne te montrer que les colonnes 'nom' et 'prix' du menu, pas toute la carte.

db.users.find(
  { status: 'active' },
  { name: 1, email: 1, _id: 0 }
);

Cas d'usage : Optimiser les performances en ne récupérant que les champs nécessaires a l'affichage.

Opérateurs préfixes par $ utilises dans les filtres de requête : $eq, $gt, $lt, $gte, $lte, $in, $nin, $regex, $exists, $and, $or, $not. Ils permettent des requêtes complexes sans SQL.

Les symboles mathématiques de tes requêtes : au lieu de dire 'supérieur a 18', tu écris $gt: 18.

db.users.find({
  age: { $gte: 18, $lte: 65 },
  role: { $in: ['admin', 'editor'] },
  email: { $exists: true }
});

Cas d'usage : Filtrer les documents avec des conditions complexes combinant comparaisons, ensembles et existence de champs.

Chiffrement cote client qui stocke les données sensibles sous forme entièrement randomisee sur le serveur, tout en permettant des requêtes d'égalité et, depuis MongoDB 8.0, des requêtes par plage (range) directement sur les champs chiffres, sans jamais déchiffrer cote serveur.

Comme interroger un coffre-fort ferme en lui demandant si le contenu dépassé un certain montant, sans jamais l'ouvrir.

const encryptedFieldsMap = {
  'app.patients': { fields: [
    { path: 'ssn', bsonType: 'string',
      queries: { queryType: 'equality' } }
  ]}
};
// Le driver chiffre/dechiffre automatiquement
// via encryptedFieldsMap

Cas d'usage : Stocker des données réglementées (santé, finance) tout en gardant la capacité de les filtrer par égalité ou par plage.

Déterminé vers quel membre du replica set les lectures sont dirigées : primary, primaryPreferred, secondary, secondaryPreferred ou nearest.

Choisir a quel guichet faire la queue : le principal (toujours a jour) ou un secondaire (plus rapide mais potentiellement en retard).

const db = client.db('mydb', {
  readPreference: 'secondaryPreferred'
});

Cas d'usage : Lire depuis les secondaires pour les rapports analytiques, réduisant la charge sur le primary.

Remplace entièrement un document par un nouveau, en conservant le même _id. Contrairement a updateOne, ne prend pas d'opérateurs mais un document complet.

Jeter l'ancienne fiche et en écrire une toute nouvelle avec le même numéro de dossier.

await db.collection('users').replaceOne(
  { _id: userId },
  { name: 'Bob', age: 31, role: 'admin' }
);

Cas d'usage : Quand un document est entièrement recalcule et doit être remplace en bloc.

Groupe de processus mongod qui maintiennent le même jeu de données. Compose d'un Primary (écritures) et de Secondaries (copies). Offre la haute disponibilité et le failover automatique.

Un groupe de musiciens jouant la même partition : si le chanteur principal perd sa voix, un autre prend le relais.

// Config replica set
rs.initiate({
  _id: 'myRS',
  members: [
    { _id: 0, host: 'srv1:27017' },
    { _id: 1, host: 'srv2:27017' },
    { _id: 2, host: 'srv3:27017' }
  ]
});

Cas d'usage : Garantir la disponibilité en production avec failover automatique en cas de panne serveur.

Ensemble de patterns éprouves pour modeler les données en MongoDB : Bucket (regrouper par intervalles), Outlier (gérer les documents anormalement gros), Computed (pre-calculer), Subset (charger un sous-ensemble).

Des recettes de cuisine pour architecte de données : chaque pattern résout un problème récurrent.

// Bucket Pattern : IoT data
{
  sensorId: 'A1',
  date: '2024-01-15',
  readings: [
    { t: '10:00', val: 22 },
    { t: '10:05', val: 23 }
  ],
  count: 2
}

Cas d'usage : Optimiser les schémas MongoDB pour des cas d'usage spécifiques comme l'IoT, les réseaux sociaux ou le e-commerce.

Règles de validation JSON Schema appliquées au niveau de la collection pour garantir la structure et les types des documents inseres. Peut être strict ou warning.

Un formulaire papier avec des champs obligatoires : impossible de le soumettre incomplet.

db.createCollection('users', {
  validator: {
    $jsonSchema: {
      required: ['name', 'email'],
      properties: {
        email: { bsonType: 'string' }
      }
    }
  }
});

Cas d'usage : Garantir la qualité des données sans ORM, directement au niveau de la base.

Depuis MongoDB 8.3 (4 mai 2026), la commande removeShard est dépréciée au profit de quatre commandes dédiées : startShardDraining, stopShardDraining, shardDrainingStatus et commitShardRemoval, qui séparent le déclenchement, le suivi et la validation finale du retrait d'un shard.

Comme remplacer un unique bouton tout-supprimer par un panneau de contrôle avec démarrer, suivre et confirmer séparément : moins de risque d'erreur irréversible.

db.adminCommand({ startShardDraining: 'shard0002' });
db.adminCommand({ shardDrainingStatus: 'shard0002' });
db.adminCommand({ commitShardRemoval: 'shard0002' });

Cas d'usage : Retirer un shard d'un cluster de production en suivant précisément l'avancement de la migration des chunks.

Champ (ou index compose) utilise pour distribuer les documents entre les shards. Le choix de la shard key est irréversible et détermine la répartition et les performances du cluster.

Le critère de tri pour repartir les élèves entre les classes : par âge, par nom, par niveau.

sh.shardCollection(
  'mydb.orders',
  { customerId: 'hashed' }
);

Cas d'usage : Distribuer les données sur plusieurs serveurs quand une seule machine ne suffit plus.

Hashed sharding distribue les documents uniformément via un hash de la shard key (bon pour l'écriture). Range sharding les repartit par plages de valeurs (bon pour les requêtes par intervalle). Depuis MongoDB 8.3 (4 mai 2026), le retrait d'un shard ne passe plus par removeShard (dépréciée) mais par les commandes dédiées startShardDraining / shardDrainingStatus / commitShardRemoval.

Hashed = distribuer les cartes au hasard entre les joueurs. Range = donner les cartes 1-10 au joueur 1, 11-20 au joueur 2.

// Hashed
sh.shardCollection('db.users', { _id: 'hashed' });
// Range
sh.shardCollection('db.logs', { timestamp: 1 });

Cas d'usage : Hashed pour les écritures haute fréquence. Range pour les requêtes temporelles ou par intervalles.

Index créé sur un seul champ d'une collection. Accélère les requêtes qui filtrent ou trient sur ce champ. MongoDB créé automatiquement un index sur _id.

L'index alphabétique a la fin d'un livre : tu trouves le mot sans lire toutes les pages.

db.users.createIndex({ email: 1 });
// 1 = ascendant, -1 = descendant

Cas d'usage : Optimiser les requêtes fréquentes sur un champ comme email, username ou createdAt.

Méthode de curseur qui trie les résultats selon un ou plusieurs champs. 1 pour ascendant, -1 pour descendant.

Demander au bibliothécaire de ranger les livres par date de publication avant de te les présenter.

db.users.find({})
  .sort({ age: -1, name: 1 });

Cas d'usage : Afficher les résultats dans un ordre précis comme les articles les plus récents en premier.

Index qui n'indexe que les documents ou le champ existe. Les documents sans le champ ne sont pas dans l'index, ce qui le rend plus compact.

Un annuaire qui ne liste que les gens ayant un téléphone, pas ceux sans numéro.

db.users.createIndex(
  { phone: 1 },
  { sparse: true, unique: true }
);

Cas d'usage : Créer un index unique sur un champ optionnel comme le numéro de téléphone.

Index spécial pour la recherche full-text sur des champs textuels. Supporte le stemming, les stop words et les poids par champ. Une seule text index par collection.

Un moteur de recherche interne qui comprend les variantes des mots comme un humain.

db.articles.createIndex(
  { title: 'text', body: 'text' },
  { weights: { title: 10, body: 1 } }
);
db.articles.find({ $text: { $search: 'mongo' } });

Cas d'usage : Implémenter une barre de recherche sur un blog ou un catalogue de produits.

Type de collection spécialisé (option timeseries a la création) pour stocker des séquences de mesures horodatees. Un champ timeField obligatoire, un metaField optionnel (tags rarement modifies) et une granularity (seconds/minutes/hours) permettent a MongoDB de compresser les données en colonnes et de réduire fortement l'espace disque.

Comme un tableau de bord d'usine qui range chaque capteur dans sa propre colonne plutôt que de tout mélanger ligne par ligne.

db.createCollection('weatherData', {
  timeseries: {
    timeField: 'timestamp',
    metaField: 'sensorId',
    granularity: 'hours'
  }
});

Cas d'usage : Stocker des données IoT, financières ou de monitoring avec un volume d'écriture élevé et une compression efficace.

Index Time-To-Live qui supprime automatiquement les documents après un délai défini. Fonctionne sur un champ de type Date et est vérifié par un processus d'arrière-plan toutes les 60 secondes.

Un yaourt avec une date de péremption : passe le délai, il est automatiquement jeté du frigo.

db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 3600 }
);

Cas d'usage : Gérer l'expiration automatique des sessions, tokens temporaires ou logs éphémères.

Index qui garantit l'unicité des valeurs d'un champ dans la collection. Toute tentative d'insertion d'un doublon lève une erreur E11000.

Un registre d'état civil ou chaque numéro de sécurité sociale est unique.

db.users.createIndex(
  { email: 1 },
  { unique: true }
);

Cas d'usage : Garantir qu'un email, un username ou un code produit est unique dans la base.

Met a jour tous les documents correspondant au filtre. Retourne le nombre de documents modifies dans modifiedCount.

Envoyer un memo a tous les employés d'un département pour mettre a jour leur titre de poste.

const result = await db.collection('users')
  .updateMany(
    { status: 'inactive' },
    { $set: { archived: true } }
  );
console.log(result.modifiedCount);

Cas d'usage : Appliquer une migration de données ou une correction en masse sur un sous-ensemble de documents.

Met a jour le premier document correspondant au filtre avec les opérateurs de modification specifies ($set, $inc, $push, etc.).

Corriger une seule faute sur une fiche sans réécrire toute la fiche.

await db.collection('users').updateOne(
  { _id: userId },
  { $set: { name: 'Alice V2' }, $inc: { version: 1 } }
);

Cas d'usage : Modifier un champ précis d'un document identifie, comme changer le mot de passe d'un utilisateur.

Index qui couvre tous les champs d'un document ou d'un sous-document, y compris les champs dynamiques inconnus a l'avance. Utile pour les schémas flexibles.

Un détective qui met sous surveillance tout le bâtiment au lieu d'un seul appartement.

db.products.createIndex(
  { 'attributes.$**': 1 }
);

Cas d'usage : Indexer des metadonnees ou attributs dynamiques dont les noms de champs varient selon les documents.

Write Concern définit combien de noeuds doivent confirmer une écriture (w:1, w:majority). Read Concern définit le niveau d'isolation des lectures (local, majority, snapshot).

Write concern = combien de témoins doivent signer un contrat. Read concern = le niveau de certitude que tu exiges avant de lire un document officiel.

db.orders.insertOne(
  { item: 'laptop' },
  { writeConcern: { w: 'majority', j: true } }
);

Cas d'usage : Ajuster le compromis entre performances et durabilite des données selon la criticite de l'opération.