Interpreta los resultados del plan de explicación

La siguiente query recupera documentos donde el campo quantity tiene un valor entre 100 y 200, inclusivo:

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

La query devuelve los siguientes 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 ver el plan de consulta seleccionado, encadene el cursor.explain("executionStats") método del cursor al final del comando de búsqueda:

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

explain() devuelve los siguientes resultados:

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

• queryPlanner.winningPlan.queryPlan.stage muestra COLLSCAN para indicar un escaneo de colección.

  Los análisis de la colección indican que tuvo que analizar toda la colección, documento por documento, para identificar los resultados. Esta operación suele ser costosa y puede generar consultas lentas.mongod

• executionStats.nReturned muestra 3 para indicar que el plan del query ganador devuelve tres documentos.

• executionStats.totalKeysExamined muestra 0 para indicar que esta query no está usando el índice.

• executionStats.totalDocsExamined exhibe 10 para indicar que MongoDB tuvo que escanear diez documentos (es decir, todos los documentos de la colección) para encontrar los tres documentos coincidentes.

La siguiente query recupera documentos donde el campo quantity tiene un valor entre 100 y 200, inclusivo:

Copia el siguiente filtro en la barra de query de Compass y haz clic Find:

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

La query devuelve los siguientes documentos:

Para ver el plan del query seleccionado:

1. Haga clic en la pestaña Explain Plan para la colección test.inventory.

2. Haga clic en Explain.

MongoDB Compass muestra el plan del query de la siguiente manera:

Raw JSON

Los detalles de la explicación también se pueden ver en formato JSON sin procesar haciendo clic en Raw JSON debajo de la barra de consulta:

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

Para ver las estadísticas del plan de consulta, utilice el explain() método:

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

El método explain() devuelve los siguientes 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 muestra IXSCAN para indicar el uso del índice.

• executionStats.nReturned muestra 3 para indicar que el plan del query ganador devuelve tres documentos.

• executionStats.totalKeysExamined muestra 3 para indicar que MongoDB escaneó tres entradas de índice. La cantidad de llaves examinadas coincide con la cantidad de documentos devueltos, lo que significa que mongod solo tuvo que examinar las llaves de índice para devolver los resultados. El mongod no tuvo que escanear todos los documentos, y solo fue necesario extraer a la memoria los tres documentos coincidentes. Esto da como resultado una consulta muy eficiente.

• executionStats.totalDocsExamined mostrar 3 para indicar que MongoDB ha analizado tres documentos.

1. Haga clic en la pestaña Indexes para la colección test.inventory.

2. Haga clic en Create Index.

3. Selecciona quantity del menú desplegable Select a field name.

4. Seleccione 1 (asc) del menú desplegable de tipo.

5. Haga clic en Create.

Ahora puedes ver tu índice recién creado en la pestaña Indexes:

Vuelve a la pestaña Explain Plan para la colección inventory y vuelve a ejecutar la consulta del paso anterior:

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

MongoDB Compass muestra el plan del query de la siguiente manera:

Raw JSON

Los detalles de la explicación también se pueden ver en formato JSON sin procesar haciendo clic en Raw JSON debajo de la barra de consulta:

Comparar el rendimiento de los índices

Para comparar manualmente el rendimiento de una query utilizando más de un índice, puedes utilizar el hint() método junto con el explain() método.

Considera el siguiente query:

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

La query devuelve los siguientes documentos:

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

Para respaldar la query, agregue un índice compuesto. Con los índices compuestos, el orden de los campos es importante.

Por ejemplo, añade los siguientes dos índices compuestos. El primer índice ordena primero por el campo quantity y luego por el campo type. El segundo índice ordena primero por type y luego por el campo quantity.

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

Evalúa el efecto del primer índice en la query:

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

El método devuelve la siguiente explain() salida:

{
   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 escaneó 5 claves de índice ( )executionStats.totalKeysExamined para 2 devolver documentos coincidentes (executionStats.nReturned).

Evaluar el efecto del segundo índice en la query:

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

El método devuelve la siguiente explain() salida:

{
   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 escaneó 2 claves de índice ( )executionStats.totalKeysExamined para 2 devolver documentos coincidentes (executionStats.nReturned).

El segundo índice compuesto,, { type: 1, quantity: 1 } es por lo tanto el índice más eficiente para soportar la consulta de ejemplo, ya que el servidor MongoDB solo necesita escanear 2 index keys para encontrar todos los documentos coincidentes usando este índice, en comparación con 5 cuando se usa el índice { quantity: 1, type: 1 } compuesto.