FONCTIONS

D’AGREGATION NOSQL
MEMBRES DU GROUPE:
LEMA KADER
SATCHIVI ASHLEY
TIDATOA BÉNÉDICTA
YERIMA BOUCHARATOU
 INTRODUCTION

En traitement des bases de données, une fonction d’agrégation est un opérateur

permettant de réduire des groupes de lignes à une valeur calculée à partir de l’une
des colonnes en jeu. Les opérations d'agrégation traitent les enregistrements de
données et renvoient les résultats calculés. Elles regroupent les valeurs de
plusieurs documents et peuvent effectuer diverses opérations sur les données
regroupées pour renvoyer un seul résultat.
LA MÉTHODE AGGREGATE ()

Pour l'agrégation dans MongoDB, vous devez utiliser la méthode aggregate() .

Syntaxe de base de la méthode  aggregate()  est la suivante :
>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
QUELQUES FONCTIONS NOSQL SONT:

-$sum
-$max
-$min
-$count
-$avg
-$push
-$addToSet
-$First
-$last
 OPÉRATEUR DE SOMME:$SUM

L’équivalent en SQL de l’opérateur $sum est sum

Exemple de requête sans regroupement:
=>Avec MongoDB
db.client.aggregate([
{$group: {_id: null,
nb: {$sum: "$copies"}}}
])
OPÉRATEUR DE SOMME:$SUM

=>Avec SQL
SELECT SUM(copies) as nb
FROM client
Vous remarquez qu’ici, l’expression qui guide le regroupement est soit null soit une
constante. Cela signifie que tous les documents de la base seront regroupé
ensemble et qu’un seul calcul sera fait pour ce groupe.
 OPERATEUR DE COMPTAGE: $COUNT

L’opérateur $count renvoie le nombre de documents présents dans l’agrégation.

Dans cet exemple,on assigne à la valeur NB_+24 le nombre de documents ayant
un individu avec un âge supérieur à 24:
db.users.aggregate([
{$match: {"age": {$gt: 24}}},
{$count: "NB_+24"}
])
OPERATEUR DE COMPTAGE: $COUNT

L’opérateur $match exclu les documents qui possèdent un individu avec un âge
inférieur À 24.L’opérateur $count va donc agir sur les documents ayant un individu
avec un âge supérieur à 24 à l’opérateur $gt (Plus grand que) et va assigner à la
valeur NB_+24 le nombre de documents répondant au critère.
 SANS REGROUPEMENT

=>En MongoDB =>En SQL

db.NYfood.aggregate([ SELECT COUNT(*) as nb
{$group:{_id: null, FROM NYfood
nb: {$sum: 1}}}
])
SANS REGROUPEMENT

Lorsqu’on utilise la fonction agregate,il faut donner les individus sur lesquels on veut faire
la requête. Dans notre cas, on choisit tous les individus. On le note id:null.On cré notre
variable qu’on appelle nb qui va faire la somme de tous les individus.
Dans cet exemple, nous avons compté le nombre d’individus sans sélection.
En pratique, cela n’a pas forcément beaucoup d’intérêt .Il s’avère plus utile de pouvoir
sélectionner le nombre de variables répondant à un critère. Pour cela, nous allons regarder
avec une requête de regroupement.
 AVEC REGROUPEMENT

=>En MongoDB =>En SQL

db.NYfood.aggregate([ SELECT COUNT(*) AS
{$group:{_id: "$cuisine", nb_par_cuisine

nb_par_cuis: {$sum: FROM NYfood

1}}} GROUP BY cuisine
])
AVEC REGROUPEMENT

On obtient donc plusieurs listes différentes contenant pour chacune le nombre de restaurants
dans chaque liste nommée par le type de cuisine.
 OPÉRATEURS D’EXTREMUM:$MIN,$MAX

Syntaxe Pour cette partie on se basera sur cette collection

pour les exemples :
db.coll.aggregate([
{ "_id" : 1, "objet" : "a", "prix" : 10, "quantité" : 2},
{$group:
{ "_id" : 2, "objet" : "b", "prix" : 20, "quantité" : 1},
{_id: { <var>,
{ "_id" : 3, "objet" : "c", "prix" : 5, "quantité" : 5},
max: {$max: [ <expression1>,
{ "_id" : 4, "objet" : "a", "prix" : 10, "quantité" :
<expression2> ... ]}}}
10},
} { "_id" : 5, "objet" : "c", "prix" : 5, "quantité" : 10}
]
)
OPÉRATEURS D’EXTREMUM:$MIN,$MAX

Nous allons nous intéresser aux opérateurs $min et $max

au sein de l’opérateur $group, ils peuvent aussi être utilisés
dans l’opérateur $project que nous verrons en deuxième
partie de chapitre. En SQL, les équivalents sont les
opérateurs MIN et MAX.
 SANS REGROUPEMENT

$min et $max s’ils sont utilisés sans

regroupement retournent respectivement la
valeur minimale et la valeur maximale de
l’attribut sur lequel ils sont appliqués et ceci
sur tous les documents.
 EXEMPLE

=>MongoDB =>SQL
db.ventes.aggregate([ SELECT MAX(prix) as "prix max",
{$group: {_id: null, MIN(prix) as "prix min"

prix_max: {$max: "$prix"}, FROM ventes

prix_min: {$min: "$prix"}}}

])
EXEMPLE

Attention: Ne pas oublier le “$” dans les attributs entre guillemets à droite des deux
points pour bien faire référence à l’attribut et non à une chaîne de caractères.
Cette requête renvoie la valeur maximale puis minimale que prend la variable
$prix sur tous les documents
{
"_id" : null,
"prix_max" : 20.0,
"prix_min" : 5.0
}
 AVEC REGROUPEMENT

On peut aussi réaliser un regroupement et ainsi $min et

$max renvoient toujours la valeur minimale et la valeur
maximale de l’attribut sur lequel ils sont appliqués, mais
cette fois-ci en étant appliqués sur les documents de
l’ensemble de documents qui partagent la même clé de
regroupement.
 EXEMPLE

=>MongoDB =>SQL
db.ventes.aggregate([ SELECT MAX(prix) as "prix max",
{$group: {_id:"$objet", MIN(prix) as "prix min"
quantité_max: {$max: FROM ventes
"$quantité"},
GROUP BY quantité
quantité_min: {$min:
"$quantité"}}}
])
 EXEMPLE

On groupe à l’aide de la clé objet, , on renvoie donc la valeur

maximale puis minimale que prend la variable quantité pour
chaque objet différent.
{
"_id" : "a",
"quantité_max" : 10.0,
"quantité_min" : 2.0
}

/* 2 */
{
"_id" : "b",
"quantité_max" : 1.0,
"quantité_min" : 1.0
}

/* 3 */
{
"_id" : "c",
"quantité_max" : 10.0,
"quantité_min" : 5.0
}
 NULL OU INEXISTANT

Si certains documents ont une valeur de type null ou qui n’existe

pas pour l’attribut sur lequel on applique $min ou $max , les
opérateurs ne prennent pas en compte les valeurs de type null ou
manquantes pour le calcul. Si tous les documents ont une valeur
de type null ou qui n’existe pas, les opérateurs renvoient null pour
la valeur minimale ou la valeur maximale.
 FONCTION DE MOYENNE:AVG

La fonction AVG recherche tous les éléments de la collection de joueurs et renvoie le score moyen. Notez la
différence par rapport à la fonction MIN qui renvoie l’élément de données complet, la fonction AVG renvoie
uniquement la valeur.
Exemple de requête sans regroupement:
=>Avec MongoDB
db.coll.aggregate([
{$group: {_id: null,
moy: {$AVG: "$att"}}}
])
 CONCEPT DE PIPELINE

Dans la commande UNIX, le pipeline Shell signifie la possibilité d'exécuter une opération sur
une entrée et d'utiliser la sortie comme entrée pour la commande suivante et ainsi de suite.
MongoDB prend également en charge le même concept dans le cadre d'agrégation. Il existe
un ensemble d'étapes possibles et chacune d'elles est considérée comme un ensemble de
documents en tant qu'entrée et produit un ensemble de documents résultant (ou le document
JSON final résultant à la fin du pipeline). Cela peut ensuite être utilisé à son tour pour l'étape
suivante et ainsi de suite.
Voici les étapes possibles du cadre d'agrégation -
$projet - Utilisé pour sélectionner certains champs spécifiques d'une collection.
$match - Il s'agit d'une opération de filtrage et donc cela peut réduire la quantité de
documents qui sont donnés en entrée à l'étape suivante.
• .
CONCEPT DE PIPELINE

$group - Cela fait l'agrégation réelle comme indiqué ci-dessus.

$sort - Trie les documents
$skip - Avec cela, il est possible d'avancer dans la liste des documents pour un nombre donné de documents.
$limit - Cela limite la quantité de documents à consulter, par le nombre donné à partir des positions actuelles.
$unwind- Ceci est utilisé pour dérouler les documents qui utilisent des tableaux. Lors de l'utilisation d'un
tableau, les données sont en quelque sorte pré-jointes et cette opération sera annulée avec cela pour avoir à
nouveau des documents individuels. Ainsi, avec cette étape, nous augmenterons la quantité de documents pour
la prochaine étape.
 RESUMÉ

Dans l’exemple ci-dessus, nous avons regroupé les

documents par champ by_user et à chaque
occurrence de par utilisateur, la valeur précédente
de la somme est incrémentée. Voici une liste des
expressions d’agrégation disponibles.
 CONCLUSION

• L’agrégation de base de données NoSql est une fonctionnalité importante dans

de nombreuses applications. restdb.io(Backend de base de données NoSQL en
ligne simple) prend en charge les requêtes avec regroupement et agrégation
d’ensembles de données. Ceci est très utile pour développer des rapports
personnalisés, des graphiques visuels, des analyses de données, etc.