/ /

Interpretar os resultados do plano de explicação

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 um modal Plano Explicativo, 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

Os exemplos nesta página usam dados do conjunto de dados de amostra sample_mflix. Para obter detalhes sobre como carregar esse conjunto de dados em sua implantação autogerenciada do MongoDB , consulte Carregar o conjunto de dados de amostra. Se você fez modificações nos bancos de dados de amostra, talvez seja necessário descartar e recriar os bancos de dados para executar os exemplos nesta página.

Os exemplos nesta página usam dados do conjunto de dados de amostra sample_mflix. Para detalhes de como carregar esse conjunto de dados em seu sistema, consulte Importar dados de amostra para seu sistema do Atlas .

Após carregar o conjunto de dados, conecte o MongoDB Compass à mesma implantação e abra a coleção movies.

Os documentos da collection aparecem no MongoDB Compass da seguinte forma:

Compass listando documentos na collection de filmes

clique para ampliar

Consulta sem Índice

A query a seguir recupera documentos em que o campo year tem um valor entre 2000 e 2005, inclusive:

db.movies.find( { year: { $gte: 2000, $lte: 2005 } } )

Esta query corresponde a 3809 dos 21349 documentos na coleção.

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

db.movies.find(
   { year: { $gte: 2000, $lte: 2005 } }
).explain("executionStats")

{
  queryPlanner: {
    namespace: 'sample_mflix.movies',
    winningPlan: {
      stage: 'COLLSCAN',
      '...': '...'
    },
    '...': '...'
  },
  executionStats: {
    executionSuccess: true,
    nReturned: 3809,
    totalKeysExamined: 0,
    totalDocsExamined: 21349,
    executionStages: {
      stage: 'COLLSCAN',
      '...': '...'
    },
    '...': '...'
  },
  '...': '...'
}

queryPlanner.winningPlan.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 3809 para indicar que o plano de query vencedor retorna 3,809 documentos.
executionStats.totalKeysExamined exibe 0 para indicar que esta query não está usando um índice.
executionStats.totalDocsExamined exibe 21349 para indicar que o MongoDB precisou verificar todos os documentos 21,349 na coleção para encontrar os documentos 3,809 correspondentes.

A query a seguir recupera documentos em que o campo year tem um valor entre 2000 e 2005, inclusive:

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

{ year: { $gte: 2000, $lte: 2005 } }

Esta query corresponde a 3809 dos 21349 documentos na coleção.

Para visualizar o plano de query, clique em Explain na barra de query.

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

plano de query sem índice do Compass para a coleção de filmes

clique para ampliar

Árvore visual

O Query Performance Summary mostra as estatísticas de execução da consulta:
- Documents Returned exibe 3809 para indicar que o plano de query vencedor retorna 3,809 documentos.
- Documents Examined exibe 21349 para indicar que o MongoDB precisou verificar todos os documentos 21,349 na coleção para encontrar os documentos correspondentes 3,809.
- Index Keys Examined exibe 0 para indicar que essa query não está usando um índice.
O MongoDB Compass exibe o estágio de query COLLSCAN para indicar que uma verificação de collection foi usada para essa query. 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 do Explain Plan também podem ser visualizados no formato JSON bruto clicando na opção Raw Output:

JSON bruto do plano de query sem índice do Compass

clique para ampliar

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

Consulta com índice

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

db.movies.createIndex( { year: 1 } )

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

db.movies.find(
   { year: { $gte: 2000, $lte: 2005 } }
).explain("executionStats")

{
  queryPlanner: {
    namespace: 'sample_mflix.movies',
    winningPlan: {
      stage: 'FETCH',
      inputStage: {
        stage: 'IXSCAN',
        keyPattern: {
          year: 1
        },
        '...': '...'
      },
      '...': '...'
    },
    '...': '...'
  },
  executionStats: {
    executionSuccess: true,
    nReturned: 3809,
    totalKeysExamined: 3809,
    totalDocsExamined: 3809,
    '...': '...'
  },
  '...': '...'
}

queryPlanner.winningPlan.inputStage.stage exibe IXSCAN para indicar o uso do índice.
executionStats.nReturned exibe 3809 para indicar que o plano de query vencedor retorna 3,809 documentos.
executionStats.totalKeysExamined exibe 3809 para indicar que o MongoDB verificou 3,809 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. O mongod não precisou verificar todos os documentos, e apenas os documentos correspondentes do 3,809 tiveram que ser colocados na memória. Isso resulta em uma query muito eficiente.
executionStats.totalDocsExamined exibe 3809 para indicar que o MongoDB digitalizou 3,809 documentos.

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

Clique Indexes na guia sample_mflix.movies collection.
Clique em Create e selecione Index no menu suspenso.
Selecione year no menu suspenso Select or type a field name.
Selecione 1 (asc) no menu suspenso Select a type.
Clique em Create Index.

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:

Compass mostrando o índice do ano na aba Índices

clique para ampliar

Retorne à aba Documents para a coleção sample_mflix.movies e execute novamente a query da etapa anterior:

{ year: { $gte: 2000, $lte: 2005 } }

Abra o modal Explain Plan. O MongoDB Compass exibe o plano de query da seguinte maneira:

Compass explica o plano com o índice do ano

clique para ampliar

Árvore visual

O Query Performance Summary mostra as estatísticas de execução da consulta:
- Documents Returned exibe 3809 para indicar que o plano de query vencedor retorna 3,809 documentos.
- Documents Examined exibe 3809 para indicar que o MongoDB digitalizou 3,809 documentos.
- Index Keys Examined exibe 3809 para indicar que o MongoDB verificou 3,809 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 verificar todos os documentos, e somente os documentos correspondentes do 3,809 tiveram que ser colocados na memória. Isso resulta em uma query muito eficiente.
- Na parte inferior do Query Performance Summary, o MongoDB Compass mostra que a query utilizou o índice year.
À esquerda do Query Performance Summary, o MongoDB Compass exibe os estágios de query FETCH e IXSCAN. IXSCAN indica que mongod usou um índice para satisfazer a query antes de executar o estágio FETCH e recuperar os documentos.

Raw JSON

Os detalhes da explicação também podem ser visualizados no formato JSON bruto clicando na opção Raw Output:

Compass explica o plano com JSON bruto do índice do ano

clique para ampliar

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

Quando executada com um índice, a query verifica somente o número de entradas de índice e documentos que retorna, resultando em uma query mais eficiente.

Comparar Desempenho dos Índices

Para comparar manualmente o desempenho de uma consulta usando mais de um índice, você pode usar o método em hint() explain() conjunto com o método.

Considere a seguinte query:

db.movies.find( {
   year: {
      $gte: 2000, $lte: 2005
   },
   rated: "PG"
} )

Esta query corresponde a 235 documentos.

Para dar suporte à consulta, adicione um índice composto. Com índices compostos, a ordem dos campos é importante.

Por exemplo, adicione os dois índices compostos a seguir. O primeiro índice ordena primeiro pelo campo year e depois pelo campo rated. O segundo índice ordena primeiro por rated e, em seguida, pelo campo year.

db.movies.createIndex( { year: 1, rated: 1 } )
db.movies.createIndex( { rated: 1, year: 1 } )

Avalie o efeito do primeiro índice na query:

db.movies.find(
   { year: { $gte: 2000, $lte: 2005 }, rated: "PG" }
).hint( { year: 1, rated: 1 } ).explain("executionStats")

{
  queryPlanner: {
    namespace: 'sample_mflix.movies',
    winningPlan: {
      stage: 'FETCH',
      inputStage: {
        stage: 'IXSCAN',
        keyPattern: {
          year: 1,
          rated: 1
        },
        '...': '...'
      },
      '...': '...'
    },
    '...': '...'
  },
  executionStats: {
    executionSuccess: true,
    nReturned: 235,
    totalKeysExamined: 246,
    totalDocsExamined: 235,
    '...': '...'
  },
  '...': '...'
}

O MongoDB escaneou 246 chaves de índice (executionStats.totalKeysExamined) para retornar 235 documentos correspondentes (executionStats.nReturned).

Avalie o efeito do segundo índice na query:

db.movies.find(
   { year: { $gte: 2000, $lte: 2005 }, rated: "PG" }
).hint( { rated: 1, year: 1 } ).explain("executionStats")

{
  queryPlanner: {
    namespace: 'sample_mflix.movies',
    winningPlan: {
      stage: 'FETCH',
      inputStage: {
        stage: 'IXSCAN',
        keyPattern: {
          rated: 1,
          year: 1
        },
        '...': '...'
      },
      '...': '...'
    },
    '...': '...'
  },
  executionStats: {
    executionSuccess: true,
    nReturned: 235,
    totalKeysExamined: 235,
    totalDocsExamined: 235,
    '...': '...'
  },
  '...': '...'
}

O MongoDB escaneou 235 chaves de índice (executionStats.totalKeysExamined) para retornar 235 documentos correspondentes (executionStats.nReturned).

O segundo índice composto, { rated: 1, year: 1 }, é, portanto, o índice mais eficiente para suportar a query de exemplo , pois o servidor MongoDB só precisa verificar 235 index keys para encontrar todos os documentos correspondentes usando esse índice, em comparação com 246 quando usando o índice composto { year: 1, rated: 1 }.

Dica

Voltar

Explicação de resultados

Explicar queries lentas