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.

Par JaviPublié Mis à jour 12 min de lectureIntermédiaire

Tableau de l’activité SQL Server en cours comparant sessions, bases, CPU, lectures et états d’attente

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

Requête SQL: Requêtes en cours d’exécutionT-SQL
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;
T-SQL52 lignesAffichage en lecture seule. Aucune connexion à une base de données.

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_sessions et 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 NOLOCK ou 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

Vérifié en novembre 2026.

Étiquettes

  • SQL Server
  • Performance
  • Dépannage
  • DMV
  • Blocages