Agrégation MongoDB

Dans MongoDB, l'agrégation est principalement utilisée pour traiter des données (comme le calcul de moyennes, de sommes, etc.) et renvoyer les résultats calculés.

un peu similaire àSQLdans l'instruction SQLcount(*)。


méthode aggregate()

La méthode d'agrégation dans MongoDB utilise aggregate().

Syntaxe

Le format de syntaxe de base de la méthode aggregate() est le suivant :

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

Exemple

Les données de la collection sont les suivantes :

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'example.com',
   url: 'http://www.example.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'example.com',
   url: 'http://www.example.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

Utilisons maintenant la collection ci-dessus pour calculer le nombre d'articles écrits par chaque auteur. Le résultat de l'utilisation de aggregate() est le suivant :

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "example.com",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

L'exemple ci-dessus est similaire à l'instruction SQL :

 select by_user, count(*) from mycol group by by_user

Dans l'exemple ci-dessus, nous regroupons les données par le champ by_user et calculons la somme des mêmes valeurs dans le champ by_user.

Le tableau suivant présente quelques expressions d'agrégation :

ExpressionDescriptionExemple
$sumCalcule la somme.db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
$avgCalcule la moyennedb.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
$minObtient la valeur minimale correspondant à tous les documents de la collection.db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
$maxObtient la valeur maximale correspondant à tous les documents de la collection.db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
$pushAjoute des valeurs à un tableau sans vérifier la présence de doublons.db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])
$addToSetAjoute des valeurs à un tableau en vérifiant la présence de doublons ; si la même valeur existe déjà dans le tableau, elle n'est pas ajoutée.db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
$firstRécupère les données du premier document selon le tri des documents source.db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
$lastRécupère les données du dernier document selon le tri des documents source.db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

Concept de pipeline

Sous Unix et Linux, les pipelines sont généralement utilisés pour prendre la sortie de la commande courante comme argument de la commande suivante.

Le pipeline d'agrégation de MongoDB traite les documents MongoDB dans une étape du pipeline, puis transmet les résultats à l'étape suivante du pipeline. Les opérations du pipeline peuvent être répétées.

Expression : Traite les documents d'entrée et produit des résultats. Les expressions sont sans état et ne peuvent être utilisées que pour calculer des documents dans le pipeline d'agrégation courant ; elles ne peuvent pas traiter d'autres documents.

Nous présentons ici plusieurs opérations couramment utilisées dans le framework d'agrégation :

  • $project : Modifie la structure du document d'entrée. Il peut être utilisé pour renommer, ajouter ou supprimer des champs, ainsi que pour créer des résultats calculés et des documents imbriqués.
  • $match : Utilisé pour filtrer les données et ne produire que les documents qui répondent aux conditions. $match utilise les opérations de requête standard de MongoDB.
  • $limit : Utilisé pour limiter le nombre de documents renvoyés par le pipeline d'agrégation de MongoDB.
  • $skip : Ignore un nombre spécifié de documents dans le pipeline d'agrégation et renvoie les documents restants.
  • $unwind : Décompose un champ de type tableau dans un document en plusieurs documents, chacun contenant une valeur du tableau.
  • $group : Regroupe les documents d'une collection, ce qui peut être utilisé pour des résultats statistiques.
  • $sort : Trie les documents d'entrée et les produit en sortie.
  • $geoNear : Produit des documents ordonnés qui se trouvent près d'un certain emplacement géographique.

Exemples d'opérateurs de pipeline

1. Exemple avec $project

db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );

De cette façon, le résultat contient uniquement les trois champs : _id, tilte et author. Par défaut, le champ _id est inclus. Si vous ne voulez pas inclure _id, vous pouvez faire ceci :

db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

2. Exemple avec $match

db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );

$match est utilisé pour récupérer les enregistrements ayant des scores supérieurs à 70 et inférieurs ou égaux à 90, puis envoyer les enregistrements correspondants à l'étape suivante, l'opérateur de pipeline $group, pour traitement.

3. Exemple avec $skip

db.article.aggregate(
    { $skip : 5 });

Après traitement par l'opérateur de pipeline $skip, les cinq premiers documents sont "filtrés".

Autres extensions