Répertorier les requêtes en cours d'exécution sur SQL Server

Existe-t-il un moyen de répertorier les requêtes en cours d'exécution sur MS SQL Server (via Enterprise Manager ou SQL) et / ou qui est connecté?

Je pense que j'ai une très longue requête en cours d'exécution sur l'un de mes serveurs de base de données et j'aimerais la retrouver et l'arrêter (ou la personne qui continue de la démarrer).

Cela vous montrera les SPID les plus longs sur un serveur SQL 2000 ou SQL 2005:

select
    P.spid
,   right(convert(varchar, 
            dateadd(ms, datediff(ms, P.last_batch, getdate()), '1900-01-01'), 
            121), 12) as 'batch_duration'
,   P.program_name
,   P.hostname
,   P.loginame
from master.dbo.sysprocesses P
where P.spid > 50
and      P.status not in ('background', 'sleeping')
and      P.cmd not in ('AWAITING COMMAND'
                    ,'MIRROR HANDLER'
                    ,'LAZY WRITER'
                    ,'CHECKPOINT SLEEP'
                    ,'RA MANAGER')
order by batch_duration desc

Si vous devez voir le SQL s'exécuter pour un spid donné à partir des résultats, utilisez quelque chose comme ceci:

declare
    @spid int
,   @stmt_start int
,   @stmt_end int
,   @sql_handle binary(20)

set @spid = XXX -- Fill this in

select  top 1
    @sql_handle = sql_handle
,   @stmt_start = case stmt_start when 0 then 0 else stmt_start / 2 end
,   @stmt_end = case stmt_end when -1 then -1 else stmt_end / 2 end
from    sys.sysprocesses
where   spid = @spid
order by ecid

SELECT
    SUBSTRING(  text,
            COALESCE(NULLIF(@stmt_start, 0), 1),
            CASE @stmt_end
                WHEN -1
                    THEN DATALENGTH(text)
                ELSE
                    (@stmt_end - @stmt_start)
                END
        )
FROM ::fn_get_sql(@sql_handle)

Si vous exécutez SQL Server 2005 ou 2008, vous pouvez utiliser les DMV pour trouver ceci ...

SELECT  *
FROM    sys.dm_exec_requests  
        CROSS APPLY sys.dm_exec_sql_text(sql_handle)  

• En savoir plus sur sys.dm_exec_requests
• En savoir plus sur sys.dm_exec_sql_text

Vous pouvez exécuter la commande sp_who pour obtenir une liste de tous les utilisateurs, sessions et processus actuels. Vous pouvez ensuite exécuter la commande KILL sur n'importe quel spid qui en bloque d'autres.

Je suggérerais d'interroger les sysvues. quelque chose de similaire à

SELECT * 
FROM 
   sys.dm_exec_sessions s
   LEFT  JOIN sys.dm_exec_connections c
        ON  s.session_id = c.session_id
   LEFT JOIN sys.dm_db_task_space_usage tsu
        ON  tsu.session_id = s.session_id
   LEFT JOIN sys.dm_os_tasks t
        ON  t.session_id = tsu.session_id
        AND t.request_id = tsu.request_id
   LEFT JOIN sys.dm_exec_requests r
        ON  r.session_id = tsu.session_id
        AND r.request_id = tsu.request_id
   OUTER APPLY sys.dm_exec_sql_text(r.sql_handle) TSQL

De cette façon, vous pouvez obtenir un fichier TotalPagesAllocatedqui peut vous aider à déterminer celui spidqui prend toutes les ressources du serveur. Il y a de nombreuses fois où je ne peux même pas afficher le moniteur d'activité et utiliser ces sysvues pour voir ce qui se passe.

Je vous recommande de lire l'article suivant. J'ai obtenu cette référence d'ici .

Il existe différentes vues de gestion intégrées au produit. Sur SQL 2000, vous utiliseriez des processus système . Sur SQL 2K5, il existe plus de vues comme sys.dm_exec_connections , sys.dm_exec_sessions et sys.dm_exec_requests .

Il existe également des procédures telles que sp_who qui exploitent ces vues. Dans 2K5 Management Studio, vous bénéficiez également du moniteur d'activité.

Et enfin et surtout, il existe des scripts contribués par la communauté comme Who Is Active d'Adam Machanic .

En fait, l'exécution EXEC sp_who2dans Query Analyzer / Management Studio donne plus d'informations que sp_who.

Au-delà, vous pouvez configurer SQL Profiler pour surveiller tout le trafic entrant et sortant vers le serveur. Le profileur vous permet également d'affiner exactement ce que vous recherchez.

Pour SQL Server 2008:

START - All Programs - Microsoft SQL Server 2008 - Performance Tools - SQL Server Profiler

Gardez à l'esprit que le profileur est vraiment une application de journalisation et d'observation. Il continuera à se connecter et à regarder tant qu'il est en cours d'exécution. Il pourrait remplir des fichiers texte ou des bases de données ou des disques durs, alors faites attention à ce que vous avez à regarder et pendant combien de temps.

SELECT
    p.spid, p.status, p.hostname, p.loginame, p.cpu, r.start_time, r.command,
    p.program_name, text 
FROM
    sys.dm_exec_requests AS r,
    master.dbo.sysprocesses AS p 
    CROSS APPLY sys.dm_exec_sql_text(p.sql_handle)
WHERE
    p.status NOT IN ('sleeping', 'background') 
AND r.session_id = p.spid

Remarque: le moniteur d'activité SQL Server pour SQL Server 2008 peut être trouvé en cliquant avec le bouton droit sur votre serveur actuel et en accédant à "Moniteur d'activité" dans le menu contextuel. J'ai trouvé que c'était le moyen le plus simple de tuer les processus si vous utilisez SQL Server Management Studio.

Dans l'Explorateur d'objets, accédez à: Serveur -> Gestion -> Moniteur d'activité. Cela vous permettra de voir toutes les connexions sur le serveur actuel.

voici une requête qui montrera toutes les requêtes bloquantes. Je ne suis pas tout à fait sûr s'il affichera simplement des requêtes lentes:

SELECT p.spid
,convert(char(12), d.name) db_name
, program_name
, convert(char(12), l.name) login_name
, convert(char(12), hostname) hostname
, cmd
, p.status
, p.blocked
, login_time
, last_batch
, p.spid
FROM      master..sysprocesses p
JOIN      master..sysdatabases d ON p.dbid =  d.dbid
JOIN      master..syslogins l ON p.sid = l.sid
WHERE     p.blocked = 0
AND       EXISTS (  SELECT 1
          FROM      master..sysprocesses p2
          WHERE     p2.blocked = p.spid )

Le bon script serait comme ceci:

select 
p.spid, p.status,p.hostname,p.loginame,p.cpu,r.start_time, t.text
    from sys.dm_exec_requests as r, sys.sysprocesses p 
    cross apply sys.dm_exec_sql_text(p.sql_handle) t
    where p.status not in ('sleeping', 'background')
    and r.session_id=p.spid

Vous pouvez utiliser la requête ci-dessous pour trouver la dernière demande en cours:

SELECT
    der.session_id
    ,est.TEXT AS QueryText
    ,der.status
    ,der.blocking_session_id
    ,der.cpu_time
    ,der.total_elapsed_time
FROM sys.dm_exec_requests AS der
CROSS APPLY sys.dm_exec_sql_text(sql_handle) AS est

En utilisant le script ci-dessous, vous pouvez également trouver le nombre de connexions par base de données:

SELECT 
    DB_NAME(DBID) AS DataBaseName
    ,COUNT(DBID) AS NumberOfConnections
    ,LogiName 
FROM sys.sysprocesses
WHERE DBID > 0
GROUP BY DBID, LogiName

Pour plus de détails, veuillez visiter: http://www.dbrnd.com/2015/06/script-to-find-running-process-session-logged-user-in-sql-server/

en 2005, vous pouvez cliquer avec le bouton droit sur une base de données, accéder aux rapports et il y a toute une liste de rapports sur les transitions et les verrous, etc.

Essayez avec ceci:

Il vous fournira toutes les requêtes des utilisateurs. Jusqu'à spid 50, tout est constitué de sessions de processus internes au serveur SQL. Mais, si vous le souhaitez, vous pouvez supprimer la clause where:

select
r.session_id,
r.start_time,
s.login_name,
c.client_net_address,
s.host_name,
s.program_name,
st.text
from sys.dm_exec_requests r
inner join sys.dm_exec_sessions s
on r.session_id = s.session_id
left join sys.dm_exec_connections c
on r.session_id = c.session_id
outer apply sys.dm_exec_sql_text(r.sql_handle) st where r.session_id  > 50

SELECT 
    p.spid, p.status, p.hostname, p.loginame, p.cpu, r.start_time, t.text
FROM
    sys.dm_exec_requests as r,
    master.dbo.sysprocesses as p
    CROSS APPLY sys.dm_exec_sql_text(p.sql_handle) t
WHERE
    p.status NOT IN ('sleeping', 'background')
AND r.session_id = p.spid

Et

KILL @spid

Utilisez Sql Server Profiler (menu Outils) pour surveiller l'exécution des requêtes et utilisez le moniteur d'activité dans Management Studio pour voir comment est connecté et si leur connexion bloque d'autres connexions.

Vous devriez essayer une procédure très utile sp_whoIsActivequi peut être trouvée ici: http://whoisactive.com et elle est gratuite.