Module 2 : Operations CRUD

Create - Insertion

// Insérer un document
db.users.insertOne({
    nom: "Dupont",
    email: "dupont@test.com",
    age: 30,
    ville: "Paris"
})

// Insérer plusieurs documents
db.users.insertMany([
    { nom: "Martin", email: "martin@test.com", age: 25 },
    { nom: "Bernard", email: "bernard@test.com", age: 35 },
    { nom: "Petit", email: "petit@test.com", age: 28 }
])

// Resultat
{
    acknowledged: true,
    insertedId: ObjectId("...")
}

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

Read - Lecture

find() - Requêtes de base

// Tous les documents
db.users.find()

// Avec filtre d'égalité
db.users.find({ ville: "Paris" })

// Plusieurs critères (AND implicite)
db.users.find({ ville: "Paris", age: 30 })

// Premier document seulement
db.users.findOne({ email: "dupont@test.com" })

// Compter les documents
db.users.countDocuments({ ville: "Paris" })

Opérateurs de comparaison

// $eq - Egal (implicite)
db.users.find({ age: { $eq: 30 } })

// $ne - Différent
db.users.find({ ville: { $ne: "Paris" } })

// $gt, $gte - Supérieur, Supérieur ou égal
db.users.find({ age: { $gt: 25 } })
db.users.find({ age: { $gte: 25 } })

// $lt, $lte - Inférieur, Inférieur ou égal
db.users.find({ age: { $lt: 30 } })
db.users.find({ age: { $lte: 30 } })

// $in - Dans une liste
db.users.find({ ville: { $in: ["Paris", "Lyon", "Marseille"] } })

// $nin - Pas dans une liste
db.users.find({ ville: { $nin: ["Paris", "Lyon"] } })

// Combinaison
db.users.find({ age: { $gte: 25, $lte: 35 } })

Opérateurs logiques

// $and - ET (explicite)
db.users.find({
    $and: [
        { age: { $gte: 25 } },
        { ville: "Paris" }
    ]
})

// $or - OU
db.users.find({
    $or: [
        { ville: "Paris" },
        { ville: "Lyon" }
    ]
})

// $not - Négation
db.users.find({
    age: { $not: { $gt: 30 } }
})

// $nor - NI ... NI
db.users.find({
    $nor: [
        { ville: "Paris" },
        { age: { $lt: 25 } }
    ]
})

Opérateurs sur les champs

// $exists - Champ existe
db.users.find({ email: { $exists: true } })

// $type - Type de donnée
db.users.find({ age: { $type: "int" } })
db.users.find({ age: { $type: "number" } })

// $regex - Expression régulière
db.users.find({ email: { $regex: /@gmail\.com$/ } })
db.users.find({ nom: { $regex: /^Dup/i } })  // i = case insensitive

Opérateurs sur les tableaux

// Document exemple
{
    nom: "Dupont",
    competences: ["Python", "MongoDB", "Azure"],
    scores: [85, 90, 78]
}

// $all - Contient tous les éléments
db.users.find({ competences: { $all: ["Python", "MongoDB"] } })

// $elemMatch - Élément qui matche tous les critères
db.users.find({
    scores: { $elemMatch: { $gte: 80, $lt: 90 } }
})

// $size - Taille du tableau
db.users.find({ competences: { $size: 3 } })

// Accès par index
db.users.find({ "scores.0": { $gt: 80 } })  // Premier élément

Projection - Sélectionner les champs

// Inclure des champs (1)
db.users.find(
    { ville: "Paris" },
    { nom: 1, email: 1 }
)
// Résultat: { _id: ..., nom: "...", email: "..." }

// Exclure des champs (0)
db.users.find(
    { ville: "Paris" },
    { _id: 0, password: 0 }
)

// $slice - Limiter les éléments d'un tableau
db.users.find(
    {},
    { competences: { $slice: 2 } }  // Premiers 2 éléments
)

// $elemMatch en projection
db.users.find(
    {},
    { scores: { $elemMatch: { $gte: 90 } } }
)

Tri, limite, skip

// Trier (1 = ASC, -1 = DESC)
db.users.find().sort({ age: 1 })
db.users.find().sort({ age: -1, nom: 1 })

// Limiter le nombre de résultats
db.users.find().limit(10)

// Sauter des résultats (pagination)
db.users.find().skip(20).limit(10)

// Pagination complète
const page = 3
const pageSize = 10
db.users.find()
    .sort({ _id: 1 })
    .skip((page - 1) * pageSize)
    .limit(pageSize)

Update - Mise à jour

// updateOne - Met à jour un document
db.users.updateOne(
    { email: "dupont@test.com" },  // Filtre
    { $set: { age: 31, ville: "Lyon" } }  // Mise à jour
)

// updateMany - Met à jour plusieurs documents
db.users.updateMany(
    { ville: "Paris" },
    { $set: { pays: "France" } }
)

// replaceOne - Remplace le document entier
db.users.replaceOne(
    { email: "dupont@test.com" },
    { nom: "Dupont", email: "dupont@test.com", age: 32 }
)

Opérateurs de mise à jour

// $set - Définir des champs
db.users.updateOne(
    { _id: ObjectId("...") },
    { $set: { "adresse.ville": "Paris" } }
)

// $unset - Supprimer des champs
db.users.updateOne(
    { _id: ObjectId("...") },
    { $unset: { telephone: "" } }
)

// $inc - Incrémenter
db.users.updateOne(
    { _id: ObjectId("...") },
    { $inc: { age: 1, loginCount: 1 } }
)

// $mul - Multiplier
db.users.updateOne(
    { _id: ObjectId("...") },
    { $mul: { salaire: 1.1 } }  // +10%
)

// $min, $max - Mettre à jour si plus petit/grand
db.users.updateOne(
    { _id: ObjectId("...") },
    { $min: { minScore: 75 }, $max: { maxScore: 95 } }
)

// $rename - Renommer un champ
db.users.updateOne(
    { _id: ObjectId("...") },
    { $rename: { "nom": "lastName" } }
)

// $currentDate - Date actuelle
db.users.updateOne(
    { _id: ObjectId("...") },
    { $currentDate: { lastModified: true } }
)

Opérateurs sur les tableaux

// $push - Ajouter un élément
db.users.updateOne(
    { _id: ObjectId("...") },
    { $push: { competences: "Docker" } }
)

// $push avec $each - Ajouter plusieurs
db.users.updateOne(
    { _id: ObjectId("...") },
    { $push: { competences: { $each: ["K8s", "Terraform"] } } }
)

// $addToSet - Ajouter si n'existe pas
db.users.updateOne(
    { _id: ObjectId("...") },
    { $addToSet: { competences: "Python" } }  // Pas de doublon
)

// $pop - Retirer premier (-1) ou dernier (1) élément
db.users.updateOne(
    { _id: ObjectId("...") },
    { $pop: { competences: 1 } }  // Dernier élément
)

// $pull - Retirer des éléments spécifiques
db.users.updateOne(
    { _id: ObjectId("...") },
    { $pull: { competences: "Docker" } }
)

// $pullAll - Retirer plusieurs éléments
db.users.updateOne(
    { _id: ObjectId("...") },
    { $pullAll: { competences: ["Docker", "K8s"] } }
)

// $ - Opérateur positionnel (élément matché)
db.users.updateOne(
    { "scores.matiere": "math" },
    { $set: { "scores.$.note": 90 } }
)

Upsert

// Insère si n'existe pas, met à jour sinon
db.users.updateOne(
    { email: "nouveau@test.com" },
    { $set: { nom: "Nouveau", age: 25 } },
    { upsert: true }
)

// findOneAndUpdate - Retourne le document
db.users.findOneAndUpdate(
    { email: "dupont@test.com" },
    { $inc: { age: 1 } },
    { returnDocument: "after" }  // "before" ou "after"
)

Delete - Suppression

// Supprimer un document
db.users.deleteOne({ email: "dupont@test.com" })

// Supprimer plusieurs documents
db.users.deleteMany({ age: { $lt: 18 } })

// Supprimer tous les documents
db.users.deleteMany({})

// findOneAndDelete - Retourne le document supprimé
db.users.findOneAndDelete({ email: "dupont@test.com" })

// Supprimer une collection
db.users.drop()

Bulk Operations

// Opérations en lot
db.users.bulkWrite([
    {
        insertOne: {
            document: { nom: "Test1", age: 20 }
        }
    },
    {
        updateOne: {
            filter: { nom: "Test2" },
            update: { $set: { age: 25 } }
        }
    },
    {
        deleteOne: {
            filter: { nom: "Test3" }
        }
    }
], { ordered: false })  // ordered: false = continue meme si erreur