Module 1Exploiter les fonctionnalités des bases de données NoSQL MongoDB
Chapitre 4 sur 7
Les requêtes CRUD, la sélection, la restriction et la projection, distinct, count et limit, les opérateurs, l'agrégation avec $match, $group et $sort, et le tri.
Objectifs
Avec ce chapitre, tu sauras…
distinct(), count(), limit() ;$exists, et l'agrégation ($match, $group, $sort) ;sort().CRUD est l'abréviation de Create (créer), Read (lire), Update (modifier), Delete (supprimer) : les quatre opérations de base sur les données. Tous les exemples utilisent la collection Stagiaires de la base Examples (le script est au début du cours, dans « Comment utiliser ce cours »).
Leçon 1
Insérer des documents
L'insertion se fait avec la méthode insert, à qui on donne le ou les documents à insérer :
db.le_nom_de_la_collection.insert({"cle1" :"valeur1","cle2" :"valeur2"})db.Stagiaires.insert ({"prenom":"Amina", "filiere":"Dev Digital ", "niveau":"1A" })On peut aussi utiliser la méthode insertOne :
db.le_nom_de_la_collection.insertOne({"cle1" :"valeur1","cle2" :"valeur2"})db.Stagiaires.insertOne ({"prenom":"Amina", "filiere":"Dev Digital ", "niveau":"1A" })Pour insérer plusieurs documents d'un coup, on donne un tableau à insertMany (c'est ce que fait le script des 4 stagiaires) :
db.Stagiaires.insertMany([ { "prenom": "Kamal" }, { "prenom": "Sanaa" } ])Supprimer des documents
db.le_nom_de_la_collection.drop()db.le_nom_de_la_collection.deleteOne({"cle1" :"valeur1"})
db.Filieres.deleteOne ({"_id":"DD" })db.le_nom_de_la_collection.deleteMany({"cle1" :"valeur1"})
db.Filieres.deleteMany ({"intitule":"Développement Digital" })La réponse indique combien de documents ont été supprimés : { acknowledged: true, deletedCount: 1 }.
Remplacer un document
MongoDB fournit la fonction update, avec différents opérateurs selon le type de mise à jour voulu. Elle prend deux arguments obligatoires :
Si plusieurs documents vérifient la condition, seul le premier est modifié.
Sans opérateur, le second document remplace entièrement le document trouvé :
db.Filieres.update(
{"_id":"ID", "intitule":"Infrastructure digitale"},
{"_id":"ID", "intitule":"Infrastructure digitale", "nbOptions":3} )Pour modifier plusieurs documents à la fois, on ajoute {multi: true} en fin de requête :
db.Filieres.update(
{"_id":"ID", "intitule":"Infrastructure digitale"},
{"_id":"ID", "intitule":"Infrastructure digitale", "nbOptions":3} ,
{multi: true}
)Mettre à jour des documents
Si on veut garder les autres champs et ne changer que certains, on met la mise à jour dans un $set :
db.Filieres.update(
{"intitule" : "Developpement digital"},
{$set: {"organisme": "OFPPT"}},
{multi: true}
)Toutes les filières « Developpement digital » reçoivent le champ organisme, et gardent leurs autres champs. Si le champ existe déjà, $set change sa valeur ; sinon, il l'ajoute.
Vidéo · À regarder
FRBase de données : MongoDB - Manipulation des données
Algomius · YouTube
Leçon 2
| Requête | Résultat |
|---|---|
db.le_nom_de_la_collection.findOne() | le premier document de la collection |
db.le_nom_de_la_collection.find() | tous les documents de la collection |
| Requête | Résultat |
|---|---|
db.le_nom_de_la_collection.find({"champ1":"val1","champ2":"val2"}) |
Leçon 3
| Opérateur | Signification | En SQL |
|---|---|---|
$eq | Equal : égal | = |
$gt | Greater Than : plus grand que | > |
$gte | Greater Than or Equal : plus grand ou égal | >= |
$lt |
Leçon 4
Vidéo · À regarder
FRBase de données : MongoDB - Objets, tableaux et curseurs
Algomius · YouTube
1Pour insérer plusieurs documents d'un coup, on utilise…
2db.Stagiaires.find({"niveau":"2A"}) équivaut en SQL à…
3Dans find({}, {"nom":1, "_id":0}), le second document est…
4Pour viser l'intitulé de la filière imbriquée, on écrit…
5$gte signifie…
6Pour garder les autres champs lors d'une mise à jour, on utilise…
7$nor renvoie les documents qui…
8Dans un $group, pour compter les documents de chaque groupe, on écrit…
9sort({"moy1A": -1}) trie par moyenne…
10La méthode actuelle qui remplace find().count() est…
L'essentiel du chapitre
insertOne({…}), insertMany([{…}, {…}]) (insert est déprécié).deleteOne(cond), deleteMany(cond), drop() pour la collection.updateOne / updateMany(cond, { $set: {…} }) garde les autres champs ; replaceOne(cond, doc) remplace tout ; update(…, {multi: true}) ne marche qu'avec des opérateurs.find(condition, projection) et findOne ; projection {"champ": 1, "_id": 0} ; sous-champ "filiere.intitule" ; distinct("champ"), countDocuments(cond), limit(n), skip(n), sort({"champ": 1 ou -1}).$eq $gt $gte $lt $lte $ne, $in $nin, $and $or $nor (tableau de conditions), $exists.aggregate([ {$match: …}, {$group: {_id: "$champ", x: {$sum|$avg|$min|$max: "$champ"}}}, {$sort: {x: 1}} ]) ; {$sum: 1} compte.champ1 vaut val1 et champ2 vaut val2db.le_nom_de_la_collection.findOne({"champ1":"val1","champ2":"val2"}) | le premier de ces documents |
| Requête | Résultat |
|---|---|
db.nom_de_la_collection.find({},{"champ1":1,"champ2":1}) | les champs champ1 et champ2 de tous les documents |
db.nom_de_la_collection.findOne({},{"champ1":1,"champ2":1}) | les champs champ1 et champ2 du premier document |
Vidéo · À regarder
FRBase de données : MongoDB - Manipulation des données
Algomius · YouTube
Vidéo · À regarder
FRBase de données : MongoDB - Manipulation des données
Algomius · YouTube
Vidéo · À regarder
FRBase de données : MongoDB - Objets, tableaux et curseurs
Algomius · YouTube
Vidéo · À regarder
FRBase de données : MongoDB - Objets, tableaux et curseurs
Algomius · YouTube
Vidéo · À regarder
FRBase de données : MongoDB - Objets, tableaux et curseurs
Algomius · YouTube
< |
$lte | Less Than or Equal : plus petit ou égal | <= |
$ne | Not Equal : différent | <> |
| Opérateur | Signification | En SQL |
|---|---|---|
$in | appartient à la liste | IN (…) |
$nin | n'appartient pas à la liste | NOT IN (…) |
| Opérateur | Signification |
|---|---|
$and | ET logique |
$or | OU logique |
$nor | NON (OU logique) : aucune des conditions n'est vraie |
| Opérateur | Signification |
|---|---|
$exists | teste la présence (true) ou l'absence (false) d'un champ |
Vidéo · À regarder
FRBase de données : MongoDB - Manipulation des données
Algomius · YouTube
Vidéo · À regarder
FRBase de données : MongoDB - Agréations et vues
Algomius · YouTube
Ce que tu vas voir (6 min) : le chapitre « Insertion, modification et suppression des données ». Le formateur insère des documents, les modifie avec un opérateur de mise à jour, puis les supprime : les opérations CRUD de cette section.
La sélection
MongoDB propose deux requêtes simples, find et findOne :
db.Stagiaires.findOne(){ "_id" : ObjectId("62e01de8dc15f0d3b0bc282c"),
"nom" : "Alami",
"prenom" : "Amina",
"filiere" : { "_id" : "DD", "intitule" : "Developpement digital" },
"moy1A" : 14.5,
"niveau" : "2A",
"option" : "Mobile" }db.Stagiaires.find() affiche les quatre stagiaires : Amina, Nidal, Salim et Karima.
"Full Stack" (avec un espace), alors que tous les résultats affichent "FullStack". Le script de ce cours utilise "FullStack" pour que les exemples donnent les mêmes résultats."prenom" / "prénom" et "Developpement" / "Développement". Pour MongoDB, ce sont des valeurs différentes : une recherche sur "Développement digital" ne trouve pas "Developpement digital". Le cours écrit partout "prenom" et "Developpement digital", comme dans le script.La restriction
La restriction sélectionne les documents qui vérifient une condition. La condition est un document JSON avec les critères de sélection, qu'on passe en paramètre à find ou findOne.
Les opérateurs commencent par $. Ils se placent dans la condition, comme valeur du champ : { "champ": { "$operateur": valeur } }.
Tableau: Les opérateurs de comparaison
La fonction sort
find avec la fonction sort().db.Stagiaires.find({},{"nom":1,"prenom":1,"_id":0}).sort({"nom":-1}){ "nom" : "Ennaim", "prenom" : "Nidal" }
{ "nom" : "Dalil", "prenom" : "Karima" }
{ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Alami", "prenom" : "Salim" }Les deux Alami sont ex æquo sur le nom : leur ordre entre eux n'est pas garanti. On ajoute un second champ de tri pour les départager :
db.Stagiaires.find({},{"nom":1,"prenom":1,"_id":0}).sort({"nom":-1,"prenom":-1}){ "nom" : "Ennaim", "prenom" : "Nidal" }
{ "nom" : "Dalil", "prenom" : "Karima" }
{ "nom" : "Alami", "prenom" : "Salim" }
{ "nom" : "Alami", "prenom" : "Amina" }db.Stagiaires.find({},{"nom":1,"prenom":1,"_id":0}).sort(){ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Ennaim", "prenom" : "Nidal" }
{ "nom" : "Alami", "prenom" : "Salim" }
{ "nom" : "Dalil", "prenom" : "Karima" }Dans mongosh, appeler sort() sans argument n'a pas d'intérêt : écris simplement find() sans sort. Et pense à l'ordre des méthodes : MongoDB applique toujours le tri, puis skip, puis limit, quel que soit l'ordre où tu les écris. find().sort({"moy1A": -1}).limit(1) donne donc bien le major (Nidal).
Ce que tu vas voir (3 min) : le chapitre « Tri d'un curseur ». Il trie un curseur avec sort(), en ordre croissant (1) et décroissant (-1).
Sur la base eshop_db (chapitres 2 et 3) :
pu × qtstock pour chaque id_cat (indice : {$multiply: ["$pu", "$qtstock"]}).$mul).Sur la collection Stagiaires, écris les requêtes, puis donne le résultat attendu :
_id.{ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Ennaim", "prenom" : "Nidal" }
{ "nom" : "Alami", "prenom" : "Salim" }
{ "nom" : "Dalil", "prenom" : "Karima" }db.Stagiaires.findOne({"nom":"Alami"})On obtient Amina seulement.
db.Stagiaires.find({"nom":"Alami"})On obtient Amina et Salim.
Le second exemple porte le même titre que le premier (« le premier stagiaire… ») : avec find, ce sont tous les stagiaires nommés Alami. Le résultat affiche aussi "option" : "Mobile" pour Salim : son option est FullStack.
find({ "nom": "Alami" }) est l'équivalent SQL de SELECT * FROM Stagiaires WHERE nom = 'Alami';. Plusieurs champs dans la condition, c'est un ET : { "nom": "Alami", "niveau": "2A" } = WHERE nom = 'Alami' AND niveau = '2A'.
La projection
La projection limite les champs renvoyés : on précise les champs voulus dans un document JSON, passé en second paramètre de find ou findOne.
Le premier paramètre {} est une condition vide : tous les documents.
db.Stagiaires.findOne({},{"nom":1,"prenom":1}){ "_id" : ObjectId("62e01de8dc15f0d3b0bc282c"), "nom" : "Alami", "prenom" : "Amina" }Remarques :
_id est toujours renvoyé ; pour l'exclure, on l'écrit avec la valeur 0.db.Stagiaires.findOne({},{"nom":1,"prenom":1,"_id":0}){ "nom" : "Alami", "prenom" : "Amina" }{ "nom" : "Alami", "prenom" : "Amina" }Le résumé écrit " _id":0, avec un espace avant _id. Ce n'est pas le même champ : mongosh répond par une erreur (FieldPath field names may not be empty strings). Il faut écrire "_id":0, sans espace.
db.Stagiaires.find({},{"nom":1,"prenom":1,"_id":0})db.Stagiaires.find({"nom": "Alami"},{"prenom":1,"option":1,"_id":0}){ "prenom" : "Amina", "option" : "Mobile" }
{ "prenom" : "Salim", "option" : "FullStack" }On peut écrire les deux documents JSON, la sélection et la projection, en dehors de la requête, dans des variables :
projection = {"prenom":1,"option":1,"_id":0}
selection = {"nom":"Alami"}
db.Stagiaires.find(selection,projection)Le résultat est le même. C'est plus lisible quand les conditions sont longues.
projection = {"nom":1,"prenom":1,"_id":0}
selection = {"option": "Mobile"}
db.Stagiaires.find(selection , projection)Le résumé appelle la variable sélection (avec un accent). JavaScript l'accepte, mais c'est une source d'erreurs de frappe : préfère selection, sans accent, comme dans les autres exemples.
Pour viser un sous-champ (un champ d'un objet imbriqué), on utilise la notation pointée : champ.souschamp, entre guillemets.
projection = {"nom":1,"prenom":1,"_id":0}
selection = {"filiere.intitule": "Developpement digital"}
db.Stagiaires.find(selection , projection){ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Alami", "prenom" : "Salim" }Ce que tu vas voir (13 min) : le chapitre « Filtrer les données ». Il filtre les documents avec find et une condition (la restriction), sur plusieurs exemples.
Ce que tu vas voir (4 min) : le chapitre « Filtrer les champs ». Il choisit les champs affichés avec le second paramètre de find : la projection, avec 1, 0 et le cas de _id.
Ce que tu vas voir (8 min) : les chapitres « Rechercher dans un objet », « Quelques exemples d'objets ». Il cherche dans un objet imbriqué avec la notation pointée ("filiere.intitule" dans ce cours), avec plusieurs exemples.
La fonction distinct()
distinct() liste les valeurs différentes prises par le champ passé en paramètre. Elle renvoie un tableau :
db.Stagiaires.distinct("option")[ "Cyber Security", "FullStack", "Mobile" ]On utilise la même notation champ.souschamp pour un sous-champ :
db.Stagiaires.distinct("filiere.intitule")[ "Developpement digital", "Digital Design", "Infrastructure digitale" ]Le résultat du résumé n'affiche que deux intitulés : il manque « Digital Design », la filière de Karima. Karima n'a pas d'option : elle n'apparaît donc pas dans le premier résultat, ce qui est normal.
La fonction count
count() compte les documents renvoyés par une sélection. Elle s'écrit à la suite d'un find :
db.Stagiaires.find().count() // 4 : le nombre total de stagiaires
db.Stagiaires.find({"niveau":"2A"}).count() // 3 : le nombre de stagiaires de 2e annéecursor.count() est déprécié (avertissement dans mongosh, et supprimé de PyMongo 4). On écrit db.Stagiaires.countDocuments({"niveau":"2A"}), qui donne aussi 3. Pour le total, countDocuments({}) ou estimatedDocumentCount() (plus rapide, approximatif).
La fonction limit
limit(n) limite le nombre de documents renvoyés par find ;find et renvoie les n premiers résultats ;limit() sans nombre (ou limit(0)) renvoie tous les documents.db.Stagiaires.find({},{"nom":1,"prenom":1,"_id":0}).limit(2){ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Ennaim", "prenom" : "Nidal" }{ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Ennaim", "prenom" : "Nidal" }{ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Ennaim", "prenom" : "Nidal" }skip(n) fait l'inverse : il saute les n premiers. find().skip(2).limit(2) donne la « page 2 » de 2 résultats (Salim et Karima).
Ce que tu vas voir (3 min) : le chapitre « Opération sur les curseurs ». Il présente les opérations sur les curseurs renvoyés par find, comme count.
Ce que tu vas voir (4 min) : le chapitre « Fonctions skip() et limit() ». Il utilise skip() et limit() pour sauter et limiter les résultats.
selection = {"moy1A":{"$gte":14.00}}
db.Stagiaires.find(selection,{"nom":1,"prenom":1,"_id":0})On peut combiner deux comparaisons sur le même champ : {"moy1A": {"$gte": 12, "$lt": 15}} (entre 12 inclus et 15 exclu) donne Amina et Salim.
Tableau: Les opérateurs de comparaison de listes
selection = {"option":{"$in":["FullStack","Cyber Security"]}}
db.Stagiaires.find(selection,{"nom":1,"prenom":1,"_id":0}){ "nom" : "Ennaim", "prenom" : "Nidal" }
{ "nom" : "Alami", "prenom" : "Salim" }Tableau: Les opérateurs logiques
Ils prennent un tableau de conditions.
selection = { "$or": [ { "moy1A" : { "$gte" : 15 } }, { "option": "Mobile" } ] }
db.Stagiaires.find(selection,{"nom":1,"prenom":1,"_id":0})Amina est trouvée par l'option Mobile, Nidal par sa moyenne de 17,25.
selection = { "$nor": [ { "moy1A" : { "$gte" : 15 } }, { "option": "Mobile" } ] }
db.Stagiaires.find(selection,{"nom":1,"prenom":1,"_id":0}){ "nom" : "Alami", "prenom" : "Salim" }
{ "nom" : "Dalil", "prenom" : "Karima" }Karima est trouvée alors qu'elle n'a ni moyenne ni option : un champ absent ne vérifie aucune des deux conditions.
Tableau: L'opérateur $exists
selection = { "option": {$exists : false }}
db.Stagiaires.find(selection,{"nom":1,"prenom":1,"_id":0}){ "nom" : "Dalil", "prenom" : "Karima" }selection = { "option": {$exists : true }}
db.Stagiaires.find(selection,{"nom":1,"prenom":1,"_id":0}){ "nom" : "Alami", "prenom" : "Amina" }
{ "nom" : "Ennaim", "prenom" : "Nidal" }
{ "nom" : "Alami", "prenom" : "Salim" }Le résumé écrit tantôt "$gte" (entre guillemets), tantôt $exists (sans guillemets). Dans le shell, les deux marchent. Dans un fichier JSON ou en Python (chapitre 5), les guillemets sont obligatoires : "$exists".
Ce que tu vas voir (15 min) : les chapitres « Les opérateurs de comparaison », « Les opérateurs logiques ». Il utilise les opérateurs de comparaison ($gt, $gte, $lt, $in…) puis les opérateurs logiques ($and, $or, $nor) dans des conditions.
L'agrégation
aggregate(), qui prend en paramètre un tableau d'opérations : le pipeline (« tuyau »).db.nom_de_la_collection.aggregate([operateur1, operateur2, ...])Le pipeline est une chaîne de montage : les documents de la collection entrent à gauche, chaque poste (étape) les filtre, les regroupe ou les trie, et le résultat sort à droite.
Les opérateurs d'agrégation : $match
$match filtre les documents : il réduit la quantité de documents fournis à l'étape suivante.db.nom_de_la_collection.aggregate([{$match: {selection}}])La selection s'écrit exactement comme la condition d'un find.
db.Stagiaires.aggregate([
{$match: {"filiere.intitule" : "Developpement digital" }}
])Le résultat contient les documents complets d'Amina et de Salim.
Les opérateurs d'agrégation : $group
$group fait des regroupements et des calculs sur chaque groupe : c'est le GROUP BY du SQL._id.$sum (somme), $avg (moyenne), $min (minimum), $max (maximum).db.nom_de_la_collection.aggregate([
{$group: {_id: "$champ_regroupement",
variable: { fonctionAggregation : "$champ" },
...}
}
])Dans un pipeline, "$champ" (avec un $ et entre guillemets) veut dire « la valeur du champ ». Sans le $, ce serait le texte « champ ».
La syntaxe du résumé écrit _id: $champ_regroupement et $champ sans guillemets, et dit que le champ de regroupement est indiqué par « id ». Il faut écrire _id: "$champ_regroupement" et "$champ" entre guillemets ; sinon le shell cherche une variable JavaScript qui n'existe pas.
db.Stagiaires.aggregate([
{$group: {_id: "$filiere.intitule", total : {$sum:"$moy1A"}}}
]){ "_id" : "Digital Design", "total" : NumberInt(0) }
{ "_id" : "Developpement digital", "total" : 27.25 }
{ "_id" : "Infrastructure digitale", "total" : 17.25 }27,25 = 14,5 (Amina) + 12,75 (Salim). Karima n'a pas de moy1A : $sum ignore les valeurs absentes et donne 0 pour Digital Design. Dans mongosh, ce zéro s'affiche simplement 0. L'ordre des groupes n'est pas garanti : utilise $sort pour le fixer.
db.Stagiaires.aggregate([
{$group: {_id: "$filiere.intitule", noteMax : {$max:"$moy1A"}}}
]){ "_id" : "Digital Design", "noteMax" : null }
{ "_id" : "Developpement digital", "noteMax" : 14.5 }
{ "_id" : "Infrastructure digitale", "noteMax" : 17.25 }{ "_id" : "Digital Design", "noteMax" : null }
{ "_id" : "Developpement digital", "noteMax" : 14.5 }
{ "_id" : "Infrastructure digitale", "noteMax" : 17.25 }Pour Digital Design, il n'y a aucune valeur : $max donne null.
Pour compter les documents de chaque groupe, on fait la somme de 1 par document : { $sum: 1 }.
db.Stagiaires.aggregate([
{$group: {_id: "$filiere.intitule", nb: {$sum: 1}, moyenne: {$avg: "$moy1A"}}}
])Developpement digital : 2 stagiaires, moyenne 13,625 ; Infrastructure digitale : 1, moyenne 17,25 ; Digital Design : 1, moyenne null.
Les opérateurs d'agrégation : $sort
$sort trie les documents de l'étape précédente : 1 pour l'ordre croissant, -1 pour l'ordre décroissant.
db.Stagiaires.aggregate([
{$group: {_id: "$filiere.intitule", noteMax : {$max:"$moy1A"}}},
{$sort: {noteMax:1}} // tri suivant l'ordre croissant des noteMax par filière
])null est plus petit que tous les nombres : il arrive en premier dans un tri croissant.
Le commentaire du code renvoie à « (voir slide 37) » : cela concerne la diapositive d'origine, il n'y a rien à voir de plus. Le tri sort est expliqué à la section 4.
D'autres étapes du pipeline sont très utilisées : $project (choisir ou calculer des champs), $limit, $count, $unwind (une sortie par élément d'un tableau) et $lookup (la « jointure », vue au chapitre 3).
Ce que tu vas voir (29 min) : les chapitres « Introduction aux agrégations », « Utilisation d'un pipeline », « Le GROUP BY de SQL », « Quelques exemples d'agrégation ». Le formateur introduit les agrégations, construit un pipeline d'étapes, refait l'équivalent du GROUP BY de SQL avec $group, puis montre d'autres exemples d'agrégation.
Toujours sur Stagiaires :
"organisme": "OFPPT" à tous les stagiaires.$inc).organisme de tous les stagiaires (opérateur $unset).db.Stagiaires.updateOne({"nom":"Dalil"}, {"niveau":"2A"}) est-il refusé dans mongosh, et que faudrait-il utiliser pour remplacer tout le document ?Écris un pipeline qui donne, pour chaque niveau (1A, 2A) : le nombre de stagiaires, la moyenne de 1re année et la meilleure moyenne, trié par niveau croissant. Puis un second pipeline qui ne garde d'abord que les stagiaires de la filière « Developpement digital », et calcule leur moyenne de 1re année.