M.

AZZOUZ

Bases de Données Avancées

TD/TP : NoSQL- MongoDB

– USTHB Master 01 IL–

M. AZZOUZ
Dernière mis à jour :Mai 2020
1
 Exercice 01

a. Créer une nouvelle base de données nommée info

et vérifiez qu'elle est sélectionnée.
Syntaxe de création de base de données MongoDB
est la suivante: use DATABASE_NAME.
La clause use: Si la base de données n'existe pas le
SGBD va créer une base de données. Sinon le SGBD va
se connecter à la base de données spécifiée. D’où use
permet de créer et se connecter à une BD.
>use info
switched to db info
> db
info
Si vous voulez voir toutes les bases de données, vous
pouvez utiliser la commande show dbs.
 Exercice 01

La syntaxe de suppression d’une base de

données MongoDB est la suivante:
db.dropDatabase().
L’instruction permet la supprimer de la base
de données actuellement connectée. Le SGBD
connecte par défaut la base de données test.
Exemple:
> use mydb
switched to db mydb
> db.dropDatabase()
{ "ok" : 1 }
 Exercice 01

Dans MongoDB, comme nous le verrons par la

suite, nous utilisons un formalisme de type
db.collection.fonction() :
db représente la base de données choisie
grâce à la commande use (ce mot clé est non
modifiable).
collection représente la collection dans
laquelle nous allons effectuer l’opération, et
doit donc correspondre à une des collections
présentes dans la base.
fonction() détermine l’opération à effectuer
sur la collection.
 Exercice 01

b. Créer une nouvelle collection nommée produits et y

insérer le document suivant:
La syntaxe de création de la collection est
db.createCollection("CollectionName")
> db.createCollection("produit")
{ "ok" : 1 }
Pour afficher les collections d’une BD, on utilise : show
collections
Plusieurs fonctionnalités sont disponibles pour insérer
des documents: Insert, InsertOne et InsertMany.
Il est possible d'insérer directement le document ou le
définir puis l'insérer.
db.produit.insert({"nom": "Macbook Pro", "fabriquant":
"Apple", "prix": 11435.99, "options": ["Intel Core i5",
"Retina Display", "Long life battery"]})
 Exercice 01

c. et d. Ajout d’autres documents:

document1=({"nom" : "Macbook Air",
"fabriquant" : "Apple",
"prix" : 125794.73, "ultrabook" : true,
"options" : ["Intel Core i7", "SSD", "Long life
battery"]})
db.produit.insert(document1)
document2=({"nom" : "Thinkpad X230",
"fabriquant" : "Lenovo",
"prix" : 114358.74, "ultrabook": true,
options: ["Intel Core i5", "SSD", "Long life
battery"]})
db.produit.insert( document2)
 Exercice 01

e. Requêtes:
Récupérer tous les produits.
Pour visualiser tous les documents de la
collection on utilise la fonction find().
db.produit.find()

L’affichage rendu par find() est compact et

peu lisible directement. On peut ajouter la
fonction pretty() pour avoir une présentation
propre.
db.prouduit.find().pretty()
 Exercice 01

e. Requêtes:
La fonction find() sans paramètre, elle
renvoie l’ensemble des documents. Mais
celle-ci peut aussi prendre deux paramètres :
Les critères de sélection des documents
(condition)
Les choix d’items des documents à
afficher(projection)
Ces deux paramètres doivent être écrits sous
la forme d’objets JSON.
 Exercice 01

e. Requêtes:
Récupérer le premier produit.
db.produit.findOne()
ou bien db.produit.find()[0]

Une autre fonction très utile pour mieux

appréhender les données est de lister les
valeurs prises par les différents items de la
collection sans les doublons, grâce à distinct().
db.produit.distinct("fabriquant")
[ "Apple",
"Lenovo"]
 Exercice 01

e. Requêtes:
Trouver l’id du Thinkpad X230 et faire la requête pour
récupérer ce produit avec son id.
 db.produit.find(
{ "nom": "Thinkpad X230" }, Critères de sélection

{"_id":1}) Projection: les items à garder

Si l’on désire n’afficher que certains éléments, il est

possible d’ajouter un deuxième argument spécifiant les
items que l’on veut (avec 1) ou qu’on ne veut pas (avec
0).
- Résultat:{"_id":ObjectId("5ea74afa390a5ba392b3c7fd" )}
-db.produit.find(
{"_id": ObjectId("5ea74afa390a5ba392b3c7fd")})
 Exercice 01

e. Requêtes:
Récupérer les produits dont le prix est supérieur
à 13723 DA.
Pour les comparaisons, nous disposons des
opérateurs $eq(equal), $gt (greater than), $gte
(greater than or equal), $lt (less than), $lte (less
than or equal) et $ne (not equal).
-db.produit.find(
{"prix": {$gt: 13723}},
{"_id":0})
En plus de ces comparaisons simples, nous
disposons d’opérateurs de comparaisons à une
liste : $in (présent dans la liste) et $nin (non
présent dans la liste).
 Exercice 01

e. Requêtes:
Récupérer le premier produit ayant le champ
ultrabook à true.
Pour limiter le nombre de documents renvoyés
par la fonction find() en lui ajoutant la fonction
limit(), comme ici où nous nous restreignons au
premier résultat.
-db.produit.find(
{"ultrabook" : true},
{"nom":1, "_id":0}
).limit(1)
 Exercice 01

e. Requêtes:
Une autre opération classique est le tri des
résultats, réalisable avec la fonction sort(). On
doit indiquer les items de tri et leur attribuer
une valeur de 1 pour un tri ascendant et une
valeur de -1 pour un tri descendant. On affiche
ici les produits dans l’ordre croissant de leur
prix.
db.produit.find().sort({ "prix" : 1 })
Idem que précédemment, mais dans l’ordre
décroissant
db.produit.find().sort({ "prix" : -1 })
 Exercice 01

e. Requêtes:
Utilisation des expressions régulières
Récupérer le premier produit dont le nom
contient Macbook.
db.produit.find({"nom": /Macbook/}).limit(1)
 Récupérer les produits dont le nom
commence par Macbook
db.produit.find({"nom":/^Macbook/},
{"_id":0, "nom":1, "prix":1}
).sort({ "nom" : 1 })
Récupérer les produits dont le nom se
termine par Macbook: db.produit.find({"nom":
/Macbook$/}).limit(1)
 Exercice 01

Mise à jour d’un document dans une collection

Dans cet exemple on modifié le prix de produit de
nom Macbook Air.
db.produit.updateOne({"nom" : "Macbook Air"},
{$set:{"prix" : 125795}}).
Mise à jour de plusieurs documents dans une
collection
Dans cet exemple on modifié le fabricant des
produit dont le nom commence par Macbook.
db.produit.updateMany({"nom":/^Macbook/},
{$set:{"fabriquant" : "Apple Entreprise"}})
 Exercice 01

Opération de mise à jour avec remplacement

d’un document dans une collection:
db.produit.replaceOne(
{"nom" : "Macbook Pro"},
{"nom" : "Macbook Pro",
"fabriquant" : "Apple",
"prix" : 11436,
"options" : [
"Intel Core i5",
"Retina Display",
"Long life battery"
]})
- Le document remplacé conserve le même
identifiant de l’objet _id.
 Exercice 01

e. Requêtes:
Supprimer les deux produits dont le fabricant est
Apple
-db.produit.remove({"fabriquant": "Apple"})
Supprimer le Thinkpad X230 en utilisant
uniquement son id
db.produit.find({"nom":"Thinkpad X230"},
{"_id":1, "nom":1})
Résultat:
{ "_id" : ObjectId("5ea74afa390a5ba392b3c7fd"),
"nom" : "Thinkpad X230"}
db.produit.remove({"_id":
ObjectId("5ea74afa390a5ba392b3c7fd")})
 Exercice 02

Vue d’ensemble sur la BD gym:

 Exercice 02

Collection gymnases:
 Exercice 02

Collection Sportifs:
 Exercice 02

a. Quels sont les sportifs (identifiant, nom et

prénom) qui ont un âge entre 20 et 30 ans ?
db.Sportifs.find(
{
"Age": { "$gte": 20, "$lte": 30 } La restriction
},
{
"_id": 0,
"IdSportif": 1,
"Nom": 1, La Projection
"Prenom": 1
}
)
 Exercice 02

b. Quels sont les gymnases de ville “Villetaneuse”

ou de “Sarcelles” qui ont une surface de plus de 400
m2 ?
db.Gymnases.find(
{"Ville":{"$in":["VILLETANEUSE", "SARCELLES"]},
"Surface": { "$gt": 400 }
},
{
"_id": 0,
"NomGymnase": 1,
"Ville": 1,
"Surface": 1
})
 Exercice 02

c. Quels sont les sportifs (identifiant et nom) qui

pratiquent du hand ball ?
db.Sportifs.find(
{
"Sports.Jouer": "Hand ball"
},
{ Pour spécifier un sous-item
"_id": 0, d’un item, il est nécessaire
d’utiliser le formalisme
"IdSportif": 1,
item.sousitem.
"Nom": 1
}
)
 Exercice 02

e. Dans quels gymnases et quels jours y a t-il des

séances de hand ball ?

-Chaque document gymnase peut

avoir un item Seances qui
correspond à un tableau des
Seances et chaque séance
correspond à un sport(item
Libelle), pour qu’on puisse faire la
requête il faut faire le découpage de
tableau Seances (rappelez vous de
l’opérateur table en SQL3).
- Pour faire la requête on utilise le
Framework d’agrégation
 Exercice 02

Framework d’agrégation: Depuis la version 2.2,

MongoDB propose un Framework d'agrégation.
Le frameworkd'agrégation comporte un ensemble large
d'opérateurs :
$project : redéfinition des documents (si nécessaire).
$match : restriction sur les documents à utiliser.
$group : regroupements et calculs à effectuer.
$sort : tri sur les agrégats.
$unwind : découpage de tableaux.
 Une requête d'agrégation est de la forme
db.collection.aggregate( [ { … }, { …}, ... ] ).
 Exercice 02

e. Dans quels gymnases et quels jours y a t-il des

séances de hand ball ?
db.Gymnases.aggregate([ $unwind : permet d’éclater le tableau en
{ $unwind : "$Seances" }, autant de documents que de séances.
{ $match: { "Seances.Libelle" : "Hand ball" }},
{ $group: {
"_id": { L'opérateur $group doit
"Nom": "$NomGymnase ", contenir obligatoirement
"Ville": "$Ville", une clé de groupement
"Jour": { $toLower: "$Seances.Jour"} (_id), puis une clé (nb) à
}, laquelle on associe la
"nb": { $sum: 1 } fonction d'agrégation ici
}}, ($sum)
{ $sort: {
"_id.Ville": 1,
"_id.Nom": 1,
"nb": -1
}}
])
 Exercice 02

f. Quels sportifs (identifiant et nom) ne pratiquent

aucun sport ?

db.Sportifs.find(
Si l’on cherche à tester
{
la présence ou non
"Sports" : { "$exists" : false }
d’un item, on utilise
}, l’opérateur $exists
{ (avec true si on teste la
"_id": 0, présence, et false
"Nom": 1 l’absence).
}
)
 Exercice 02

g. Quels gymnases n’ont pas de séances le

dimanche ?

db.Gymnases.find(
{"Seances.Jour": { "$nin" : [ "dimanche", "Dimanche" ]}
},
{ "_id": 0,
"NomGymnase": 1,
"Ville": 1,
"Seances.Jour": 1
}
)
 Exercice 02
h. Quels gymnases ne proposent que des séances de
basket ball ou de volley ball ?
il existe des opérateurs logiques : $and, $or et $nor. Ces
trois opérations prennent un tableau de critères comme
valeur.
db.Gymnases.find(
{
"$nor": [
{ "Seances.Libelle": { "$ne": "Basket ball" }},
{ "Seances.Libelle": { "$ne": "Volley ball" }} ]
},
{ $nor effectue une opération logique NOR
"_id": 0, sur un tableau d'une ou plusieurs
"NomGymnase": 1, expressions de requête et sélectionne les
"Ville": 1, documents qui échouent à toutes les
"Seances.Libelle": 1 expressions de requête du tableau.
})
 Exercice 02

i. Quels sont les entraîneurs qui sont aussi joueurs ?

db.Sportifs.find(
{
"Sports.Jouer" : { "$exists" : true },
"Sports.Entrainer" : { "$exists" : true }
},
{
"_id": 0,
"Nom": 1
}
)
 Exercice 02

j. Quels sont les sportifs qui sont des conseillers ?

db.Sportifs.find(
{"IdSportif":{"$in":
db.Sportifs.distinct("IdSportifConseiller")}
},
Pour récupérer la liste
{
de tous les conseillers
"_id": 0,
"Nom": 1
}
)
 Exercice 02

k. Pour le sportif “Kervadec” quel est le nom de son

conseiller ? rechercher id de
db.Sportifs.find( conseiller de
{ sportif de nom
Kervadec
"IdSportif":db.Sportifs.findOne(
{"Nom": "KERVADEC" }).IdSportifConseiller
},
{
"_id": 0,
"Sports": 0
}
)
 Exercice 02

l. Quels entraîneurs entraînent du hand ball et du

basket ball ?
db.Sportifs.find(
{ "Sports.Entrainer": "Hand ball",
"Sports.Entrainer": "Basket ball" },
{ "_id": 0,
"Nom": 1,
"Sports.Entrainer": 1 }
)

db.Sportifs.find(
{$and: [
{ "Sports.Entrainer": "Hand ball" },
{ "Sports.Entrainer": "Basket ball" }
]
},
{ "_id": 0,
"Nom": 1,
"Sports.Entrainer": 1
}
)
 Exercice 02
m. Quels sont les couples de sportifs (identifiant et
nom et prénom de chaque) de même age ?
Var sportifs1=db.Sportifs.find({},
{"_id":0, "IdSportif":1,"Nom":1,"Prenom":1,"Age":1 }
).toArray();
var sportifs2 =sportifs1;
for(var i = 0; i < sportifs1.length; i++){
for(var j = 0; j < sportifs2.length; j++)
{ if(sportifs1[i].IdSportif<sportifs2[j].IdSportif)
{ if(sportifs1[i].Age==sportifs2[j].Age)
{printjson('( '+sportifs1[i].IdSportif +’ '+ sportifs1[i].Nom+'
'+sportifs1[i].Prenom+ ' , '+ sportifs2[j].IdSportif + '
'+sportifs2[j].Nom+' '+sportifs2[j].Prenom+' )'); }}}}
 Exercice 02

n. Quelle est la moyenne d’âge des sportives qui

pratiquent du basket ball ?

db.Sportifs.aggregate([

{ $match: { "Sports.Jouer": "Basket ball", "Sexe": { $in: [

"f", "F" ]} }},

{ $group: { "_id": null, "AgeMoyen": { $avg: "$Age" }}}

])
 Exercice 02

o. Quels sont les sportifs les plus jeunes ?

On calcule l’âge min et on le stocke dans une
variable agemin. Le calcul de l’âge min se fait en
utilisant la fonction « aggregate ».
var agemin=db.Sportifs.aggregate(
[{$group: {_id: null, "agemin": {$min:"$Age"}}}]).next();
On cherche les sportifs avec Age = agemin.agemin.
db.Sportifs.find({"Age": agemin.agemin}, {"_id":0,
"Sports":0})
 Exercice 02

o. Quels sont les sportifs les plus jeunes ?

On peut faire la requête en une seule ligne

comme suit:
db.Sportifs.find({"Age":
db.Sportifs.aggregate([
{$group: {_id: null, "agemin":
{$min:"$Age"}}}]).next().agemin},
{"_id":0, "Sports":0}
)
 Exercice 02

q. Quels entraîneurs n’entraînent que du hand ball

ou du basket ball ?

On récupère la liste des sports entraînés.

var sports = db.Sportifs.distinct("Sports.Entrainer");

On fait un filtre pour supprimer le hand et le basket

en utilisant la fonction filter .

var autres = sports.filter(function(s) {

return (s != "Hand ball" & s != "Basket ball")
});
 Exercice 02

q. Quels entraîneurs n’entraînent que du hand ball ou

du basket ball ?
On cherche ceux qui entraîne l’un ou l’autre, mais pas
d’autres sports.
db.Sportifs.find(
{$and: [{ $or: [ { "Sports.Entrainer": "Hand ball" },
{ "Sports.Entrainer": "Basket ball" }
] },
{ "Sports.Entrainer" : { $nin : autres }}]
},
{"_id": 0,
"Nom": 1,
"Sports.Entrainer": 1
})
 Exercice 02

t. Pour chaque sportif donner le nombre de sports

qu’il arbitre

db.Sportifs.aggregate([

{ $match: { "Sports.Arbitrer": { $exists: true }}},

{ $unwind: "$Sports.Arbitrer"},

{ $group: { _id: "$Nom", "nbArbitrer": { $sum: 1 }}}

])
 Exercice 02

u. Pour chaque gymnase de Stains donner par jour

d’ouverture les horaires des premières et dernières
séances
db.Gymnases.aggregate([
{ $match: { "Ville": "STAINS" } },
{ $unwind: "$Seances" },
{$project: { "nom": "$NomGymnase", "jour":
{$toLower: "$Seances.Jour" }, "h": "$Seances.Horaire"}},
{ $group: { _id: { "nom": "$nom", "jour": "$jour" },
"debut": { $min: "$h"}, "fin": { $max: "$h" }}}
])
 Exercice 02
u. Pour chaque entraîneurs de hand ball quel est le nombre de
séances journalières qu’il assure ?
On récupère la liste des identifiants des entraîneurs de Hand.
var entraineursHand = db.Sportifs.find({ "Sports.Entrainer" :
"Hand ball" }, { _id: 0, IdSportif: 1 }).toArray().map(function(e) {
return e.IdSportif });
On les utilise pour faire la restriction (avec le $match) dans
l’agrégation.
db.Gymnases.aggregate([
{ $unwind: "$Seances" },
{ $match: { "Seances.IdSportifEntraineur": { $in: entraineursHand
}}},
{ $project : { "ent": "$Seances.IdSportifEntraineur",
"jour": { $toLower: "$Seances.Jour"}}},
{ $group: { _id: { "entraineur": "$ent", "jour": "$jour"},
nbSeances: { $sum: 1}}}
])
 Exercice 02

4. Le paradigme MapReduce en MongoDB

MapReduce est un des mécanismes les plus
complexes de requêtes de mongoDB.
Il se base sur la spécification des deux fonctions Map
et Reduce(écrites en javascript).
Ces deux fonctions sont des fonctions définies par
l'utilisateur.
En mongoDB, la fonction Map, permet de générer
des documents clés-valeurs pour les transmettre en
entrée à Reduce. La fonction ne prend aucun
paramètre, on accède à l’objet analysé via l’opérateur
this. La fonction peut émettre des couples via la
fonction emit(key, value) autant de fois que nécessaire
dans la fonction.
 Exercice 02

4. Le paradigme MapReduce en MongoDB

La fonction Reduce retourne le résultat agrégé à
partir de ces documents en entrée. La fonction
prendre deux paramètres key et values (tableau des
valeurs de la clé). Elle peut être appelée plusieurs fois
pour la même clé, elle doit donc renvoyer une valeur
de même type que celles dans le tableau.
On doit passer un troisième paramètre, un littéral
JSON, qui représente les options de la fonction. La
principale option (out) est la collection dans laquelle
le résultat sera placé. Si l’on veut voir le résultat, sans
le stocker, il est possible d’indiquer out: { inline: 1 }
 Exercice 02

a. Calculer le nombre de gymnases pour chaque ville

La fonction Map, crée un
var Map=function() { document avec comme clé la ville
et 1 comme valeur. Ce document
emit(this.Ville, 1); } est transmis à la fonction Reduce

La fonction Reduce, crée un

var Reduce=function(cle, nbgym) document clé/valeur avec
{return Array.sum(nbgym); } comme clé ville et nbgym qui
indique le nombre de
gymnases pour cette ville

db.Gymnases.mapReduce( Map, Reduce,

{ out: { inline: 1 }}) Exécution des fonctions Map
et Reduce, sur la collection des
gymnases et affichage des
résultats
 Exercice 02

a. Calculer le nombre de gymnases pour chaque

ville (résultats):
 Exercice 02

b. Calculer le nombre de séances pour chaque jour

de la semaine
var Map=function() {
if (this.Seances) {//il y a des gymnases qui ne proposent pas de
séances
for (s of this.Seances) // pour chaque item de Seances, émettre
ses jours
{ emit(s.Jour.toLowerCase(), 1);
} } };
var Reduce =function(jours, nbseances) {
return Array.sum(nbseances); };
db.Gymnases.mapReduce(Map, Reduce,
{ out: { inline: 1 }} )
 Exercice 02

d. Calculer la superficie moyenne des gymnases, pour chaque

ville. Pour cela, vous devez calculer la somme des superficie
ET le nombre de gymnase (à émettre dans un même objet et à
réduire en tenant compte que ce double aspect)

var Map=function() { var Reduce=function(ville, valeurs) {

emit(this.Ville, var nb = 0, surface = 0;
{ "nb": 1, for (val of valeurs) {
"surface": this.Surface nb += val.nb;
}); }; surface += val.surface; }
return { "nb": nb,
"surface": surface,
"surfMoy": Math.round( surface / nb)
} };

db.Gymnases.mapReduce(Map, Reduce, { out: { inline: 1 }})