JohnG's questions

Meu software, compatível com todas as versões do SQL2016 e superiores, incluindo o SQL Azure, trava quando o SQL 2022 é inferior à versão 16.0.1135.2 ou inferior à 16.0.4165.4 - dependendo do RTM, GDR, CU (que estou tendo dificuldade em entender a arquitetura de versão que a MS usa)

Eu escrevi este código para descobrir se uma atualização de SQL é necessária

-- if it's Version 16
IF (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),1,charindex('.',convert(varchar(20),SERVERPROPERTY('productversion')))-1))='16'
-- If so is it 16.0.1xxxxxxx or 16.0.4xxxxxxxx
    IF (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),1,charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion')))))='1'
-- if 16.0.1 it needs to be < 16.0.1135.2 
BEGIN 
        if (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion'))),len(convert(varchar(20),SERVERPROPERTY('productversion')))))<'16.0.1135.2'
 select 1
END
ELSE 
BEGIN 
-- if 16.0.4 it needs to be < 16.0.4165.4 
        IF (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),1,charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion')))))='4'
            if (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion'))),len(convert(varchar(20),SERVERPROPERTY('productversion')))))<'16.0.4165.4'
            select 1 
END 

Meu problema é que em 16.0.YYYY.z, não acho que posso confiar no primeiro Y para me dizer qual branch devo olhar porque, olhando para versões anteriores do SQL, no mesmo branch o primeiro Y pode mudar de dígito... O que estou procurando são as 2 versões atualizadas antes de 2024-11-12. Quero ser sinalizado se a versão do SQL2022 instalada não incluir as atualizações de 2024-11-12.

1. Existe algum padrão que eu possa seguir ou haveria uma maneira melhor de fazer isso?
2. Devo me preocupar com o Azure ou posso presumir que o Azure está sempre atualizado?

Queremos que o usuário saiba que ele precisa de no mínimo 16.0.1135.2 ou 16.0.4165.4. Minha preocupação é selecionar o branch (='1' ou ='4') na consulta. Não acho que será confiável com o tempo (o dígito pode mudar), pois não tenho certeza da convenção que a MS usa.

O Software tem mais de 30000 scripts (mais de 30 anos de desenvolvimento) e milhares de clientes. As atualizações são feitas por especialistas (e não pelo cliente). Como ele é atualizado quatro vezes por ano, queremos adicionar um aviso durante a atualização se descobrirmos que o servidor SQL é incompatível para que o especialista possa tomar medidas.

Estou usando o SQL Server 2019 e acabei de encontrar um comportamento estranho. A pesquisa não me levou a lugar nenhum.

Alguém pode explicar esse comportamento?

SET QUOTED_IDENTIFIER ON; 
if ((256 & @@options) = 256) print '1- quoted_identifier is on' else print '1- quoted_identifier is off';
BEGIN TRY 
    if ((256 & @@options) = 256) print '2- quoted_identifier is on' else print '2- quoted_identifier is off';
END TRY 
BEGIN CATCH
    if ((256 & @@options) = 256) print '3- quoted_identifier is on' else print '3- quoted_identifier is off';
    -- SET QUOTED_IDENTIFIER OFF
    -- if ((256 & @@options) = 256) print '4- quoted_identifier is on' else print '4- quoted_identifier is off';
END CATCH

Devoluções:

1- quoted_identifier is on
2- quoted_identifier is on

mas o seguinte código:

SET QUOTED_IDENTIFIER ON; 
if ((256 & @@options) = 256) print '1- quoted_identifier is on' else print '1- quoted_identifier is off';
BEGIN TRY 
    if ((256 & @@options) = 256) print '2- quoted_identifier is on' else print '2- quoted_identifier is off';
END TRY 
BEGIN CATCH
    if ((256 & @@options) = 256) print '3- quoted_identifier is on' else print '3- quoted_identifier is off';
    SET QUOTED_IDENTIFIER OFF
    if ((256 & @@options) = 256) print '4- quoted_identifier is on' else print '4- quoted_identifier is off';
END CATCH

Devoluções:

1- quoted_identifier is off
2- quoted_identifier is off

Mesmo que não vá para a captura!!! Eu devo estar esquecendo alguma coisa.

Consegui até simplificar o código para o mais simples:

SET QUOTED_IDENTIFIER ON; 
if ((256 & @@options) = 256) print '1- quoted_identifier is on' else print '1- quoted_identifier is off';
SET QUOTED_IDENTIFIER OFF
if ((256 & @@options) = 256) print '2- quoted_identifier is on' else print '2- quoted_identifier is off';

Resultados:

1- quoted_identifier is off
2- quoted_identifier is off

Eu tenho algum código que usa FOR XML, o que exige que eu defina o identificador citado como LIGADO, mas preciso colocá-lo novamente em DESLIGADO, não importa se a parte XML for bem-sucedida ou falhar. Como você faria isso?

Meus testes mostram que, se eu colocar o SET QUOTED_IDENTIFIERto off no CATCH, a inserção falha ao dizer que meu identificador citado não está definido corretamente, embora esteja definido no início do TRYto ON.

Com base no seguinte código:

/* This SP takes a query and a unique temporary table name as input... 
The outputs is a string with the command to create the tmp table based on the query that is given in the @SRC parameter 
*/ 
EXEC dbo.createTmpFromQuery @SRC,@uniqueTMP,@createTmpStr=@SQLStr OUTPUT
/* This executed the query that will create the tmp table and insert the data from @SRC */
EXEC(@SQLStr)

Todo o procedimento armazenado que chama essas 2 linhas (entre muitas outras) está em um Try Catch. Acabei de encontrar um problema em que a consulta no @SRC teve um erro de sintaxe que chamou a parte Catch:

BEGIN CATCH
        ROLLBACK TRANSACTION;
        SET @ERRORMESSAGE=CASE WHEN @ERRORMESSAGE='' THEN ERROR_MESSAGE() ELSE @ERRORMESSAGE END 
        RAISERROR (@ERRORMESSAGE,16,1)
END CATCH

o Try tem muitas validações e eu configurei @ErrorMessage para mensagens personalizadas na maioria dos casos. Nesse caso, gostaria de definir uma mensagem personalizada em vez de receber a mensagem de erro padrão

(example): Incorrect syntax near 'FROM'.

Estou tentando descobrir como posso obter o EXEC(@SqlStr) retornar um código bem-sucedido ou com falha, para que eu possa definir o @ErrorMessage antes que ele entre na parte de captura do código.

Estou sendo desafiado, pois temos clientes que estão vendo diferentes tipos de erros ao executar o que deveria ser manutenção online. erros como tempos limite, verificação interrompida devido à movimentação de dados e muito mais.

Alguns de nossos clientes compraram o SQL Server Enterprise Edition para obter o recurso online de índice de reconstrução.

Para replicar os problemas, tenho testado em um grande banco de dados o dbcc checkdb, reorganização e reconstrução de índices e atualização de estatísticas enquanto bombardeio o servidor com transações em um banco de dados que tem quase 1TB.

Meu primeiro teste foi com o checkdb com maxdop=1 enquanto o sqlServer estava processando 124000 pequenas transações... Recebi um timeout da minha aplicação que tem um timeout definido para 5 minutos. Pesquise sobre como o check db funciona, é que ele cria um snapshot, usa tempdb intensivamente e nolocks são criados para criar o snapshot... Então, como uma das minhas pequenas transações pode ser bloqueada se não bloquear tabelas?

Meu segundo teste foi reorganizar todos os índices (que também deveria estar online) enquanto processava 124.000 transações, dessa vez consegui um impasse...

Meu terceiro teste foi atualizar todas as estatísticas com maxdop=1 enquanto executava 124.000 transações. O erro recebido neste caso é: Não foi possível continuar a varredura sem bloqueio devido à movimentação de dados

meu quarto teste para reconstruir todos os índices online durante a execução de 124.000 transações será executado em breve e atualizarei meu post com os resultados.

O maxdop=1 que usei onde pode ser usado foi para eliminar a contenção de recursos.

Eu li vários artigos, incluindo a explicação de Paul Randal sobre online vs offline da reconstrução de índices e entendo a diferença ... .

Qualquer entrada seria muito apreciada.

O que estou perdendo

Com base neste post , consegui resolver o problema de desempenho adicionando índices e pensei que concluí meu projeto até encontrar um problema com a soma de verificação ... descobriu que o checksum e o binary_checksum não são confiáveis ​​em um ambiente crítico do sistema .

Estou procurando uma maneira confiável de calcular dados para uma tabela em uma loja e depois compará-los com a mesma tabela na sede.

Conforme explicado no post mencionado acima, os arquivos de dados são transferidos de várias lojas (transações) para a sede à medida que acontecem. Para cada loja, a mesa em questão é bem grande. Na sede, essa mesma tabela contém as mesmas informações de todas as lojas, o que a torna enorme. Os dados são transferidos por meio de arquivos, pois não há conexões diretas entre o HO e as lojas. Idealmente, seria ótimo se eu pudesse transferir todos os dados da loja, linha por linha, e compará-los com a tabela da matriz, mas é impensável, pois é muito grande.

Tentei usar a HASHBYTESconversão de colunas para strings, mas descobri que tem uma limitação de 8.000 caracteres até o SQL Server 2014. Nossos sistemas precisam suportar qualquer versão do SQL Server de 2008 até hoje.

Estou tentando encontrar uma maneira confiável de obter algum tipo de valor de soma de verificação agregado que possa ser comparado entre cada loja e sua matriz_escritório tabela por tabela.

ATUALIZAÇÃO: Já tentei usar o Hashbyte mas no meu caso não funciona pois não estou comparando linha por linha devido a quantidade de dados entre cada loja e a matriz. Exemplo: se uma loja tiver 100.000 linhas para uma tabela, a matriz que teria as informações de 10 lojas conteria 1.000.000 linhas nessa mesma tabela... Não consigo enviar todas as linhas da loja para o sede apenas para comparar e certificar-se de que todos os dados foram transferidos com sucesso. Então minha forma de pensar é agregar as informações da loja por data e comparar com a mesma agregação para a mesma loja na matriz e se eu encontrar uma incompatibilidade, tenho um processo que é acionado para solicitar as informações da loja para uma data específica à sede.

Fiquei tão feliz em encontrar o Checksum_agg de um checksum, que fez exatamente isso...

Alguma outra ideia? alguém?

Eu tenho um aplicativo instalado em todo o mundo que usa versões do SQL do SQL Server 2008 Express para o SQL Server 2017 Enterprise Edition.

Eu tentei várias maneiras de criar um índice (3 colunas com uma inclusão de 3 colunas) em uma grande tabela onde o banco de dados geralmente está em modelo de recuperação simples, mas pode ser como modelo de recuperação completa... Hardware pode variar drasticamente de um cliente para cima outro:

1. Alterar tabela criar índice...
2. Crie uma tabela tmp com o novo índice e copie os dados com um "inserir em" seguido de uma tabela de descarte da tabela original e uma renomeação da tabela tmp para substituir a original.
3. Crie uma tabela tmp com o novo índice e use um script do PowerShell para copiar os dados seguido por uma tabela de descarte da tabela original e uma renomeação da tabela tmp para substituir a original.

A mais rápida das 3 foi a 1ª opção (a forma tradicional de criar um índice não clusterizado) que levou 1h15m para um pouco mais de 106 milhões de registros (a tabela tem 200 colunas... não é o ideal mas é com o que estou trabalhando ) as outras opções levaram o triplo do tempo e mais)

Infelizmente, não posso usar o recurso online, pois há uma variedade de versões do SQL Server e o online só é bom para a edição corporativa.

Uma hora e 15 minutos no meu laboratório é muito tempo e eu gostaria de tentar encontrar outra maneira de diminuir isso, especialmente que em uma de nossas próximas atualizações de aplicativos, precisaremos criar 23 índices ... e eu ainda não vi uma atualização que leva de 5 a 6 horas e os clientes não vão querer esperar de 5 a 6 horas por uma atualização de software.

Além disso, a atualização não exigirá nenhuma atividade no banco de dados durante a atualização.

Tudo o que estou procurando são ideias que eu possa tentar criar meus índices em um período de tempo razoável. Nenhum código! só precisa de ideias teóricas.

Qualquer ideia seria muito apreciada.

Para simplificar a situação, considerarei apenas uma tabela grande...
Todas as noites, uma loja enviará todos os dados novos e alterados de um dia para uma tabela grande para a matriz. (essa porção é boa) Além disso, a loja envia um resumo dessa tabela dos últimos 30 dias para a matriz dessa mesa grande.

Na sede, os dados novos e alterados são atualizados na tabela grande (sem problemas aqui). O resumo dos últimos 30 que são recebidos e carregados em uma tabela. Ele é então comparado a uma consulta que resume os dados na matriz dessa tabela muito grande (que contém todas as lojas) para essa mesma loja.<-- é aí que está o problema. Isso é feito para garantir que os dados da loja correspondam aos dados da sede dessa loja (recebemos um aviso se não corresponderem para os quais eles precisam agir)

O problema é que a consulta de resumo leva muito tempo... Estou procurando mudar a maneira como comparamos a tabela de armazenamento com a tabela de host de uma maneira mais eficiente.

Experimentei a visualização indexada e os resultados foram óptimos mas o facto de terem demasiadas limitações torna praticamente impossível implementá-la em larga escala (para todos os proprietários de software, caixas registadoras, Lojas e Sedes) devido às diferentes estruturas e diferentes versões do nosso software.

Tenho tentado pensar em diferentes maneiras de garantir que os dados de uma tabela (pelo menos nos últimos 30 dias) de uma loja correspondam à matriz, mas sinto que estou girando em círculos... estou procurando idéias para me ajudar a olhar para isso de forma diferente.

Limitações: Usamos o SQL Express nas lojas e geralmente padrão nas matrizes. Não há conexão direta entre os dois bancos de dados (os dados são transferidos por meio de arquivos).

Qualquer ajuda é apreciada. obrigada

Adicionadas mais informações: Estrutura da tabela (sei que não é a ideal, é o que herdei): Data, Loja, terminal, transNum, lineNum, Qty, Amount + 194 MAIS COLUNAS. O índice PK e clusterizado é : Date, Store, terminal, transNum, lineNum

A consulta para resumir é simples:

Select Date, Store, sum(Qty) as Qty, sum(Amount) as Amt
from MyHugeTable 
where date between '2017-07-22' and '2017-08-22'
and store = '1234'
group by Date, Store;

Tentando criar um grande banco de dados de teste, tenho um SP que criei que usa uma lista predefinida de tabelas (35 que me interessam) e multiplica os dados em cada uma delas.

Em outras palavras, uma tabela tem dados para uma loja. Eu insiro nesta tabela os mesmos dados, mas com um número de loja diferente (o que me dá 2 lojas). Eu então chamo o mesmo SP que multiplica os dados de 2 Stores para 4 stores, e assim por diante. No final de semana iniciei o processo de 6 chamadas consequentes do SP pensando que quando eu voltasse segunda feira meu BD teria dados para 64 lojas. Infelizmente não foi assim...

Quando cheguei na segunda-feira, encontrei o HD de dados cheio, mas o processo nunca travou e parecia estar suspenso. meu banco de dados está em modelo de recuperação simples, abri espaço movendo arquivos e encolhendo o TempDB (através da opção de arquivo shrink no SSMS) e criei um arquivo ndf extra com tamanho inicial de 100 GB em uma unidade externa ... O processo ainda está em execução (mais de 24 horas depois de abrir espaço).

O estado da tarefa do spid mostra suspenso com o tipo de espera PAGEIOLATCH_EX, mas com pequenos tempos de espera (abaixo de 100ms), o que me faz acreditar que o processo ainda está em execução.

34 tabelas de 35 são de tamanho decente e são rápidas o suficiente para multiplicar... O processo multiplicou o 1 armazenamento de dados em todas as tabelas para 8 armazenamentos e ainda está em processo de completar a multiplicação dos dados de 8 para 16 armazenamentos ... a única mesa em que parece estar trabalhando é a maior de todas...

O processo real de multiplicar os dados de 8 para 16 lojas para esta tabela, está inserindo 400 milhões de registros de uma seleção de 400 milhões de registros e a tabela tem 200 colunas de todos os tipos diferentes.

Estou perdendo tempo esperando? Receio que matar o processo leve vários dias para reverter... Devo apenas esperar? Tornou-se um processo Fantasma? Como posso saber o que está fazendo?

Qualquer opinião/idéia seria muito apreciada.

obrigada

Sou novo no SQL Server web Service e não tenho muito conhecimento em configurar um ambiente web seguro... Pelo que li até agora sobre o SQL Web Service, eu precisaria: 1. criar um procedimento armazenado, 2. criar um endpoint 3. criar um serviço da web 4. chamar o procedimento armazenado da web...

Parece fácil o suficiente, embora para as etapas 3 e 4, eu não tenha idéia de como fazer por enquanto ... mas minha pergunta é na arquitetura antes de começar a testar. Do meu entendimento, o serviço web do SQL reside no SQL Server? Se for esse o caso, significa que a DMZ teria acesso direto à nossa rede interna? isso é um nono até onde eu sei...

Em uma arquitetura onde eu gostaria de um SQL Server dentro de uma rede fechada, e uma camada de aplicativos/negócios dentro de uma DMZ e servidores web em outra DMZ... Como eu poderia obter algumas informações necessárias do SQL Server na rede fechada, mantendo-a segura? daí a razão pela qual comecei a investigar a possibilidade de usar o SQL Server Web Service...

Na minha opinião, cada servidor web na DMZ1 terá seu banco de dados na DMZ que conterá informações mínimas não confidenciais para executar o site, mas recuperando informações gerais acumuladas (como pontos, vendas ou informações históricas, etc.) que podem ser geradas de diferentes sites e fontes diferentes não podem ser transferidos para os BDs do site devido ao seu tamanho e precisam que os dados estejam em tempo real. Eu estava pensando em ter um DMZ2 que contém o SQL Server Web Service (como um SQL Web Service Layer) que recuperaria dados do servidor SQL dentro de nossa rede.
É possível? É uma boa ideia? Se não, como você faria?

Obrigado pela ajuda.

Alguém saberia como posso fazer o DBCC CheckDB produzir um erro? Estou testando um script e preciso do DBCC Checkdb no modo mais simples para retornar um erro, também ao tentar reparar e ao tentar entrar no modo monousuário...

O comando dbcc checkdb simples que estou usando faz parte de um arquivo em lote e é o seguinte:

OSQL -S MYPC -E -d MyDB -l 10 -Q "DBCC CHECKDB(AG_DB_STORESQL)" -b -o c:\MyFolder\MSSQL_DB_CHECK.Log

Se nenhum erro for encontrado, o script será encerrado. Se forem encontrados erros, o script tenta corrigi-los com a opção REPAIR_REBUILD e, se isso falhar, o script tenta corrigi-los com a opção REPAIR_ALLOW_DATA_LOSS. Obviamente, antes de tentar reparar, o script tenta colocar o banco de dados no modo de usuário único (que também é uma armadilha de erro)

Então, tudo o que estou procurando é uma maneira de fazer com que o DBCC CheckDB retorne um erro.

Esta é uma pergunta simples para a qual não consigo encontrar a resposta.

Em termos de desempenho, se eu tiver uma WHEREcláusula como a=0 and b=0 and ... z=0, eu obteria algum desempenho se substituísse essa condição por a+b+...+z=0?

Em outras palavras, há algum ganho de desempenho substituindo o seguinte

Select * 
From MyTable 
Where A=0 and B=0 and C=0 and D=0...

Com

Select * 
From MyTable 
Where A+B+C+D=0...

Sei que pode depender de índices, mas, para esse fim, digamos que não existam índices. O operador aritmético (+) funciona melhor que um operador lógico "OU" ou "E"?

Tenho a impressão de que a adição funciona melhor do que várias condições com ANDs ou ORs.

Resultado dos testes

Em uma tabela de 4,2 milhões de linhas

Retornando linhas Onde A=0 B=0 e C=0 -> 351748 Linhas

A adição (A+B+C=0) levou 5 segundos, enquanto as condições lógicas A=0 e B=0 e C=0 levaram 11 segundos.

Por outro lado

Retornando linhas Onde A<>0 B<>0 ou C<>0 -> 3829750 Linhas 58 segundos

Retornando linhas Onde F65+ F67+f64<>0 -> 3829750 Linhas 57 segundos

Para o OR, parece que não há diferença significativa.

Concordo com gbn:

Se A é -1 e B é 1, A+B=0 mas A=0 e B= 0 é falso

e com AMtwo:

ABS(A)+ABS(B)+ABS(C)+ABS(D)... Mesmo que você espere apenas valores positivos, se a coluna aceitar valores negativos, você deve presumir que poderá encontrar um

Os resultados são muito impressionantes, como pensei, parece que a adição é muito mais rápida que os operadores lógicos.

A = Float, B = Dinheiro e C = Float. A consulta utilizada é a mostrada. No meu caso, todos são números positivos. Sem índices. É lógico em minha mente que a adição seja mais rápida do que as condições lógicas!

Isso pode soar como uma pergunta estúpida, mas não consigo encontrar uma maneira melhor. É um sistema de postagem onde as lojas nos enviam informações diariamente (pode ser por vários dias). Essa informação é colocada em TempTable. Para cada dia encontrado no TempTable é sempre um dia inteiro, e o TempTable é bom para todas as lojas encontradas nele. Portanto, se TempTable tiver 2 lojas diferentes e 2 dias diferentes, como Day1-Store1 e Day2-Store2, isso significaria que nada aconteceu no Day1 para Store2 e no Day2 para Store1.

Então, quero deletar qualquer registro que o BigTable tenha (para um Dia e Loja Específicos) que não esteja na tempTable (para os Dias encontrados e Lojas Encontrados na TempTable) Em outras palavras, Se Temptable tiver uma entrada para Day1-Store1 e Day2-Store2, preciso deletar da Big Table Day1-Store2 e Day2-Store1 e qualquer outra entrada que não esteja na tabela temporária...

Isso é o que estou usando agora (funciona), mas demora muito. Estou procurando uma maneira de minimizar o número de junções na TempTable. Índices agrupados correspondentes existem em BigTable e TempTable (Data/Loja/SKU_id)

Delete X 
From BigTable X 
join (Select Distinct postingDate from TempTable) D on X.PostingDate = D.PostingDate
Join (Select Distinct postingStore from TempTable) S on X.Store = S.PostingStore
Left join TempTable T on X.PostingDate = T.PostingDate 
    and X.Store = T.PostingStore and X.SKU_id = T.SKU_id
Where T.Sku_id is null

Tenho certeza que esta não é a melhor maneira de fazer isso. Agradecendo a todos antecipadamente

[MAIS INFORMAÇÕES] Como percebi que as sugestões dadas postadas são para excluir tudo no BigTable que não está no TempTable, pensei que deveria adicionar o seguinte ponto:

BigTable contém Todos os dias para todas as lojas que já foram postadas. TempTable contém as informações de postagem de dias e lojas específicos encontrados em TempTable. Desejo excluir do BigTable os Stores e Days encontrados no TempTable, mas sem excluir as boas entradas que já estão no BigTable.

Se Big Table tiver as seguintes entradas:

Day1 Store1 Sku123 ... 
Day1 Store2 Sku124 ...
Day1 Store3 Sku123 ...
Day2 Store1 Sku124 ... 
Day2 Store2 Sku123 ... 
Day2 Store3 Sku123 ... 

E TmpTable tem as seguintes entradas:

Day1 Store1 Sku124 ...
Day2 Store2 Sku123 ... 

Gostaria de excluir do BigTable qualquer registro para Day1 e Day2 para Store1 e Store2 que não esteja em TempTable... Portanto, gostaria de excluir os seguintes registros do BigTable:

Day1 Store1 Sku123 ... 
Day1 Store2 Sku124 ...
Day2 Store1 Sku124 ... 

Trabalho com SQL Server desde o SQL Server 7. Portanto, conheço BCP, Bulk insert, openrowset e SSIS.

Minha dúvida é simples:

• Você conhece outras maneiras de importar/exportar dados usando as versões do SQL Server Express SQL 2005 a 2014 (e em breve 2016).

Quero ter a certeza que não há mais nada pelo facto de a utilização do BCP (que é o que estou a utilizar neste momento) requer a utilização de xp_cmdshelle por questões de segurança, requer uma xp_cmdshell_proxyconta. Estou sendo desafiado no trabalho e quero ter certeza de que não existe mais nada ou que seja novo no Microsoft SQL Server (Express) antes de responder.

Meu projeto é auditar de 5 a 10 tabelas existentes em nosso sistema sem prolongar as transações. Seja qual for o método usado, ele deve funcionar no SQL Server Express 2005 até (eventualmente) 2016.

Eu fiz pesquisas sobre Change Data Capture (CDC) e Change Tracking. O controle de alterações não captura as alterações específicas e o CDC está disponível apenas na Enterprise Edition.

Então me deparei com o Service Broker. Fiquei intrigado com o Service Broker, então comecei a criar um protótipo. O Service Broker está funcionando bem, mas as respostas recebidas em duas de minhas outras postagens me levam a acreditar que esse pode não ser o caminho certo a seguir. Muito complicado para nada. Ainda estou no estágio de análise e tentando coisas diferentes como parte da minha análise.

No momento, os resultados do corretor de serviços não são convincentes... uma atualização em massa de 105.000 itens para uma tabela de preços leva 38 segundos, enquanto o processamento da Fila (a parte de auditoria) leva 17 segundos... mas os 38 segundos incluem o processamento duplo de inserção em 2 tabelas #temp que são usadas para inserir nos TMPins e TMPdel. Então, acho que posso cortar isso pela metade... Agora estou questionando o uso do service broker... logicamente, o gatilho provavelmente levaria o mesmo tempo apenas inserindo as informações diretamente na tabela de auditoria. .

Para esclarecer, quando digo inserção em massa, não é a função "Inserção em massa". Estou falando de um grande bloco de dados que é inserido ou atualizado de uma só vez. ao atualizar 105.000 itens na tabela de preços, quero auditar as alterações ocorridas. Quando digo mudanças que acontecem, resolvi inserir os novos valores na tabela de auditoria (se for um insert ou update) ou inserir a chave primária com todos os outros campos nulos (para registros que foram apagados)... Então sim! pode ser depois que os dados forem carregados, mas não quero perder nenhuma auditoria (não quero que uma transação passe fora de ordem)

As outras duas postagens ajudarão a obter o contexto do que estou tentando fazer e do que tentei:

• Gatilho para criar uma tabela de variáveis ​​a ser enviada ao service broker
• gatilhos - usando as tabelas inseridas/excluídas no SQL dinâmico

Eu valorizo ​​cada ideia.

Dentro de uma trigger, estou tentando criar um nome de tabela único (usando o NEWID()) onde possa armazenar os dados que se encontram nas tabelas inseridas e deletadas.

Declare @NewID varchar(50) = Replace(convert(Varchar(50),NEWID()),'-','')
Declare @SQLStr varchar(8000)
Set @SQLStr= 'Select * into [TMPIns' + @newID + '] from inserted'
Exec (@SQLStr)

Recebo o seguinte erro: Nome de objeto inválido 'inserted'

Eu sei que posso fazer:

Select * into #inserted from inserted
Set @SQLStr= 'Select * into [TMPIns' + @newID + '] from #inserted'
Exec (@SQLStr)

Mas não quero usar o TempDB, pois essas tabelas podem ficar grandes e também acho redundante. Existe uma maneira de evitar a criação de #inserted?

Eu configurei um service broker pela primeira vez e testei... Parece bom. Toda vez que uma operação DML acontece em uma tabela específica; Digamos a Tabela de Preços, uma trigger chama uma stored procedure passando para ela as tabelas inseridas e deletadas como parâmetros XML que vão enviar a mensagem (contendo os 2 XMLs) para a fila.

O procedimento de ativação processa a fila e insere as alterações feitas na tabela inicial em uma tabela de auditoria... Funciona muito bem.

O Problema ocorre quando a atualização da tabela Price é massiva. No meu caso, testei uma atualização de alteração de preço em 105.000 itens. As variáveis ​​XML inseridas e excluídas contêm 1,3 milhão de linhas cada... O que causa grandes problemas: TempDB cresce infinitamente e o processador sobe para 95%, o que é compreensível... mas nunca parece concluir a operação.

O código para o Trigger é Price_TAB_Audit_trig . O gatilho chama o procedimento SendMsgServiceBroker para enviar a mensagem para a Fila. Veja os comentários abaixo para o procedimento de ativação.

Estou tentando descobrir como posso dividir as variáveis ​​inseridas e excluídas (mensagens) em XMLs menores. Minhas perguntas/pensamentos são: Posso criar variáveis ​​de tabela e passar isso na mensagem em vez de XML? Se sim, como criar tabelas de variáveis ​​em uma trigger? Devo criar tabelas temporárias exclusivas globais e referenciá-las na mensagem?

Qualquer outra sugestão, é bem vinda. Desde já agradeço JG