Parcourir les aide-mémoire · SQL Server

Technologie: SQL ServerCatégorie: PerformanceNiveau: IntermédiaireMis à jour

Query Store : référence rapide

Utilisez Query Store dans SQL Server pour trouver les régressions, comparer les plans, analyser l’historique d’exécution, forcer ou annuler le forçage d’un plan sans risque, et savoir quand les données de Query Store peuvent vous induire en erreur.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Vérifier si Query Store est activé
  5. 2. Trouver les requêtes les plus lentes par durée moyenne
  6. 3. Trouver les requêtes les plus coûteuses en CPU total
  7. 4. Trouver les requêtes les plus coûteuses en lectures logiques
  8. 5. Afficher tous les plans d’une requête
  9. 6. Comparer l’exécution par plan
  10. 7. Comparer une requête avant et après une fenêtre de changement
  11. 8. Forcer un plan connu pour être bon
  12. 9. Annuler le forçage d’un plan
  13. 10. Trouver les requêtes ayant plusieurs plans
  14. 11. Afficher l’historique d’exécution récent d’une requête
  15. Interpréter le résultat
  16. Points à vérifier
  17. Même requête, plan différent, écart d’exécution important
  18. La durée augmente mais pas le CPU
  19. Le CPU et les lectures logiques augmentent tous les deux
  20. Un plan ne domine qu’après un déploiement
  21. Durée moyenne élevée avec un très faible nombre d’exécutions
  22. Notes de production
  23. Query Store conserve un historique, mais pas un historique infini
  24. Les horodatages de Query Store sont stockés dans des métadonnées orientées UTC
  25. Les statistiques d’exécution sont agrégées
  26. Les moyennes pondérées valent mieux que la moyenne des moyennes
  27. Le forçage de plan est un levier opérationnel puissant
  28. Query Store peut passer en lecture seule
  29. Erreurs fréquentes
  30. 1. Calculer directement la moyenne de avg_duration sur plusieurs intervalles
  31. 2. Supposer que plusieurs plans signifient un problème de parameter sniffing
  32. 3. Forcer le plan qui semble le plus rapide sans contexte
  33. 4. Considérer le forçage de plan comme le correctif définitif
  34. 5. Ignorer les conditions à l’échelle du serveur
  35. 6. Comparer des horodatages UTC à des heures locales sans conversion
  36. 7. Supposer que Query Store dispose d’un historique complet
  37. Étape suivante
  38. Pour aller plus loin

Problème

Une requête était rapide hier et lente aujourd’hui, un déploiement a modifié les performances, ou un problème intermittent a déjà disparu avant que vous ayez pu examiner la charge de travail en direct.

sys.dm_exec_requests ne montre que ce qui s’exécute en ce moment. Query Store vous aide à répondre aux questions historiques :

  • Quelles requêtes ont consommé le plus de CPU ou de durée au fil du temps ?
  • Quelle requête a régressé ?
  • SQL Server a-t-il changé de plan d’exécution ?
  • Quel plan était le plus rapide ?
  • Quand la régression a-t-elle commencé ?
  • Peut-on forcer temporairement un plan connu pour être bon ?
  • Le problème est-il limité à une seule requête ou s’inscrit-il dans un changement plus large de la charge de travail ?

Query Store est surtout utile lorsque vous avez besoin d’historique, de comparaison de plans et d’analyse des régressions.

Réponse rapide

Commencez avec Query Store activé et utilisez les vues intégrées pour trouver les requêtes coûteuses d’après leur exécution récente.

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;

Servez-vous-en comme point de départ, puis regroupez par requête et par plan pour comparer le comportement historique.

Code / commandes

1. Vérifier si Query Store est activé

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;

Ce que vous voulez généralement :

  • actual_state_desc = READ_WRITE
  • suffisamment d’espace de stockage libre pour Query Store
  • un mode de capture adapté à la charge de travail

Si Query Store est en READ_ONLY, ne supposez pas que la collecte fonctionne normalement.


2. Trouver les requêtes les plus lentes par durée moyenne

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;

La pondération par le nombre d’exécutions est importante.

Une simple moyenne des moyennes peut donner une image faussée de la charge de travail lorsque les intervalles d’exécution contiennent des nombres d’exécutions très différents.


3. Trouver les requêtes les plus coûteuses en 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;

C’est souvent plus utile que le CPU moyen lorsque vous voulez savoir quelle requête a consommé le plus de CPU au total.


4. Trouver les requêtes les plus coûteuses en lectures logiques

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 volume élevé de lectures logiques peut révéler une charge de travail coûteuse même lorsque la durée semble acceptable parce que les données sont déjà en cache.


5. Afficher tous les plans d’une requête

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;

Utilisez cette requête lorsque vous soupçonnez une régression de plan.

Une requête avec plusieurs plans n’est pas automatiquement un problème.

La vraie question est de savoir si les différents plans correspondent à des comportements d’exécution sensiblement différents.


6. Comparer l’exécution par 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;

C’est l’une des requêtes Query Store les plus utiles pour analyser une régression de plan.


7. Comparer une requête avant et après une fenêtre de changement

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;

Utilisez cette requête après :

  • des changements de niveau de compatibilité
  • des déploiements
  • des modifications d’index
  • des modifications de statistiques
  • des changements de configuration

Méfiez-vous des intervalles qui chevauchent l’horodatage du changement. Le filtre ci-dessus exclut ces intervalles mixtes.


8. Forcer un plan connu pour être bon

Ne le faites qu’après avoir identifié une requête précise et validé le plan.

EXEC sys.sp_query_store_force_plan
    @query_id = 123,
    @plan_id = 456;

Puis vérifiez :

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;

Le forçage de plan est une mesure d’atténuation, pas nécessairement le correctif définitif.


9. Annuler le forçage d’un plan

EXEC sys.sp_query_store_unforce_plan
    @query_id = 123,
    @plan_id = 456;

Annulez le forçage lorsque :

  • la cause racine est corrigée
  • le plan forcé ne convient plus à la charge de travail
  • le forçage provoque des régressions
  • le schéma ou la distribution des données a suffisamment changé pour que l’ancien plan ne soit plus adapté

10. Trouver les requêtes ayant plusieurs plans

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;

Il s’agit uniquement d’une requête d’exploration.

Avoir plusieurs plans peut être normal.

Appuyez-vous sur les données d’exécution pour décider si la variation est nuisible.


11. Afficher l’historique d’exécution récent d’une requête

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;

Cette requête permet de voir précisément à quel moment une requête a ralenti et si un changement de plan coïncide avec la régression.

Interpréter le résultat

Champ Pourquoi c’est important
query_id Identifiant Query Store stable de l’entrée de requête.
plan_id Identifiant Query Store d’un plan d’exécution capturé.
count_executions Nombre d’exécutions représentées par une ligne de statistiques d’exécution.
avg_duration Durée moyenne des exécutions de cette entrée de statistiques d’exécution.
avg_cpu_time Temps CPU moyen des exécutions de l’entrée.
avg_logical_io_reads Lectures logiques moyennes associées à l’entrée.
is_forced_plan Indique si le forçage de plan de Query Store est actuellement actif.
force_failure_count Nombre de fois où SQL Server n’a pas réussi à forcer le plan.
last_force_failure_reason_desc Motif du dernier échec de forçage de plan.
runtime_stats_interval_id Regroupe les statistiques d’exécution selon les intervalles Query Store configurés.
start_time / end_time Bornes de l’intervalle d’exécution.

Points à vérifier

Même requête, plan différent, écart d’exécution important

C’est le signe classique d’une régression de plan.

Vérifiez que :

  • la période plus lente coïncide avec le nouveau plan
  • le nombre d’exécutions est suffisant pour comparer
  • les valeurs de paramètres et la charge de travail sont comparables
  • la régression n’est pas due à des blocages ou à une pression sur l’ensemble du serveur

La durée augmente mais pas le CPU

Causes possibles :

  • blocages
  • attentes d’E/S
  • attentes mémoire
  • concurrence
  • pression sur des ressources externes

Ne supposez pas que le plan est la seule variable.

Le CPU et les lectures logiques augmentent tous les deux

Cela indique souvent un chemin d’accès moins efficace.

Examinez le plan à la recherche de :

  • analyses (scans) plus volumineuses
  • une stratégie de jointure différente
  • des problèmes d’estimation du nombre de lignes
  • une multiplication des recherches (lookups)
  • des index manquants ou modifiés

Un plan ne domine qu’après un déploiement

Bon candidat pour une analyse avant/après.

Comparez :

  • le niveau de compatibilité
  • le paramétrage
  • les statistiques
  • les index
  • le texte de la requête
  • le comportement de l’optimiseur

Durée moyenne élevée avec un très faible nombre d’exécutions

Ne surestimez pas la priorité d’une requête ponctuelle sans en comprendre l’impact métier.

La fréquence et l’importance comptent.

Notes de production

Query Store conserve un historique, mais pas un historique infini

La rétention dépend :

  • de la taille de stockage maximale
  • du nettoyage des requêtes obsolètes
  • du mode de capture
  • de l’état lecture/écriture

Si le magasin se remplit ou passe en lecture seule, la collecte peut s’arrêter ou se dégrader.

Les horodatages de Query Store sont stockés dans des métadonnées orientées UTC

Soyez prudent lorsque vous comparez les horodatages des intervalles Query Store avec les heures locales d’un déploiement ou d’un incident.

Normalisez les fuseaux horaires avant de tirer des conclusions.

Les statistiques d’exécution sont agrégées

Query Store ne stocke pas chaque exécution comme une ligne individuelle dans les vues de statistiques d’exécution.

Il stocke des statistiques agrégées par intervalle.

Cela signifie que :

  • les valeurs aberrantes peuvent être masquées par les moyennes
  • des exécutions très différentes peuvent être regroupées
  • la pondération par le nombre d’exécutions compte

Les moyennes pondérées valent mieux que la moyenne des moyennes

Lorsque vous combinez des intervalles, pondérez par count_executions.

Sinon, un intervalle comptant 1 exécution peut influencer votre résultat autant qu’un autre intervalle en comptant 10 000.

Le forçage de plan est un levier opérationnel puissant

Le forçage de plan peut stabiliser rapidement une régression, mais il doit être surveillé.

Un plan forcé peut devenir inadapté par la suite en raison :

  • de la croissance des données
  • de modifications du schéma
  • de modifications d’index
  • d’une évolution de la distribution des paramètres
  • de changements de l’optimiseur

Query Store peut passer en lecture seule

Les causes courantes incluent l’atteinte des limites de stockage configurées ou d’autres transitions d’état.

Vérifiez toujours sys.database_query_store_options avant de supposer que de nouvelles données sont capturées.

Erreurs fréquentes

1. Calculer directement la moyenne de avg_duration sur plusieurs intervalles

Cela produit un résultat mathématiquement trompeur lorsque les intervalles contiennent des nombres d’exécutions différents.

Utilisez des moyennes pondérées.

2. Supposer que plusieurs plans signifient un problème de parameter sniffing

Plusieurs plans peuvent avoir de nombreuses origines.

Considérez la variation de plan comme un élément de preuve, pas comme un diagnostic.

3. Forcer le plan qui semble le plus rapide sans contexte

Un plan rapide pour un jeu de paramètres peut être médiocre pour un autre.

Validez la forme de la charge de travail avant de forcer un plan.

4. Considérer le forçage de plan comme le correctif définitif

Le forçage peut être une excellente mesure d’atténuation.

Mais vous devez quand même examiner :

  • les statistiques
  • les index
  • l’estimation de cardinalité
  • la conception de la requête
  • la sensibilité aux paramètres
  • les changements de compatibilité

5. Ignorer les conditions à l’échelle du serveur

Un intervalle Query Store lent peut coïncider avec :

  • une saturation du CPU
  • des blocages
  • une latence du stockage
  • une pression mémoire

N’attribuez pas chaque régression au plan.

6. Comparer des horodatages UTC à des heures locales sans conversion

Cela peut décaler de plusieurs heures votre corrélation avec l’incident.

Normalisez d’abord.

7. Supposer que Query Store dispose d’un historique complet

La rétention, le nettoyage, le mode de capture et les limites de stockage influent tous sur ce qui reste disponible.

Étape suivante

Utilisez le schéma que vous identifiez pour choisir l’action suivante.

  • Même requête + nouveau plan + régression nette → validez et envisagez de forcer temporairement le plan connu pour être bon.
  • Aucun changement de plan + durée plus élevée → examinez les blocages, les attentes, le CPU et les conditions d’E/S.
  • CPU + lectures en hausse avec un nouveau plan → examinez la forme du plan d’exécution, les estimations et l’indexation.
  • Query Store est en lecture seule → résolvez le problème de stockage ou d’état avant de vous fier à des données récentes.
  • Fenêtre d’historique très courte → collectez davantage de données avant d’apporter des changements structurels.
  • Le plan forcé échoue → examinez last_force_failure_reason_desc et validez les modifications de schéma ou d’index.
  • Le problème est intermittent → combinez Query Store avec les DMV en temps réel et la supervision pour obtenir une vue plus complète.

← Tous les aide-mémoire