Parcourir les aide-mémoire · SQL Server
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
- Problème
- Réponse rapide
- Code / commandes
- 1. Vérifier si Query Store est activé
- 2. Trouver les requêtes les plus lentes par durée moyenne
- 3. Trouver les requêtes les plus coûteuses en CPU total
- 4. Trouver les requêtes les plus coûteuses en lectures logiques
- 5. Afficher tous les plans d’une requête
- 6. Comparer l’exécution par plan
- 7. Comparer une requête avant et après une fenêtre de changement
- 8. Forcer un plan connu pour être bon
- 9. Annuler le forçage d’un plan
- 10. Trouver les requêtes ayant plusieurs plans
- 11. Afficher l’historique d’exécution récent d’une requête
- Interpréter le résultat
- Points à vérifier
- Même requête, plan différent, écart d’exécution important
- La durée augmente mais pas le CPU
- Le CPU et les lectures logiques augmentent tous les deux
- Un plan ne domine qu’après un déploiement
- Durée moyenne élevée avec un très faible nombre d’exécutions
- Notes de production
- Query Store conserve un historique, mais pas un historique infini
- Les horodatages de Query Store sont stockés dans des métadonnées orientées UTC
- Les statistiques d’exécution sont agrégées
- Les moyennes pondérées valent mieux que la moyenne des moyennes
- Le forçage de plan est un levier opérationnel puissant
- Query Store peut passer en lecture seule
- Erreurs fréquentes
- 1. Calculer directement la moyenne de avg_duration sur plusieurs intervalles
- 2. Supposer que plusieurs plans signifient un problème de parameter sniffing
- 3. Forcer le plan qui semble le plus rapide sans contexte
- 4. Considérer le forçage de plan comme le correctif définitif
- 5. Ignorer les conditions à l’échelle du serveur
- 6. Comparer des horodatages UTC à des heures locales sans conversion
- 7. Supposer que Query Store dispose d’un historique complet
- Étape suivante
- 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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.