web-dev-qa-db-fra.com

Mongodb Cadre Expliquer pour l'agrégation

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

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

Je sais avec trouver tu viens de faire

db.collection.find().explain()

Mais avec le framework 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()
mongodbaggregation-framework
102
SCB

À 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 anciennes versions> = 2.6, vous devrez utiliser l'option explain 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 à considérer avec Aggregation Framework 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 $match, $sort, $geonear Au début d'un pipeline) ainsi que les étapes $lookup et $graphLookup suivantes. Une fois que les données ont été extraites 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 seront en mémoire fichiers si l'option allowDiskUse est définie).

Optimiser les pipelines

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

  • Démarrer un pipeline avec une étape $match Pour limiter le traitement aux documents pertinents.
  • S'assurer que les étapes initiales $match/$sort Sont prises en charge par un index efficace .
  • Filtrage précoce des données à l'aide de $match, $limit Et $skip.
  • Minimiser les étapes inutiles et la manipulation de documents (par exemple, reconsidérer votre schéma si une gymnastique d'agrégation complexe est requise).
  • Tirez parti des nouveaux opérateurs d'agrégation si vous avez mis à niveau votre serveur MongoDB. Par exemple, MongoDB 3.4 a ajouté de nombreux nouvelles étapes et expressions d'agrégation , notamment la prise en charge de l'utilisation de tableaux, de chaînes et de 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, les étapes adjacentes peuvent être fusionnées et/ou réorganisées pour améliorer l'exécution sans affecter les résultats de sortie.

Limites

Comme dans MongoDB 3.4, l'option Aggregation Framework explain fournit des informations sur le traitement d'un pipeline mais ne prend pas en charge le même niveau de détail que le mode executionStats pour un find(). question. Si vous vous concentrez sur l'optimisation de l'exécution de la requête initiale, vous aurez probablement intérêt à consulter la requête équivalente find().explain() avec executionStats ou allPlansExecution verbosité .

Il y a quelques demandes de fonctionnalités pertinentes à surveiller/augmenter le vote dans l'outil de suivi des problèmes de MongoDB concernant des statistiques d'exécution plus détaillées permettant d'optimiser/profiler les pipelines d'agrégation:

144
Stennie

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

Tout ce que vous avez à faire est d’ajouter expliquez: 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 uniquement par le biais de runCommand(). Mais maintenant, vous pouvez également utiliser l'agrégat.

27
Salvador Dali

The Aggregation framework

La structure d'agrégation est un ensemble d'outils d'analyse au sein de MongoDB qui nous permet d'exécuter divers types de rapports ou d'analyses sur des documents d'une ou de plusieurs collections. Basé sur l'idée d'un pipeline. Nous prenons les entrées d'une collection MongoDB et passons les documents de cette collection à travers une ou plusieurs étapes, chacune effectuant une opération différente sur ses entrées. Chaque étape prend en entrée quelle que soit l'étape avant de la produire en sortie. Et les entrées et les sorties pour toutes les étapes constituent un flux de documents. Chaque étape a un travail spécifique. Il attend une forme spécifique de document et produit un résultat spécifique, qui est lui-même un flux de documents. Au bout du pipeline, nous avons accès à la sortie.

aggregation framework stage

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 génère le flux de sortie des documents. Encore une fois, un à la fois. Chaque étape fournit un ensemble de boutons ou de paramètres ajustables que nous pouvons contrôler pour paramétrer l’étape et exécuter 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, et paramétre l’étape pour l’ensemble de documents avec lequel nous travaillons. Et exactement ce que nous voudrions que cette étape fasse avec ces documents. Ces paramètres ajustables prennent généralement la forme d'opérateurs que nous pouvons fournir pour modifier les champs, effectuer des opérations arithmétiques, remodeler des documents ou effectuer une sorte de tâche d'accumulation ainsi que de nombreuses autres choses. Souvent, nous souhaitons inclure le même type d’étapes à plusieurs reprises dans un même pipeline.

same type of stage multiple times within a single pipeline

par exemple. Nous souhaiterons peut-être effectuer un premier filtre afin de ne pas avoir à transférer la totalité de la collection dans notre pipeline. Mais, plus tard, après un traitement supplémentaire, souhaitez filtrer à nouveau en utilisant un ensemble de critères différent. Donc, pour récapituler, le pipeline fonctionne avec une collection MongoDB. Elles sont composées d'étapes, chacune effectuant une tâche de traitement de données différente sur son entrée et produisant des documents sous forme de sortie à transmettre à l'étape suivante. Et finalement, à la fin du pipeline, la sortie est produite et 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 même pipeline.

14
student