SQL Server: Filtrar a saída de sp_who2

190

No SQL Server, existe uma maneira fácil de filtrar a saída de sp_who2? Digamos que eu queira apenas mostrar linhas para um determinado banco de dados, por exemplo.

Craig Schwarze
fonte
2
como o @Nick sugeriu, as visualizações de gerenciamento dinâmico (DMVs) também podem valer a pena.
Mitch Wheat
i ter acrescentado resposta que usa DMVs vez de sp_who2
N30

Respostas:

348

Você poderia tentar algo como

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 filtre o que você precisa.

Adriaan Stander
fonte
O +1 na bo-flexson possui uma boa extensão para essa abordagem.
precisa saber é o seguinte
114

Você pode salvar os resultados em uma tabela temporária , mas seria ainda melhor ir diretamente à fonte emmaster.dbo.sysprocesses .

Aqui está uma consulta que retornará quase exatamente o mesmo resultado que 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 

Agora você pode adicionar facilmente qualquer cláusula ORDER BYou WHEREque desejar para obter uma saída significativa.


Como alternativa, você também pode considerar o uso do Activity Monitor no SSMS ( Ctrl+ Alt+ A)

KyleMit
fonte
24

Uma maneira é criar uma tabela temporária:

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
Mitch Wheat
fonte
selecione * de sp_who2 onde login = 'bla' - a tabela deve fazer referência aqui por # sp_who2?
Peter Schofield
Obter "O nome da coluna ou o número de valores fornecidos não corresponde à definição da tabela". executando isso no SQL 2008 R2
TheLegendaryCopyCoder
11

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

eu criei o seguinte script,
que resolve encontrar conexões ativas a qualquer banco de dados usando DMV, isso funciona no sql 2005, 2008 e 2008R2

O script a seguir usa 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+'%'
N30
fonte
muito complicado quando comparado com outras respostas. mas merece um voto positivo
Doan Cuong
Nem sempre é útil pelo DB, prefira a abordagem @astander e @ bo-flexson .
Lankymart
1
Este mostra como ingressar no processo do sistema operacional pai, que é o que eu queria.
redcalx
Descobri que o uso de sys.dm_tran_locks é esse script que diminui enormemente esse código se você tiver muitos bloqueios de transação abertos (por exemplo, uma transação de longa duração).
Mike
6

Ligeira melhoria na resposta de Astander . Eu gosto de colocar meus critérios no topo e facilitar a reutilização no dia a dia:

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)
Bo Flexson
fonte
4

Existem alguns procedimentos armazenados sp_who3 bons por aí - tenho certeza de que Adam Machanic fez realmente um bom, o AFAIK.

Adam o chama de Quem está ativo: http://whoisactive.com

Peter Schofield
fonte
Eu tentei isso, não foi tão fácil ... Estou postando outra maneira que é semelhante a alguns desses outros posts (mas é testada e correta).
Don Rolando
4

Semelhante à resposta do KyleMit , é possível selecionar diretamente as tabelas usadas pelo SP_WHO2, embora eu ache que seja necessário apenas a tabela dbo.sysprocesses.

Se alguém abrir esse SP, ele poderá entender o que faz. Esta é a minha melhor opção para ter uma saída semelhante à 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)
  ;

Sobre essa seleção, você pode selecionar os campos necessários e ter a ordem desejada.

dchang
fonte
Funcionou muito bem para mim #
211 Shai Alon
3

Uma maneira realmente fácil de fazer isso é criar um link ODBC no EXCEL e executar o SP_WHO2 a partir daí.

Você pode atualizar sempre que quiser e, porque é EXCEL, tudo pode ser manipulado facilmente!

BM
fonte
7
Tem certeza de que esta é a maneira mais fácil?
geomagas
2

Sim, capturando a saída de sp_who2 em uma tabela e selecionando a partir da tabela, mas seria uma maneira ruim de fazer isso. Primeiro, porque sp_who2, apesar de sua popularidade, é um procedimento não documentado e você não deve confiar em procedimentos não documentados. Segundo, porque todo o sp_who2 pode fazer, e muito mais, pode ser obtido em sys.dm_exec_requests e outros DMVs, e o show pode ser filtrado, ordenado, unido e todos os outros itens fornecidos com conjuntos de linhas consultáveis.

Remus Rusanu
fonte
4
Este é o caso em que eu não usaria um DMV connect.microsoft.com/SQLServer/feedback/details/257502/…
gbn
1

Extensão da primeira e melhor resposta ... Eu criei um procedimento armazenado no banco de dados mestre para o qual você pode passar parâmetros para .. como o nome do banco de dados:

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 

Eu poderia estendê-lo para adicionar uma ordem por parâmetro ou mesmo um paramatmer kill, para matar todas as conexões com dados específicos

Jon Bosker
fonte