Compte Rendu

des TPs
d’administration
de MongoDB

Realisee par : Abdelhak Falih

Encadre par : Pr.BELARABI Younes
Annee Universitaire : 2023/2024
 Contenu :

BUT DES TPS :

01

02 TP 1 :

TP 2 :
03

04 TP 3 :

05 TP 4 :

06 TP 5 :
Part I : BUT DES TPs

MongoDB est un système de gestion de base de données (SGBD) non relationnel

orienté document, offrant une approche souple et évolutive pour stocker et
manipuler des données. Il se caractérise par sa capacité à stocker des données sous
forme de documents JSON, offrant ainsi une flexibilité dans la structure des données.
MongoDB est également reconnu pour sa scalabilité horizontale, sa haute
disponibilité et sa rapidité, ce qui en fait un choix populaire pour une large gamme
d'applications, notamment dans les domaines du développement web, des
applications mobiles et de l'analyse de données.

Les cinq travaux pratiques (TP) ont pour objectif de permettre aux apprenants de
maîtriser la manipulation de MongoDB. Ces TP couvrent divers aspects de
l'utilisation de MongoDB, notamment la création et la gestion de bases de données
et de collections, l'insertion, la consultation, la mise à jour et la suppression de
données, ainsi que des concepts avancés tels que l'indexation, l'agrégation et la
configuration de la réplication pour garantir la fiabilité et la disponibilité des
données. En somme, ces TP offrent une immersion pratique dans le monde de
MongoDB, permettant aux apprenants de développer des compétences essentielles
pour travailler avec ce SGBD moderne et performant.
TP1 :
Ecrire les commandes MongoDB permettant de :
1. Créer une nouvelle base de données nommée info et vérifiez qu'elle est
sélectionnée.
use info;
db.getName(); // should return "info"
2. Afficher toutes les bases de données.
show dbs;
3. Créer une nouvelle collection nommée
produits. db.createCollection("produits");
4. Afficher les collections de la base de données info.
Show collections
5. Insérer le document suivant dans la collection produits
: db.produits.insertOne({
name: "Macbook Pro",
manufacturer: "Apple",
price: 16430.32,
options: {
"MI MAX Ecran LED 4K": 1,
"Long Life Battery": 1
}
});

6. Créer deux documents nommés successivement document1, document2

et db.produits.insertMany([
{
name: "Macbook Air",
manufacturer: "Apple",
price: 12579.73,
options: {
"Intel Core i7 • Disque dur SSD":
1, "Long Life Battery Intel Core i5":
1
}
},
{
name: "ThinkPad T490",
manufacturer: "Lenovo",
price: 10394.56,
options: {
"Disque dur SSD Ecran 360": 1
}
}
]);
7. Récupérer tous les produits de la collection
produits. db.produits.find({});
8. Récupérer le premier produit de la
collection. db.produits.findOne();
9. Trouver l'id du produit Thinkpad T490. ({ _id: 1})
db.produits.find({ manufacturer: "Lenovo" }).project({_id: 1});
10. Récupérer les produits dont le prix est supérieur à 12000
dhs. db.produits.find({ price: { $gt: 12000 } });
11. 11. Modifier le prix de produit de nom Macbook Air à 13400 dhs.
db.produits.updateOne({ name: "Macbook Air" }, { $set: { price: 13400
} });
12. Modifier le fabriquant de Apple à Apple Inc.
db.produits.updateMany({ manufacturer: "Apple" }, { $set: { manufacturer:
"Apple Inc." } });
13. Afficher les résultats des
modifications. Db.products.find()
14. Supprimer le produit dont le fabricant est Lenovo.
db.produits.deleteOne({ manufacturer: "Lenovo"
});
TP 2 :
1 - use entreprise
2 - db
3 - show dbs
4 - db.createCollection("employes")
db.createCollection("clients")
5 - show collections
6-
emp1 = { emp2 = { emp3 = {
"Infos_perso": { "nom": "Allaoui", "nom": "Bennis",
"nom": "Rochdi", "prénom": "Youssef", "prénom": "Adam",
"prénom": "Amine", "age": 28, "age": 36,
"age": 31, "salaire": 6000, "salaire": 16000,
"salaire": 12000, "poste": "technicien", "poste": "commercial",
"poste": "Manager", "competences": [ "competences": [
"diplomes": [ "Leadership", "stratégie
"Licence Info", "gestion d'équipe" commerciale",
"Master IA", ], "gestion d'équipe"
"Technicien", "adresse": { ],
"Ingénieur" "rue": "oulfa", "diplomes": [
] "ville": "casa" "Technicien",
} } "Ingénieur"
} } ]
}
db.employes.insertOne(e db.employes.insertOne(e db.employes.insertOne(e
mp1) mp2) mp3)
7-
client1 = { client2 = {
"nom": "Lebbar", "nom": "Benazouz",
"prenom": "Mohamed", "age": 43, "prenom": "Khadija", "age": 34,
"adresse": { "rue": "anfa", "adresse": {
"ville": "casa" "rue": "hay riad",
}, "ville": "rabat"
"articles_achetes": [ },
{ "articles_achetes": [
"nom": "Ordinateur portable", "quantite": 1,{
"prix_unitaire": 9000 "nom": "smartphone", "quantite": 2,
} "prix_unitaire": 2500
] }
} ]
}
db.clients.insertOne(client1) db.clients.insertOne(client2)

8. Récupérer tous les clients de la collection clients.

db.clients.find().pretty()
9. Trouver l'ID du client ayant pour nom "lebbar" et prénom "mohamed".
db.clients.find({ "nom": "Lebbar", "prenom": "Mohamed" }).pretty()
10. Récupérer les clients dont l'âge est supérieur à 40
ans. db.clients.find({ "age": { "$gt": 40 }
}).pretty()
11. Modifier l'adresse du client ayant pour nom "Benazouz" et prénom "Khadija", en
changeant la rue en "hay nahda".
db.clients.updateOne({"nom": "Benazouz","prenom": "Khadija"},{
"$set": {
"adresse": {
"rue": "hay nahda",
"ville": "rabat"
}
}
}
)
12. Modifier le salaire de l'employé ayant pour nom "bennis" à
18000. db.employes.updateOne(
{
"Infos_perso.nom": "Bennis",
"Infos_perso.prenom": "Adam"
},
{
"$set": {
"Infos_perso.salaire": 18000
}
}
)
13. Afficher les résultats des modifications.
db.clients.find().pretty()
db.employes.find().pretty()
14. Supprimer le client ayant pour nom "lebbar" et prénom
"mohamed". db.clients.deleteOne({
"nom": "Lebbar",
"prenom": "Mohamed"})
15. Modifier le poste de l'employé ayant pour nom "Rochdi" et prénom "Amine", en le
changeant pour "Chef de projet".
db.employes.updateOne(
{
"Infos_perso.nom": "Rochdi",
"Infos_perso.prenom": "Amine"
 },
{
"$set": {
"Infos_perso.poste": "Chef de projet"
}
}
)
16. Rechercher les clients ayant un salaire supérieur à 7000.
db.clients.find({
"articles_achetes": {
"$not": {
"$size": 0
},
"$elemMatch": {
"prix_unitaire": {
"$gt": 7000
}
}
}
}).pretty()
17. Supprimer l'adresse de tous les clients.
db.clients.updateMany({}, { $unset: { address: 1 } });
18. Insérer le champ "date_embauche" avec la date actuelle pour tous les employés.
db.employees.updateMany({}, { $currentDate: { date_embauche: { $type:
"timestamp" } } });
19. Supprimer la collection "employes" entière de la base de données.
db.employes.drop();
TP3 :

1 - use DBLP
2 - db.createCollection("publis")
3 - doc1={type:"Book",title:"Modern database system:the object
model,Interoperability,abd beyond.",year:1995,publisher:"ACM Press and
Addison- Wesley",authors:["Won Kim"],Source:"DBLP"}
4 - db.publis.insert(doc1) {NB : db.publis.save n’a pas travaille erreur : save n’est
pass une fonction}
5 - db.publis.find()
6 - mongoimport --host localhost:27017 --db DBLP --collection publis --jsonArray
-- type json --file "C:/Users/J.P.M/Desktop/dblp.json"
7 - db.publis.find({"type":{$eq:"Book"}})
8 - db.publis.find({"year":{$gte:"2011"}})
9 - db.publis.find({"year":{$gte:"2014"},"type":{$eq:"Book"}})
10 - db.publis.find({ "author.name": "Toru Ishida" })
11 - db.publis.distinct("publisher")
12 - db.publis.distinct("author.name")
13 - db.publis.find({ "author.name": "Toru Ishida" }).sort( { "title": 1, "pageStart": 1 } )
14 - db.publis.find({ "author.name": "Toru Ishida" }, { "title": 1, "pageStart": 1, _id: 0
}) 15 - db.publis.count({ "author.name": "Toru Ishida" })
16 - db.publis.count({ "year": { $gte: 2011 }, "type": { $exists: true } }, { "type": 1,
_id: 0 })
17 - db.publis.aggregate([{ $group: { _id: "$author.name", count: { $sum: 1 } } },
{ $sort: { count: 1 } }
])
TP4 :
1) Pour créer une nouvelle base de données nommée "Ecole" et la vérifier, vous
pouvez utiliser les requêtes MongoDB suivantes :

use Ecole
show collections

2) Pour créer les collections "etudiants" et "cours", vous pouvez utiliser les
requêtes MongoDB suivantes :

db.createCollection("etudiants")
db.createCollection("cours")

3) Pour vérifier les collections, vous pouvez utiliser la requête suivante : show

collections

4) Pour importer les données dans les collections correspondantes, vous pouvez
utiliser les commandes mongoimport suivantes :

mongoimport --db Ecole --collection etudiants --file etudiants.json

mongoimport --db Ecole --collection cours --file cours.json

5) Pour récupérer tous les étudiants de la collection "etudiants" et ceux inscrits

au cours "python", vous pouvez utiliser les requêtes MongoDB suivantes :

db.etudiants.find()
db.etudiants.find({ "cours": "python" })

6) Pour modifier la note de l'étudiant "Rachid Allaoui" à 18, vous pouvez

utiliser la requête MongoDB suivante :

db.etudiants.update({ "nom": "Rachid", "prenom": "Allaoui" }, { $set:

{ "note": 18 } })

7) Pour rechercher les étudiants dont la note est supérieure à 15, vous pouvez
utiliser la requête MongoDB suivante :

db.etudiants.find({ "note": { $gt: 15 } })

8) Pour afficher les noms et prénoms des étudiants triés par ordre
alphabétique, vous pouvez utiliser la requête MongoDB suivante :
 db.etudiants.find().sort( { "nom": 1, "prenom": 1 } )

9) Pour calculer la moyenne des notes des étudiants par département, vous pouvez
utiliser la requête MongoDB suivante :

db.etudiants.aggregate([
{ $group: { _id: "$departement", moyenne: { $avg: "$note" } } },
{ $sort: { moyenne: -1 } }
])

10) Pour afficher tous les cours et leurs enseignants, vous pouvez utiliser la
requête MongoDB suivante :

db.cours.find() db.cours.find().forEach(function(cours)
{ print(cours.nom + " - " + cours.enseignant)
})

11) Pour compter le nombre d'étudiants par département, vous pouvez utiliser la
requête MongoDB suivante :

db.etudiants.aggregate([
{ $group: { _id: "$departement", count: { $sum: 1 } } },
{ $sort: { count: -1 } }
])
TP 5 :

Exercice 1:
Ecrire le code Python qui permet de :
1. Se connecter à une base de données MongoDB locale appelée "ecole".
2. Insérer un nouveau document dans les collections "étudiants" et
"cours". Le document doit contenir les champs suivants :
• "nom", "age" et "ville", pour la collection "étudiants" ;
• "nom", "enseignant" et "salle", pour la collection "cours"
Nb : Remplissez-les avec des valeurs de votre choix.
3. Rechercher et afficher tous les étudiants dans la collection "étudiants".
4. Mettre à jour le champ "ville" du document où le champ "nom" est égal à "X".
Changez la valeur de "ville" pour "Rabat".
5. Supprimer un cours de votre choix où le champ "nom" est égal à "X" de la
collection
"cours".
Remarque : X : un nom de votre choix.

Le code :

import pymongo

# Connecter à la base de données MongoDB locale "ecole"

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["ecole"]

# Insérer un nouveau document dans la collection "étudiants"

db.etudiants.insert_one({
"nom": "X",
"age": 20,
"ville": "Casablanca"
})

# Insérer un nouveau document dans la collection "cours"

db.cours.insert_one({
"nom": "X",
"enseignant": "John Doe",
"salle": "123"
})

# Afficher tous les étudiants dans la collection "étudiants"

print(db.etudiants.find())
 # Mettre à jour le champ "ville" du document où le champ "nom" est "X"
db.etudiants.update_one({ "nom": "X" }, { "$set": { "ville": "Rabat" } })

# Supprimer un cours de la collection "cours" où le champ "nom" est "X"

db.cours.delete_one({ "nom": "X" })

Exercice 2 :
Ecrire un programme python qui demande à l'utilisateur d'insérer des données dans
une
collection et affiche toutes les données de cette collection.

Le code :
import pymongo

# Connecter à la base de données MongoDB locale "ecole"

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["ecole"]

# Demander à l'utilisateur d'entrer des données

donnees = input("Entrez les données à insérer : ")

# Insérer les données dans la collection "donnees"

db.donnees.insert_one({ "donnees": donnees })

# Afficher toutes les données dans la collection "donnees"

print(db.donnees.find())

Exercice 3 :
Écrire un programme Python qui demande à l'utilisateur récupère des données d'une
collection MongoDB et les trie en fonction de leur valeur dans un champ donné.

Le code :
import pymongo

# Connecter à la base de données MongoDB locale "ecole"

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["ecole"]

# Demander à l'utilisateur d'entrer le nom de la collection et le nom du champ

à trier
collection = input("Entrez le nom de la collection : ")
 champ = input("Entrez le nom du champ à trier : ")

# Trier les données dans la collection par le champ spécifié

print(db[collection].find().sort(champ))

Exercice 4 :
Écrire un programme Python qui demande à l'utilisateur de saisir le nom de la
collection et
le(s) champ(s) à mettre à jour pour une ou plusieurs entrées d’une collection
MongoDB.

Le code :
import pymongo

# Connecter à la base de données MongoDB locale "ecole"

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["ecole"]

# Demander à l'utilisateur d'entrer le nom de la collection et les champs à

mettre à jour
collection = input("Entrez le nom de la collection : ")
champs = input("Entrez les champs à mettre à jour (séparés par des virgules) :
").split(",")

# Mettre à jour les champs pour tous les documents dans la collection
for champ in champs:
db[collection].update_many({}, { "$set": { champ.strip(): "" } })

# Afficher toutes les données dans la collection

print(db[collection].find())

Exercice 5 :
Écrire un programme Python qui demande à l'utilisateur quelle fonction il souhaite
exécuter
sur une collection MongoDB (recherche, insertion, modification ou suppression)

Le code :
import pymongo

# Connect to the MongoDB database

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["ecole"]
 # Ask the user which collection to use
collection = input("Enter the name of the collection: ")

# Ask the user which action they want to perform

action = input("Enter the action you want to perform (search, insert, update,
delete): ")

# Perform the specified action

if action == "search":
# Ask the user for the search term
search_term = input("Enter the search term: ")
# Print the results of the search
print(db[collection].find({"$text": {"$search": search_term}}))

elif action == "insert":

# Ask the user for the data to insert
data = input("Enter the data to insert:
") # Insert the data into the collection
db[collection].insert_one({"data": data})
# Print the data that was inserted
print(db[collection].find_one({"data": data}))

elif action == "update":

# Ask the user for the field to update and the new value
field = input("Enter the field to update: ")
new_value = input("Enter the new value: ")
# Update the specified field for the document with the specified id
db[collection].update_one({"_id": 1}, {"$set": {field: new_value}})
# Print the updated document
print(db[collection].find_one({"_id": 1}))

elif action == "delete":

# Delete the document with the specified id
db[collection].delete_one({"_id": 1})
# Print a message confirming the deletion
print("Document with id 1 has been deleted")

else:
print("Invalid action")

Exercice 6 :
Un programme Python qui demande à l'utilisateur d'entrer des documents et les
enregistre
dans un fichier JSON, puis les importe dans une base de données MongoDB

Le code :
import json
import pymongo

# Connect to the MongoDB database

client = pymongo.MongoClient("mongodb://localhost:27017/")

# Specify the name of the database and collection

db_name = "ecole"
collection_name = "documents"
db = client[db_name]
collection = db[collection_name]

# Prompt the user to enter documents

num_docs = int(input("Enter the number of documents you want to enter: "))
docs = []
for i in range(num_docs):
doc = {}
keys = ["nom", "age", "ville"]
for key in keys:
value = input(f"Enter the value for {key}: ")
doc[key] = value
docs.append(doc)

# Save the documents to a JSON file

with open("documents.json", "w") as f:
json.dump(docs, f, indent=4)

# Import the documents from the JSON file into the MongoDB collection
with open("documents.json", "r") as f:
docs = json.load(f)
collection.insert_many(docs)

# Print all the documents in the collection

print("All documents in the collection:")
for doc in collection.find():
print(doc)