Mongodb Explain pour le cadre d'agrégation

Question

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

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

Je sais que pour trouver, il faut 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()

Answer 1

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

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

à

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

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

Pour les versions antérieures >= 2.6, vous devrez utiliser la fonction explain option 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
  }
)

Un point important à prendre en compte avec le cadre d'agrégation est qu'un index ne peut être utilisé que pour récupérer les données initiales d'un pipeline (par exemple, l'utilisation de la fonction $match , $sort , $geonear au début d'un pipeline) ainsi que les suivants $lookup et $graphLookup étapes. Une fois que les données ont été récupérées dans le pipeline d'agrégation pour être traitées (par exemple en passant par des étapes telles que $project , $unwind et $group ), les manipulations ultérieures se feront en mémoire (en utilisant éventuellement des fichiers temporaires si l'option allowDiskUse est définie).

Optimisation des pipelines

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

• Démarrer un pipeline avec un $match pour limiter le traitement aux documents pertinents.
• Veiller à ce que les $match / $sort sont soutenus par une indice efficace .
• Filtrage précoce des données à l'aide de $match , $limit et $skip .
• Réduire au minimum les étapes et les manipulations de documents inutiles (peut-être en reconsidérant votre schéma si des gymnastiques d'agrégation compliquées sont nécessaires).
• Profiter des nouveaux opérateurs d'agrégation si vous avez mis à jour votre serveur MongoDB. Par exemple, la version 3.4 de MongoDB a ajouté de nombreux opérateurs d'agrégation. de nouvelles étapes et expressions d'agrégation y compris la prise en charge du travail avec les tableaux, les chaînes de caractères et les facettes.

Il existe également un certain nombre de Optimisations du pipeline d'agrégation qui se produisent automatiquement en fonction de la version de votre serveur MongoDB. Par exemple, des étapes adjacentes peuvent être regroupées et/ou réorganisées pour améliorer l'exécution sans affecter les résultats de sortie.

Limites

À partir de MongoDB 3.4, le Cadre d'agrégation explain fournit des informations sur la façon dont un pipeline est traité mais ne permet pas le même niveau de détail que l'option executionStats pour un find() question. Si vous vous concentrez sur l'optimisation de l'exécution initiale de la requête, vous trouverez probablement avantageux d'examiner les équivalents suivants find().explain() la requête avec executionStats o allPlansExecution verbosité .

Il y a quelques demandes de fonctionnalités pertinentes à suivre/supprimer dans le tracker de problèmes MongoDB concernant des statistiques d'exécution plus détaillées pour aider à optimiser/profiler les pipelines d'agrégation :

• SERVER-19758 : Ajout des modes d'explication "executionStats" et "allPlansExecution" à l'explication de l'agrégation
• SERVER-21784 : suivi des statistiques d'exécution pour chaque étape du pipeline d'agrégation et exposition via explain
• SERVER-22622 : Amélioration de $lookup explain pour indiquer le plan de requête sur la collection "from".

Answer 2

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

Il suffit d'ajouter explain : true.

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

Grâce à Rafa, je sais qu'il était possible de le faire même en 2.4, mais seulement par le biais de runCommand() . Mais maintenant, vous pouvez aussi utiliser l'agrégat.

Answer 3

Le cadre d'agrégation est un ensemble d'outils d'analyse au sein de l'entreprise. MongoDB qui nous permet d'exécuter divers types de rapports ou d'analyses sur les documents d'une ou plusieurs collections. Basé sur l'idée d'un pipeline. Nous prenons l'entrée d'un MongoDB et fait passer les documents de cette collection par une ou plusieurs étapes, chacune d'entre elles effectuant une opération différente sur ses entrées. Chaque étape prend en entrée ce que l'étape précédente a produit en sortie. Et les entrées et sorties de toutes les étapes sont un flux de documents. Chaque étape a une tâche spécifique à accomplir. 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.

Un étage individuel est une unité de traitement des 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 documents de sortie. Là encore, un par un. Chaque étape fournit un ensemble de boutons ou de paramètres que nous pouvons contrôler pour paramétrer l'étape afin qu'elle effectue la tâche qui nous intéresse. Ainsi, une étape exécute une tâche générique - une tâche d'usage général d'un certain type et paramétrer l'étape pour l'ensemble particulier de documents avec lesquels nous travaillons. Et exactement ce que nous aimerions que cette étape fasse avec ces documents. Ces paramètres prennent généralement la forme d'opérateurs que nous pouvons fournir pour modifier les champs, effectuer des opérations arithmétiques, remodeler les documents ou effectuer une sorte de tâche d'accumulation ainsi qu'une multitude d'autres choses. Il arrive souvent que l'on veuille inclure le même type d'étape plusieurs fois dans un même pipeline.

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, nous voulons filtrer à nouveau en utilisant un autre ensemble de critères. Donc, pour résumer, le pipeline fonctionne avec un fichier MongoDB collection. Ils sont composés d'étapes, chacune d'entre elles effectuant une tâche différente de traitement des données en entrée et produisant des documents en sortie qui seront transmis à l'étape suivante. Et enfin, à la fin du pipeline, on obtient un résultat que l'on peut ensuite utiliser 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.

Answer 4

    I tried the above method but didn't get any explain information about the aggregation query.

    I tried this one.

    db['<Collection_Name>'].aggregate([{
        $group: {
            _id: null,
            queryIdList: {
                $addToSet: "$_id"
            }
        }
    }, {
        $sort: {
            "queryIdList": 1
        }
    }], {
        explain: true
    })

    It didn't worked for me.

    I find an alternative to use explain on aggregation queries using db.runCommand().

    E.g: 
    db.runCommand({
        aggregate: "<Collection_Name>",
        pipeline: [{
            $group: {
                _id: null,
                queryIdList: {
                    $addToSet: "$_id"
                }
            }
        }],
        explain: true
    })

Hope this will be helpful.