Interpretar os resultados do plano de explicação

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 query 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:

Raw JSON

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

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.

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:

Raw JSON

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

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

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 quantity e depois pelo campo type. O segundo índice ordena primeiro por type e, em seguida, pelo campo quantity.

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

Avalie o efeito do primeiro índice na query:

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

O método explain() retorna a seguinte saída:

{
   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: {
      ...
      }
   },
   ...
}

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

Avalie o efeito do segundo índice na query:

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

O método explain() retorna a seguinte saída:

{
   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: {
         ...
      }
   },
   ...
}

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

O segundo índice composto, { type: 1, quantity: 1 }, é, portanto, o índice mais eficiente para dar suporte à consulta de exemplo, pois o servidor MongoDB só precisa escanear 2 index keys para encontrar todos os documentos correspondentes usando esse índice, em comparação com 5 ao usar o índice composto { quantity: 1, type: 1 }.