olle's questions

Eu tenho uma consulta como

SELECT COUNT(*) FROM Foo Where Bar = 1 AND Baz = 2

a tabela tem 12934600 registros dos quais 1000001 correspondem a esse predicado

Olhando para as estatísticas de consulta que vejo

(1 linha(s) afetada(s) Tabela 'Foo'. Contagem de varredura 1, leituras lógicas 1863 , leituras físicas 0, leituras antecipadas 0, leituras lógicas lob 0, leituras físicas lob 0, leituras antecipadas lob 0.

(1 linha(s) afetada(s))

Tempos de execução do SQL Server: tempo de CPU = 250 ms, tempo decorrido = 503 ms.

Observando o plano de consulta, 80% do tempo é gasto em uma busca de índice nas colunas Bar e Baz e 20% na agregação do resultado.

Existe uma maneira de acelerar isso e, em caso afirmativo, como? Também gostaria de entender quais componentes de hardware têm uma grande influência aqui CPU ou disco IO ou velocidade do barramento.

Eu tenho uma tabela p com pontos de coluna. Existem alguns milhões de registros na tabela e preciso calcular e atualizar regularmente os pontos de cada linha. Esse processo leva alguns minutos e bloqueia a tabela. Eu preciso ser capaz de inserir e atualizar registros em p enquanto isso. Uma solução que eu estava pensando é criar uma segunda tabela e adicionar uma chave estrangeira para p e a coluna de pontos lá. Se esta tabela estiver bloqueada por alguns minutos, tudo bem. Existem desvantagens/consequências que devo ter em mente com esta solução?

Estou tentando descobrir qual seria uma boa maneira de escrever a pseudoconsulta abaixo no TSQL, levando em consideração que haverá cerca de 50 registros de actualResult e 100.000 registros de previsão por resultado real envolvido.

update prediction
set points = (
    @points = 0
    if(prediction.valueA = actualResult.valueA AND prediction.valueB = actualResult.valueB)
        @points = @points + 3
    if (prediction.valueA = actualResult.valueA OR prediction.valueB = actualResult.valueB)
        @points = @points + 1
    select @points
)   
join actualResult on prediction.actualid = actualResult.id
where actualResult.id in (some subquery)

o que eu estou pensando é:

• Existe uma maneira de fazer o cálculo que na realidade é mais complexo em linha? No momento, só posso fazê-lo funcionar se colocá-lo em uma função, mas pelo que entendi, isso significa que ele é constantemente recalculado, mesmo que a entrada seja a mesma (o que eu provavelmente atribuo às previsões)
• Dessa forma bloquearia toda a gama de registros? E se assim for, há uma maneira de evitar isso? Por exemplo, copiando tudo para uma variável de tabela e, em seguida, fazendo o cálculo sobre ela e atualizando os registros assim que todos os cálculos forem feitos?

estou no caminho certo aqui ou você escreveria de uma maneira diferente?

Eu tenho um banco de dados existente que está faltando alguns índices. Quando tentei criar alguns, o servidor de banco de dados realmente sofreu com o uso da CPU durante a criação do índice, interferindo na carga de trabalho regular. Existe uma maneira de prevenir ou limitar isso? Afinal estou criando o índice para aumentar a performance. Ou este é um golpe único que tenho que suportar para que as coisas sejam melhores no futuro?

Para diagnosticar alguns problemas de desempenho, gostaria de entender melhor o número de vezes que determinados procedimentos são chamados em comparação com o desempenho do sistema. Existe uma maneira de obter o número de vezes que cada procedimento foi chamado durante um determinado período de tempo?

Quando executo sp_whoisactiveem meu servidor, geralmente mostra instruções de criação sendo executadas para procedimentos armazenados, mas isso não faz sentido, pois o procedimento já existe.

Veja o seguinte exemplo:

dd hh:mm:ss.mss session_id  sql_text
00 00:00:00.120 103 CREATE PROCEDURE [dbo].[TempGetStateItemExclusive3]
00 00:00:00.140 274 CREATE PROCEDURE [dbo].[TempGetStateItemExclusive3]
00 00:00:00.133 324 CREATE PROCEDURE [dbo].[TempGetStateItemExclusive3]

Isso é de uma execução sp_whoisactive, parece que há três sessões criando o procedimento. Isso é algo que estou interpretando mal ou, se não, como posso descobrir de onde isso está vindo? Essas instruções de criação estão bloqueando as inserções reais.

estou executando

EXEC sp_WhoIsActive 
     @find_block_leaders = 1, 
     @sort_order = '[blocked_session_count] DESC',
     @get_full_inner_text = 1

O lote que está sendo executado é (que é um procedimento armazenado do estado de sessão baseado no asp.net SQL Server, mas estou vendo exatamente a mesma coisa para outros procedimentos armazenados também)

CREATE PROCEDURE [dbo].[TempGetStateItemExclusive3]
        @id         tSessionId,
        @itemShort  tSessionItemShort OUTPUT,
        @locked     bit OUTPUT,
        @lockAge    int OUTPUT,
        @lockCookie int OUTPUT,
        @actionFlags int OUTPUT
AS
    DECLARE @textptr AS tTextPtr
    DECLARE @length AS int
    DECLARE @now AS datetime
    DECLARE @nowLocal AS datetime

    SET @now = GETUTCDATE()
    SET @nowLocal = GETDATE()

    UPDATE dbo.ASPStateTempSessions
    SET Expires = DATEADD(n, Timeout, @now), 
        LockDate = CASE Locked
                      WHEN 0 THEN @now
                      ELSE LockDate
                   END,
        LockDateLocal = CASE Locked
                           WHEN 0 THEN @nowLocal
                           ELSE LockDateLocal
                        END,
            @lockAge = CASE Locked
                WHEN 0 THEN 0
                ELSE DATEDIFF(second, LockDate, @now)
                END,
            @lockCookie = LockCookie = CASE Locked
                WHEN 0 THEN LockCookie + 1
                ELSE LockCookie
                END,
            @itemShort = CASE Locked
                WHEN 0 THEN SessionItemShort
                ELSE NULL
                END,
            @textptr = CASE Locked
                WHEN 0 THEN TEXTPTR(SessionItemLong)
                ELSE NULL
                END,
            @length = CASE Locked
                WHEN 0 THEN DATALENGTH(SessionItemLong)
                ELSE NULL
                END,
            @locked = Locked,
            Locked = 1,

            /* If the Uninitialized flag (0x1) if it is set,
               remove it and return InitializeItem (0x1) in actionFlags */
            Flags = CASE
                WHEN (Flags & 1) <> 0 THEN (Flags & ~1)
                ELSE Flags
                END,
            @actionFlags = CASE
                WHEN (Flags & 1) <> 0 THEN 1
                ELSE 0
                END
        WHERE SessionId = @id
        IF @length IS NOT NULL BEGIN
            READTEXT dbo.ASPStateTempSessions.SessionItemLong @textptr 0 @length
        END

        RETURN 0

Em um servidor SQL de produção, vejo picos enormes e intermitentes no tráfego de dados. Até 200Mbit/s que está causando esperas de NETWORK IO que, por sua vez, causam tempos limite de consulta. Como posso descobrir quais consultas estão retornando grandes conjuntos de resultados?

Qual é o significado de DOP no contexto do sql server?