Docs Menu
Docs Home
/ /

PlanCache.list() (método mongosh)

PlanCache.list(<pipeline>)

Devuelve una matriz de planificar entradas de caché para una colección.

El método solo está disponible desde el de una colección específica; es plan cache object decir

db.collection.getPlanCache().list(<pipeline>)
Parameter
Tipo
Descripción

Arreglo

Opcional. Pipeline de agregación para filtrar/procesar las formas del query.

Puede ejecutar este método desde una instancia o. Al ejecutarse en un clúster fragmentado, el método devuelve información de entrada mongod de la caché del plan de un único miembro en cada conjunto de réplicas de fragmentos.mongos Este miembro se identifica con los campos de fragmento y host. Consulte también Preferencia de lectura.

El método encapsula PlanCache.list() $planCacheStats la canalización de agregación. Es decir,

db.collection.getPlanCache().list([<stage1>, <stage2>, ...] )

es equivalente a

db.collection.aggregate([ <$planCacheStats stage>, <stage1>, <stage2>, ... ]).toArray();

Para obtener detalles sobre la salida, consulte Salida de $planCacheStats.

No todas las consultas colocan automáticamente un plan de consulta en la memoria caché. PlanCache.list() devuelve una matriz vacía si actualmente no hay formas de consulta con planes de consulta almacenados en caché.

Tip

PlanCache.list() no está permitido en las transacciones.

Para identificar consultas lentas con la misma forma de consulta, cada una se asocia a un queryHash.queryHash es una cadena hexadecimal que representa un hash de la forma de consulta y depende únicamente de esta.

Nota

Como con cualquier función encriptada, dos formas del query diferentes pueden dar como resultado el mismo valor encriptado. Sin embargo, es poco probable que ocurran colisiones encriptadas entre diferentes formas del query.

El optimizador de consultas solo almacena en caché los planes de aquellas formas de consulta que pueden tener más de un plan viable.

Cada entrada en la caché del plan está asociada con un queryHash.

PlanCache.list() observa la preferencia de lectura al seleccionar el/los host(s) desde los cuales devolver la información de caché del plan.

Las aplicaciones pueden dirigirse a diferentes miembros de un conjunto de réplicas. Por lo tanto, cada miembro del conjunto de réplicas puede recibir comandos de lectura diferentes y tener información de caché de plan diferente a la de los demás miembros. Sin embargo, ejecutar PlanCache.list() en un conjunto de réplicas o en un clúster fragmentado sigue las reglas de preferencia de lectura habituales. Es decir, en un conjunto de réplicas, la operación recopila información de caché de plan de un solo miembro del conjunto de réplicas, mientras que en un clúster fragmentado, la operación recopila información de caché de plan de un solo miembro de cada conjunto de réplicas fragmentado.

En los sistemas que se ejecutan con, el authorization planCacheRead usuario debe tener el privilegio para la recopilación.

Nota

  • No todas las consultas colocan automáticamente un plan de consulta en la memoria caché. PlanCache.list() devuelve una matriz vacía si actualmente no hay formas de consulta con planes de consulta almacenados en caché.

  • Para obtener detalles sobre la salida, consulte Salida de $planCacheStats.

Los ejemplos de esta sección utilizan la siguiente colección orders:

db.orders.insertMany( [
{ "_id" : 1, "item" : "abc", "price" : Decimal128("12"), "quantity" : 2, "type": "apparel" },
{ "_id" : 2, "item" : "jkl", "price" : Decimal128("20"), "quantity" : 1, "type": "electronics" },
{ "_id" : 3, "item" : "abc", "price" : Decimal128("10"), "quantity" : 5, "type": "apparel" },
{ "_id" : 4, "item" : "abc", "price" : Decimal128("8"), "quantity" : 10, "type": "apparel" },
{ "_id" : 5, "item" : "jkl", "price" : Decimal128("15"), "quantity" : 15, "type": "electronics" }
] )

Cree los siguientes índices en la colección:

db.orders.createIndex( { item: 1 } );
db.orders.createIndex( { item: 1, quantity: 1 } );
db.orders.createIndex( { item: 1, price: 1 }, { partialFilterExpression: { price: { $gte: Decimal128("10")} } } );
db.orders.createIndex( { quantity: 1 } );
db.orders.createIndex( { quantity: 1, type: 1 } );

Nota

El índice { item: 1, price: 1 } es un índice parcial y solo indexa documentos con el price campo mayor o igual Decimal128("10") a.

Ejecute algunas consultas contra la colección:

db.orders.find( { item: "abc", price: { $gte: Decimal128("10") } } )
db.orders.find( { item: "abc", price: { $gte: Decimal128("5") } } )
db.orders.find( { quantity: { $gte: 20 } } )
db.orders.find( { quantity: { $gte: 5 }, type: "apparel" } )

Lo siguiente devuelve las formas de orders consulta que tienen planes almacenados en caché para la colección:

db.orders.getPlanCache().list()

El método devuelve una matriz de las formas de consulta almacenadas en caché. En el ejemplo, la colección orders tenía planes de consulta almacenados en caché asociados con las siguientes formas:

[
{
"createdFromQuery" : {
"query" : { "quantity" : { "$gte" : 5 }, "type" : "apparel" },
"sort" : { },
"projection" : { }
},
"queryHash" : "4D151C4C",
"planCacheKey" : "DD67E353",
"isActive" : false,
"works" : Long(4),
"cachedPlan" : {
"stage" : "FETCH",
"filter" : { "type" : { "$eq" : "apparel" } },
"inputStage" : {
"stage" : "IXSCAN",
"keyPattern" : { "quantity" : 1 },
"indexName" : "quantity_1",
"isMultiKey" : false,
"multiKeyPaths" : { "quantity" : [ ] },
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : { "quantity" : [ "[5.0, inf.0]" ] }
}
},
"timeOfCreation" : ISODate("2020-02-06T15:57:18.219Z"),
"creationExecStats" : [
{
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"totalKeysExamined" : 3,
"totalDocsExamined" : 3,
"executionStages" : {
"stage" : "FETCH",
"filter" : { "type" : { "$eq" : "apparel" } },
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 4,
...
}
},
{
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"totalKeysExamined" : 3,
"totalDocsExamined" : 2,
"executionStages" : {
"stage" : "FETCH",
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 4,
...
}
}
],
"candidatePlanScores" : [
1.5002,
1.5002
],
"indexFilterSet" : false,
"estimatedSizeBytes" : Long(3160), // Available starting in MongoDB 5.0
"host" : "mongodb1.example.net:27018",
"shard" : "shardA" // Available if run on sharded cluster
},
{
"createdFromQuery" : {
"query" : { "quantity" : { "$gte" : 20 } },
"sort" : { },
"projection" : { }
},
"queryHash" : "23B19B75",
"planCacheKey" : "6F23F858",
"isActive" : false,
"works" : Long(1),
...
},
{
"createdFromQuery" : {
"query" : { "item" : "abc", "price" : { "$gte" : Decimal128("5") } },
"sort" : { },
"projection" : { }
},
"queryHash" : "117A6B10",
"planCacheKey" : "A1824628",
"isActive" : false,
"works" : Long(4),
...
},
{
"createdFromQuery" : {
"query" : { "item" : "abc", "price" : { "$gte" : Decimal128("10") } },
"sort" : { },
"projection" : { }
},
"queryHash" : "117A6B10",
"planCacheKey" : "2E6E536B",
"isActive" : false,
"works" : Long(3),
...
}
]

Para obtener detalles sobre la salida, consulte Salida de $planCacheStats.

Para obtener una lista de todas las formas de consulta con un plan en caché, puede PlanCache.list() usar. Por ejemplo, la siguiente operación pasa por una canalización con una etapa $project para generar únicamente los campos createdFromQuery y queryHash.

db.orders.getPlanCache().list( [ { $project: {createdFromQuery: 1, queryHash: 1 } } ] )

La operación devuelve las siguientes formas de consulta:

[
{ "createdFromQuery" : { "query" : { "quantity" : { "$gte" : 5 }, "type" : "apparel" }, "sort" : { }, "projection" : { } }, "queryHash" : "4D151C4C" },
{ "createdFromQuery" : { "query" : { "quantity" : { "$gte" : 20 } }, "sort" : { }, "projection" : { } }, "queryHash" : "23B19B75" },
{ "createdFromQuery" : { "query" : { "item" : "abc", "price" : { "$gte" : Decimal128("5") } }, "sort" : { }, "projection" : { } }, "queryHash" : "117A6B10" },
{ "createdFromQuery" : { "query" : { "item" : "abc", "price" : { "$gte" : Decimal128("10") } }, "sort" : { }, "projection" : { } }, "queryHash" : "117A6B10" }
]

Para obtener detalles sobre la salida, consulte Salida de $planCacheStats.

Para devolver información de caché de plan para una forma de consulta particular, pase una canalización con un $match en el campo planCacheKey.

db.orders.getPlanCache().list([ { $match: { planCacheKey: "DD67E353"} } ] )

La operación devuelve lo siguiente:

[
{
"createdFromQuery" : {
"query" : {
"quantity" : {
"$gte" : 5
},
"type" : "apparel"
},
"sort" : {
},
"projection" : {
}
},
"queryHash" : "4D151C4C",
"planCacheKey" : "DD67E353",
"isActive" : false,
"works" : Long(4),
"cachedPlan" : {
"stage" : "FETCH",
"filter" : {
"type" : {
"$eq" : "apparel"
}
},
"inputStage" : {
"stage" : "IXSCAN",
"keyPattern" : {
"quantity" : 1
},
"indexName" : "quantity_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"quantity" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
"quantity" : [
"[5.0, inf.0]"
]
}
}
},
"timeOfCreation" : ISODate("2020-02-11T17:14:33.873Z"),
"creationExecStats" : [
{
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"totalKeysExamined" : 3,
"totalDocsExamined" : 3,
"executionStages" : {
"stage" : "FETCH",
"filter" : {
"type" : {
"$eq" : "apparel"
}
},
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 4,
"advanced" : 2,
"needTime" : 1,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"docsExamined" : 3,
"alreadyHasObj" : 0,
"inputStage" : {
"stage" : "IXSCAN",
"nReturned" : 3,
"executionTimeMillisEstimate" : 0,
"works" : 4,
"advanced" : 3,
"needTime" : 0,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"keyPattern" : {
"quantity" : 1
},
"indexName" : "quantity_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"quantity" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
"quantity" : [
"[5.0, inf.0]"
]
},
"keysExamined" : 3,
"seeks" : 1,
"dupsTested" : 0,
"dupsDropped" : 0
}
}
},
{
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"totalKeysExamined" : 3,
"totalDocsExamined" : 2,
"executionStages" : {
"stage" : "FETCH",
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 4,
"advanced" : 2,
"needTime" : 1,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"docsExamined" : 2,
"alreadyHasObj" : 0,
"inputStage" : {
"stage" : "IXSCAN",
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 4,
"advanced" : 2,
"needTime" : 1,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"keyPattern" : {
"quantity" : 1,
"type" : 1
},
"indexName" : "quantity_1_type_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"quantity" : [ ],
"type" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
"quantity" : [
"[5.0, inf.0]"
],
"type" : [
"[\"apparel\", \"apparel\"]"
]
},
"keysExamined" : 3,
"seeks" : 2,
"dupsTested" : 0,
"dupsDropped" : 0
}
}
}
],
"candidatePlanScores" : [
1.5002,
1.5002
],
"indexFilterSet" : false,
"estimatedSizeBytes" : Long(3160), // Available starting in MongoDB 5.0
"host" : "mongodb1.example.net:27018",
"shard" : "shardA" // Available if run on sharded cluster
}
]

Para obtener detalles sobre la salida, consulte Salida de $planCacheStats.

Volver

PlanCache.ayuda

En esta página