SQL Server: filtro di output di sp_who2


191

In SQL Server, esiste un modo semplice per filtrare l'output di sp_who2? Supponiamo di voler mostrare solo le righe per un determinato database, ad esempio.


2
come ha suggerito @Nick, vale la pena dare un'occhiata anche alle viste di gestione dinamica (DMV).
Mitch Wheat,

ho aggiunto una risposta che utilizza DMV invece di sp_who2
N30,

Risposte:


349

Potresti provare qualcosa del genere

DECLARE @Table TABLE(
        SPID INT,
        Status VARCHAR(MAX),
        LOGIN VARCHAR(MAX),
        HostName VARCHAR(MAX),
        BlkBy VARCHAR(MAX),
        DBName VARCHAR(MAX),
        Command VARCHAR(MAX),
        CPUTime INT,
        DiskIO INT,
        LastBatch VARCHAR(MAX),
        ProgramName VARCHAR(MAX),
        SPID_1 INT,
        REQUESTID INT
)

INSERT INTO @Table EXEC sp_who2

SELECT  *
FROM    @Table
WHERE ....

E filtra su ciò di cui hai bisogno.


+1 @ bo-flexson ha una buona estensione a questo approccio.
Lankymart,

115

È possibile salvare i risultati in una tabella temporanea , ma sarebbe ancora meglio andare direttamente alla fonte master.dbo.sysprocesses.

Ecco una query che restituirà quasi lo stesso risultato esatto di sp_who2:

SELECT  spid,
        sp.[status],
        loginame [Login],
        hostname, 
        blocked BlkBy,
        sd.name DBName, 
        cmd Command,
        cpu CPUTime,
        physical_io DiskIO,
        last_batch LastBatch,
        [program_name] ProgramName   
FROM master.dbo.sysprocesses sp 
JOIN master.dbo.sysdatabases sd ON sp.dbid = sd.dbid
ORDER BY spid 

Ora puoi facilmente aggiungere una ORDER BYo più WHEREclausole che desideri per ottenere risultati significativi.


In alternativa, potresti considerare di utilizzare Activity Monitor anche in SSMS ( Ctrl+ Alt+ A)


bloccato è diverso con BlkBy. bloccato è la vittima che sta aspettando il rilascio del blocco. BlkBy è un criminale a cui viene causato il blocco. Quindi usare l'alias BlkBy per bloccare la colonna è assolutamente sbagliato. Se sp_who restituisce 1 come SPID, 2 come BlkBy, 1 viene bloccato da 2.
doctorgu

25

Un modo è creare una tabella temporanea:

CREATE TABLE #sp_who2 
(
   SPID INT,  
   Status VARCHAR(1000) NULL,  
   Login SYSNAME NULL,  
   HostName SYSNAME NULL,  
   BlkBy SYSNAME NULL,  
   DBName SYSNAME NULL,  
   Command VARCHAR(1000) NULL,  
   CPUTime INT NULL,  
   DiskIO INT NULL,  
   LastBatch VARCHAR(1000) NULL,  
   ProgramName VARCHAR(1000) NULL,  
   SPID2 INT
) 
GO

INSERT INTO #sp_who2
EXEC sp_who2
GO

SELECT *
FROM #sp_who2
WHERE Login = 'bla'
GO

DROP TABLE #sp_who2
GO

seleziona * da sp_who2 dove login = 'bla' - la tabella dovrebbe fare riferimento qui con # sp_who2?
Peter Schofield,

Ottenere "Il nome della colonna o il numero di valori forniti non corrisponde alla definizione della tabella." in esecuzione su SQL 2008 R2
TheLegendaryCopyCoder

11

basato su http://web.archive.org/web/20080218124946/http://sqlserver2005.databases.aspfaq.com/how-do-i-mimic-sp-who2.html

ho creato il seguente script,
che risolve la ricerca connessioni attive a qualsiasi base di dati tramite DMV funziona con sql 2005, 2008 e 2008R2

Lo script seguente utilizza sys.dm_exec_sessions , sys.dm_exec_requests , sys.dm_exec_connections , sys.dm_tran_locks

Declare @dbName varchar(1000)
set @dbName='abc'

;WITH DBConn(SPID,[Status],[Login],HostName,DBName,Command,LastBatch,ProgramName)
As
(
SELECT 
    SPID = s.session_id,
    Status = UPPER(COALESCE
        (
            r.status,
            ot.task_state,
            s.status, 
        '')),
    [Login] = s.login_name,
    HostName = COALESCE
        (
            s.[host_name],
            '  .'
        ),
    DBName = COALESCE
        (
            DB_NAME(COALESCE
            (
                r.database_id,
                t.database_id
            )),
            ''
        ),
    Command = COALESCE
        (
            r.Command,
            r.wait_type,
            wt.wait_type,
            r.last_wait_type,
            ''
        ),
    LastBatch = COALESCE
        (
            r.start_time,
            s.last_request_start_time
        ),
    ProgramName = COALESCE
        (
            s.program_name, 
            ''
        )
FROM
    sys.dm_exec_sessions s
LEFT OUTER JOIN
    sys.dm_exec_requests r
ON
    s.session_id = r.session_id
LEFT OUTER JOIN
    sys.dm_exec_connections c
ON
    s.session_id = c.session_id
LEFT OUTER JOIN
(
    SELECT 
        request_session_id,
        database_id = MAX(resource_database_id)
    FROM
        sys.dm_tran_locks
    GROUP BY
        request_session_id
) t
ON
    s.session_id = t.request_session_id
LEFT OUTER JOIN
    sys.dm_os_waiting_tasks wt
ON 
    s.session_id = wt.session_id
LEFT OUTER JOIN
    sys.dm_os_tasks ot
ON 
    s.session_id = ot.session_id
LEFT OUTER JOIN
(
    SELECT
        ot.session_id,
        CPU_Time = MAX(usermode_time)
    FROM
        sys.dm_os_tasks ot
    INNER JOIN
        sys.dm_os_workers ow
    ON
        ot.worker_address = ow.worker_address
    INNER JOIN
        sys.dm_os_threads oth
    ON
        ow.thread_address = oth.thread_address
    GROUP BY
        ot.session_id
) tt
ON
    s.session_id = tt.session_id
WHERE
    COALESCE
    (
        r.command,
        r.wait_type,
        wt.wait_type,
        r.last_wait_type,
        'a'
    ) >= COALESCE
    (
        '', 
        'a'
    )
)

Select * from DBConn
where DBName like '%'+@dbName+'%'

troppo complicato se confrontato con altre risposte. ma meritano un voto positivo
Doan Cuong

Non sempre utile da parte di DB, preferisci l' approccio @astander e @ bo-flexson .
Lankymart,

1
Questo mostra come partecipare al processo del sistema operativo principale, che è quello che volevo.
redcalx,

Ho scoperto che l'uso di sys.dm_tran_locks è che questo script rallenta enormemente questo codice se hai molti blocchi di transazioni aperti (ad esempio una transazione di lunga durata).
Mike

6

Leggero miglioramento alla risposta di Astander . Mi piace mettere in cima i miei criteri e semplificare il riutilizzo di tutti i giorni:

DECLARE @Spid INT, @Status VARCHAR(MAX), @Login VARCHAR(MAX), @HostName VARCHAR(MAX), @BlkBy VARCHAR(MAX), @DBName VARCHAR(MAX), @Command VARCHAR(MAX), @CPUTime INT, @DiskIO INT, @LastBatch VARCHAR(MAX), @ProgramName VARCHAR(MAX), @SPID_1 INT, @REQUESTID INT

    --SET @SPID = 10
    --SET @Status = 'BACKGROUND'
    --SET @LOGIN = 'sa'
    --SET @HostName = 'MSSQL-1'
    --SET @BlkBy = 0
    --SET @DBName = 'master'
    --SET @Command = 'SELECT INTO'
    --SET @CPUTime = 1000
    --SET @DiskIO = 1000
    --SET @LastBatch = '10/24 10:00:00'
    --SET @ProgramName = 'Microsoft SQL Server Management Studio - Query'
    --SET @SPID_1 = 10
    --SET @REQUESTID = 0

    SET NOCOUNT ON 
    DECLARE @Table TABLE(
            SPID INT,
            Status VARCHAR(MAX),
            LOGIN VARCHAR(MAX),
            HostName VARCHAR(MAX),
            BlkBy VARCHAR(MAX),
            DBName VARCHAR(MAX),
            Command VARCHAR(MAX),
            CPUTime INT,
            DiskIO INT,
            LastBatch VARCHAR(MAX),
            ProgramName VARCHAR(MAX),
            SPID_1 INT,
            REQUESTID INT
    )
    INSERT INTO @Table EXEC sp_who2
    SET NOCOUNT OFF
    SELECT  *
    FROM    @Table
    WHERE
    (@Spid IS NULL OR SPID = @Spid)
    AND (@Status IS NULL OR Status = @Status)
    AND (@Login IS NULL OR Login = @Login)
    AND (@HostName IS NULL OR HostName = @HostName)
    AND (@BlkBy IS NULL OR BlkBy = @BlkBy)
    AND (@DBName IS NULL OR DBName = @DBName)
    AND (@Command IS NULL OR Command = @Command)
    AND (@CPUTime IS NULL OR CPUTime >= @CPUTime)
    AND (@DiskIO IS NULL OR DiskIO >= @DiskIO)
    AND (@LastBatch IS NULL OR LastBatch >= @LastBatch)
    AND (@ProgramName IS NULL OR ProgramName = @ProgramName)
    AND (@SPID_1 IS NULL OR SPID_1 = @SPID_1)
    AND (@REQUESTID IS NULL OR REQUESTID = @REQUESTID)

4

Ci sono alcune buone procedure salvate dall'utente sp_who3 là ​​fuori - Sono sicuro che Adam Machanic ha fatto davvero una buona, AFAIK.

Adam lo chiama Chi è attivo: http://whoisactive.com


Ho provato questo, non è stato così facile ... Sto pubblicando un altro modo simile ad alcuni di questi altri post (ma è testato e corretto).
Don Rolling,

4

Simile alla risposta di KyleMit , è possibile selezionare direttamente le tabelle utilizzate da SP_WHO2, anche se penso che sia necessaria solo la tabella dbo.sysprocesses.

Se qualcuno apre questo SP, può capire cosa fa. Questa è la mia scelta migliore per avere un output simile a SP_WHO2

select convert(char(5),sp.spid) as SPID
        ,  CASE lower(sp.status)
                 When 'sleeping' Then lower(sp.status)
                 Else  upper(sp.status)
              END as Status
        , convert(sysname, rtrim(sp.loginame)) as LOGIN
        , CASE sp.hostname
                 When Null  Then '  .'
                 When ' ' Then '  .'
                 Else    rtrim(sp.hostname)
              END as HostName
        , CASE isnull(convert(char(5),sp.blocked),'0')
                 When '0' Then '  .'
                 Else isnull(convert(char(5),sp.blocked),'0')
              END as BlkBy
        , case when sp.dbid = 0 then null when sp.dbid <> 0 then db_name(sp.dbid) end as DBName
        , sp.cmd as Command
        , sp.cpu as CPUTime
        , sp.physical_io as DiskIO
        , sp.last_batch as LastBatch
        , sp.program_name as ProgramName 
        from master.dbo.sysprocesses sp (nolock)
  ;

Oltre questa selezione, è possibile selezionare i campi necessari e disporre l'ordine desiderato.


Ha funzionato alla grande per me
Shai Alon,

3

Un modo davvero semplice per farlo è creare un collegamento ODBC in EXCEL ed eseguire SP_WHO2 da lì.

Puoi aggiornare quando vuoi e poiché è EXCEL tutto può essere manipolato facilmente!


7
Sei sicuro che questo sia il modo più semplice?
geomagas,

2

Sì, catturando l'output di sp_who2 in una tabella e quindi selezionandolo dalla tabella, ma sarebbe un brutto modo di farlo. Innanzitutto, perché sp_who2, nonostante la sua popolarità, è una procedura non documentata e non dovresti fare affidamento su procedure non documentate. In secondo luogo perché tutto sp_who2 può fare, e molto altro ancora, può essere ottenuto da sys.dm_exec_requests e altri DMV e show può essere filtrato, ordinato, unito e tutte le altre chicche fornite con set di righe interrogabili.


4
Questo è l'unico caso in cui non userei un DMV connect.microsoft.com/SQLServer/feedback/details/257502/…
gbn

1

Estensione della prima e migliore risposta ... Ho creato una procedura memorizzata sul database principale che è quindi possibile passare parametri a ... come il nome del database:

USE master
GO

CREATE PROCEDURE sp_who_db
(
    @sDBName varchar(200)   = null,
    @sStatus varchar(200)   = null,
    @sCommand varchar(200)  = null,
    @nCPUTime int           = null
)
AS
DECLARE @Table TABLE
(
    SPID INT,
    Status VARCHAR(MAX),
    LOGIN VARCHAR(MAX),
    HostName VARCHAR(MAX),
    BlkBy VARCHAR(MAX),
    DBName VARCHAR(MAX),
    Command VARCHAR(MAX),
    CPUTime INT,
    DiskIO INT,
    LastBatch VARCHAR(MAX),
    ProgramName VARCHAR(MAX),
    SPID_1 INT,
    REQUESTID INT
)

INSERT INTO @Table EXEC sp_who2

SELECT  *
    FROM    @Table
    WHERE   (@sDBName IS NULL OR DBName = @sDBName)
    AND     (@sStatus IS NULL OR Status = @sStatus)
    AND     (@sCommand IS NULL OR Command = @sCommand)
    AND     (@nCPUTime IS NULL OR CPUTime > @nCPUTime)
GO 

Potrei estenderlo per aggiungere un ordine per parametro o addirittura un kill paramatmer in modo che uccida tutte le connessioni a un dato particolare


0

Sto scrivendo qui per un uso futuro del mio. Utilizza sp_who2 e inserisce nella tabella variabili invece della tabella temporanea perché la tabella temporanea non può essere utilizzata due volte se non la rilascia. E mostra bloccato e bloccante sulla stessa linea.

--blocked: waiting becaused blocked by blocker
--blocker: caused blocking
declare @sp_who2 table(
    SPID int,
    Status varchar(max),
    Login varchar(max),
    HostName varchar(max),
    BlkBy varchar(max),
    DBName varchar(max),
    Command varchar(max),
    CPUTime int,
    DiskIO int,
    LastBatch varchar(max),
    ProgramName varchar(max),
    SPID_2 int,
    REQUESTID int
)
insert into @sp_who2 exec sp_who2
select  w.SPID blocked_spid, w.BlkBy blocker_spid, tblocked.text blocked_text, tblocker.text blocker_text
from    @sp_who2 w
        inner join sys.sysprocesses pblocked on w.SPID = pblocked.spid
        cross apply sys.dm_exec_sql_text(pblocked.sql_handle) tblocked
        inner join sys.sysprocesses pblocker on case when w.BlkBy = '  .' then 0 else cast(w.BlkBy as int) end = pblocker.spid
        cross apply sys.dm_exec_sql_text(pblocker.sql_handle) tblocker
where   pblocked.Status = 'SUSPENDED'

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.