Explorar guías rápidas · SQL Server

Tecnología: SQL ServerCategoría: RendimientoNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Comprobar si Query Store está habilitado
  5. 2. Encontrar las consultas principales por duración media
  6. 3. Encontrar las consultas principales por CPU total
  7. 4. Encontrar las consultas principales por lecturas lógicas
  8. 5. Mostrar todos los planes de una consulta
  9. 6. Comparar la ejecución por plan
  10. 7. Comparar una consulta antes y después de una ventana de cambio
  11. 8. Forzar un plan que se sabe que es bueno
  12. 9. Deshacer el forzado de un plan
  13. 10. Encontrar consultas con varios planes
  14. 11. Mostrar el historial de ejecución reciente de una consulta
  15. Qué significa el resultado
  16. Qué revisar
  17. Misma consulta, plan diferente, gran diferencia de ejecución
  18. La duración aumenta pero la CPU no
  19. Aumentan tanto la CPU como las lecturas lógicas
  20. Un plan solo predomina después de un despliegue
  21. Duración media alta con muy pocas ejecuciones
  22. Notas de producción
  23. Query Store guarda historial, pero no un historial infinito
  24. Las marcas de tiempo de Query Store se almacenan en metadatos orientados a UTC
  25. Las estadísticas de ejecución están agregadas
  26. Las medias ponderadas son mejores que promediar medias
  27. El forzado de planes es una herramienta operativa potente
  28. Query Store puede pasar a solo lectura
  29. Errores comunes
  30. 1. Promediar avg_duration directamente entre intervalos
  31. 2. Suponer que varios planes significan parameter sniffing
  32. 3. Forzar el plan que parece más rápido sin contexto
  33. 4. Tratar el forzado de planes como la solución definitiva
  34. 5. Ignorar las condiciones de todo el servidor
  35. 6. Comparar marcas de tiempo UTC con horas locales sin convertirlas
  36. 7. Suponer que Query Store tiene el historial completo
  37. Siguiente paso
  38. 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.

Siguiente paso

Usa el patrón que encuentres para elegir la siguiente acción.

  • Misma consulta + plan nuevo + regresión clara → valida y plantéate forzar temporalmente el plan que se sabe que es bueno.
  • Sin cambio de plan + mayor duración → revisa los bloqueos, las esperas, la CPU y las condiciones de E/S.
  • CPU + lecturas en aumento con un plan nuevo → revisa la forma del plan de ejecución, las estimaciones y la indexación.
  • Query Store está en solo lectura → resuelve el problema de almacenamiento o de estado antes de confiar en datos recientes.
  • Ventana de historial muy corta → recopila más datos antes de hacer cambios estructurales.
  • El plan forzado está fallando → revisa last_force_failure_reason_desc y valida los cambios de esquema o de índices.
  • El problema es intermitente → combina Query Store con las DMV en vivo y el monitoreo para obtener una visión más completa.

← Todas las guías rápidas