Sqlserver
 sql >> Base de Dados >  >> RDS >> Sqlserver

Criar um gatilho DML no SQL Server


No SQL Server, você pode usar o CREATE TRIGGER instrução para criar um gatilho.

Um gatilho é um tipo especial de procedimento armazenado que é executado automaticamente quando ocorre um evento no servidor de banco de dados.

Você pode criar um gatilho DML, um gatilho DDL ou um gatilho de logon.

Este artigo fornece um exemplo de criação de um gatilho DML.

O que é um gatilho DML?


Um gatilho DML é um gatilho executado quando um usuário tenta modificar dados por meio de um evento de linguagem de manipulação de dados (DML).

Os eventos DML incluem INSERT , UPDATE , ou DELETE declarações. Os gatilhos DML podem ser usados ​​para impor regras de negócios e integridade de dados, consultar outras tabelas e incluir instruções T-SQL complexas.

O gatilho e a instrução que o aciona são tratados como uma única transação, que pode ser revertida de dentro do gatilho.

Exemplo


Aqui está um exemplo para demonstrar como os gatilhos DML funcionam. 
CREATE TABLE t1 (
    id int IDENTITY(1,1) NOT NULL,
    c1 int DEFAULT 0,
    c2 int DEFAULT 0,
    c3 int DEFAULT 0
);

CREATE TRIGGER trg_t1
ON t1
AFTER INSERT, UPDATE
AS
UPDATE t1
SET c3 = c3 + 1
WHERE id IN (SELECT DISTINCT id FROM inserted);

Neste exemplo eu crio uma tabela e também crio um gatilho que será acionado sempre que uma linha for inserida ou atualizada naquela tabela.

Nesse caso, o gatilho adiciona 1 ao c3 coluna sempre que os dados são inseridos ou atualizados.

Chamei o gatilho trg_t1 . Eu segui essa parte com ON t1 , o que significa que o gatilho será executado na tabela chamada t1 .

Você pode, alternativamente, especificar uma visualização para o gatilho ser executado, embora você só possa fazer referência a uma visualização por um INSTEAD OF gatilho (neste caso, substitua AFTER com INSTEAD OF ). Além disso, você não pode definir gatilhos DML em tabelas temporárias locais ou globais.

AFTER especifica que o acionador DML é acionado somente quando todas as operações especificadas na instrução SQL de acionamento forem iniciadas com êxito. Você pode, alternativamente, especificar FOR aqui.

Outra alternativa é usar INSTEAD OF , que executará o gatilho em vez da instrução SQL de acionamento. Isso, portanto, substitui as ações das instruções de acionamento.

Qual ​​é o inserted Tabela?


No meu gatilho, consigo descobrir qual linha foi atualizada consultando o inserted tabela.

SQL Server cria e gerencia uma tabela chamada inserted , que é uma tabela temporária residente na memória que armazena cópias das linhas afetadas durante INSERT e UPDATE declarações. Durante uma transação de inserção ou atualização, novas linhas são adicionadas ao inserted tabela e a tabela de gatilho. As linhas na tabela inserida são cópias das novas linhas na tabela de gatilhos.

O SQL Server também cria e mantém uma tabela semelhante chamada delete, que armazena cópias das linhas afetadas durante DELETE e UPDATE declarações. Durante a execução de um DELETE ou UPDATE instrução, as linhas são excluídas da tabela de gatilhos e transferidas para a tabela excluída.

Execute o gatilho


Agora que a tabela e seu gatilho foram criados, vamos executar algumas instruções SQL que irão acioná-lo. 
INSERT INTO t1 (c1) 
VALUES (1);

SELECT * FROM t1;

Resultado:
+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 1    | 0    | 1    |
+------+------+------+------+

Assim, podemos ver que o gatilho funcionou como esperado. Quando inseri uma linha, especifiquei apenas um valor para o c1 coluna, mas o gatilho garantiu que o c3 coluna também foi atualizada.

Observe que o valor padrão para todas as colunas é 0 (conforme especificado quando criei a tabela) e o gatilho adicionou 1 a isso.

Vamos realizar um UPDATE operação na mesma coluna. 
UPDATE t1 
SET c1 = c1 + 1
WHERE id = 1;

SELECT * FROM t1;

Resultado:
+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 2    | 0    | 2    |
+------+------+------+------+

Mais uma vez, o c3 coluna também foi atualizada pelo gatilho.

Agora vamos atualizar o c2 coluna. 
UPDATE t1 
SET c2 = c2 + 1
WHERE id = 1;

SELECT * FROM t1;

Resultado:
+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 2    | 1    | 3    |
+------+------+------+------+

Então, mais uma vez, o c3 coluna é atualizada pelo gatilho.

Esse gatilho específico é acionado sempre que qualquer outra coluna na mesma linha é atualizada.

Você também pode usar IF UPDATE(column_name) para verificar se há uma atualização em uma única coluna, ou COLUMNS_UPDATED() para verificar atualizações em várias colunas.