chapitre6:

-Dans ce premier exemple, essayant de calculer la population de chaque Etat en utilisant la

fonction aggregate, le mot clé $group pour regrouper sur les Etats, le mot clé $sum pour sommer
les éléments de population.

>db.zips.aggregate({$group:{_id:"$state",population:{$sum:"$pop"}}})

Détaillons ces éléments:

$group indique un regroupement. La clé de regroupement est indiquée par id.

Dans notre cas, nous lui passons le code de l’Etat $state(le $ précise qu’il faut reprendre le
champ state de notre collection zip.

$sum: ” $pop “ indique que l’on va additionner les populations de chaque code postal.

-En effet, MongoDB propose plusieurs opérateurs d’agrégation : ($min, $max, $first, $last, $push,
$addToSet, $stdDevPop, $stdDevSamp).

-Nous aimerions calculer la population de chaque ville puis trier les villes par ordre décroissant
de leur population. C’est possible grâce au mot clé $sort.
>db.zips.aggregate({$group:{_id:"$city",population:{$sum:"$pop"}}},{$sort:{population:-1}}) La
-fonction aggregate prend en deuxième argument le tri des données qui sont traités
séquentiellement. On parle ici d’étape ou de stage dans le traitement d’agrégation.

-Rajoutons maintenant un filtre pour ne conserver que les villes de Californie. On pourrait le
placer n’importe où dans notre chaîne de traitement. Néanmoins, le plus efficace est de le placer
en début de chaîne pour limiter les calculs ultérieurs. Cela se fait avec le mot clé $match.
>db.zips.aggregate({$match:{state:"CA"}},{$group:{_id:"$city",population:{$sum:"$po
p"}}},{$sort:{population:-1}})

-Si nous voulons maintenant agir sur les code postaux. La commande suivante permet ainsi de
compter le nombre de codes postaux par état.
>db.zips.aggregate({$group:{_id:"$state",nb_zip:{$sum:1}}},{$sort:{nb_zip:-1}})

-Si nous voulons maintenant agir sur les code postaux. La commande suivante permet ainsi de
compter le nombre de codes postaux par état (dans un approche équivalent d’un count en SQL).
>db.zips.aggregate({$group:{_id:"$state",nb_zip:{$sum:1}}},{$sort:{nb_zip:-1}})

le pipeline d’agrégation:
-Nous allons simplement faire un premier regroupement par Etat et ville (pour éviter de regrouper
des villes situées dans des états différents mais portant le même nom) puis comptabiliser
ensuite le nombre de villes par état. La première étape consiste donc à opérer un regroupement
sur 2 champs.

>db.zips.aggregate({$group:{_id:{state:"$state",city:"$city"}}})

Puis, on regroupe maintenant les villes par Etat. Le champ « état » s’appelle maintenant _id.state.
>db.zips.aggregate({$group:{_id:{state:"$state",city:"$city"}}},{$group:{_id:"$_id.
state",nb_villes:{$sum:1}}})
-Nous souhaitions afficher les états ayant le plus de villes à plus de 100 000 habitants.
Explications :

Nous allons alors intercaler dans notre traitement un filtre sur le nombre d’habitants et rajouter à
la fin un tri par ordre décroissant. Bien sûr, il ne faut pas oublier dans la première étape de
calculer la population de chaque ville puisque nous allons en avoir besoin dans notre filtre à
l’étape 2.

> db.zips.aggregate({$group:{_id:{state:"$state",city:"$city"},population:{$sum:"$pop
"}}},{$match:{population:{$gt:100000}}},{$group:{_id:"$_id.state",nb_villes:{$sum:1
}}},{$sort:{nb_villes:-1}})

-Encore d’autres possibilités Nous avons donc vu les types d’étape suivants :

• $group: groupement des données

• $match: filtre des données

• $sort: tri des données MongoDB propose de nombreux autres types

. Citons par exemple, sans que cette liste soit exhaustive :

• $project: pour sélectionner les champs que l’on souhaite conserver dans le résultat

• $limit: pour limiter les résultats

• $skip: pour sauter n résultats

• $unwind: pour opérer une transposition sur un champ contenant un tableau

• $out: pour enregistrer le résultat dans une nouvelle collection

La documentation précise que les étapes d’agrégation ne doivent pas consommer plus de 100
Mo en mémoire sous peine de générer une erreur.

Cette limitation pouvant être rapidement contraignante, on peut l’outrepasser en passant le

paramètre allowDiskUse à true.

Le passage de paramètre se fait en fin de commande après les stages. Pour différencier les
stages des paramètres, il faut veiller à mettre les stages dans un tableau.

>db.zips.aggregate([{$group:{_id:{state:"$state",city:"$city"},population:{$sum:"$p
op"}}},{$match:{"_id.state":"CA"}},{$sort:{population:-1}}],{allowDiskUse:true})

chapitre7:

Pour créer un index dans une collection « ma_collection » :

>db.ma_collection.createIndex({<clé>:1})

La clé est le nom du champ sur lequel vous voulez créer l’index et 1 est pour l’ordre croissant.
Pour créer un index dans l’ordre décroissant, vous devez utiliser -1. Nous pouvons créer un index
sur de multiple clées :
>db.ma_collection.createIndex({<clé1>:1,<clé2> :-1})

Cette méthode accepte quelques options qui permet de modifier son comportement :
>db.ma_collection.createIndex({<clé>:1},{<option>:valeurs})

Pour récupérer les informations sur tout les index d’une collection
>db.ma_collection.getIndexes()

Pour supprimer un index nous utilisons la méthode :

>db.ma_collection.dropIndex({<clé>:1})

Pour supprimer plusieurs index nous utilisant la méthode :

>db.ma_collection.dropIndexes({<clé1>:1,<clé2> :-1})

chapitre 8:

-Importation
Comme nous avons déjà vu, MongoDB possède une méthode externe qui permet d’importer des
données dans une collection à partir d’un fichier JSON. La syntaxe de cette méthode est la
suivante : >

mongoimport --db nom_base --collection nom_collection --drop --type --host --file

C:\dossier\fichier.json

-db : le nom de la base ou les données vont être importées.

--collection : le nom de la collection ou les données vont être importées.

--drop : option qui permet de supprimer la collection (si elle existe) du même nom que la
collection importée avant l’importation.

--collection : le nom de la collection ou les données vont être importées

--type : le type de document d’importation (csv , json), par défaut : json.

--host : préciser l’adresse de host et le port de la base de données importées.

--file : le chemin du fichier à importer (faites la différence entre chemin windows Vs unix).

--fields : liste de champs séparées par virgules des noms de champs à importer à partir du
fichier csv/json

--headerline : dans le cas d’importation de fichier csv, permet d’utiliser la premier ligne comme
noms pour les champs de la collection.

-Exportation de données :
Inversement, il existe une autre méthode qui permet d’exporter les données en d’autres formats
d’exportation ou de migration tels que .JSON et .CSV La syntaxe de cette méthode est la
suivante :
>mongoexport --db code_post --collection=zip --out=expoZIP.json

Modes d’exportation de données :

En effet, il y’a deux mode d’exportation en fichier JSON :

• Mode relaxe : Un format de chaîne qui met l'accent sur la lisibilité et l'interopérabilité au
détriment de la préservation du type. Autrement dit, la conversion du format détendu en BSON
peut perdre des informations sur le type des champs.

• Mode canonique : Un format de chaîne qui met l'accent sur la préservation du type au détriment
de la lisibilité et de l'interopérabilité. Autrement dit, la conversion canonique en BSON conservera
généralement les informations sur le type sauf dans certains cas spécifiques. Par défaut c’est le
mode relaxe qui est actif.

Si nous voulons avoir une format canonique du document json :

>mongoexport --db code_post --collection=zip --jsonFormat=canonical --

out=expoZIP.json

Si nous voulons exporter des champs spécifique d’une collection --fields:

>mongoexport --db code_post --collection=zip –fields "_id,city,state" -- out=expoZIP,json

-Sauvegarde
MongoDB fournit un outil appelé mongodump.exe pour sauvegarder votre base de données
MongoDB.

En appelant mongodump --help, vous obtiendrez une liste assez grande des options qui peuvent
être utilisées.

L'exemple le plus basique serait de sauvegarder une base de données dans un dossier
spécifique, ce qui peut être réalisé comme suit:

>mongodump -h localhost --db mon_bd --out c:\sauvegarde

En Ajoutant l’option --gzip, la sauvegarde est auto compressée :

>mongodump -h localhost --db mon_bd --gzip --out c:\sauvegarde

Vous pouvez aussi générer le nom du dossier de sauvegarde en tenant compte de la date de la
sauvegarde:

>mongodump -h localhost --db mon_bd --gzip --out “c:\sauvegarde_$(date%F_%r)

Un argument important pour mongodump est -- db , qui spécifie le nom de la base de données
que vous souhaitez sauvegarder. Si vous ne spécifiez pas de nom de base de données,
mongodump sauvegarde toutes vos bases de données. Le second argument important est -- out
qui spécifie le répertoire dans lequel les données seront sauvegardées. Prenons un exemple avec
la sauvegarde de la base de données mon_bd et son stockage dans le répertoire c:\sauvegarde.
Exemple :

>mongodump -h localhost --db code_post -o c:\sauvegarde

Restauration

Exemple : Nous restaurons la base sauvegardée précédemment dans une base

de nom : code_post2

>mongorestore --db code_post2 C:\sauvegarde\code_post

Si la base de données sauvegardée contient plusieurs collection, et nous voulons

extraire une collection particulière, nous utilisant l’option
--nsInclude="base.collection"

Exemple :

>mongorestore --db code_post3 --nsInclude="code_post.zip"

C:\sauvegarde\code_post

chapite 9

● La réplication : C’est le processus de synchronisation des données sous format de

copies identiques sur plusieurs serveurs, afin d’assurer la redondance et la disponibilité
des données. La réplication protège une base de données contre la perte causée par
l’utilisation d’un seul serveur et permet de récupérer après une panne ou une interruption
de service.
● Le Replica Set : C’est un ensemble de processus mongod qui hébergent le même
ensemble de données. Le premier mongod, le mongod primaire, reçoit toutes les
opérations de lecture et écriture. Les autres instances mongod, les répliques
secondaires, appliquent les instructions reçues par le membre primaire. En cas
d’indisponibilité du membre primaire, le replica set élit un des membres secondaires pour
le remplacer.
● L’arbitrage : C’est un mécanisme qui permet de déterminer la majorité du vote lors d’une
élection dans un replica set. Un arbitre est une instance mongod qui n’a aucun pouvoir
sur l’ensemble des données, mais qui peut voter en cas d’élection requise. Un arbitre est
nécessaire si le nombre de membres secondaires est pair.

chapitre 11

Voici les syntaxes existantes dans ce document avec leur utilité :

● $lookup : permet d’effectuer une jointure entre deux collections dans une opération
d’agrégation.
● from : spécifie la collection à joindre avec la collection de départ.
● localField : spécifie le champ dans les documents de la collection de départ qui
correspond au champ foreignField dans la collection à joindre.
● foreignField : spécifie le champ dans les documents de la collection à joindre qui
correspond au champ localField dans la collection de départ.
● as : spécifie le nom du tableau qui sera ajouté aux documents du jeu de résultat,
contenant les documents correspondants de la collection à joindre.

exemple

$lookup:

from: "inventory",

localField: "item",

foreignField: "sku",

as: "inventory_docs"

chapitre 12:

● db.createUser(): Cette commande permet de créer un utilisateur avec des rôles et des
privilèges spécifiés dans une base de données donnée.

db.createUser(

user: "<name>",

pwd: passwordPrompt(), // or "<cleartext password>"

roles: [ { role: "<role>", db: "<database>" } ]

● passwordPrompt(): Cette méthode permet de saisir le mot de passe de l’utilisateur sans

le révéler à l’écran.

passwordPrompt()
● db.adminCommand(): Cette commande permet d’exécuter des commandes
administratives sur le serveur MongoDB, comme la commande shutdown pour arrêter
l’instance mongod.

db.adminCommand( { shutdown: 1 } )

● db.auth(): Cette méthode permet de s’authentifier auprès d’une base de données en

utilisant un nom d’utilisateur et un mot de passe.

db.auth("<username>", "<password>")

● db.grantRolesToUser(): Cette commande permet d’ajouter des rôles supplémentaires à

un utilisateur existant.

db.grantRolesToUser(

"<username>",

{ role: "<role>", db: "<database>" }

● db.revokeRolesFromUser(): Cette commande permet de supprimer des rôles d’un

utilisateur existant.

db.revokeRolesFromUser(

"<username>",

{ role: "<role>", db: "<database>" }

● db.runCommand(): Cette commande permet d’exécuter une commande arbitraire sur le

serveur MongoDB, comme la commande dropUser pour supprimer un utilisateur.

db.runCommand( { dropUser: "<username>" } )

● db.dropUser(): Cette commande permet de supprimer un utilisateur de la base de

données sur laquelle elle est exécutée.

db.dropUser("<username>")