Insira Atualizar procedimento armazenado no SQL Server

Eu escrevi um procedimento armazenado que fará uma atualização se houver um registro, caso contrário, fará uma inserção. É mais ou menos assim:

update myTable set Col1=@col1, Col2=@col2 where ID=@ID
if @@rowcount = 0
insert into myTable (Col1, Col2) values (@col1, @col2)

Minha lógica por trás de escrever desta forma é que a atualização executará uma seleção implícita usando a cláusula where e se retornar 0, então a inserção ocorrerá.

A alternativa para fazer dessa maneira seria fazer uma seleção e, a seguir, com base no número de linhas retornadas, fazer uma atualização ou uma inserção. Isso eu considerei ineficiente porque se você for fazer uma atualização causará 2 selects (a primeira chamada select explícita e a segunda implícita no where da atualização). Se o proc fizesse uma inserção, não haveria diferença na eficiência.

Minha lógica está soando aqui? É assim que você combinaria uma inserção e uma atualização em um procedimento armazenado?

Sua suposição está certa, esta é a maneira ideal de fazer isso e é chamada de upsert / merge .

Importância do UPSERT - de sqlservercentral.com :

Para cada atualização no caso mencionado acima, estamos removendo uma leitura adicional da tabela se usarmos o UPSERT em vez de EXISTS. Infelizmente para um Insert, os métodos UPSERT e IF EXISTS usam o mesmo número de leituras na tabela. Portanto, a verificação de existência só deve ser feita quando houver um motivo muito válido para justificar a E / S adicional. A maneira otimizada de fazer as coisas é garantir que você tenha o mínimo de leituras possíveis no banco de dados.

A melhor estratégia é tentar a atualização. Se nenhuma linha for afetada pela atualização, insira. Na maioria das circunstâncias, a linha já existirá e apenas uma E / S será necessária.

Editar : verifique esta resposta e a postagem do blog vinculada para saber mais sobre os problemas com esse padrão e como fazê-lo funcionar de forma segura.

Leia a postagem em meu blog para ver um padrão bom e seguro que você pode usar. Há muitas considerações e a resposta aceita para essa pergunta está longe de ser segura.

Para uma resposta rápida, tente o seguinte padrão. Funcionará bem no SQL 2000 e superior. O SQL 2005 fornece tratamento de erros que abre outras opções e o SQL 2008 fornece um comando MERGE.

begin tran
   update t with (serializable)
   set hitCount = hitCount + 1
   where pk = @id
   if @@rowcount = 0
   begin
      insert t (pk, hitCount)
      values (@id,1)
   end
commit tran

Se for usado com o SQL Server 2000/2005, o código original precisa ser incluído na transação para garantir que os dados permaneçam consistentes no cenário simultâneo.

BEGIN TRANSACTION Upsert
update myTable set Col1=@col1, Col2=@col2 where ID=@ID
if @@rowcount = 0
insert into myTable (Col1, Col2) values (@col1, @col2)
COMMIT TRANSACTION Upsert

Isso incorrerá em custos de desempenho adicionais, mas garantirá a integridade dos dados.

Adicione, como já sugerido, MERGE deve ser usado quando disponível.

MERGE é um dos novos recursos do SQL Server 2008, aliás.

Você não precisa apenas executá-lo na transação, mas também precisa de um alto nível de isolamento. Na verdade, o nível de isolamento padrão é Read Commited e esse código precisa Serializable.

SET transaction isolation level SERIALIZABLE
BEGIN TRANSACTION Upsert
UPDATE myTable set Col1=@col1, Col2=@col2 where ID=@ID
if @@rowcount = 0
  begin
    INSERT into myTable (ID, Col1, Col2) values (@ID @col1, @col2)
  end
COMMIT TRANSACTION Upsert

Talvez adicionar também a verificação de erro @@ e reversão possa ser uma boa ideia.

Se você não estiver fazendo uma mesclagem no SQL 2008, deve alterá-lo para:

se @@ rowcount = 0 e @@ error = 0

caso contrário, se a atualização falhar por algum motivo, ele tentará inserir depois porque o número de linhas em uma instrução com falha é 0

Grande fã do UPSERT, realmente reduz o código para gerenciar. Aqui está outra maneira de fazer isso: Um dos parâmetros de entrada é o ID, se o ID for NULL ou 0, você sabe que é um INSERT, caso contrário, é uma atualização. Presume que o aplicativo sabe se há um ID, então não funcionará em todas as situações, mas reduzirá a execução pela metade se você o fizer.

Postagem modificada de Dima Malenko:

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE 

BEGIN TRANSACTION UPSERT 

UPDATE MYTABLE 
SET    COL1 = @col1, 
       COL2 = @col2 
WHERE  ID = @ID 

IF @@rowcount = 0 
  BEGIN 
      INSERT INTO MYTABLE 
                  (ID, 
                   COL1, 
                   COL2) 
      VALUES      (@ID, 
                   @col1, 
                   @col2) 
  END 

IF @@Error > 0 
  BEGIN 
      INSERT INTO MYERRORTABLE 
                  (ID, 
                   COL1, 
                   COL2) 
      VALUES      (@ID, 
                   @col1, 
                   @col2) 
  END 

COMMIT TRANSACTION UPSERT 

Você pode interceptar o erro e enviar o registro para uma tabela de inserção com falha.
Eu precisava fazer isso porque estamos pegando todos os dados enviados via WSDL e, se possível, corrigindo-os internamente.

Sua lógica parece correta, mas você pode querer considerar a adição de algum código para evitar a inserção se você tiver passado uma chave primária específica.

Caso contrário, se você está sempre fazendo uma inserção se a atualização não afetou nenhum registro, o que acontece quando alguém exclui o registro antes de executar o "UPSERT"? Agora, o registro que você estava tentando atualizar não existe, então, em vez disso, será criado um registro. Esse provavelmente não é o comportamento que você estava procurando.