Trigger no SQL Server

Uma trigger é um código que é executado automaticamente quando ocorre um evento específico em uma tabela, como uma inserção, atualização ou exclusão de dados. Triggers podem ser usadas para realizar validações, auditorias, manter históricos, calcular valores ou implementar regras de negócios que precisam ser garantidas em todos os momentos. Neste post, aprenda trigger no SQL Server.

Tipos de triggers no SQL Server

1. AFTER Trigger

Esse tipo de trigger é acionado após a execução de uma operação DML (Data Manipulation Language) como INSERT, UPDATE ou DELETE. São úteis quando você deseja garantir que a operação foi realizada com sucesso antes de executar uma ação adicional.

Exemplo de AFTER Trigger para INSERT:

CREATE TRIGGER trg_AfterInsert
ON Employees
AFTER INSERT
AS
BEGIN
    -- Exemplo de auditoria: inserir uma linha de log em outra tabela
    INSERT INTO EmployeeAudit(EmployeeID, Action, ActionDate)
    SELECT EmployeeID, 'INSERT', GETDATE()
    FROM Inserted
END

Neste exemplo, toda vez que uma nova linha for inserida na tabela Employees, a trigger trg_AfterInsert será acionada e irá registrar essa ação na tabela EmployeeAudit.

2. INSTEAD OF Trigger

Esse tipo de trigger é executado no lugar da operação DML. Ela permite que você substitua a operação padrão, executando um código personalizado em vez de INSERT, UPDATE ou DELETE.

Exemplo de INSTEAD OF Trigger para DELETE:

CREATE TRIGGER trg_InsteadOfDelete
ON Employees
INSTEAD OF DELETE
AS
BEGIN
    -- Impede que a linha seja excluída, mas define a coluna 'Active' como 0
    UPDATE Employees
    SET Active = 0
    WHERE EmployeeID IN (SELECT EmployeeID FROM Deleted)
END

Neste exemplo, ao invés de excluir um registro, a trigger trg_InsteadOfDelete simplesmente marca o funcionário como inativo (definindo a coluna Active como 0).

Como as triggers funcionam?

As triggers utilizam tabelas temporárias chamadas Inserted e Deleted que armazenam os dados antes e depois da operação DML. Essas tabelas são muito úteis para que você possa trabalhar com os dados alterados durante a execução de uma trigger.

• Tabela Inserted: Armazena os valores novos (inseridos ou atualizados);
  
  
• Tabela Deleted: Armazena os valores antigos (antes de uma atualização ou exclusão).

Essas tabelas temporárias podem ser usadas dentro da trigger para capturar as mudanças que ocorreram durante a operação.

Exemplo de AFTER Trigger para UPDATE:

CREATE TRIGGER trg_AfterUpdate
ON Employees
AFTER UPDATE
AS
BEGIN
    -- Exemplo de auditoria para capturar atualizações de salário
    INSERT INTO SalaryAudit(EmployeeID, OldSalary, NewSalary, ChangeDate)
    SELECT D.EmployeeID, D.Salary, I.Salary, GETDATE()
    FROM Deleted D
    INNER JOIN Inserted I ON D.EmployeeID = I.EmployeeID
    WHERE D.Salary <> I.Salary
END

Neste exemplo, sempre que o salário de um funcionário for atualizado na tabela Employees, a trigger trg_AfterUpdate registra as alterações na tabela SalaryAudit, incluindo o salário antigo e o novo.

Usos comuns de triggers

As triggers são bastante versáteis e podem ser usadas em diversas situações no SQL Server. Alguns dos usos mais comuns incluem:

• Auditoria de dados: Registrar quando e quem realizou uma operação em uma tabela;
  
  
• Validações de negócios: Garantir que certas regras sejam seguidas antes de permitir a inserção, atualização ou exclusão de dados;
  
  
• Cálculos automáticos: Realizar cálculos automáticos ou atualizar dados relacionados em outras tabelas;
  
  
• Gerenciamento de logs: Manter um histórico de alterações de registros para monitoramento ou auditoria.

Prós e contras das triggers

Assim como qualquer recurso, as triggers têm suas vantagens e desvantagens. É importante entender esses pontos antes de usá-las extensivamente.

Vantagens:

• Automatização: Elas são executadas automaticamente quando um evento ocorre, eliminando a necessidade de chamadas manuais de código;
  
  
• Integridade de dados: Garantem que regras de negócios sejam aplicadas consistentemente em todas as operações;
  
  
• Auditoria: Triggers são perfeitas para auditoria, rastreando alterações de dados e mantendo um histórico.

Desvantagens:

• Complexidade: O uso excessivo de triggers pode tornar a lógica de negócios mais difícil de entender e manter, especialmente se várias triggers estiverem associadas à mesma tabela;
  
  
• Desempenho: Se mal implementadas, podem impactar o desempenho, pois são executadas em resposta a operações DML, o que pode aumentar o tempo dessas operações;
  
  
• Depuração: Depurar problemas em triggers pode ser mais complicado, pois elas são executadas automaticamente no banco de dados, fora do controle da aplicação.

Outro exemplo de uso

   CREATE TRIGGER trg_atualiza_data //define a trigger   
   ON cadastro_clientes //define a tabela na qual a trigger vai agir
   FOR INSERT //a trigger será disparada ao executar o comando INSERT
   //ações que a trigger irá executar 
   AS
   BEGIN
    DECLARE //declaração de variáveis
       @codigo_cliente int,
       @nome varchar(100),
       @data_de_hoje date;
     
     //serão armazenados os dados do cliente que acabou de ser inserido no banco de dados
     SELECT //pega os valores informados e atribui as variáveis
       @codigo_cliente = codigo_cliente,
       @nome = nome,
       @data_de_hoje = GETDATE() //pega data do servidor
     FROM
      INSERTED //pega último registro inserido na tabela de clientes (cadastro_clientes) 
     
   /* será executado o comando de inserção na outra tabela pelo trigger usando os valores 
   armazenados nas variáveis */
      INSERT INTO datas_cadastros (codigo_cliente, data_cadastro)
      VALUES(@codigo_cliente, @data_de_hoje)
   END

Também é possível utilizar condições dentro dos blocos DECLARE e informar possíveis inconsistências ou erros:

DECLARE
   @codigo int,
   @nome varchar(100),
   @salario money
   
SELECT
   @nome = nome, @salario = salario FROM funcionarios
   
   IF(@salario < 998.00)
   BEGIN
      RAISERROR('O salário não pode ser inferior ao salário mínimo!', 16, 1)//(16, 1) é a descrição de erros de usuário
      ROLLBACK TRANSACTION //As transações são desfeitas
   END 

Uma boa prática é definir valores vindos de tabelas com o comando SELECT. Já para valores vindos de funções ou valores literais, o comando a ser utilizado é o SET:

SELECT @produto = produto FROM inserted
SET @data = GETDATE()

Para fazer o trigger disparar:

//executa um comandos simples de inclusão no banco de dados 
   INSERT INTO cadastro_clientes(codigo_cliente, nome, data)
   VALUES(1,'Benedito', GETDATE())

Ao executar o comando INSERT o trigger irá disparar a ação de inserir a data atual do servidor na outra tabela.

Para excluir o trigger:

DROP TRIGGER trg_atualiza_data
   GO

Listar todas as triggers criadas:

SELECT * FROM sys.triggers

As triggers no SQL Server são ferramentas poderosas para garantir que suas regras de negócios sejam aplicadas de forma consistente e automatizada no banco de dados. Elas podem ser usadas para auditoria, validação de dados, cálculos automáticos e muito mais. No entanto, é importante usá-las com cautela, já que podem adicionar complexidade e impactar o desempenho se mal utilizadas.

Dúvidas ou sugestões sobre trigger no SQL Server? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
 https://youtube.com/criandobits

Tags: triggers