Menu Docs
Página inicial do Docs
/ /
Otimização de Consulta
/
Analisar o desempenho
/
Explicação de resultados

Interpretar os resultados do plano de explicação

Nesta página

Você pode usar a explicação dos resultados para determinar as seguintes informações sobre uma query:

  • O tempo que uma query levou para ser concluída

  • Se a query usou um índice

  • O número de documentos e chaves de índice verificados para atender a uma query

Observação

Os resultados do plano de explicação para queries estão sujeitos a alterações entre as versões MongoDB.

Os métodos cursor.explain("executionStats") e db.collection.explain("executionStats") fornecem estatísticas sobre o desempenho de uma query. Essas estatísticas podem ser úteis para medir se e como uma query utiliza um índice. Consulte db.collection.explain() para obter detalhes.

O MongoDB Compass fornece uma guia Explicar plano , que exibe estatísticas sobre o desempenho de uma query. Essas estatísticas podem ser úteis para medir se e como uma query utiliza um índice.

Avalie o desempenho de uma query

Considere uma coleção inventory com os seguintes documentos:

{ "_id" : 1, "item" : "f1", type: "food", quantity: 500 }
{ "_id" : 2, "item" : "f2", type: "food", quantity: 100 }
{ "_id" : 3, "item" : "p1", type: "paper", quantity: 200 }
{ "_id" : 4, "item" : "p2", type: "paper", quantity: 150 }
{ "_id" : 5, "item" : "f3", type: "food", quantity: 300 }
{ "_id" : 6, "item" : "t1", type: "toys", quantity: 500 }
{ "_id" : 7, "item" : "a1", type: "apparel", quantity: 250 }
{ "_id" : 8, "item" : "a2", type: "apparel", quantity: 400 }
{ "_id" : 9, "item" : "t2", type: "toys", quantity: 50 }
{ "_id" : 10, "item" : "f4", type: "food", quantity: 75 }

Os documentos aparecem no MongoDB Compass como os seguintes:

Consulta sem Índice

A query a seguir recupera documentos em que o campo quantity tem um valor entre 100 e 200, inclusive:

db.inventory.find( { quantity: { $gte: 100, $lte: 200 } } )

A consulta retorna os seguintes documentos:

{ "_id" : 2, "item" : "f2", "type" : "food", "quantity" : 100 }
{ "_id" : 3, "item" : "p1", "type" : "paper", "quantity" : 200 }
{ "_id" : 4, "item" : "p2", "type" : "paper", "quantity" : 150 }

Para exibir o plano de query selecionado, encadeie o método cursor.explain("executionStats") cursor até o final do comando find:

db.inventory.find(
   { quantity: { $gte: 100, $lte: 200 } }
).explain("executionStats")

explain() retorna os seguintes resultados:

{
   queryPlanner: {
         ...
         winningPlan: {
            queryPlan: {
               stage: 'COLLSCAN',
               ...
            }
         }
   },
   executionStats: {
      executionSuccess: true,
      nReturned: 3,
      executionTimeMillis: 0,
      totalKeysExamined: 0,
      totalDocsExamined: 10,
      executionStages: {
         stage: 'COLLSCAN',
         ...
      },
      ...
   },
   ...
}

  • queryPlanner.winningPlan.queryPlan.stage exibe COLLSCAN para indicar uma verificação de collection.

    As verificações de collection indicam que mongod precisou verificar documento por documento de toda a collection para identificar os resultados. Essa é uma operação geralmente cara e pode resultar em queries lentas.

  • executionStats.nReturned exibe 3 para indicar que o plano de query vencedor retorna três documentos.

  • executionStats.totalKeysExamined exibe 0 para indicar que esta query não está usando um índice.

  • executionStats.totalDocsExamined exibe 10 para indicar que o MongoDB teve que verificar dez documentos (ou seja, todos os documentos na collection) para encontrar os três documentos correspondentes.

A query a seguir recupera documentos em que o campo quantity tem um valor entre 100 e 200, inclusive:

Copie o seguinte filtro na barra de consulta do Compass e clique em Find:

{ quantity: { $gte: 100, $lte: 200 } }

A consulta retorna os seguintes documentos:

Para visualizar o plano de query selecionado:

  1. Clique Explain Plan na guia test.inventory collection.

  2. Clique em Explain.

O MongoDB Compass exibe o plano de query da seguinte maneira:

Observação

Como estamos trabalhando com um conjunto de dados tão pequeno para os fins deste tutorial, o Actual Query Execution Time exibe 0 segundos, mesmo que não estejamos usando um índice.

Em um conjunto de dados maior, a diferença no tempo de execução da query entre uma query indexada e uma query não indexada seria muito maior.

Árvore visual

  • O Query Performance Summary mostra as estatísticas de execução da consulta:

    • Documents Returned exibe 3 para indicar que o plano de query vencedor retorna três documentos.

    • Index Keys Examined exibe 0 para indicar que esta query não está usando um índice.

    • Documents Examined exibe 10 para indicar que o MongoDB teve que verificar dez documentos (ou seja, todos os documentos na coleção) para encontrar os três documentos correspondentes.

  • Abaixo de Query Performance Summary, o MongoDB Compass exibe o estágio de consulta COLLSCAN para indicar que uma verificação de collection foi usada para esta consulta.

    As verificações de collection indicam que mongod precisou verificar documento por documento de toda a collection para identificar os resultados. Essa é uma operação geralmente cara e pode resultar em queries lentas.

Raw JSON

Os detalhes explicativos também podem ser visualizados no formato JSON bruto clicando em Raw JSON abaixo da barra de consulta:

A diferença entre o número de documentos correspondentes e o número de documentos examinados pode sugerir que, para melhorar a eficiência, a query pode se beneficiar do uso de um índice.

Consulta com índice

Para suportar a query no campo quantity, adicione um índice no campo quantity:

db.inventory.createIndex( { quantity: 1 } )

Para visualizar as estatísticas do plano de query, use o método explain() :

db.inventory.find(
   { quantity: { $gte: 100, $lte: 200 } }
).explain("executionStats")

O método explain() retorna os seguintes resultados:

{
   queryPlanner: {
         ...
         winningPlan: {
            queryPlan: {
               stage: 'FETCH',
               inputStage: {
                  stage: 'IXSCAN',
                  keyPattern: {
                     quantity: 1
                  },
                  ...
               }
            }
         },
         rejectedPlans: [ ]
   },
   executionStats: {
         executionSuccess: true,
         nReturned: 3,
         executionTimeMillis: 0,
         totalKeysExamined: 3,
         totalDocsExamined: 3,
         executionStages: {
            ...
         },
         ...
   },
   ...
}

  • queryPlanner.winningPlan.queryPlan.inputStage.stage exibe IXSCAN para indicar o uso do índice.

  • executionStats.nReturned exibe 3 para indicar que o plano de query vencedor retorna três documentos.

  • executionStats.totalKeysExamined exibe 3 para indicar que o MongoDB verificou três entradas de índice. O número de chaves examinadas corresponde ao número de documentos retornados, o que significa que o mongod só precisou examinar as chaves do índice para retornar os resultados. O mongod não precisou digitalizar todos os documentos, e apenas os três documentos correspondentes tiveram que ser colocados na memória. Isso resulta em uma query muito eficiente.

  • executionStats.totalDocsExamined exibe 3 para indicar que o MongoDB digitalizou três documentos.

  1. Clique Indexes na guia test.inventory collection.

  2. Clique em Create Index.

  3. Selecione quantity no menu suspenso Select a field name.

  4. Selecione 1 (asc) no menu suspenso de tipos.

  5. Clique em Create.

Observação

Deixar o campo do nome do índice em branco faz com que o MongoDB Compass crie um nome padrão para o índice.

Agora você pode ver o índice recém-criado na guia Indexes:

Retorne à aba Explain Plan para a coleção inventory e execute novamente a query da etapa anterior:

{ quantity: { $gte: 100, $lte: 200 } }

O MongoDB Compass exibe o plano de query da seguinte maneira:

Árvore visual

  • O Query Performance Summary mostra as estatísticas de execução da consulta:

    • Documents Returned exibe 3 para indicar que o plano de query vencedor retorna três documentos.

    • Index Keys Examined exibe 3 para indicar que o MongoDB verificou três entradas de índice. O número de chaves examinadas corresponde ao número de documentos retornados, o que significa que mongod só precisou examinar as chaves do índice para retornar os resultados. mongod não precisou verificar todos os documentos e apenas os três documentos correspondentes tiveram que ser colocados na memória. Isso resulta em uma query muito eficiente.

    • Documents Examined exibe 3 para indicar que o MongoDB digitalizou três documentos.

    • No lado direito do Query Performance Summary, o MongoDB Compass mostra que a query usou o índice quantity .

  • Abaixo do Query Performance Summary, o MongoDB Compass exibe os estágios de consulta FETCH e IXSCAN. IXSCAN indica que o mongod usou um índice para satisfazer a consulta antes de executar o estágio FETCH e recuperar os documentos.

Raw JSON

Os detalhes explicativos também podem ser visualizados no formato JSON bruto clicando em Raw JSON abaixo da barra de consulta:

Sem o índice, a query verificaria toda a collection de 10 documentos para retornar 3 documentos correspondentes. A query também precisou verificar a totalidade de cada documento, potencialmente colocando-os na memória. Isso resulta em uma operação de query cara e potencialmente lenta.

Ao executar com um índice, a query verificou 3 entradas de índice e 3 documentos para retornar 3 documentos correspondentes, resultando em uma query muito eficiente.

Compare Performance of Indexes

To manually compare the performance of a query using more than one index, you can use the hint() method in conjunction with the explain() method.

Consider the following query:

db.inventory.find( {
   quantity: {
      $gte: 100, $lte: 300
   },
   type: "food"
} )

A consulta retorna os seguintes documentos:

{ "_id" : 2, "item" : "f2", "type" : "food", "quantity" : 100 }
{ "_id" : 5, "item" : "f3", "type" : "food", "quantity" : 300 }

To support the query, add a compound index. With compound indexes, the order of the fields matter.

For example, add the following two compound indexes. The first index orders by quantity field first, and then the type field. The second index orders by type first, and then the quantity field.

db.inventory.createIndex( { quantity: 1, type: 1 } )
db.inventory.createIndex( { type: 1, quantity: 1 } )

Evaluate the effect of the first index on the query:

db.inventory.find(
   { quantity: { $gte: 100, $lte: 300 }, type: "food" }
).hint({ quantity: 1, type: 1 }).explain("executionStats")

The explain() method returns the following output:

{
   queryPlanner: {
      ...
      winningPlan: {
         queryPlan: {
            stage: 'FETCH',
            inputStage: {
               stage: 'IXSCAN',
               keyPattern: {
                  quantity: 1,
                  type: 1
               },
               ...
               }
            }
         }
      },
      rejectedPlans: [ ]
   },
   executionStats: {
      executionSuccess: true,
      nReturned: 2,
      executionTimeMillis: 0,
      totalKeysExamined: 5,
      totalDocsExamined: 2,
      executionStages: {
      ...
      }
   },
   ...
}

MongoDB scanned 5 index keys (executionStats.totalKeysExamined) to return 2 matching documents (executionStats.nReturned).

Evaluate the effect of the second index on the query:

db.inventory.find(
   { quantity: { $gte: 100, $lte: 300 }, type: "food" }
).hint({ type: 1, quantity: 1 }).explain("executionStats")

The explain() method returns the following output:

{
   queryPlanner: {
      ...
      queryPlan: {
         winningPlan: {
            stage: 'FETCH',
            inputStage: {
               stage: 'IXSCAN',
               keyPattern: {
                  type: 1,
                  quantity: 1
               },
               ...
            }
         }
      },
      rejectedPlans: [ ]
   },
   executionStats: {
      executionSuccess: true,
      nReturned: 2,
      executionTimeMillis: 0,
      totalKeysExamined: 2,
      totalDocsExamined: 2,
      executionStages: {
         ...
      }
   },
   ...
}

MongoDB scanned 2 index keys (executionStats.totalKeysExamined) to return 2 matching documents (executionStats.nReturned).

The second compound index, { type: 1, quantity: 1 }, is therefore the more efficient index for supporting the example query, as the MongoDB server only needs to scan 2 index keys to find all matching documents using this index, compared to 5 when when using the compound index { quantity: 1, type: 1 }.

Veja também:

Voltar

Explicação de resultados

Próximo

Database Profiler