MongoDB 56 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 supplementaire sur une fiche sans rien effacer de ce qui est deja ecrit.

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

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

Stage d'aggregation qui distribue les documents dans des intervalles (buckets) definis par des bornes. Utile pour creer des histogrammes ou des tranches.

Trier des eleves par tranche d'age : 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 : Creer des rapports avec des tranches de prix, d'ages ou de scores.

Stage d'aggregation qui execute plusieurs sous-pipelines en parallele sur le meme jeu de documents. Chaque sous-pipeline produit un resultat independant dans un seul document de sortie.

Un journaliste qui ecrit trois angles differents du meme evenement en meme temps.

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

Cas d'usage : Generer un dashboard avec des statistiques multiples en un seul appel a la base.

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

Trier des billes par couleur dans des bols differents, 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 metriques agregees par categorie, utilisateur, periode ou tout autre critere de regroupement.

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

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

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

Cas d'usage : Combiner des donnees de collections separees quand l'embedding n'est pas adapte.

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

Le vigile a l'entree de la boite de nuit : seuls ceux qui remplissent les criteres passent.

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

Cas d'usage : Filtrer les documents en amont du pipeline pour reduire le volume de donnees traite par les stages suivants.

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

Un monteur video qui selectionne les scenes a garder et ajoute des effets speciaux.

{ $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 qui decompacte un champ tableau en creant un document par element. Transforme un document avec un tableau de N elements 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 : Preparer les donnees d'un tableau pour un $group ou un $sort sur les elements individuels.

Depuis la version 4.0, MongoDB supporte les proprietes ACID (Atomicite, Coherence, 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 gere 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 necessitant des garanties transactionnelles.

Framework de transformation de donnees ou les documents passent par une sequence d'etapes (stages). Chaque stage transforme les documents et les passe au suivant, comme un pipeline Unix.

Une chaine de montage en usine : chaque poste (stage) effectue une operation sur la piece 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, generer des rapports ou transformer des donnees complexes directement dans MongoDB.

Mecanismes d'authentification de MongoDB. SCRAM (Salted Challenge Response Authentication Mechanism) est le defaut, 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 : Securiser l'acces a la base en production, SCRAM pour les humains, x509 pour les services.

Binary JSON, format de serialisation binaire utilise par MongoDB pour stocker les documents. BSON etend JSON avec des types supplementaires comme Date, ObjectId, Decimal128 et BinData.

JSON en tenue de sport : meme structure mais plus rapide a parcourir et capable de porter des types de donnees 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 decimaux precis, contrairement au JSON brut.

Execute un ensemble d'operations d'ecriture (insert, update, delete) en un seul appel reseau. Supporte les modes ordonne et non-ordonne pour optimiser les performances.

Envoyer un colis contenant plusieurs courriers au lieu de poster chaque lettre separement.

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

Cas d'usage : Executer des migrations complexes melangeant insertions, mises a jour et suppressions en une seule operation atomique.

Regroupement de documents dans MongoDB, equivalent d'une table en SQL. Les collections n'imposent pas de schema par defaut, chaque document peut avoir une structure differente.

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

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

Cas d'usage : Organiser les documents par domaine metier : users, orders, products.

Index cree sur plusieurs champs. L'ordre des champs est crucial : il suit la regle 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 requetes qui filtrent et trient sur plusieurs champs simultanement.

Pointeur iterable vers les resultats d'une requete. Le curseur ne charge pas tous les documents en memoire mais les recupere 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 resultats sans saturer la memoire de l'application.

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

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

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

Cas d'usage : Isoler les donnees de differentes applications ou environnements sur un meme 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 donnees obsoletes comme des logs ou des sessions expirees.

Supprime le premier document correspondant au filtre. Retourne deletedCount indiquant si un document a ete 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 precis comme un compte utilisateur apres demande RGPD.

Strategie de design qui duplique volontairement des donnees entre documents pour eviter les jointures couteuses. Optimise la lecture au prix de la complexite en ecriture.

Ecrire le nom du client directement sur chaque facture au lieu de ne mettre qu'un numero client.

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

Cas d'usage : Quand les lectures sont beaucoup plus frequentes que les ecritures et que les donnees dupliquees changent rarement.

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

Une fiche client dans un classeur : chaque fiche peut avoir des champs differents, contrairement aux lignes figees d'un tableur.

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

Cas d'usage : Stocker des donnees semi-structurees ou le schema peut varier d'un enregistrement a l'autre.

Choix de design fondamental en MongoDB : embarquer les donnees liees dans le meme document (denormalisation) ou stocker une reference (ObjectId) vers un autre document (normalisation).

Coller la photo dans le passeport (embedding) ou noter un numero 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.

Methode qui retourne le plan d'execution d'une requete, montrant quels index sont utilises, le nombre de documents scannes et le temps d'execution.

Le GPS qui te montre l'itineraire prevu 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 requetes lentes et verifier que les index sont correctement utilises.

Chiffrement cote client de champs individuels avant envoi au serveur. Le serveur ne voit jamais les donnees en clair, meme un admin DB ne peut pas les lire.

Envoyer une lettre dans une enveloppe scellee : 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 : Proteger les donnees sensibles (PII, donnees medicales) meme en cas de compromission du serveur.

Methode 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 criteres, 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 : Recuperer une liste filtree de documents pour un affichage pagine ou un export.

Methode qui retourne le premier document correspondant au filtre, ou null si aucun resultat. Plus efficace que find().limit(1) car elle ne cree pas de curseur.

Demander au bibliothecaire de te trouver UN livre precis au lieu de parcourir tout le rayon.

const user = await db.collection('users')
  .findOne({ email: 'alice@mail.com' });

Cas d'usage : Recuperer un document unique par son identifiant ou un champ unique comme l'email.

Index 2dsphere ou 2d pour les requetes geographiques. Permet de chercher des points proches, dans un polygone ou dans un rayon donne.

Un GPS integre a ta base de donnees : '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.

Methode qui insere plusieurs documents en une seule operation. Par defaut, l'insertion est ordonnee et s'arrete a la premiere erreur.

Deposer 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 donnees en masse ou inserer des logs par batch pour reduire les allers-retours reseau.

Methode qui insere un seul document dans une collection. Retourne un objet contenant l'insertedId du document cree.

Deposer 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 : Creer un nouvel enregistrement unique comme un utilisateur apres inscription.

limit(n) restreint le nombre de documents retournes. skip(n) saute les n premiers resultats. 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 : Implementer la pagination dans une API REST ou une interface utilisateur.

Service cloud manage de MongoDB qui gere automatiquement le deploiement, le scaling, les backups et la securite. Disponible sur AWS, Azure et GCP.

Un hotel pour ta base de donnees : tu arrives, ta chambre est prete, le menage et la securite sont inclus.

// Connection string Atlas
mongoose.connect(
  'mongodb+srv://user:pass@cluster.mongodb.net/mydb'
);

Cas d'usage : Deployer une base MongoDB en production sans gerer l'infrastructure serveur.

Interface graphique officielle de MongoDB pour explorer les donnees, construire des requetes visuellement et analyser les performances via les plans d'execution.

L'equivalent 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 requetes sans ecrire de code.

Routeur de requetes dans une architecture shardee. Il recoit les requetes des clients et les redirige vers le(s) shard(s) concerne(s) en consultant les config servers.

Le standard telephonique d'une grande entreprise : il redirige chaque appel vers le bon departement.

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

Cas d'usage : Point d'entree 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 donnees, 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'atomicite sur plusieurs documents et collections. Introduite en MongoDB 4.0 pour les replica sets et 4.2 pour les clusters shardes.

Un virement bancaire : le debit ET le credit doivent reussir 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 : Operations financieres ou tout scenario ou plusieurs documents doivent etre modifies de facon atomique.

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

Un numero de serie sur un produit : unique au monde, et en le lisant tu peux deviner quand et ou il a ete fabrique.

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

Cas d'usage : Identifier de maniere unique chaque document sans compteur central, ideal pour les systemes distribues.

Operations Log, collection cappee speciale qui enregistre chronologiquement toutes les operations de modification. Les secondaries la repliquent pour rester synchronises avec le primary.

Un journal de bord du capitaine : chaque manoeuvre est notee pour que l'equipage suivant puisse reproduire le trajet.

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

Cas d'usage : Implementer des Change Streams, debugger la replication ou faire du point-in-time recovery.

Mecanisme pour selectionner les champs a inclure ou exclure dans les resultats d'une requete. Reduit la quantite de donnees transferees 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 recuperant que les champs necessaires a l'affichage.

Operateurs prefixes par $ utilises dans les filtres de requete : $eq, $gt, $lt, $gte, $lte, $in, $nin, $regex, $exists, $and, $or, $not. Ils permettent des requetes complexes sans SQL.

Les symboles mathematiques de tes requetes : au lieu de dire 'superieur a 18', tu ecris $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.

Determine vers quel membre du replica set les lectures sont dirigees : 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, reduisant la charge sur le primary.

Remplace entierement un document par un nouveau, en conservant le meme _id. Contrairement a updateOne, ne prend pas d'operateurs mais un document complet.

Jeter l'ancienne fiche et en ecrire une toute nouvelle avec le meme numero de dossier.

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

Cas d'usage : Quand un document est entierement recalcule et doit etre remplace en bloc.

Groupe de processus mongod qui maintiennent le meme jeu de donnees. Compose d'un Primary (ecritures) et de Secondaries (copies). Offre la haute disponibilite et le failover automatique.

Un groupe de musiciens jouant la meme 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 disponibilite en production avec failover automatique en cas de panne serveur.

Ensemble de patterns eprouves pour modeler les donnees en MongoDB : Bucket (regrouper par intervalles), Outlier (gerer les documents anormalement gros), Computed (pre-calculer), Subset (charger un sous-ensemble).

Des recettes de cuisine pour architecte de donnees : chaque pattern resout un probleme recurrent.

// 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 schemas MongoDB pour des cas d'usage specifiques comme l'IoT, les reseaux sociaux ou le e-commerce.

Regles de validation JSON Schema appliquees au niveau de la collection pour garantir la structure et les types des documents inseres. Peut etre 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 qualite des donnees sans ORM, directement au niveau de la base.

Champ (ou index compose) utilise pour distribuer les documents entre les shards. Le choix de la shard key est irreversible et determine la repartition et les performances du cluster.

Le critere de tri pour repartir les eleves entre les classes : par age, par nom, par niveau.

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

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

Hashed sharding distribue les documents uniformement via un hash de la shard key (bon pour l'ecriture). Range sharding les repartit par plages de valeurs (bon pour les requetes par intervalle).

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 ecritures haute frequence. Range pour les requetes temporelles ou par intervalles.

Index cree sur un seul champ d'une collection. Accelere les requetes qui filtrent ou trient sur ce champ. MongoDB cree automatiquement un index sur _id.

L'index alphabetique 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 requetes frequentes sur un champ comme email, username ou createdAt.

Methode de curseur qui trie les resultats selon un ou plusieurs champs. 1 pour ascendant, -1 pour descendant.

Demander au bibliothecaire de ranger les livres par date de publication avant de te les presenter.

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

Cas d'usage : Afficher les resultats dans un ordre precis comme les articles les plus recents 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 telephone, pas ceux sans numero.

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

Cas d'usage : Creer un index unique sur un champ optionnel comme le numero de telephone.

Index special 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 : Implementer une barre de recherche sur un blog ou un catalogue de produits.

Index Time-To-Live qui supprime automatiquement les documents apres un delai defini. Fonctionne sur un champ de type Date et est verifie par un processus d'arriere-plan toutes les 60 secondes.

Un yaourt avec une date de peremption : passe le delai, il est automatiquement jete du frigo.

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

Cas d'usage : Gerer l'expiration automatique des sessions, tokens temporaires ou logs ephemeres.

Index qui garantit l'unicite des valeurs d'un champ dans la collection. Toute tentative d'insertion d'un doublon leve une erreur E11000.

Un registre d'etat civil ou chaque numero de securite 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 employes d'un departement 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 donnees ou une correction en masse sur un sous-ensemble de documents.

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

Corriger une seule faute sur une fiche sans reecrire toute la fiche.

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

Cas d'usage : Modifier un champ precis 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 schemas flexibles.

Un detective qui met sous surveillance tout le batiment 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 definit combien de noeuds doivent confirmer une ecriture (w:1, w:majority). Read Concern definit le niveau d'isolation des lectures (local, majority, snapshot).

Write concern = combien de temoins 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 donnees selon la criticite de l'operation.