Explorar guías rápidas · SQL Server
Referencia rápida de Query Store
Usa Query Store de SQL Server para encontrar regresiones, comparar planes, analizar el historial de ejecución, forzar planes o deshacer su forzado con seguridad, y entender cuándo los datos de Query Store pueden llevarte a conclusiones equivocadas.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Comprobar si Query Store está habilitado
- 2. Encontrar las consultas principales por duración media
- 3. Encontrar las consultas principales por CPU total
- 4. Encontrar las consultas principales por lecturas lógicas
- 5. Mostrar todos los planes de una consulta
- 6. Comparar la ejecución por plan
- 7. Comparar una consulta antes y después de una ventana de cambio
- 8. Forzar un plan que se sabe que es bueno
- 9. Deshacer el forzado de un plan
- 10. Encontrar consultas con varios planes
- 11. Mostrar el historial de ejecución reciente de una consulta
- Qué significa el resultado
- Qué revisar
- Misma consulta, plan diferente, gran diferencia de ejecución
- La duración aumenta pero la CPU no
- Aumentan tanto la CPU como las lecturas lógicas
- Un plan solo predomina después de un despliegue
- Duración media alta con muy pocas ejecuciones
- Notas de producción
- Query Store guarda historial, pero no un historial infinito
- Las marcas de tiempo de Query Store se almacenan en metadatos orientados a UTC
- Las estadísticas de ejecución están agregadas
- Las medias ponderadas son mejores que promediar medias
- El forzado de planes es una herramienta operativa potente
- Query Store puede pasar a solo lectura
- Errores comunes
- 1. Promediar avg_duration directamente entre intervalos
- 2. Suponer que varios planes significan parameter sniffing
- 3. Forzar el plan que parece más rápido sin contexto
- 4. Tratar el forzado de planes como la solución definitiva
- 5. Ignorar las condiciones de todo el servidor
- 6. Comparar marcas de tiempo UTC con horas locales sin convertirlas
- 7. Suponer que Query Store tiene el historial completo
- Siguiente paso
- Para profundizar
Problema
Una consulta era rápida ayer y hoy es lenta, un despliegue cambió el rendimiento, o un problema intermitente ya desapareció antes de que pudieras revisar la carga de trabajo en vivo.
sys.dm_exec_requests solo muestra lo que se está ejecutando ahora. Query Store te ayuda a responder preguntas históricas:
- ¿Qué consultas consumieron más CPU o más duración a lo largo del tiempo?
- ¿Qué consulta sufrió una regresión?
- ¿Cambió SQL Server de plan de ejecución?
- ¿Qué plan era más rápido?
- ¿Cuándo empezó la regresión?
- ¿Se puede forzar temporalmente un plan que se sabe que es bueno?
- ¿El problema se limita a una consulta o forma parte de un cambio más amplio en la carga de trabajo?
Query Store es más útil cuando necesitas historial, comparación de planes y análisis de regresiones.
Respuesta rápida
Empieza con Query Store habilitado y usa las vistas integradas para encontrar las consultas costosas según su ejecución reciente.
SELECT TOP (20)
q.query_id,
qt.query_sql_text,
p.plan_id,
rs.count_executions,
CAST(rs.avg_duration / 1000.0 AS decimal(18,2)) AS avg_duration_ms,
CAST(rs.avg_cpu_time / 1000.0 AS decimal(18,2)) AS avg_cpu_ms,
rs.avg_logical_io_reads,
rsi.start_time,
rsi.end_time
FROM sys.query_store_query_text AS qt
INNER JOIN sys.query_store_query AS q
ON q.query_text_id = qt.query_text_id
INNER JOIN sys.query_store_plan AS p
ON p.query_id = q.query_id
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
INNER JOIN sys.query_store_runtime_stats_interval AS rsi
ON rsi.runtime_stats_interval_id = rs.runtime_stats_interval_id
WHERE
rsi.end_time > DATEADD(hour, -1, SYSUTCDATETIME())
ORDER BY
rs.avg_duration DESC;
Úsala como punto de partida y luego agrupa por consulta y por plan para comparar el comportamiento histórico.
Código / comandos
1. Comprobar si Query Store está habilitado
SELECT
actual_state_desc,
desired_state_desc,
readonly_reason,
current_storage_size_mb,
max_storage_size_mb,
query_capture_mode_desc,
size_based_cleanup_mode_desc,
stale_query_threshold_days
FROM sys.database_query_store_options;
Lo que normalmente quieres ver:
actual_state_desc = READ_WRITE- suficiente almacenamiento libre en Query Store
- un modo de captura adecuado para la carga de trabajo
Si Query Store está en READ_ONLY, no des por hecho que la recopilación funciona con normalidad.
2. Encontrar las consultas principales por duración media
SELECT TOP (20)
q.query_id,
qt.query_sql_text,
SUM(rs.count_executions) AS executions,
CAST(
SUM(rs.avg_duration * rs.count_executions)
/ NULLIF(SUM(rs.count_executions), 0)
/ 1000.0
AS decimal(18,2)
) AS weighted_avg_duration_ms
FROM sys.query_store_query_text AS qt
INNER JOIN sys.query_store_query AS q
ON q.query_text_id = qt.query_text_id
INNER JOIN sys.query_store_plan AS p
ON p.query_id = q.query_id
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
GROUP BY
q.query_id,
qt.query_sql_text
ORDER BY
weighted_avg_duration_ms DESC;
Ponderar por el número de ejecuciones es importante.
Una simple media de medias puede dar una imagen distorsionada de la carga de trabajo cuando los intervalos de ejecución contienen números de ejecuciones muy distintos.
3. Encontrar las consultas principales por CPU total
SELECT TOP (20)
q.query_id,
qt.query_sql_text,
SUM(rs.count_executions) AS executions,
CAST(
SUM(rs.avg_cpu_time * rs.count_executions)
/ 1000.0
AS decimal(18,2)
) AS total_cpu_ms
FROM sys.query_store_query_text AS qt
INNER JOIN sys.query_store_query AS q
ON q.query_text_id = qt.query_text_id
INNER JOIN sys.query_store_plan AS p
ON p.query_id = q.query_id
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
GROUP BY
q.query_id,
qt.query_sql_text
ORDER BY
total_cpu_ms DESC;
Suele ser más útil que la CPU media cuando quieres saber qué consulta consumió más CPU en total.
4. Encontrar las consultas principales por lecturas lógicas
SELECT TOP (20)
q.query_id,
qt.query_sql_text,
SUM(rs.count_executions) AS executions,
CAST(
SUM(rs.avg_logical_io_reads * rs.count_executions)
AS decimal(18,2)
) AS total_logical_reads
FROM sys.query_store_query_text AS qt
INNER JOIN sys.query_store_query AS q
ON q.query_text_id = qt.query_text_id
INNER JOIN sys.query_store_plan AS p
ON p.query_id = q.query_id
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
GROUP BY
q.query_id,
qt.query_sql_text
ORDER BY
total_logical_reads DESC;
Un número alto de lecturas lógicas puede revelar una carga de trabajo costosa incluso cuando la duración parece aceptable porque los datos ya están en caché.
5. Mostrar todos los planes de una consulta
DECLARE @query_id bigint = 123;
SELECT
p.query_id,
p.plan_id,
p.is_forced_plan,
p.force_failure_count,
p.last_force_failure_reason_desc,
p.last_execution_time,
p.query_plan
FROM sys.query_store_plan AS p
WHERE
p.query_id = @query_id
ORDER BY
p.plan_id;
Úsala cuando sospeches una regresión de plan.
Que una consulta tenga varios planes no es automáticamente un problema.
La pregunta importante es si los distintos planes se corresponden con un comportamiento de ejecución sustancialmente diferente.
6. Comparar la ejecución por plan
DECLARE @query_id bigint = 123;
SELECT
p.plan_id,
p.is_forced_plan,
SUM(rs.count_executions) AS executions,
CAST(
SUM(rs.avg_duration * rs.count_executions)
/ NULLIF(SUM(rs.count_executions), 0)
/ 1000.0
AS decimal(18,2)
) AS weighted_avg_duration_ms,
CAST(
SUM(rs.avg_cpu_time * rs.count_executions)
/ NULLIF(SUM(rs.count_executions), 0)
/ 1000.0
AS decimal(18,2)
) AS weighted_avg_cpu_ms,
CAST(
SUM(rs.avg_logical_io_reads * rs.count_executions)
/ NULLIF(SUM(rs.count_executions), 0)
AS decimal(18,2)
) AS weighted_avg_logical_reads,
MIN(rsi.start_time) AS first_interval,
MAX(rsi.end_time) AS last_interval
FROM sys.query_store_plan AS p
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
INNER JOIN sys.query_store_runtime_stats_interval AS rsi
ON rsi.runtime_stats_interval_id = rs.runtime_stats_interval_id
WHERE
p.query_id = @query_id
GROUP BY
p.plan_id,
p.is_forced_plan
ORDER BY
weighted_avg_duration_ms DESC;
Es una de las consultas de Query Store más útiles para analizar regresiones de plan.
7. Comparar una consulta antes y después de una ventana de cambio
DECLARE @query_id bigint = 123;
DECLARE @change_time datetimeoffset = '2026-10-04T14:00:00-04:00';
SELECT
CASE
WHEN rsi.end_time <= @change_time THEN 'Before'
ELSE 'After'
END AS period,
p.plan_id,
SUM(rs.count_executions) AS executions,
CAST(
SUM(rs.avg_duration * rs.count_executions)
/ NULLIF(SUM(rs.count_executions), 0)
/ 1000.0
AS decimal(18,2)
) AS weighted_avg_duration_ms,
CAST(
SUM(rs.avg_cpu_time * rs.count_executions)
/ NULLIF(SUM(rs.count_executions), 0)
/ 1000.0
AS decimal(18,2)
) AS weighted_avg_cpu_ms
FROM sys.query_store_plan AS p
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
INNER JOIN sys.query_store_runtime_stats_interval AS rsi
ON rsi.runtime_stats_interval_id = rs.runtime_stats_interval_id
WHERE
p.query_id = @query_id
AND (
rsi.end_time <= @change_time
OR rsi.start_time >= @change_time
)
GROUP BY
CASE
WHEN rsi.end_time <= @change_time THEN 'Before'
ELSE 'After'
END,
p.plan_id
ORDER BY
period,
p.plan_id;
Úsala después de:
- cambios de nivel de compatibilidad
- despliegues
- cambios de índices
- cambios de estadísticas
- cambios de configuración
Ten cuidado con los intervalos que abarcan el momento del cambio. El filtro anterior excluye esos intervalos mixtos.
8. Forzar un plan que se sabe que es bueno
Hazlo solo después de haber identificado una consulta concreta y validado el plan.
EXEC sys.sp_query_store_force_plan
@query_id = 123,
@plan_id = 456;
Después, verifica:
SELECT
query_id,
plan_id,
is_forced_plan,
force_failure_count,
last_force_failure_reason_desc
FROM sys.query_store_plan
WHERE
query_id = 123;
El forzado de planes es una mitigación, no necesariamente la solución definitiva.
9. Deshacer el forzado de un plan
EXEC sys.sp_query_store_unforce_plan
@query_id = 123,
@plan_id = 456;
Deshaz el forzado cuando:
- la causa raíz esté corregida
- el plan forzado ya no se ajuste a la carga de trabajo
- el forzado provoque regresiones
- el esquema o la distribución de los datos hayan cambiado lo suficiente como para que el plan anterior ya no sea adecuado
10. Encontrar consultas con varios planes
SELECT
q.query_id,
COUNT(*) AS plan_count
FROM sys.query_store_query AS q
INNER JOIN sys.query_store_plan AS p
ON p.query_id = q.query_id
GROUP BY
q.query_id
HAVING
COUNT(*) > 1
ORDER BY
plan_count DESC;
Es solo una consulta de exploración.
Tener varios planes puede ser normal.
Usa las evidencias de ejecución para decidir si la variación es perjudicial.
11. Mostrar el historial de ejecución reciente de una consulta
DECLARE @query_id bigint = 123;
SELECT
rsi.start_time,
rsi.end_time,
p.plan_id,
rs.count_executions,
CAST(rs.avg_duration / 1000.0 AS decimal(18,2)) AS avg_duration_ms,
CAST(rs.avg_cpu_time / 1000.0 AS decimal(18,2)) AS avg_cpu_ms,
rs.avg_logical_io_reads
FROM sys.query_store_plan AS p
INNER JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
INNER JOIN sys.query_store_runtime_stats_interval AS rsi
ON rsi.runtime_stats_interval_id = rs.runtime_stats_interval_id
WHERE
p.query_id = @query_id
ORDER BY
rsi.start_time DESC,
p.plan_id;
Sirve para ver exactamente cuándo una consulta se volvió más lenta y si un cambio de plan coincide con la regresión.
Qué significa el resultado
| Campo | Por qué importa |
|---|---|
query_id |
Identificador estable de Query Store para la entrada de la consulta. |
plan_id |
Identificador de Query Store para un plan de ejecución capturado. |
count_executions |
Número de ejecuciones representadas por una fila de estadísticas de ejecución. |
avg_duration |
Duración media de las ejecuciones de esa entrada de estadísticas de ejecución. |
avg_cpu_time |
Tiempo medio de CPU de las ejecuciones de la entrada. |
avg_logical_io_reads |
Lecturas lógicas medias asociadas a la entrada. |
is_forced_plan |
Indica si el forzado de planes de Query Store está activo actualmente. |
force_failure_count |
Número de veces que SQL Server no pudo forzar el plan. |
last_force_failure_reason_desc |
Motivo del fallo más reciente al forzar el plan. |
runtime_stats_interval_id |
Agrupa las estadísticas de ejecución en los intervalos configurados de Query Store. |
start_time / end_time |
Límites del intervalo de ejecución. |
Qué revisar
Misma consulta, plan diferente, gran diferencia de ejecución
Es la evidencia clásica de una regresión de plan.
Valida que:
- el periodo más lento coincide con el nuevo plan
- el número de ejecuciones es suficiente para comparar
- los valores de los parámetros y la carga de trabajo son comparables
- la regresión no se debe a bloqueos ni a presión en todo el servidor
La duración aumenta pero la CPU no
Entre las posibles causas están:
- bloqueos
- esperas de E/S
- esperas de memoria
- concurrencia
- presión sobre recursos externos
No des por hecho que el plan es la única variable.
Aumentan tanto la CPU como las lecturas lógicas
Esto suele apuntar a una ruta de acceso menos eficiente.
Revisa en el plan:
- exploraciones (scans) más grandes
- una estrategia de combinación (join) diferente
- problemas de estimación de filas
- multiplicación de búsquedas (lookups)
- índices que faltan o que han cambiado
Un plan solo predomina después de un despliegue
Buen candidato para un análisis de antes y después.
Compara:
- el nivel de compatibilidad
- la parametrización
- las estadísticas
- los índices
- el texto de la consulta
- el comportamiento del optimizador
Duración media alta con muy pocas ejecuciones
No sobredimensiones la prioridad de una consulta puntual sin entender su impacto en el negocio.
La frecuencia y la importancia cuentan.
Notas de producción
Query Store guarda historial, pero no un historial infinito
La retención depende de:
- el tamaño máximo de almacenamiento
- la limpieza de consultas obsoletas
- el modo de captura
- el estado de lectura/escritura
Si el almacén se llena o pasa a solo lectura, la recopilación puede detenerse o degradarse.
Las marcas de tiempo de Query Store se almacenan en metadatos orientados a UTC
Ten cuidado al comparar las marcas de tiempo de los intervalos de Query Store con las horas locales de un despliegue o de un incidente.
Normaliza las zonas horarias antes de sacar conclusiones.
Las estadísticas de ejecución están agregadas
Query Store no almacena cada ejecución como una fila individual en las vistas de estadísticas de ejecución.
Almacena estadísticas agregadas por intervalo.
Eso significa que:
- los valores atípicos pueden quedar ocultos por las medias
- ejecuciones muy distintas pueden agruparse
- la ponderación por número de ejecuciones importa
Las medias ponderadas son mejores que promediar medias
Al combinar intervalos, pondera por count_executions.
De lo contrario, un intervalo con 1 ejecución puede influir en tu resultado tanto como otro intervalo con 10.000 ejecuciones.
El forzado de planes es una herramienta operativa potente
El forzado de planes puede estabilizar una regresión rápidamente, pero hay que monitorearlo.
Un plan forzado puede dejar de ser adecuado más adelante debido a:
- el crecimiento de los datos
- cambios de esquema
- cambios de índices
- cambios en la distribución de los parámetros
- cambios en el optimizador
Query Store puede pasar a solo lectura
Entre las causas habituales están alcanzar los límites de almacenamiento configurados u otras transiciones de estado.
Comprueba siempre sys.database_query_store_options antes de dar por hecho que se están capturando datos nuevos.
Errores comunes
1. Promediar avg_duration directamente entre intervalos
Esto produce un resultado matemáticamente engañoso cuando los intervalos contienen números de ejecuciones distintos.
Usa medias ponderadas.
2. Suponer que varios planes significan parameter sniffing
Los planes múltiples pueden deberse a muchas cosas.
Trata la variación de planes como una evidencia, no como un diagnóstico.
3. Forzar el plan que parece más rápido sin contexto
Un plan rápido para un conjunto de parámetros puede ser malo para otro.
Valida la forma de la carga de trabajo antes de forzarlo.
4. Tratar el forzado de planes como la solución definitiva
El forzado puede ser una mitigación excelente.
Pero aun así tienes que investigar:
- las estadísticas
- los índices
- la estimación de cardinalidad
- el diseño de la consulta
- la sensibilidad a los parámetros
- los cambios de compatibilidad
5. Ignorar las condiciones de todo el servidor
Un intervalo lento de Query Store puede coincidir con:
- saturación de CPU
- bloqueos
- latencia de almacenamiento
- presión de memoria
No atribuyas cada regresión al plan.
6. Comparar marcas de tiempo UTC con horas locales sin convertirlas
Esto puede desplazar varias horas tu correlación con el incidente.
Normaliza primero.
7. Suponer que Query Store tiene el historial completo
La retención, la limpieza, el modo de captura y los límites de almacenamiento afectan a lo que sigue disponible.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.