SQL Server

Obtenir l’ID de session SQL Server et voir ce qu’elle fait

Trouvez l’ID de votre session SQL Server, examinez une autre session et inspectez sa requête, son texte SQL, ses attentes, ses blocages et sa transaction ouverte.

Par JaviPublié Mis à jour 12 min de lectureDébutant

Le SPID 123 relié à sa session, sa requête en cours, son texte SQL, son login, son hôte, son attente et son bloqueur

Réponse courte : SELECT @@SPID renvoie votre propre ID de session. Pour toute autre session, partez de sys.dm_exec_sessions (qui : login, hôte, application, heure de connexion), joignez sys.dm_exec_requests (ce qu’elle fait maintenant : statut, attente, bloqueur, instruction) et sys.dm_exec_connections (quand elle s’est connectée), et utilisez sys.dm_exec_input_buffer pour le dernier lot envoyé par une session inactive. Avant d’agir sur un ID de session, vérifiez qu’il s’agit toujours de la même connexion : les ID sont réutilisés après la fermeture d’une connexion.

Un ID de session SQL Server identifie une connexion cliente. C’est le numéro que les équipes de support demandent généralement lorsqu’elles doivent relier un symptôme applicatif à l’activité du serveur. Une même session peut exécuter de nombreuses requêtes au cours de sa vie : l’ID de session indique où chercher, pas quelle instruction s’est exécutée à un moment antérieur.

Problème

Le responsable d’une application signale que la session 123 est bloquée. Vous devez savoir à qui appartient la session, d’où elle s’est connectée, si elle exécute quelque chose en ce moment, quelle instruction est en cours, ce qu’elle attend, si une autre session la bloque et si elle détient une transaction ouverte.

Ne commencez pas par KILL 123. Les ID de session sont réutilisés après une déconnexion, et mettre fin à une session peut déclencher un long rollback. Capturez et confirmez d’abord les éléments de diagnostic.

Diagnostic rapide

Pour obtenir l’ID de votre connexion actuelle, exécutez :

Requête SQL: Diagnostic rapideT-SQL
SELECT @@SPID AS session_id;
T-SQL1 ligneAffichage en lecture seule. Aucune connexion à une base de données.

Chaque connexion d’une fenêtre de requête a normalement son propre ID de session. Une reconnexion peut produire une autre valeur. Le pool de connexions d’une application conserve et réutilise les connexions ; la session peut donc durer plus longtemps qu’une seule requête Web.

Quelle DMV répond à quelle question

Question Source Colonnes à lire
Quelle est ma session ? @@SPID La valeur elle-même
À qui appartient cette session ? sys.dm_exec_sessions login_name, original_login_name, host_name, program_name, login_time
Que fait-elle maintenant ? sys.dm_exec_requests status, command, wait_type, blocking_session_id, start_time
Quand et comment s’est-elle connectée ? sys.dm_exec_connections connect_time, client_net_address, most_recent_sql_handle
Qu’a-t-elle envoyé en dernier ? sys.dm_exec_input_buffer event_info (SQL Server 2014 SP2 et versions ultérieures)
Détient-elle une transaction ? sys.dm_tran_session_transactions avec sys.dm_tran_active_transactions transaction_begin_time

Requête : tout sur la session 123

Définissez le paramètre une seule fois. La requête renvoie la session même si elle est inactive (sleeping) et la complète avec la requête en cours et les informations de transaction lorsqu’elles existent.

Requête SQL: Tout sur la session 123T-SQL
DECLARE @SessionId int = 123;

SELECT
    SYSDATETIMEOFFSET() AS captured_at,
    s.session_id,
    s.login_name,
    s.original_login_name,
    s.host_name,
    s.program_name,
    s.client_interface_name,
    s.login_time,
    c.connect_time,
    c.client_net_address,
    s.last_request_start_time,
    s.last_request_end_time,
    s.status AS session_status,
    DB_NAME(COALESCE(r.database_id, s.database_id)) AS database_name,
    r.request_id,
    r.status AS request_status,
    r.command,
    r.start_time AS request_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,
    s.open_transaction_count AS session_open_transaction_count,
    r.open_transaction_count AS request_open_transaction_count,
    at.transaction_begin_time,
    at.transaction_type,
    at.transaction_state,
    SUBSTRING(
        sql_text.text,
        (COALESCE(r.statement_start_offset, 0) / 2) + 1,
        CASE
          WHEN r.statement_start_offset IS NULL THEN LEN(sql_text.text)
          ELSE ((CASE r.statement_end_offset
                   WHEN -1 THEN DATALENGTH(sql_text.text)
                   ELSE r.statement_end_offset
                 END - r.statement_start_offset) / 2) + 1
        END
    ) AS current_or_recent_statement,
    sql_text.text AS batch_text,
    ib.event_info AS input_buffer
FROM sys.dm_exec_sessions AS s
LEFT JOIN sys.dm_exec_requests AS r
    ON r.session_id = s.session_id
LEFT JOIN sys.dm_exec_connections AS c
    ON c.session_id = s.session_id
LEFT JOIN sys.dm_tran_session_transactions AS st
    ON st.session_id = s.session_id
LEFT JOIN sys.dm_tran_active_transactions AS at
    ON at.transaction_id = st.transaction_id
OUTER APPLY sys.dm_exec_sql_text(COALESCE(r.sql_handle, c.most_recent_sql_handle)) AS sql_text
OUTER APPLY sys.dm_exec_input_buffer(s.session_id, NULL) AS ib
WHERE s.session_id = @SessionId;
T-SQL60 lignesAffichage en lecture seule. Aucune connexion à une base de données.

L’expression de database_name utilise la base de la requête lorsqu’une requête est active, sinon la base courante de la session. most_recent_sql_handle et le tampon d’entrée peuvent afficher le lot le plus récent d’une connexion inactive, mais cela ne prouve ni que ce texte est encore en cours d’exécution, ni qu’il a ouvert la transaction actuelle.

Lire le résultat

Une session active possède normalement des valeurs de requête : commande, heure de début, compteurs, attente et texte de l’instruction. Une session inactive n’a pas de requête active ; ces colonnes sont donc NULL. Inactive signifie seulement que la session n’exécute rien en ce moment. Elle peut tout de même détenir une transaction ouverte, conserver des verrous et bloquer d’autres sessions.

login_name, host_name et program_name relient la session à un responsable. Les valeurs d’hôte et de programme sont fournies par le client : considérez-les comme des indices opérationnels. last_request_start_time et last_request_end_time montrent l’activité récente de la session, mais ne constituent pas un historique durable des instructions.

blocking_session_id identifie le bloqueur immédiat d’une requête active. Ce n’est pas forcément le bloqueur principal. Suivez la chaîne jusqu’à une session qui n’est pas elle-même bloquée, puis examinez la transaction de cette session et son SQL actuel ou le plus récent.

Les valeurs d’état de transaction sont des codes internes compacts documentés pour sys.dm_tran_active_transactions ; conservez la valeur brute dans les captures d’incident et interprétez-la avec la documentation de votre version. L’heure de début est généralement plus directement utile : une transaction ancienne associée à des blocages ou à une croissance du journal mérite une investigation rapide.

Ce que le résultat peut signifier

Une session active dont le CPU et les lectures augmentent peut être en train d’avancer dans un travail coûteux. Une attente de verrou stable associée à un ID de bloqueur indique une dépendance plutôt qu’une exécution lente au sein de la requête bloquée. Une session inactive avec une transaction ouverte peut indiquer qu’une application a démarré une transaction puis rendu la main sans commit ni rollback. Ce schéma peut maintenir des verrous et empêcher la troncature du journal.

Plusieurs lignes peuvent apparaître lorsqu’une session a plusieurs transactions ou requêtes actives. Il ne s’agit pas d’une duplication accidentelle : les relations sont de un à plusieurs. Ne sommez pas les compteurs de requête sur des lignes de transaction répétées sans avoir d’abord séparé ces granularités.

Vérifier qu’il s’agit de la même session avant d’agir

Les ID de session sont réutilisés : quand une connexion se ferme, son numéro peut être attribué à la suivante, souvent en quelques secondes sur un serveur chargé. Un ID copié depuis un ticket, une alerte de supervision ou une requête lancée il y a dix minutes peut désormais appartenir à un autre utilisateur. Notez une empreinte lors de la première identification (session_id, login_time, host_name, program_name, et le start_time de la requête si elle était active) et revérifiez-la juste avant toute action :

Requête SQL: Vérifier qu’il s’agit de la même session avant d’agirT-SQL
-- Valeurs relevées lors de la première identification de la session
DECLARE @SessionId   int           = 123,
        @LoginTime   datetime      = '2026-11-06T08:14:03.120',
        @HostName    nvarchar(128) = N'APP-SERVER-01',
        @ProgramName nvarchar(128) = N'Billing API';

SELECT s.session_id, s.login_time, s.host_name, s.program_name, s.login_name
FROM sys.dm_exec_sessions AS s
WHERE s.session_id   = @SessionId
  AND s.login_time   = @LoginTime
  AND s.host_name    = @HostName
  AND s.program_name = @ProgramName;
-- Aucune ligne : l’ID appartient maintenant à une autre connexion, ou à aucune. Arrêtez-vous et reprenez l’investigation.
T-SQL13 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Pendant un incident de blocage, le runbook de blocage SQL Server (en anglais) précise quand mettre fin au bloqueur de tête est justifié et comment le faire sans risque. Si une session est arrêtée, KILL <session_id> WITH STATUSONLY indique l’avancement de l’annulation sans rien arrêter d’autre.

Que vérifier ensuite

En cas de blocage, passez à la requête de chaîne de blocage et identifiez le bloqueur principal, comme expliqué dans Diagnostiquer les blocages dans SQL Server. Si les lectures ou le CPU dominent, capturez le plan d’exécution et examinez la taille des tables, les prédicats, les estimations et les méthodes d’accès. Pour une session inactive avec une transaction ancienne, reliez la connexion à la télémétrie applicative et au code de gestion des transactions. Si l’activité est déjà terminée, utilisez Query Store, Extended Events ou le traçage applicatif plutôt que d’attendre des DMV de session qu’elles la reconstruisent.

Pour voir toutes les requêtes actives du serveur plutôt qu’une seule session, consultez Comment voir les requêtes en cours dans SQL Server.

Erreurs fréquentes

  • Supposer que l’ID de session 123 désigne toujours la même connexion après une déconnexion.
  • Considérer qu’une session et sa requête en cours ont la même durée de vie.
  • Qualifier d’inactive une session sleeping sans vérifier ses transactions ouvertes.
  • Prendre le texte SQL le plus récent comme preuve qu’il a ouvert une transaction existante.
  • Mettre fin à une session avant d’estimer l’impact du rollback et d’identifier son responsable.
  • Dépendre de procédures utilitaires non documentées comme méthode principale de diagnostic.

Notes de production

Voir les autres sessions nécessite l’autorisation d’état serveur appropriée. Le texte SQL peut contenir des données sensibles : contrôlez qui peut le capturer et le partager. L’état des DMV est transitoire en cas de redémarrage ou de basculement, et l’état de la session disparaît à la fermeture de la connexion.

La requête est volontairement diagnostique et en lecture seule. S’il devient nécessaire de mettre fin à une session, confirmez que l’identifiant désigne toujours la connexion visée, prévenez le responsable de la charge, mesurez les conséquences sur la disponibilité et attendez-vous à ce que le rollback prenne du temps. Mettre fin à une session est une décision opérationnelle, pas une technique d’optimisation.

Continuer le parcours de performance

Replacez cette inspection dans la démarche d’optimisation. Commencez par les requêtes en cours, passez à la chaîne de blocage si nécessaire, suivez le runbook de blocage SQL Server (en anglais) pendant un incident de blocage en cours et utilisez les régressions Query Store lorsque l’activité est terminée. Gardez les fiches Détails de session, Activité par login, hôte et application et Transactions ouvertes à portée de main.

Sources

Vérifié en novembre 2026. Voir les autres sessions exige VIEW SERVER STATE, ou VIEW SERVER PERFORMANCE STATE sur SQL Server 2022 et versions ultérieures.

Étiquettes

  • SQL Server
  • Dépannage
  • DMV
  • Blocages