MongoDB

(cid:1) Tutrice : Dr Abir KHALDI

Introduction

(cid:1) MongoDB est l'un des systèmes « NoSQL » les plus populaires:

(cid:2) Il fait partie des NoSQL dits « documentaires » (avec CouchDB);

(cid:2) Il s'appuie sur un modèle de données semi-structure (encodage JSON) ;

(cid:2) Il n’a pas de schéma (fléxibilité complète);

(cid:2) C’est un langage d'interrogation original (et spécifique) ;

(cid:2) Il n’a pas (ou très peu) de support transactionnel.

(cid:1) Construit des l'origine comme un système scalable et distribué:

(cid:2) Distribution par partitionnement (sharding) ;

(cid:2) Technique adoptée: découpage par intervalles (type BigTable, Google) ;

(cid:2) Tolérance aux pannes par réplication.

Outils MongoDB

(cid:1) MongoDB Compass: Interface graphique pour MongoDB permettant:

(cid:2) exploration visuelle des données

(cid:2) interaction avec les données avec la fonctionnalité CRUD complète

(cid:2) exécution des requêtes ad-hoc en quelques secondes

(cid:2) afficher et optimiser les performances de votre requête

(cid:1) MongoDB Atlas: Serveur de données MongoDB assurant le stockages des

données en cloud

(cid:1) Shell Mongo: Interface JavaScript interactive pour MongoDB permettant une

interrogation et mettre a jour des données, ainsi que les opérations

d'administration

Structure d’une BDD Mongo

(cid:1) Une bases de données est un ensemble de collections

(cid:2) Chaque collection regroupe un ensemble de documents

(cid:2) La base de données et ses collections définissent un « namespace »

(cid:2) Le schéma est le modèle de données des documents dans une collection

Qu’est ce qu’un document?

Un document est la représentation d'une donnée en BSON.

BSON = Binary JSON: Extension du JSON.

(cid:1) JSON: Java Script Object Notation.

(cid:1) JSON est un format fréquemment utilisé pour représenter les documents.

Document JSON

Un document JSON est compose d'un ensemble de champs délimite par des

accolades: { champs }

(cid:2) Un champ est un couple clé:valeur

(cid:2) Toutes les clés sont entourées de guillemets « »

(cid:2) Les clés et les valeurs sont séparés par 2 points :

(cid:2) Les différents champs sont sépares par une virgule ,

Document JSON

Les documents JSON peuvent contenir différents types de valeurs:

(cid:2) String: chaîne des caractères entourée de de double quotes. L'espace est considere

comme caractere.

(cid:2) Number: Réel a virgule flottante.

(cid:2) Boolean: true/false.

(cid:2) Null.

(cid:2) Object: sous-documents. Les documents peuvent être imbriques sur plusieurs

niveaux.

(cid:2) Array: tableau délimite par des crochets. Les tableaux contiennent des valeurs

ordonnées séparées par des virgules.

Exemple

{"nom": "Phoenix", "prenom" : "Joaquim", =>Des chaînes de caractères

"couleurs preferees" : ["vert", "marron"]}=> Un tableau

Sachant que la valeur d'une paire clé/valeur peut être un objet (document) et que le

tableau peut contenir des objets (des documents), on peut ordonner les

informations sur plusieurs niveaux. Exemple:

{"acteur": {

"nom": "Phoenix", "prenom" : "Joaquim" },

"roles" : [

{"personnage" : "Theodore", "Film" : "her" },

{"personnage" : "Leonard Kraditor",

]

" Film" : "Two Lovers"}

}

BSON

(cid:1) Les documents ne sont pas directement stockés dans la base de données en

JSON mais dans un format binaire appelé BSON.

(cid:1) BSON est une extension de JSON qui fournit des types de données

supplémentaires (tel que les dates) et des champs ordonnés. C'est un format

efficace pour le codage et décodage dans des langues différents.

(cid:1) Les fichiers BSON sont dans un format binaire, donc illisible par les utilisateurs.

Shell Mongo

(cid:1) La commande mongo lance l’interpréteur de commandes (Shell Mongo).

(cid:2) Pour lancer le Shell Mongo, ouvrez une invite de commande pour lancer

l'interpréteur de commandes mongo

(cid:2) Mongo vous permet de travailler en local

(cid:2) Pour vous connectez à un serveur de données Atlas, utilisez la commande: mongo

"mongodb+srv://sandbox.w4xyz.mongodb.net/myFirstDatabase" --username mii-

student

(cid:2) Vous serez connecte a votre serveur de base de données

Opérations CRUD

MongoDB facilite les opérations CRUD:

(cid:2) Create: Ajout de nouveaux documents;

(cid:2) Read: Recherche de documents selon des filtres. Correspond à la sélection et

projection de documents;

(cid:2) Update: Mise-à-jour de documents;

(cid:2) Delete: Suppression de documents.

Création avec le Shell

Shell Mongo: création implicite a l'insertion du premier document.

(cid:2) La création d'une base de données se fait implicitement lors de la création de sa

première collection.

(cid:2) La création d'une collection se fait implicitement avec l'insertion d'un premier

document.

(cid:2) Pour afficher toutes les bases de données: show dbs

(cid:2) Pour sélectionner la base de données a utiliser: use <nomBDD>

(cid:2) Pour lister les collections d'une base de données: show <collections>

(cid:2) Nommer la base de données en cours d'utilisation: db

Création avec le Shell

(cid:1) Il faut commencer par sélectionner la base de données dans laquelle vous voulez

modifier/interroger une collection:

use <nomBDD>

(cid:1) Si la base de données spécifiée <nomBDD> n'existe pas, elle sera réellement

crée a la première insertion de document.

Insertion d'un document avec le Shell Mongo:

db. <nom de la collection>.insertOne(<document>)

(cid:1) Si la collection n'existe pas, elle sera crée a l'insertion du premier document.

Exemple

Dans cet exemple nous allons travailler en local (mode Standalone):

1. Lancez le Shell Mongo avec la commande mongo

show dbs listera les bases de données existante

3. use test permettra de créer une première base de données nommée test

4. db.movieScratch.insertOne({"title":"Rocky","year":1976,"imdb":"tt0075148"})

Permettra de créer une collection « movieScratch » dans la base de données

test en insérant un premier document:

{

"title":"Rocky",

"year":1976,

"imdb":"tt0075148"

}

Exemple

(cid:1) Remarquez que la requête retourne un message de type:

{

"acknowledged" : true, => l’opération d'insertion a réussi

"insertedId" : ObjectId("5daee84199d97132d833f03b") =>L'identifiant unique du

document inséré

}

Verifiez que la base de données test et la collection movieScratch ont bien été crée.

ObjectId

(cid:1) Chaque document doit avoir un identifiant unique id dans la collection.

(cid:1) Si l'indentifiant id n'est pas fourni lors de l'insertion du document, MongoDB

ajoutera un de type ObjectId.

(cid:1) Il est possible d’insérer un document tout en fournissant une valeur d'identifiant.

Exemple:

db.movieScratch.insertOne( {id:"tt0075148"

,"title":"Rocky","year":1976,"imdb":"tt0075148"})

(cid:1) La collection movieScratch convient 2 documents avec les mêmes informations

mais leur id sont différents. Les identifiant id des 2 documents sont de types

différents: Chaîne de caratères (String) et ObjectID.

Insertion de plusieurs documents

(cid:1) Au lieu d’insérer un seul document passé en paramètre, un ensemble de

documents organisés dans un tableau peut être inséré en une seule instruction

comme suit:

db. <nom de la collection>.insertMany([{document1},

{document2}, . . . ] ,{"ordered":false})

(cid:1) Insertion ordonnée (par défaut): insére les documents dans l'ordre.

L'insertion s’arrête en cas d'erreur.

(cid:1) En cas d'erreur, tous les documents a partir de celui qui a généré cette erreur

ne sont pas insérés.

(cid:1) Insertion non ordonnée (spécifié par {"ordered":false}): l'insertion continue

même en cas d'erreur. Uniquement le document générant une erreur n'est pas

inséré.

Insérez les 2 documents suivants:

{"title":"Creed","year":2015,"imdb":"tt3076658"}

{

"title":"Star Trek II: The Worth of Khan",

"year":1982,

"imdb":"tt0084726"

}

Exemple

Filtrer les documents

Les filtres sur Compass:

(cid:2) Sélectionner la base de données et la collection sur laquelle le filtre sera applique

(cid:2) Le filtre s’écrit dans l'espace qui lui est réservé comme suit:

{" Champ " :valeur}

(cid:2) Les documents qui vérifie la condition d’égalité sont sélectionnés

(cid:2) Deux conditions peuvent être couplé en les séparant par une virgule ,

(cid:2) Uniquement le ou les documents vérifiant la ou les conditions seront sélectionnés.

Exemple

Les filtres suivants permettent de sélectionner des films de la collection

movieDetails de la base de données video:

(cid:1) {year:1968}: sélectionne les films produit en 1968

(cid:1) {year:1968,type:"movie"}: sélectionne les films de type « movie » produit en

1968

(cid:1) {year:1968,type:"movie",rated:"G"}: sélectionne les films de type « movie »

produit en 1968 et de classe « G »

Filtrer les documents

Pour appliquer un filtre sur une collection avec le Shell Mongo:

2. db. <collection>.find({Champ:"valeur"})

Sélectionner la base de données

Exemples:

1. use video

2. db.movieDetails.find({year:1968}): sélectionne les films produit en 1968.

({year:1968}): sélectionne les films produit en 1968.

3. db.movieDetails.find({year:1968,type:"movie"}): sélectionne les films de type

« movie » produit en 1968.

4. db.movieDetails.find({year:1968,type:"movie",rated:"G"} ): sélectionne les films

de type movie produit en 1968 et de classe « G ».

Filtrer les sous-documents

Pour appliquer un filtre sur un champ d'un sous-document, il faut utiliser la notation

orientée objet.

Avec le Shell Mongo:

db. <collection>.find({"Champ.<Champ sous document>":valeur})

Avec le Shell Mongo:

db.movieDetails.find({"imdb.rating":8.3})

db.movieDetails.find({imdb.rating":8.3,"awards.wins":0})

Exemple

Filtre sur les tableaux

Pour appliquer un filtre sur un champ admettant un tableau comme valeur, il faut

utiliser la notation suivante:

Avec le Shell Mongo:

db. <collection>.find({"Champ" :[valeur1,valeur2,. . . ]})

Remarque: Ce type de filtre cherche les documents dont la valeur du champ de type

tableau correspond exactement au tableau spécifié dans le filtre.

Exemple

Avec le Shell Mongo:

(cid:1) db.movieDetails.find({genres:["Western"]})

(cid:1) db.movieDetails.find({writers:["Paul Monash","Erich Maria Remarque"]})

Filtre sur les tableaux

Avec le Shell Mongo:

db. <collection>.find({<Champ> :{$all:[valeur1,valeur2,. . . ]}})

(cid:1) Filtre les documents dont l'attribut champ contient les valeurs [valeur1, valeur2,.

. . ] dans n'importe quel ordre.

(cid:1) L'essentiel est que au moins toutes les valeurs [valeur1, valeur2,. . . ] font partie

de la valeur du champ.

Exemple

Avec le Shell Mongo:

(cid:1) db.movieDetails.find({genres:{$all:["Western"]}})

(cid:1) db.movieDetails.find({writers:{$all:["Paul Monash","Erich Maria Remarque"]}})

Filtre sur les tableaux

Pour filtrer les documents ayant une valeur donnée à une position donnée d'un

champ de valeur tableau:

Avec le Shell Mongo:

db. <collection>.find({ "<Champ.position>" :valeur})

Avec le Shell Mongo:

(cid:1) db.movieDetails.find({"genres.0":"Western"})

(cid:1) db.movieDetails.find({"genres.0":"Western","countries.1":"USA »})

Exemple

Projection

(cid:1) Par défaut, MongoDB retourne tous les champs de tous les documents qui

correspondent au filtre.

(cid:1) Projection: limiter les champs retournés par une requête (un filtre).

(cid:1) La projection est le deuxième argument de la méthode find.

Syntaxe:

db. <collection>.find({. . . },{<champ1>:0, <champ2>:1, . . . })

(cid:2) Les champs à retenir sont suivi par :1 dans le second argument de find.

(cid:2) Les champs à exclure sont suivi par :0 dans le second argument de find.

(cid:2) Si au moins un seul champ est retenu, tous les autres champs sont retiré sauf le id. Il

faut retirer manuellement le id.

(cid:2) Si au moins un seul champ est retiré, tous les autres champs ont retenus.

Exemple

(cid:1) db.movieDetails.find({"imdb.rating":8.3},{imdb:1})

(cid:1) db.movieDetails.find( {"imdb.rating":8.3},{imdb:1, id:1})

(cid:1) db.movieDetails.find({"imdb.rating":8.3},{"imdb.votes":1, id:1})

(cid:1) db.movieDetails.find({imdb.rating":8.3,"awards.wins":0},{imdb:1})

(cid:1) db.movieDetails.find({imdb.rating":8.3,"awards.wins":0},{imdb:1,awards:1})

Opérateurs de comparaison

Ils permettent de trier les documents sur la base de la valeur d’un attribut

relativement a une valeur fixe

Syntaxe:

db. <collection>.find({Attribut:{$op:valeur}})

(cid:2) $op: specie la relation que doit verier la valeur d'un attribut par rapport a une autre

valeur. Des exemple de $op:

(cid:2) $gt : plus grand que

(cid:2) $lt : plus petit que

(cid:2) $gte : plus grand ou egal a

(cid:2) $lte: plus petit ou egal a

(cid:2) $ne:non egal

(cid:2) $in:inclus dans

(cid:2) $nin: n'est pas inclus dans

Exemple

(cid:1) db.movieDetails.find({runtime:{$gt:90}})

(cid:1) db.movieDetails.find({runtime:{$gt:90}}, {title:1, runtime:1,id:0})

(cid:1) db.movieDetails.find({runtime:{$gt:90,$lt:120}}, {title:1,runtime:1, id:0})

(cid:1) db.movieDetails.find({runtime:{$gte:180}," tomato.meter" :{$gte:95}}, {title:1,

runtime:1, id:0})

(cid:1) db.movieDetails.find({rated:{$ne:"UNRATED »}}, {rated:1,title:1, id:0})

(cid:1) db.movieDetails.find({rated:{$in:[" G" ," PG" ]}}, {rated:1, title:1,id:0})

(cid:1) db.movieDetails.find({rated:{$nin:[" G" ," PG" ]}}, {rated:1, title:1,id:0})

$exists

(cid:1) Les documents stockés dans une collection peuvent avoir différentes clés

(attributs).

(cid:1) Certaines clés peuvent exister dans certains documents et pas dans d'autres.

(cid:1) $exists permet de filtrer les documents contenant un attribut spécifique.

Exemple 1:

db.movieDetails.find({"tomato.consensus":{$exists:true}}, {" tomato.consensus":1,

title:1, id:0})

Exemple 2:

db.movieDetails.find({"tomato.consensus":{$exists:false}},{"tomato.consensus":1,

title:1, id:0})

Exemple 3:

db.movieDetails.find({"tomato.consensus":null},{"tomato.consensus":1, title:1, id:0})

(cid:1) Filtre les documents ayant un type de données particulier pour une clé donnée.

(cid:1) Particulièrement utile pour les attributs ayant différents type de valeurs.

$type

Exemple:

db.movieDetails.find({"tomato.consensus":{$type:"string"}},

{"tomato.consensus":1, title:1, id:0})

Opérateurs logiques

(cid:1) $or combine des conditions dont une seule sut pour sélectionner les

documents.

(cid:1) $or prend un tableau comme argument; les éléments du tableau sont les

conditions qu'il suffit de satisfaire au moins une d'entre elles pour que le

document soit séléctionné.

Exemple:

db.movieDetails.find({$or:[

{" tomato.meter":{$gt:95}},

{"metacritic" :{$gt:88}}

]},

{"tomato.meter":1,"metacritic":1,title:1, id:0})

Opérateurs logiques

(cid:1) $and spécifie des conditions que les documents doivent satisfaire simultanément

pour être sélectionnés.

(cid:1) Filtre les documents qui vérifient toutes les conditions spécifiées.

(cid:1) $and prend également un tableau comme argument.

Exemple:

db.movieDetails.find({$and:[{" tomato.meter":{$gt:95}},

{" metacritic" :{$gt:88}}]},

{"tomato.meter":1,"metacritic":1,title:1, id:0})

Equivalent à:

db.movieDetails.find({" tomato.meter" :{$gt:95},

" metacritic":{$gt:88}},

{"tomato.meter":1, "metacritic":1,title:1, id:0})

Question: Quelle est l'utilité de $and?

Opérateurs de tableaux

(cid:1) $all compare les valeurs d'un attribut de type tableau à un tableau d’éléments.

Exemple:

db.movieDetails.find({genres:{$all:[" Comedy" , "Crime" , "Drama"]}},

{genres:1,title:1, id:0})

(cid:1) Uniquement les documents contenant au moins « Comedy » , « Crime »

et « Drama » dans l’attribut « genres » sont filtres.

(cid:1) $size est utilise pour filtrer des documents sur la base de la taille d'un tableau

valeur d'un attribut.

Exemple:

(cid:1) db.movieDetails.find({countries:{$size:1}}).pretty()

Opérateur d’évaluation

MongoDB support un operateur de requête permettant d'utiliser une expression

régulière $regrex pour comparer des valeurs d'attributs a des chaînes de caractères.

Exemple:

db.movieDetails.find({" awards.text" :{"$regex:/^ Won.*/}}).pretty()

Mise-à-jour d’un document

Syntaxe:

db. <collection>.updateOne({. . . },{$set:{<champ>:<nouvelle valeur>}})

(cid:1) Le premier paramètre de updateOne est un filtre utilisé pour chercher le

document a modifier. Si beaucoup de documents correspondent aux critères du

filtre; uniquement le premier document est modifié.

(cid:1) Dans le deuxième paramètre; les champs à modifier sont spécifié avec leurs

nouvelles valeurs en utilisant l'operateur $set.

(cid:1) $set met à jour le document qui correspond au filtre de sorte que les nouvelles

paires clés-valeurs apparaissent dans la nouvelle version du document.

(cid:1) Si le champ spécifié à $set n'existe pas, le couple clé-valeur est ajouté au

document qui correspond au filtre.

Exemple

db. movieDetails.updateOne({title:"The Martian"},{$set:{poster:"

http://ia.media-imdb.com/images/M »}})

(cid:1) Le champ poster n'existait pas dans le document dont le titre est

"The Martian", ce couple de clé-valeur sera ajouté au document en question.

Opérateurs de MAJ

(cid:1) $set: remplace ou ajoute le champ spécifié.

(cid:1) $unset: supprime le champ spécifié du document.

(cid:1) $min: met a jour le champ si la valeur spécifié est plus petit que la valeur

existante.

(cid:1) $max: met a jour le champ si la valeur spécifié est plus grande que la valeur

existante.

(cid:1) $inc: incrémente la valeur du champ par la valeur specifié.

Il existe d'autres operateurs dans la documentation de MongoDB:

https://docs.mongodb.com/manual/reference/operator/update/

db.movieDetails.updateOne({title:"The Martian"},{$inc:{"

tomato.reviews" :3, "tomato.userReviews" :25}})

(cid:1) Le champ "tomato.reviews" est incrémenté de 3

(cid:1) Le champ "tomato.userRevews" est incrémente de 25

Exemple

Opérateurs de MAJ de tableaux

(cid:1) $addToSet: Ajoute un élément à un tableau uniquement si cet élément n'existe

pas déjà.

(cid:1) $pop: Supprime soit le premier ou le dernier élément du tableau en fonction du

paramètre de $pop.

(cid:1) $pullAll: Supprime tous les éléments d'un tableau qui vérifient une condition

spécifiée en paramètre.

(cid:1) $push: Ajoute un élément à un tableau.

(cid:1) $pushAll: Ajoute plusieurs éléments à un tableau.

Exemple 1

db.movieDetails.updateOne({title:"The Martian" },{$push:{"reviews" :{

rating:4.5,

date:ISODate(" 2016-01-12T09:00:00Z" ),

reviewer:" Spencer H."}}})

(cid:1) Le document de titre « The Martian » ne contient aucun champ nommé

« reviews ».

(cid:1) $push ajoute un nouveau champ nomme « reviews » au document dont le titre

« The Martian » .

(cid:1) Le champs « reviews » est initialisé à une valeur spécifiée.

=> $push crée un tableau s'il n'existe pas.

Exemple 2

db.movieDetails.updateOne({title:"The Martian" },{$push:{

"reviews" :{$each:[

{rating:4.5,

date:ISODate("2016-01-12T07:00:00Z" ),

reviewer:" Yabo A." g},

{rating:5,

date:ISODate(" 2016-01-12T09:00:00Z" ),

reviewer:" Kristina A."}

]}}})

(cid:1) Dans ce cas, $push ajoute chaque document au tableau valeur du champ

« reviews ».

(cid:1) Si $each n'est pas spécifie, tout le tableau sera inséré comme étant un seul

élément au tableau valeur du champ « reviews ».

updateMany

(cid:1) updateMany(): applique les mêmes modifications sur tous les documents qui

correspondent au filtre.

(cid:1) Exactement le même fonctionnement que la méthode updateOne(), sauf que les

modifications sont appliquées a tous les documents correspondants aux filtres

et non seulement le premier document.

Syntaxe

Syntaxe:

db. <collection>.updateMany({.. . },{$set/$unset/. . . :{champ:<nouvelle_valeur>}})

Exemple:

db.movieDetails.updateMany({rated:null},{$unset: {rated:" "}})

(cid:1) $unset: {rated:" "} : Supprime le champ « rated » des documents correspondants

au filtre. La valeur " " importe peu.

(cid:1) upsert: "update" +"replace"

(cid:1) upsert met à jour les documents correspondants aux filtres; si aucun document

ne correspond au filtre alors un nouveau document est inséré dans la collection.

Upsert

Syntaxe:

(cid:1) db. <collection>.updateMany({. . .

},{$set:{champ:<nouvelle_valeur>,{upsert:true})

Remplacer un document

(cid:1) replaceOne(): est une extension des opérations CRUD utilisée soit pour

appliquer un filtre, insérer ou mettre a jour des données.

Syntaxe:

db. <collection>.replaceOne(<filtre>,<document de remplacement>)

(cid:1) filtre: Spécifie le filtre utilisé pour sélectionner le document a remplacer

(cid:1) document de remplacement: Le document qui remplacera celui correspondant

au filtre

(cid:1) Si plusieurs documents correspondent au filtre, replaceOne remplacera

uniquement le premier document.

Suppression de documents

(cid:1) Supprimer un seul document:

Syntaxe:

db. <collection>.deleteOne(<filtre>)

(cid:2) Supprime le premier document correspondant au filtre.

Exemple:

db.movieDetails.deleteOne({id:ObjectId("5dad95d9ab4b2ccdd6abbbd6")})

(cid:1) Supprimer plusieurs documents:

Syntaxe:

db.<collection>.deleteMany(<filtre>)

(cid:2) Supprime tous les documents correspondants au filtre.

Exemple:

db.movieDetails.deleteMany ({"director":null)})

Syntaxe

(cid:1) Le pipeline d’agrégation a une structure simple et fiable et une syntaxe qui se

répète.

(cid:1) Les pipelines peuvent être composé de une ou plusieurs étapes.

Syntaxe:

db. <collection>.aggregate([{Etape1},{Etape2},. . . ,{EtapeN}],{options})

(cid:1) Chaque étape est un objet json de paires clé-valeur.

(cid:1) Nous pouvons avoir autant d’étapes que nous voulons (a part quelques

Chaque étape est un objet json de paires clé

exceptions).

Exemple

Utilisez la collection solarSystem pour tester la requête suivante:

mongoimport --db video --collection solarSystem --file solarSystem.json --jsonArray

db.solarSystem.aggregate([{

$match:{

meanTemperature:{$gte:-40,$lte:40g

}},{

project:{id:0,

$project:{id:0,

name:1,

hasMoons:{$gt:[\$numberOfMoons",0] }

}],

{allowDiskUse:true})

Opérateurs de base

$match :

(cid:1) doit être parmi les premières étapes du pipeline.

(cid:1) utilise les operateurs d'interrogation standard de MongoDB (les filtres).

(cid:1) filtre des documents selon un critère. $match peut être considéré comme un

filtre pour remplacer find. Le filtre est configuré dans l’étape $match et

uniquement les documents vérifiant les critères sont passés à la prochaine étape

du pipeline.

Exemple:

db.solarSystem.aggregate([{$match:{type:{$ne:"Star"}}}])

(cid:1) Equivalente à:

db.solarSystem.find({type:{$ne:"Star"}})

Opérateurs de base

$project:

(cid:1) est différente de la projection avec find; $project est beaucoup plus.

(cid:1) ne se limite pas à la rétention ou suppression de champs; il permet aussi de

réaffecter une valeur de champ existant ou dériver entièrement un nouveau

champ.

(cid:1) applique des transformations sur les collections Mongo.

Syntaxe:

db. <collection>.aggregate([{$project:{<Expression_d’agrégation

ou Expression_logique>}}])

Exemple:

db.solarSystem.aggregate([{$project:{id:0,name:1,"gravity.value"

:}}])

1. Avec $project, la valeur d'un champ existant peut être redirigée vers un autre

champ.

$project

Exemple:

db.solarSystem.aggregate([{$project:{

id:0,

name:1,

gravity:"$gravity.value"}}])

(cid:1) Au lieu de renvoyer un sous-document avec la valeur du champ "gravity.value",

cette valeur est directement affectée au champ "gravity".

(cid:1) Affecter la valeur du champ "gravity.value" ("$gravity.value" ) au champ gravity.

2. Avec $project, il est possible de créer un nouveau champ.

Exemple:

db.solarSystem.aggregate([{$project:{

id:0,

name:1,

gravity.value"}}])

surfaceGravity:"$gravity.value"}}])

surfaceGravity

(cid:1) surfaceGravity est nouveau champ qui vient d’être crée.

$project

(cid:1)

$project

$addFields

$addFields est très similaire a $project avec une différence clé.

(cid:1) Comme son nom l'indique, $addFields ajoute des champs a un document. Tandis

qu'avec $project, des champs sont supprimés et/ou conservés de manière

sélective.

(cid:1) $addFields permet uniquement de modifier les documents entrants au pipeline

en ajoutant de nouveaux champs calculés ou en modifiant des champs existants.

Exemple

Exemple:

(cid:1) db.solarSystem.aggregate([{$project:{surfaceGravity:"$gravity.value"}}])

(cid:1) db.solarSystem.aggregate([{$addFields:{surfaceGravity:"$gravity.value"}}])

db.solarSystem.aggregate([{$project:{

id:0,

name:1,

gravity:1

mass:1,

radius:1,

sma:1}},

{$addFields:{gravity:"$gravity.value",

mass:"$mass.value",

radius:"$radius.value",

sma:"$sma.value"}}

]).pretty()

y()

Combinaison $project et $addFields

db.solarSystem.aggregate([{$proje

ct:{

id:0,

name:1,

gravity:"$gravity.value",

mass:"$mass.value",

radius:"$radius.value",

sma:"$sma.value"}}]).prett

Les curseurs avec find

(cid:1) db.solarSystem.find({},{id:0,name:1,numberOfMoons:1}): retourne id, nom et

numberOfMoons de chaque document.

(cid:1) db.solarSystem.find({},{id:0,name:1,numberOfMoons:1}).skip(5).pretty(): saute

les 5 premiers documents et retourne les 4 derniers. Les documents sont

retournés selon leur ordre d'insertion dans la collection.

(cid:1) db.solarSystem.find({},{id:0,name:1,numberOfMoons:1}).limit(5) pretty()

(cid:1) db.solarSystem.find({},{id:0,name:1,numberOfMoons:1}).limit(5).pretty():

retourne les 5 premiers documents selon l'ordre naturel d'insertion.

(cid:1) db.solarSystem.find({},{id:0,name:1,numberOfMoons:1}).sort({numberOfMoons:-

1}).pretty(): au lieu de retourner les documents dans l'ordre d'insertion dans la

collection, les documents résultants sont triés par ordre décroissant du champ

numberOfMoons.

Les curseurs dans un pipeline

Syntaxe:

(cid:1) $limit:{<integer>}

(cid:1) $skip:{<integer>}

(cid:1) $count:{<nouveau champ contenant le nombre de documents>

(cid:1) $sort:{<champ_du_tri>:<integer: sens du tri (1,-1)>}

Exemples:

(cid:1) db.solarSystem.aggregate([{$project: {id:0,name:1,numberOfMoons:1}},{$limit:5}])

(cid:1) db.solarSystem.aggregate([{$project: {id:0,name:1,numberOfMoons:1}},{$skip:1}])

(cid:1) db.solarSystem.aggregate([{$match:{type:"Terrestrial

.solarSystem.aggregate([{$match:{type:"

planet"},{$project:{id:0,name:1,numberOfMoons:1}},{$count:"terrestrial planets"}])

(cid:1) db.solarSystem.aggregate([{$project:{id:0,name:1,numberOfMoons:1}},{$sort:{numberOfMoons:1}}])

(cid:1) db.solarSystem.aggregate([{$project:{id:0,name:1,hasMagneticField:1,numberOfMoons:1}},{$sort:fhasMagneticField:

-1,numberOfMoons:-1}}],{allowDiskUse:true})

Groupement des données

$group:

(cid:1) Regroupe les documents de la collection par l'expression spécifiée dans l’_id.

(cid:1) Pour chaque groupe distinct, $group génère un document.

(cid:1) Le seul argument requis au $group est le _id. La ou les expressions spécifiées à

l’_id sont les champs de groupement.

(cid:1) Le champ _id de chaque document de sortie contient une valeur unique par

groupe.

Syntaxe:

db.<collection>.aggregate([{$group:{_id: <critère_de_groupement>,<Expression

d'accumulation>}]})

Exemple:

db.movieDetails.aggregate([{$group:{_id:"$year"}}])

Groupement des données

(cid:1) Utiliser des expressions d'accumulation: les documents de sortie peuvent

contenir des champs calculés qui contiennent les valeurs d'une expression

d'accumulation.

(cid:1) Des champs supplémentaires (autant que nécessaire) peuvent être spécifiée afin

d’éfféctuer des calculs dans la phase de groupement.

Exemples:

(cid:1) db.movieDetails.aggregate([{$group:{_id:"$

(cid:1) db.movieDetails.aggregate([{$group:{_id:"$year",num_films_annee:{$sum:1}}}])

",num_films_annee:{$sum:1}}}])

(cid:1) db.movieDetails.aggregate([{$group:{_id:"$year", num_films_annee

:{$sum:1}}},{$sort:{num_films_annee :-1}}])

(cid:1) db.movieDetails.aggregate([{$group:{_id:null,count:{$sum:1}}}])

(cid:1) db.movieDetails.aggregate([{$match:{metacritic:{$gte:0}}},{$group:{_id:null,

avgmetacritic:{$avg:"$metacritic"}}}]).

Groupement des données

(cid:1) _id spécifie les critères de groupement des documents entrants;

(cid:1) $group peut être utilise plusieurs fois dans un pipeline;

(cid:1) Il peut être nécessaire de nettoyer les données entrantes a $group;

(cid:1) Toutes les expressions d'accumulations peuvent être utilisées dans le

groupement $group.

Expression d’accumulation:

(cid:1) $sum: Renvoie une somme de valeurs numériques. Ignore les valeurs non

numériques. Peut être utilise dans $group et $project.

(cid:1) $avg: Renvoie une moyenne de valeurs numériques. Ignore les valeurs non

numériques. Peut être utilisé dans $group et $project.

(cid:1) $rst: Renvoie une valeur du premier document pour chaque groupe. L'ordre

n'est défini que si les documents sont dans un ordre défini. Peut être utilise dans

$group.

(cid:1) $last: Renvoie une valeur du dernier document pour chaque groupe. L'ordre

n'est défini que si les documents sont dans un ordre défini. Peut être utilise dans

$group.

Groupement des données

(cid:1) $max: Renvoie la valeur d'expression la plus élevée pour chaque groupe. Peut

être utilise dans $group et $project.

(cid:1) $min: Renvoie la valeur d'expression la plus faible pour chaque groupe. Peut être

utilisé dans $group et $project.

(cid:1) $push: Renvoie un tableau de valeurs d'expression pour chaque groupe. Peut

être utilisé dans $group.

(cid:1) $addToSet: Renvoie un tableau de valeurs d'expressions uniques pour chaque

groupe. L'ordre des éléments du tableau n'est pas défini. Peut être utilise dans

$group.

(cid:1) $stdDevPop: Renvoie l’écart type de population des valeurs d'entrée. Peut être

utilisé dans $group et $project.

(cid:1) $stdDevSamp: Renvoie l’écart type d’échantillon des valeurs d'entrée. Peut être

utilise dans $group et $project.

Remarque: Les expressions de l'accumulations dans $project fonctionnent

sur un tableau dans les documents de la collection donnée.

MongoDB : Architecture, Schéma BSON & Interrogation Distribuée

MongoDB : Architecture, Schéma BSON & Interrogation Distribuée