Mongodb Explain for Aggregation Framework

Existe-t-il une fonction d'explication pour le cadre d'agrégation dans MongoDB? Je ne peux pas le voir dans la documentation.

Sinon, existe-t-il un autre moyen de vérifier comment une requête fonctionne dans le cadre d'agrégation?

Je sais avec trouver que tu fais juste

db.collection.find().explain()

Mais avec le cadre d'agrégation, j'obtiens une erreur

db.collection.aggregate(
    { $project : { "Tags._id" : 1 }},
    { $unwind : "$Tags" },
    { $match: {$or: [{"Tags._id":"tag1"},{"Tags._id":"tag2"}]}},
    { 
        $group: 
        { 
            _id : { id: "$_id"},
            "count": { $sum:1 } 
        }
    },
    { $sort: {"count":-1}}
).explain()

À partir de MongoDB version 3.0, il suffit de changer l'ordre de

collection.aggregate(...).explain()

à

collection.explain().aggregate(...)

vous donnera les résultats souhaités (documentation ici ).

Pour les versions antérieures> = 2.6, vous devrez utiliser l' explainoption pour les opérations de pipeline d'agrégation

explain:true

db.collection.aggregate([
    { $project : { "Tags._id" : 1 }},
    { $unwind : "$Tags" },
    { $match: {$or: [{"Tags._id":"tag1"},{"Tags._id":"tag2"}]}},
    { $group: { 
        _id : "$_id",
        count: { $sum:1 } 
    }},
    {$sort: {"count":-1}}
  ],
  {
    explain:true
  }
)

Une considération importante avec le Cadre d' agrégation est qu'un indice ne peut être utilisé pour récupérer les données initiales pour un pipeline (par exemple l' utilisation de $match, $sort, $geonearau début d'un pipeline), ainsi que la suite $lookupet les $graphLookupétapes. Une fois que les données ont été récupérées dans la canalisation d'agrégation pour le traitement (par exemple en passant par les étapes comme $project, $unwind, et $group) une manipulation supplémentaire sera en mémoire (éventuellement en utilisant des fichiers temporaires si l' allowDiskUseoption est réglée).

Optimiser les pipelines

En général, vous pouvez optimiser les pipelines d'agrégation en:

• Démarrage d'un pipeline avec une $matchétape pour limiter le traitement aux documents pertinents.
• Assurer les premiers $match/ $sortétapes sont prises en charge par un indice efficace .
• Filtrage des données à l' aide précoce $match, $limitet $skip.
• Minimiser les étapes inutiles et la manipulation de documents (peut-être reconsidérer votre schéma si une gymnastique d'agrégation compliquée est nécessaire).
• Tirer parti des opérateurs d'agrégation plus récents si vous avez mis à niveau votre serveur MongoDB. Par exemple, MongoDB 3.4 a ajouté de nombreuses nouvelles étapes et expressions d'agrégation, y compris la prise en charge de l'utilisation de tableaux, de chaînes et de facettes.

Il existe également un certain nombre d' optimisations de pipeline d'agrégation qui se produisent automatiquement en fonction de la version de votre serveur MongoDB. Par exemple, les étages adjacents peuvent être fusionnés et / ou réorganisés pour améliorer l'exécution sans affecter les résultats de sortie.

Limites

Comme dans MongoDB 3.4, l' explainoption Aggregation Framework fournit des informations sur la façon dont un pipeline est traité mais ne prend pas en charge le même niveau de détail que le executionStatsmode d'une find()requête. Si vous vous concentrez sur l'optimisation de l'exécution de la requête initiale, vous trouverez probablement utile de passer en revue la find().explain()requête équivalente avec executionStatsou de la allPlansExecutionverbosité .

Il existe quelques demandes de fonctionnalités pertinentes à surveiller / à voter dans le suivi des problèmes de MongoDB concernant des statistiques d'exécution plus détaillées pour aider à optimiser / profiler les pipelines d'agrégation:

• SERVER-19758: Ajouter les modes d'explication "executionStats" et "allPlansExecution" à l'agrégation expliquent
• SERVER-21784: Suivez les statistiques d'exécution pour chaque étape du pipeline d'agrégation et exposez via Expliquer
• SERVER-22622: Améliorez $ lookup describe pour indiquer le plan de requête sur la collection "from"

À partir de la version 2.6.x, mongodb permet aux utilisateurs de faire des explications avec le cadre d'agrégation .

Tout ce que vous avez à faire est d'ajouter expliquez: vrai

db.records.aggregate(
  [ ...your pipeline...],
  { explain: true }
)

Grâce à Rafa, je sais qu'il était possible de faire même en 2.4, mais seulement à travers runCommand(). Mais maintenant, vous pouvez également utiliser des agrégats.

Le cadre d'agrégation est un ensemble d'outils d'analyse MongoDBqui nous permet d'exécuter divers types de rapports ou d'analyses sur des documents dans une ou plusieurs collections. Basé sur l'idée d'un pipeline. Nous prenons les entrées d'une MongoDBcollection et transmettons les documents de cette collection à une ou plusieurs étapes, chacune effectuant une opération différente sur ses entrées. Chaque étape prend comme entrée quelle que soit l'étape avant qu'elle ne soit produite comme sortie. Et les entrées et sorties pour toutes les étapes sont un flux de documents. Chaque étape a un travail spécifique qu'elle fait. Il attend une forme spécifique de document et produit une sortie spécifique, qui est elle-même un flux de documents. À la fin du pipeline, nous avons accès à la sortie.

Une étape individuelle est une unité de traitement de données. Chaque étape prend en entrée un flux de documents un par un, traite chaque document un par un et produit le flux de sortie des documents. Encore une fois, un à la fois. Chaque étape fournit un ensemble de boutons ou de paramètres réglables que nous pouvons contrôler pour paramétrer la scène afin d'effectuer toute tâche qui nous intéresse. Ainsi, une étape exécute une tâche générique - une tâche à usage général d'un certain type et paramètre l'étape pour l'ensemble particulier de documents avec lesquels nous travaillons. Et exactement ce que nous voudrions que cette étape fasse avec ces documents. Ces paramètres réglables prennent généralement la forme d'opérateurs que nous pouvons fournir qui modifieront les champs, effectueront des opérations arithmétiques, remodeler des documents ou effectuer une sorte de tâche d'accumulation ainsi qu'une vérification d'autres choses. Souvent, c'est le cas que nous '

Par exemple, nous pouvons souhaiter effectuer un filtre initial afin de ne pas avoir à passer la collection entière dans notre pipeline. Mais, plus tard, après un traitement supplémentaire, vous souhaitez filtrer à nouveau en utilisant un ensemble de critères différent. Donc, pour récapituler, pipeline fonctionne avec une MongoDBcollection. Ils sont composés d'étapes, chacune effectuant une tâche de traitement de données différente sur son entrée et produisant des documents en tant que sortie à passer à l'étape suivante. Et enfin, à la fin du pipeline, une sortie est produite que nous pouvons alors faire quelque chose dans notre application. Dans de nombreux cas, il est nécessaire d'inclure le même type d'étape, plusieurs fois dans un pipeline individuel.