SQL Server
Comment voir les requêtes en cours dans SQL Server
Une requête DMV adaptée à la production pour examiner les requêtes SQL Server actives : texte, identité, ressources, attentes et blocages.
Dans cet article
Réponse courte : interrogez sys.dm_exec_requests joint à sys.dm_exec_sessions : chaque ligne est une requête en cours d’exécution ou en attente, avec sa durée, le CPU, les lectures et les écritures consommés, ce qu’elle attend, qui l’a lancée et l’instruction qu’elle exécute. Triez par durée, CPU ou lectures pour repérer les requêtes qui méritent un examen. Si vous savez déjà qu’il s’agit d’un blocage, allez directement à Diagnostiquer les blocages.
Quand les utilisateurs disent qu’une application est lente, le premier instantané utile répond à deux questions : qu’est-ce qui s’exécute maintenant et qui l’a lancé ? SQL Server expose ces informations dans des vues de gestion dynamique documentées. La requête identifie l’unité de travail actuelle ; la session identifie le client connecté ; la connexion apporte le contexte réseau ; et la fonction de texte SQL récupère le texte du lot.
Pour retrouver les autres guides de production, passez par le hub SQL Server.
Il s’agit d’une vue en temps réel, pas d’un historique. Une instruction rapide peut se terminer entre deux échantillons, et une instruction terminée disparaît de sys.dm_exec_requests. Enregistrez le résultat avec son horodatage avant toute intervention.
Problème
Supposons que des utilisateurs signalent des rapports lents depuis ReportingDb. Vous devez distinguer un rapport très sollicité, une requête bloquée, un pic d’activité API ou une opération de maintenance sans rapport. Activity Monitor peut donner une vue rapide, mais une requête SQL est reproductible, filtrable, exportable et explicite sur les compteurs comparés.
Réponse rapide
DECLARE @SessionId int = NULL;
DECLARE @DatabaseName sysname = NULL;
DECLARE @LoginName sysname = NULL;
DECLARE @HostName nvarchar(128) = NULL;
DECLARE @ProgramName nvarchar(128) = NULL;
SELECT
SYSDATETIMEOFFSET() AS captured_at,
r.session_id,
r.request_id,
DB_NAME(r.database_id) AS database_name,
s.login_name,
s.original_login_name,
s.host_name,
s.program_name,
c.client_net_address,
s.status AS session_status,
r.status AS request_status,
r.command,
r.start_time,
r.total_elapsed_time AS elapsed_time_ms,
r.cpu_time AS cpu_time_ms,
r.logical_reads,
r.reads AS physical_reads,
r.writes,
r.wait_type,
r.wait_time AS wait_time_ms,
r.wait_resource,
NULLIF(r.blocking_session_id, 0) AS blocking_session_id,
SUBSTRING(
sql_text.text,
(r.statement_start_offset / 2) + 1,
((CASE r.statement_end_offset
WHEN -1 THEN DATALENGTH(sql_text.text)
ELSE r.statement_end_offset
END - r.statement_start_offset) / 2) + 1
) AS current_statement,
sql_text.text AS batch_text
FROM sys.dm_exec_requests AS r
INNER JOIN sys.dm_exec_sessions AS s
ON s.session_id = r.session_id
LEFT JOIN sys.dm_exec_connections AS c
ON c.session_id = s.session_id
OUTER APPLY sys.dm_exec_sql_text(r.sql_handle) AS sql_text
WHERE s.is_user_process = 1
AND r.session_id <> @@SPID
AND (@SessionId IS NULL OR r.session_id = @SessionId)
AND (@DatabaseName IS NULL OR DB_NAME(r.database_id) = @DatabaseName)
AND (@LoginName IS NULL OR s.login_name = @LoginName)
AND (@HostName IS NULL OR s.host_name = @HostName)
AND (@ProgramName IS NULL OR s.program_name = @ProgramName)
ORDER BY r.total_elapsed_time DESC, r.session_id, r.request_id;Notes
- lignes 1–5Filtres facultatifs : laissez-les à NULL pour lister toutes les requêtes en cours, ou renseignez-en un pour restreindre la liste.
- lignes 30–37L’instruction en cours d’exécution, extraite du lot : les décalages sont des octets dans un texte Unicode, et -1 signifie la fin du lot.
- ligne 44OUTER APPLY conserve les requêtes sans handle SQL ; CROSS APPLY les écarterait.
Exécutez-la d’abord sans filtre. Cherchez une durée longue, une session bloquante non nulle, des types d’attente répétés, beaucoup de CPU ou de lectures logiques, et une concentration sur une base ou une application. Renseignez ensuite un ou plusieurs paramètres pour affiner ; laisser tous les paramètres à NULL affiche toutes les requêtes utilisateur.
Pour voir les autres sessions, le login a besoin d’une autorisation sur l’état du serveur : VIEW SERVER STATE sur SQL Server 2019 et versions antérieures. SQL Server 2022 a introduit l’autorisation plus fine VIEW SERVER PERFORMANCE STATE, que Microsoft documente pour sys.dm_exec_sessions. Sans elle, un utilisateur ne voit que ses propres requêtes.
Première lecture de l’échantillon
Commencez par blocking_session_id et wait_type pour repérer un bloqueur ou une attente actuelle. Comparez ensuite elapsed_time_ms et cpu_time_ms, puis utilisez logical_reads et writes pour estimer le travail de la requête. Les colonnes de session, base, login, hôte et application aident à trouver sa source ; les noms hôte et programme fournis par le client restent des indices, pas une preuve.
Identifiant de session et identifiant de requête
Un session_id identifie une session client, historiquement appelée SPID. Une connexion applicative issue d’un pool peut rester ouverte longtemps et exécuter de nombreuses requêtes au fil du temps. Un request_id identifie une requête en cours d’exécution dans cette session. La plupart des sessions ordinaires n’ont qu’une requête active à la fois, mais Multiple Active Result Sets peut en autoriser plusieurs. Pour un instantané précis, consignez les deux valeurs.
Ne confondez pas les compteurs de session avec ceux des requêtes. Les valeurs de sys.dm_exec_requests, notamment la durée écoulée et le CPU de la requête, décrivent la requête en cours. Les totaux au niveau de la session peuvent inclure plusieurs requêtes terminées depuis son ouverture.
Interpréter les résultats
| Champ | Ce que c’est | Comment le lire |
|---|---|---|
session_id, request_id |
La session cliente et la requête qui s’y exécute | Notez les deux ; une session exécute de nombreuses requêtes au cours de sa vie |
start_time, elapsed_time_ms |
Le début de la requête, et la durée écoulée depuis | Une longue durée est une question, pas un verdict |
cpu_time_ms |
Le temps processeur consommé par cette requête | Très inférieur à la durée écoulée : la requête attend surtout |
logical_reads, physical_reads |
Pages lues dans le pool de mémoire tampon ; pages qui ont nécessité une E/S physique | Les lectures logiques sont souvent la meilleure mesure unique du travail |
writes |
Pages écrites par la requête | Inclut les tables de travail, pas seulement les données finales |
wait_type, wait_time_ms, wait_resource |
Ce que la requête attend à cet instant, depuis combien de temps et sur quoi | Change vite ; échantillonnez plusieurs fois |
blocking_session_id |
La session qui bloque actuellement cette requête ; NULL s’il n’y en a pas |
Non nul : une dépendance, pas du code lent |
database_name |
Le contexte de base de données de la requête | Une concentration sur une base resserre la recherche |
login_name, original_login_name |
Contexte de sécurité actuel ; login qui a ouvert la session | Ils diffèrent après un EXECUTE AS |
host_name, program_name, client_net_address |
L’origine de la connexion | Fournis par le client : des indices utiles, pas une preuve d’identité |
current_statement, batch_text |
L’instruction en cours, et le lot qui l’entoure | Les décalages sont des positions en octets dans un texte Unicode, d’où la division par deux ; -1 signifie jusqu’à la fin du lot |
Ce que les résultats peuvent indiquer
Une durée élevée avec peu de CPU peut signaler une attente, par exemple un blocage, des E/S, un memory grant, la consommation côté client ou une autre ressource. Un CPU et des lectures logiques élevés peuvent indiquer un scan volumineux, du travail répété, une mauvaise stratégie de jointure ou simplement une requête réellement lourde. De nombreuses requêtes similaires provenant de ApiService peuvent signaler une pression de concurrence ou de nouvelles tentatives, même si aucune requête isolée ne paraît extrême.
Un seul résultat suffit rarement pour les problèmes intermittents. Prenez quelques échantillons à plusieurs secondes d’intervalle et comparez-les. Une requête dont les compteurs continuent d’augmenter est en cours de travail ; si son attente et son bloqueur restent inchangés, examinez cette chaîne de dépendance.
Que creuser ensuite
| Observation | Ce que cela peut signifier | Où aller ensuite |
|---|---|---|
blocking_session_id est renseigné |
La requête attend les verrous d’une autre session | Diagnostiquer les blocages ; le runbook de blocage SQL Server (en anglais) si c’est l’incident en cours |
| CPU élevé, durée proche du temps CPU | La requête calcule : gros scan, mauvaise jointure, travail répété | SQL Server est lent : les 15 premières minutes ; Trouver les requêtes gourmandes en CPU |
| Beaucoup de lectures logiques | La requête touche beaucoup de pages : prédicats, estimations, chemins d’accès manquants | Capturez le plan d’exécution ; Trouver les requêtes à forte lecture |
| Longue durée, peu de CPU, même attente d’un échantillon à l’autre | Attente d’E/S, d’une allocation mémoire, du client ou d’un verrou | Types d’attente SQL Server |
| Nombreuses requêtes semblables issues d’un programme ou d’un hôte | Concurrence, nouvelles tentatives ou pic d’un traitement | Activité par login, hôte et application |
| Une requête autrefois rapide est lente | Une possible régression de plan | Régressions Query Store |
| Une session mérite un examen approfondi | Son identité, sa transaction ouverte ou son dernier lot comptent | Obtenir l’ID de session SQL Server |
| Le problème est déjà terminé | La requête n’est plus dans les DMV | Query Store et les options d’historique de la supervision en temps réel |
Erreurs fréquentes
- Interroger uniquement
sys.dm_exec_sessionset supposer que chaque session connectée exécute une requête. - Considérer les sessions en veille comme inoffensives sans vérifier l’existence d’une transaction ouverte.
- Trier uniquement par durée et qualifier de mauvaise toute requête longue.
- Considérer les noms d’hôte et de programme fournis par le client comme une frontière d’authentification.
- Exécuter la requête une fois et supposer que l’instantané représente tout l’incident.
- Utiliser
NOLOCKou vider le cache en réponse à des éléments encore mal compris.
Notes de production
La requête lit des DMV légères, mais un polling fréquent et la conservation du texte complet de chaque lot ont tout de même un coût. Adaptez l’intervalle à l’incident, horodatez chaque capture et, si possible, stockez les échantillons hors de la base concernée. Expurgez le texte SQL avant de le partager, car les lots peuvent contenir des valeurs littérales sensibles.
Cette requête affiche volontairement les requêtes utilisateur actives. Les sessions en veille n’apparaissent pas, car elles n’ont aucune ligne dans sys.dm_exec_requests. C’est correct pour savoir « ce qui s’exécute maintenant », mais une requête distincte sur les sessions ou les transactions est nécessaire pour trouver une connexion en veille qui a laissé une transaction ouverte.
Une session inactive qui garde des verrous est le bloqueur principal type ; Diagnostiquer les blocages explique comment la trouver.
Continuer le parcours de performance
Pour un signalement général « SQL Server est lent », commencez par les 15 premières minutes de triage, puis revenez à la démarche d’optimisation. Examinez une connexion avec le guide de l’ID de session, ou suivez un bloqueur avec Diagnostiquer les blocages. Pour une activité terminée, passez aux régressions Query Store ; pour une vue plus large en direct, utilisez la supervision en temps réel.
Aide-mémoire : Voir ce qui s’exécute, Inspecter une session, Types d’attente et Démarche de diagnostic.
Sources
- Microsoft Learn : sys.dm_exec_requests, sys.dm_exec_sessions (autorisations selon la version), sys.dm_exec_connections, sys.dm_exec_sql_text
Vérifié en novembre 2026.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireDémarche de diagnostic des performances SQL ServerAppliquez une démarche de diagnostic SQL Server reproductible pour distinguer blocages, CPU, E/S, attentes, régressions de requêtes et pression de charge avant de modifier quoi que ce soit.Ouvrir l’aide-mémoire
- Feuille de routeSQL Server Troubleshooting & DiagnosticsUne requête DMV adaptée à la production pour examiner les requêtes SQL Server actives : texte, identité, ressources, attentes et blocages.Voir la feuille de route
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
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.