Mongodb Explain for Aggregation framework

Existe uma função de explicação para a estrutura de agregação no MongoDB? Não consigo ver na documentação.

Se não, existe alguma outra maneira de verificar o desempenho de uma consulta na estrutura de agregação?

Eu sei que com encontrar você só faz

db.collection.find().explain()

Mas com a estrutura de agregação, recebo um erro

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()

A partir do MongoDB versão 3.0, basta alterar a ordem de

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

para

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

fornecerá os resultados desejados (documentação aqui ).

Para versões mais antigas> = 2.6, você precisará usar a explainopção para operações de pipeline de agregação

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
  }
)

Uma consideração importante com o Quadro A agregação é um índice que só pode ser usado para obter os dados iniciais de um oleoduto (por exemplo, o uso de $match, $sort, $geonearno início de um oleoduto), bem como subsequente $lookupe $graphLookupfases. Uma vez que os dados tenham sido buscados no pipeline de agregação para processamento (por exemplo, passando por estágios como $project, $unwinde $group), a manipulação adicional estará na memória (possivelmente usando arquivos temporários se a allowDiskUseopção for definida).

Otimizando pipelines

Em geral, você pode otimizar pipelines de agregação por:

• Iniciar um pipeline com um $matchestágio para restringir o processamento de documentos relevantes.
• Assegurar as iniciais $match/ $sortfases são suportados por um índice eficiente .
• Filtrando dados cedo usando $match, $limite $skip.
• Minimizando estágios desnecessários e manipulação de documentos (talvez reconsiderando seu esquema se uma complicada ginástica de agregação for necessária).
• Aproveitando os novos operadores de agregação se você atualizou seu servidor MongoDB. Por exemplo, MongoDB 3.4 adicionou muitos novos estágios de agregação e expressões, incluindo suporte para trabalhar com arrays, strings e facetas.

Também há várias otimizações de pipeline de agregação que acontecem automaticamente, dependendo da versão do servidor MongoDB. Por exemplo, estágios adjacentes podem ser coalescidos e / ou reordenados para melhorar a execução sem afetar os resultados de saída.

Limitações

Como no MongoDB 3.4, a explainopção Aggregation Framework fornece informações sobre como um pipeline é processado, mas não oferece suporte ao mesmo nível de detalhe que o executionStatsmodo para uma find()consulta. Se você estiver focado na otimização da execução inicial da consulta, provavelmente achará benéfico revisar a find().explain()consulta equivalente com executionStatsou allPlansExecutiondetalhamento .

Existem algumas solicitações de recursos relevantes para observar / votar no rastreador de problemas do MongoDB em relação a estatísticas de execução mais detalhadas para ajudar a otimizar / canais de agregação de perfil:

• SERVER-19758: Adicionar os modos de explicação "executionStats" e "allPlansExecution" para a explicação de agregação
• SERVER-21784: Rastreie as estatísticas de execução para cada estágio do pipeline de agregação e exponha via explicação
• SERVER-22622: Melhorar $ lookup explain para indicar plano de consulta na coleção "de"

A partir da versão 2.6.x, o mongodb permite que os usuários façam explicações com a estrutura de agregação .

Tudo que você precisa fazer é adicionar explain: true

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

Graças ao Rafa, sei que foi possível fazer até no 2.4, mas só através runCommand(). Mas agora você pode usar agregado também.

A estrutura de agregação é um conjunto de ferramentas analíticas MongoDBque nos permite executar vários tipos de relatórios ou análises em documentos em uma ou mais coleções. Baseado na ideia de um pipeline. Recebemos a entrada de uma MongoDBcoleção e passamos os documentos dessa coleção por um ou mais estágios, cada um dos quais executa uma operação diferente em suas entradas. Cada estágio recebe como entrada qualquer que seja o estágio antes de ser produzido como saída. E as entradas e saídas de todos os estágios são um fluxo de documentos. Cada estágio tem um trabalho específico que faz. Ele está esperando uma forma específica de documento e produz uma saída específica, que é um fluxo de documentos. No final do pipeline, temos acesso à saída.

Um estágio individual é uma unidade de processamento de dados. Cada estágio recebe como entrada um fluxo de documentos um por vez, processa cada documento um por vez e produz o fluxo de saída de documentos. Novamente, um de cada vez. Cada estágio fornece um conjunto de botões ou sintonizadores que podemos controlar para parametrizar o estágio para realizar qualquer tarefa que estivermos interessados ​​em fazer. Portanto, um estágio executa uma tarefa genérica - uma tarefa de propósito geral de algum tipo e parametriza o estágio para o conjunto específico de documentos com o qual estamos trabalhando. E exatamente o que gostaríamos que essa etapa fizesse com esses documentos. Esses ajustáveis ​​normalmente assumem a forma de operadores que podemos fornecer que modificarão campos, realizarão operações aritméticas, remodelarão documentos ou realizarão algum tipo de tarefa de acumulação, bem como uma série de outras coisas. Muitas vezes, é o caso de nós '

Por exemplo, podemos desejar realizar um filtro inicial para que não tenhamos que passar a coleção inteira em nosso pipeline. Mas, mais tarde, após algum processamento adicional, deseja filtrar mais uma vez usando um conjunto diferente de critérios. Portanto, para recapitular, o pipeline funciona com uma MongoDBcoleção. Eles são compostos de estágios, cada um dos quais executa uma tarefa de processamento de dados diferente em sua entrada e produz documentos como saída para serem passados ​​para o próximo estágio. E, finalmente, no final da saída do pipeline é produzida que podemos fazer algo dentro de nosso aplicativo. Em muitos casos, é necessário incluir o mesmo tipo de estágio, várias vezes em um pipeline individual.