garik's questions

Estou otimizando alguma tarefa de aplicativo de servidor que usa banco de dados (consultas, cálculos complexos, inserções de dados...). A execução desta tarefa gasta cerca de 16 minutos (testei mais 3 vezes) e é um tempo previsível para fazê-lo.
Então eu executei o script:

ALTER INDEX ALL ON dbo.'+ @TableName +' REBUILD

para cada tabela em um banco de dados. E o que vejo agora. O tempo de execução da minha tarefa é aumentado para 24 minutos. O que está acontecendo se não houver influências externas nesta tarefa? Eu estava esperando pelo aumento de desempenho (devido à reconstrução de índices fragmentados), mas obtive degradação.

Eu tenho algumas tabelas e serviço de aplicativo que insere intensamente, atualiza seus. Por outro lado, algum aplicativo cliente precisa ler dados usando essas tabelas. Às vezes, o aplicativo cliente obtém exceções de tempo limite devido a bloqueios desses dados compartilhados. Qual a solução comum ou talvez não ordinal para separar dados modificados intensivamente e ler rapidamente o mesmo. A propósito, os dados podem ser consistentes , mas podem ser atrasados ​​no tempo por 10 a 20 segundos (por exemplo). OLAP não pode ser usado.

O banco de dados em que nossos desenvolvedores estão trabalhando é muito grande (tem muitos objetos de banco de dados). Temos que controlar as alterações dos objetos do banco de dados (gerenciamento de alterações). Nossa empresa não pode ter uma pessoa que seja responsável apenas por alterações no banco de dados. Portanto, precisamos de uma fonte segura para objetos de banco de dados, algo como controle de versão para código padrão, mas mais relacionado ao banco de dados, que possa sincronizar banco de dados e scripts. Qual é o melhor. Confiável, Barato, Funcional - escolha os dois :)

Estou pegando todos os erros no meu Sql Server, recebi erros:

Contexto do banco de dados alterado para 'MyDbName'. Configuração de idioma alterada para us_english.

Não encontrei nenhuma explicação clara do problema e da gravidade desse erro. É crítico?

Eu tenho tão erro:

O banco de dados 'MyDb' está sendo recuperado. Aguardando até que a recuperação seja concluída.

Eu tive uma operação crítica naquele momento.

Qual é a causa desta situação? E como pode ser evitado?

Tenho uma trigger em uma tabela ( source ) que os dados devem ser copiados para a outra ( target ) em outro banco de dados. Estou tentando implementar o processo de sincronização personalizado para dados: quero que o banco de dados de destino (tabela) esteja atualizado para o banco de dados de origem (tabela). Tenho 3 centenas de tabelas para sincronizar. Alguns deles têm estrutura de dados física diferente. Não posso usar abordagens padrão do Sql Server (replicação, DTS...) devido a diferentes esquemas de dados e outras restrições (tempo de implementação, problemas de ambiente...). Meu objetivo é: esse gatilho NÃO deve impactar em INSERT, DELETE, UPDATE de registros em uma tabela de origem. Eu tentei assim solução:

CREATE TRIGGER dbo.MyTrigger
...
   AFTER INSERT
....
BEGIN TRY
     --RAISERROR('Test error', 16, 2)
END TRY
BEGIN CATCH
  -- nothing
END CATCH

Eu inseri RAISEERRORpara simular erro. Eu esperava, try/catchsuprimido que o erro e o registro foram inseridos (excluídos ou atualizados) com sucesso. Não. Não funciona. Eu tenho erro:

Foi gerado um erro durante a execução do gatilho. O lote foi abortado e a transação do usuário, se houver, foi revertida.

É possível realizar minha solução dessa maneira. Como posso capturar e segurar (suprimir) qualquer erro no meu gatilho?

Que sentido usar try/catchno trigger se não funcionar?

Tive atrasos estranhos ao fazer backup de um grupo de bancos de dados (mais 20) em um escopo (TSQL) para o mesmo local de arquivo.

É possível que várias operações de backup estejam em execução ao mesmo tempo? Não encontrei nenhuma operação "WAIT" em uma cláusula BACKUP , mas esta opção está presente no comando SMO ( Wait ) da classe Backup .

Aqui está meu código parcial (o código completo funciona bem, então quero descrevê-lo conforme mostrado abaixo):

WHILE 1 = 1
BEGIN
   SET @currentDbName = ...

   SET @sql = 'BACKUP DATABASE ' + @currentDbName + '...'

   EXEC(@sql)
   -- maybe it is a good place to wait?
   -- WAITFOR
END

Há uma grande tabela (5-6 milhões de registros). Tenho que mover 90% dos registros antigos para outro banco de dados (tabela). Solução?

Eu tenho que iniciar o processo cíclico em um procedimento armazenado e, em seguida, pará-lo após algum tempo (após 12 a 24 horas). O trabalho do procedimento armazenado não deve ser iniciado duas vezes. O cliente SQL Server (chamador) não deve esperar e não deve obter tempo limite de execução. Como pode ser implementado?

CREATE PROC dbo.CyclingProcess
AS
BEGIN


    /*

    .. how to start or stop process by external caller

    */

    WHILE(1 = 1)
    BEGIN

        EXEC mysp_WorkingProcedure -- some working process...
              @input1 = @input1
              .... 
             ,@delay  = @delay output 


           WAITFOR DELAY @delay
    END

END

Esclarecimento:

Eu tenho que fazer algum trabalho repetido durante muito tempo. Eu tenho que iniciar este processo e pará-lo. Por que procedimento armazenado? Tenho que alterar alguns parâmetros de entrada para [algum trabalho] e chamá-lo novamente após algum atraso. Talvez você conheça outra maneira mais inteligente de implementá-lo. Este processo cíclico deve funcionar no banco de dados.

Vamos examinar essas duas afirmações:

IF (CONDITION 1) OR (CONDITION 2)
...

IF (CONDITION 3) AND (CONDITION 4)
...

Se CONDITION 1for TRUE, será CONDITION 2verificado?
Se CONDITION 3for FALSE, será CONDITION 4verificado?

E as condições em WHERE: o mecanismo do SQL Server otimiza todas as condições em uma WHEREcláusula? Os programadores devem colocar as condições na ordem correta para garantir que o otimizador do SQL Server as resolva da maneira correta ?

ADICIONADO:

Obrigado a Jack pelo link, surpresa do código t-sql:

IF  1/0 = 1 OR 1 = 1
      SELECT 'True' AS result
ELSE
      SELECT 'False' AS result


IF  1/0 = 1 AND 1 = 0
      SELECT 'True' AS result
ELSE
      SELECT 'False' AS result

Não há uma exceção de divisão por zero neste caso.

CONCLUSÃO:

Se C++/C#/VB tem curto-circuito, por que o SQL Server não pode ter?

Para realmente responder a isso, vamos dar uma olhada em como ambos funcionam com condições. C++/C#/VB todos têm curto-circuito definido nas especificações da linguagem para acelerar a execução do código. Por que se preocupar em avaliar condições N OR quando a primeira já é verdadeira ou condições M AND quando a primeira já é falsa.

Nós, como desenvolvedores, temos que estar cientes de que o SQL Server funciona de maneira diferente. É um sistema baseado em custos. Para obter o plano de execução ideal para nossa consulta, o processador de consulta deve avaliar todas as condições e atribuir um custo. Esses custos são então avaliados como um todo para formar um limite que deve ser inferior ao limite definido que o SQL Server tem para um bom plano. Se o custo for inferior ao limite definido, o plano é usado, caso contrário, todo o processo é repetido novamente com uma combinação diferente de custos de condição. O custo aqui é uma varredura ou uma busca ou uma junção de mesclagem ou uma junção de hash etc... Por causa disso, o curto-circuito disponível em C++/C#/VB simplesmente não é possível. Você pode pensar que forçar o uso de índice em uma coluna conta como um curto-circuito, mas não é. Apenas força o uso desse índice e com isso encurta a lista de possíveis planos de execução. O sistema ainda é baseado em custos.

Como desenvolvedor, você deve estar ciente de que o SQL Server não faz curto-circuito como é feito em outras linguagens de programação e não há nada que você possa fazer para forçá-lo.

Eu tenho uma tabela com campo Id( bigint, IDENTITY) como chave primária e índice clusterizado nela. Eu inseri 400 linhas e vi o plano de execução. Eu obtive: o custo relativo da consulta para esta inserção 36% e para esta consulta "Clustered Index Insert" custou 97%. O que está acontecendo? Por que funciona tão devagar?

ADICIONADO:

Prosseguir

Consulte também desempenho de inserção do SQL Server

Eu li um documento ( Designing Highly Scalable OLTP Systems ) que descreve um truque para obter mais desempenho:

Como as linhas são pequenas (muitas cabem em uma página), vários bloqueios podem competir por um PAGELATCH. Podemos “desperdiçar” um pouco de espaço para obter mais desempenho. Solução: preencha as linhas com a coluna CHAR para fazer com que cada linha ocupe uma página inteira.

Alguém usa essa abordagem? Que resultados você obteve?

Obrigada.

ADICIONADO:

Aviso. O artigo vinculado não é um guia para a ação. Thomas Kejser descreve testes em bancos de dados do tamanho de terabytes, nada mais.

É verdade que os sistemas RDBMS são otimizados para COMMIToperações? Quão mais lentas/rápidas são ROLLBACKas operações e por quê?

Meu banco de dados tem uma tabela: tableX.

Task1 faz INSERTs intensivos (1000 registros por minuto) como registros para processar e muito raramente UPDATEs (1-2 registros por minuto) como registros para recalcular.

Ao mesmo tempo, outro Task2 SELECTs não processa registros (inserido por Task1) e, em seguida, insere novos registros (conforme processados) na mesma tabelaX em uma transação (é um cálculo muito longo, até 10 segundos).

Task3 recalcula registros ATUALIZADOS (por Task1): apenas ATUALIZA tableX.

Alguém poderia recomendar um design para evitar longos bloqueios e impasses para este cenário. É muito importante processar todos os registros INSERIDOS na ordem em que foram inseridos!

1) Devo separar (criar uma nova tabelaX2) registros processados ​​e não processados?

2) Devo separar a transação em Task1 e fazer SELECTs e INSERTs em duas transações separadas?

3) Devo usar rowlock, readpast...hints e onde (pode me ajudar)?

Eu tenho então tabelas:

e assim dados na tabela Language:

e assim dados na tabela Text:

Eu tenho que retornar o texto para o idioma solicitado , se existir , e o texto para o idioma padrão , se não existir . É possível fazer isso em uma consulta (não while, por favor)?

Código:

DECLARE @CommentId  bigint = 1
--DECLARE @LanguageCode  nvarchar(2) = 'en' -- "english text" returns
DECLARE @LanguageCode  nvarchar(2) = 'ua'   -- nothing at this moment

SELECT
     t.CommentId
    ,t.TextId
    ,t.[Text]
    ,t.LanguageId
    ,RequestedLanguageId = @LanguageCode
FROM dbo.common_Text t 
    INNER JOIN dbo.common_LanguageType l 
        ON t.LanguageId = l.LanguageId
WHERE l.Code = @LanguageCode 
    AND t.CommentId = @CommentId

Obrigada.

ADICIONADO:

Se o código solicitar um texto em 'ua' (ucraniano) e este não for nenhum texto para este idioma, ele irá procurar texto para russo. se encontrado - ok, caso contrário, ele procurará um texto para inglês. A lista de idiomas pode variar.

Eu tenho uma variável de tabela:

DECLARE @to_process TABLE 
(
    [Id] [bigint] NOT NULL,
    [SequenceId] [bigint] NOT NULL,
...
)


INSERT INTO @to_process
   (  Id
    , SequenceId
...
   )
  SELECT
    TOP (@recordsToProcess) 
      Id
    , SequenceId
...

no meu procedimento armazenado. Eu investiguei que a inserção gasta cerca de 66% do tempo total de execução.

Como posso melhorar ou otimizar meu código para acelerar a execução do sp?

ADICIONADO:

Eu tenho que usar exibições indexadas para alcançar o desempenho. Como posso ver nesta tabela de comparação , a edição padrão não oferece suporte a exibições indexadas. Mas BOL diz:

As exibições indexadas podem ser criadas em qualquer edição do SQL Server. No SQL Server Enterprise, o otimizador de consulta considera automaticamente a exibição indexada. Para usar uma exibição indexada em todas as outras edições, a dica de tabela NOEXPAND deve ser usada.

Então vai funcionar (estou falando sobre desempenho)

select * from dbo.OrderTotals with (noexpand, index=IXCU_OrderTotals)

na edição SQL Server Standard assim como funciona

select * from dbo.OrderTotals

no Enterprise?

Aqui está o código para visualização:

CREATE VIEW dbo.OrderTotals
WITH SCHEMABINDING
AS
select 
    OrderId     =   r.OrderId                   
  , TotalQty            =   SUM(r.Quantity)
  , TotalGrossConsid    =   SUM(r.Price * r.Quantity)
  , XCount      =   COUNT_BIG(*)
from dbo.Order r
group by r.OrderId

CREATE UNIQUE CLUSTERED INDEX IXCU_OrderTotals ON OrderTotals (OrderId)

Tenho duas tabelas: detalhes e totais desses detalhes.

Detalhes ( solução lenta ):

select 
    OrderId             =   r.OrderId                   
  , TotalQty            =   SUM(r.Quantity)
  , TotalGrossConsid    =   SUM(r.Price * r.Quantity)
from dbo.Order r
group by r.OrderId

Totais ( solução rápida ):

select 
    t.OrderId                           
  , t.TotalQty          
  , t.TotalGrossConsid  
  , t.IsValid
from dbo.OrderTotal t

Às vezes, os totais se tornam inválidos (algum trabalho precisa recalcular os totais alterados, mas atrasa). Como você entende, a segunda consulta é mais rápida e o número de totais válidos é maior que os inválidos. Portanto, estou procurando uma consulta combinada que retorne totais válidos da segunda tabela (totais) e retorne totais recalculados dinamicamente usando a primeira consulta lenta. Portanto, meu objetivo será alcançado: todos os totais são válidos e o tempo de resposta é mais rápido do que o recálculo completo.

Aqui está minha tentativa ( solução híbrida ):

with fast_static(OrderId, TotalQty, TotalGrossConsid, IsValid)
as
(
    select 
        t.OrderId                           
      , t.TotalQty          
      , t.TotalGrossConsid  
      , t.IsValid
    from dbo.OrderTotal t
)

, slow_dynamic(OrderId, TotalQty, TotalGrossConsid)
(
   select 
        OrderId             =   r.OrderId                   
      , TotalQty            =   SUM(r.Quantity)
      , TotalGrossConsid    =   SUM(r.Price * r.Quantity)
    from dbo.Order r
)
select
    OrderId, TotalQty, TotalGrossConsid
from fast_static 
where IsValid = 1  
union all
select
  OrderId, TotalQty, TotalGrossConsid 
from slow_dynamic s 
    --inner join fast_static ff
    --on ff.OrderId = s.OrderId 
where   --ff.Valid = 0 -- too slow!!!
    s.OrderId in (select OrderId from fast_static f where f.Valid = 0)

Comparei a solução Fast com a Híbrida, obtive 32% a 68% (custos relativos de consulta). Se você pode ver a variante comentada, é igual a 1% a 99% (que pena). É possível melhorar esta consulta?

ADICIONADO

@gbn:

Valid  =  case when i.OrderId is null then 1 else 0 end
...
dbo.OrderTotal t  left join dbo.InvalidOrders i

Sim, tenho um trabalho para recalcular totais e este processo não está sincronizado com os pedidos de consulta. As tabelas InvalidOrders são pequenas que armazenam registros para saber que os totais são inválidos (a serem recalculados)

SOLUÇÃO

Visualizações indexadas são a melhor escolha. Esteja ciente da edição do SQL Server ( dica noexpand para edições não corporativas) e esteja pronto para recriar alguns objetos de banco de dados ( SET ANSI_NULLS ON, SET QUOTED_IDENTIFIER ON) para começar a usar exibições indexadas no lado do cliente.

Antes eu tentava evitar o uso do cursor por causa de problemas de desempenho. Mas agora tenho que fazer alguns cálculos para atingir alguns objetivos. Eu tenho um procedimento armazenado que tem um código como este:

DECLARE  Outer_Cursor CURSOR FOR...

   OPEN Outer_Cursor
   FETCH NEXT FROM Outer_Cursor INTO ...

   WHILE @@FETCH_STATUS = 0
   BEGIN

      DECLARE  Inner_Cursor CURSOR  FOR...

      OPEN Outer_Cursor
      FETCH NEXT FROM Inner_Cursor INTO ...

      WHILE @@FETCH_STATUS = 0
      BEGIN

        ...

        FETCH NEXT FROM Inner_Cursor INTO ...
      END

      CLOSE Inner_Cursor
      DEALLOCATE Inner_Cursor    

      FETCH NEXT FROM Outer_Cursor INTO ...

  END

  CLOSE Outer_Cursor
  DEALLOCATE Outer_Cursor

Minha pergunta é: é possível evitar (minimizar) a recriação tão cara do cursor para o cursor interno. Como posso reutilizar a declaração interna do cursor, é possível?

Obrigada.

Quando estou procurando criar alguns campos de carimbo de data/hora (ou outros campos de estilo de data/hora), qual é a melhor maneira de nomeá-los? Devo apenas colocar record_timestamp?