Trigger - É um programa PL/SQL armazenado no banco de dados e que é executado

imediatamente antes ou após os comandos INSERT, UPDATE e DELETE.

Triggers em PL/SQL
Escrevendo triggers de banco de dados

Um trigger é usado para escrever a lógica de procedimento que é invocada em resposta

a um evento específico. A aplicação criativa dos triggers de banco de dados permite que
você realize muitas coisas úteis que, de outra forma, não seriam possíveis.

Os exemplos daquilo que você pode fazer com os triggers incluem a replicação de
dados, o armazenamento dos dados de forma redundante para evitar associações
freqüentes de tabela e a implantação de regras de negócios complexas.

O que é um trigger?

Um trigger é um bloco PL/SQL que é associado a um evento específico, armazenado

em um banco de dados e executado sempre que o evento ocorrer.

Oracle8i agora suporta quatro tipos fundamentais de triggers:

. Os triggers Data manipulation language (DML)

. Os triggers instead-of
. Os triggers Data definition language (DDL)
. Os triggers de evento de banco de dados

Os triggers DML são os triggers tradicionais INSERT, UPDATE e DELETE que a

Oracle tem suportado há anos.

Os triggers instead-of foram introduzidos com a Oracle8 como um modo de possibilitar

a atualização de determinados tipos de visões. Os triggers DDL e os triggers de evento
de banco de dados são novos na Oracle8i.

Triggers DML

Os triggers DML são os triggers tradicionais que podem ser definidos em uma tabela e
são executados, ou disparados, em resposta aos seguintes eventos:

Uma linha de uma tabela é atualizada. Uma linha de uma tabela é excluída. Não é
possível definir um trigger para ser disparado quando uma linha é selecionada.

Uma definição de trigger DML consiste nestas partes básicas:

. O evento que dispara o trigger.

. A tabela do banco de dados no qual o evento deve ocorrer.
. Uma condição opcional que controla a hora em que o trigger é executado.
Um bloco PL/SQL contendo o código a ser executado quando o trigger é disparado, ou
uma declaração CALL para um procedimento armazenado.

Um trigger é um objeto de banco de dados, assim como uma tabela ou um índice.

Quando você define um trigger, ele se torna parte do banco de dados e é sempre
executado quando o evento para o qual ele é definido ocorre.

Não importa se o evento é disparado por alguma digitação em uma declaração SQL
usando o SQL Plus, executando um programa de cliente-servidor que atualiza o banco
de dados, ou executam um utilitário como o SQL"-Loader do Oracle para fazer o bulk-
load dos dados.

Por causa disso, um trigger permite que você execute validação crítica ou cálculos em
resposta às alterações fitas no banco de dados, seja qual for a fonte.

Um exemplo de trigger DML

Suponhamos que você queira ter certeza de que todos os nomes de departamentos foram
armazenados usando letras maiúsculas. Talvez você esteja fazendo isso para facilitar a
pesquisa naquele campo.

1: CREATE OR REPLACE TRIGGER department insert update

2: BEFORE INSÈRT OR UPDATE ON department
3: FOR EACH ROW
4: DECLARE
5: dup flag INTEGER;
6: BEGIN
7: --Força as maiúsculas em todos os departamentos.
8: :NEW.dept name := UPPER(:NEW.dept name);
9: END;
10:

A linha 1 diz à Oracle para criar esse trigger com o nome department_insert update para
substituir, se preciso, todo trigger existente de mesmo nome. A linha 2 diz que ele será
disparado sempre que uma linha nova for inserida na tabela de departamentos ou
sempre que um registro de departamento mudar. Na linha 8 há uma linha de código que
usa a função incorporada UPPER para forçar o nome do departamento a ser colocado
em maiúsculas. Observe a referência a : NEW. Esse é o alias padrão para o novo valor
do registro.

O alias :OLD pode ser usado para se referir ao valor antigo de um campo antes que-
aconteça unia atualização. A linha 3 diz à Oracle para disparar esse trigger uma vez
para cada linha modificada. Se você precisasse emitir uma declaração UPDATE para
alterar os nomes de todos os departamentos da tabela, esse trigger seria disparado para
cada um daqueles registros.

Para demonstrar o efeito desse trigger, tente emitir as declarações da Listagem

1: INSERT INTO department (dept id, dept_name) VALUES (10,'marcio');
2: 1 row created.
3: INSERT INTO department (dept id, dept_name) VALUES (11,'novelli');
4: 1 row created.
5: UPDATE department SET dept_name = 'Payroll' WHERE dept_id = 10;
6: 1 row updated.
7: SELECT dept_id, dept_name FROM department WHERE dept_id BETWEEN 10
AND 11;
8: DEPT ID DEPT NAME
9: --------- -------------------------------
10: 10 MARCIO
11: 11 NOVELLI

OBS: Observe que o trigger forçou todos os nomes de departamento a serem colocados
em maiúsculas, independentemente do nome ter sido o resultado de um registro novo
inserido ou de um registro existente que foi atualizado.

Tipos de triggers DML

Os triggers DML podem ser classificados de duas maneiras diferentes: quando eles são
disparados com relação à declaração SQL de trigger, ou se eles disparam ou não para
cada linha afetada pela declaração SQL de disparo.

Existem duas opções quando um trigger é disparado com relação a uma declaração
SQL: antes ou depois. Os before triggers são executados antes do disparo da declaração
SQL. Os after triggers são executados depois do disparo da declaração SQL.

Um trigger DML é um trigger no nível de linha ou um trigger no nível de declaração.

Um trigger no nível de linha é executado uma vez para cada linha afetada pelo disparo
da declaração SQL, enquanto que um trigger no nível de declaração é executado apenas
unia vez. Somente os triggers no nível de linha têm acesso aos valores de dados dos
registros afetados.

Os triggers no nível de declaração não. Isso acontece porque a SQL é uma linguagem
orientada para o conjunto-as declarações SQL podem afetar muitas ou mesmo todas as
linhas de uma tabela.

Os triggers no nível de declaração são disparados apenas uma vez; portanto, não seria
possível determinar uma referência de coluna em tal trigger.

Quando são disparados Nível Descrição

Os triggers são executados como resposta a uma declaração SQL e podem ser definidos
para as declarações INSERT, UPDATE e DE LETE. Estas são chamadas de insert
triggers, update tringgers e delete triggers, respectivamente.

Na próxima matéria vou falar de como usar os triggers para modificar os dados que
estão sendo inseridos em uma tabela.
Usos dos triggers em PL/SQL
A sintaxe para definir um trigger de banco de dados

A sintaxe usada para definir um trigger DML tradicional em uma tabela de banco de
dados. Partes da sintaxe são meio complexas, mas não se deixe intimidar.

CREATE [OR REPLACE] TRIGGER [schema.]trigger name

{BEFORE{AFTER} verb_list ON [schema.]table name
[[REFERENCING correlation_names] FOR EACH ROW [WHEN (condition)]]
DECLARE
declarations
BEGIN
pl/sql code
END;

Nessa sintaxe os parâmetros são os seguintes:

schema - Refere-se ao proprietário de uni objeto. Quando usado antes de um nome e

triger, ele se refere ao proprietário do trigger. Quando usado antes de um nome de tabela
ele se refere ao proprietário da tabela.

trigger name - é o nome que você deseja dar ao trigger.

verb_list - identifica os verbos SQL que são disparados por aquele trigger. A sintaxe de
verb_list é a seguinte:

{INSERT;DELETE;UPDATE [DF column_list]} [OR verb_list]

Os parâmetros de verb_list são:

column_list - Faz com que uni update, trigger seja disparado apenas quando uma das
colunas listadas é alterada. Caso contrário, o trigger dispara sempre que alguma coluna
da tabela é alterada.

verb_list - Essa é outra interação de verb_list. Você pode criar um trigger

que é disparado por mais de um verbo SQL.

table_name - é a tabela na qual o trigger está definido.

correlation_names - permite especificar os nomes de correlação além do padrão OLD e

NEW. Isso é útil quando a tabela na qual o trigger é definido se chama OLD ou NEW, e
também pode ser útil para tornar o código do trigger auto documentado. A cláusula de
referência se parece com o seguinte:

{OLD AS old alias;NEW AS new alias [corre lation nomes]}

Na sintaxe acima os parâmetros são:

old_alias - Esse é o nome que você deseja usar quando se referir ao valor de um campo
antes que o verbo SQL seja executado.

new_alias - Esse é o nome que você quer usar quando se referir ao valor de uni campo
depois que o verbo SQL for executado

correlation_names - Essa é outra iteração do alias_list. Você pode especificar um alias

para os valores old e new.

condition - é uma condição opcional colocada na execução do trigger. Ela só pode ser
usada nos triggers no nível de linha. Se condition estiver presente, o trigger só será
disparado quando a condição for verdadeira.

A condição pode ser qualquer expressão boolean, não pode conter nenhuma consulta e
deve usar os nomes de correlação, em outras palavras, NEW e OLD para se referir aos
valores de coluna da linha que está sendo alterada.

declarations - consiste em quaisquer declarações de variável, registro ou cursor

necessárias para esse bloco PL/SQL.

pl /sgl_code - é o código PL/SQL que é executado quando o trigger é disparado.

DECLARE...END; - Opcionalmente você pode substituir todo o bloco PL/SQI. por

uma declaração CALL que se parece com o seguinte:

CALL procedure name;

A declaração CALL é usada para fazer com que o trigger consista em apenas uma
chamada de procedimento armazenado.

Os nomes de correlação: OLD e: NEW merecem unia explicação adicional.

É comum ao escrever um trigger referenciar os valores do registro que estão sendo
inseridos, atualizados ou excluídos. Além disso, no caso de unia atualização, quase
sempre é preciso acessar os valores anteriores e posteriores a determinado campo.

Os nomes de correlação: OLD e: NEW são fornecidos para esse fim. Isso funciona
como uni registro da PL/SQL: OLD contém os valores de campo antes deles serem
atualizados e: NEW contém os valores de campo depois da atualização. Use i notação
de ponto padrão, em outras palavras: OLD.field_name para se referir ao valor de
determinado campo. Você verá exemplos disso em diversas listagens deste capítulo.

Usos dos triggers

Os usos possíveis para os triggers de banco de dados variam e são limitados apenas pela
sua imaginação. Alguns usos comuns são:

-Implantação de regras de negócios

-Manutenção da integridade referencial
-Implantação de segurança
-Manutenção de um registro histórico das alterações
-Geração de valores de coluna, incluindo valores de chave primária
-Replicação de dados

Manutenção da integridade de dados

Os triggers são usados para ajudar na manutenção da integridade dos dados que estão
armazenados no banco de dados. Suponhamos que você queira armazenar urna
contagem do número de empregados de cada departamento e que você queira armazenar
essa contagem na tabela de departamentos. Primeiro você adicionaria um campo de
contagem de empregados à tabela de departamentos usando uma declaração como esta:

ALTER TABLE department

ADD (num_emp NUMBER(38));

O campo num_emp é usado para controlar o número de empregados de determinado

departamento. Pense em como essa contagem de empregados poderia ser atualizada.

Uma solução possível seria fazer com que todo programa que adicionasse, excluísse ou
alterasse a atribuição de departamento de um empregado também atualizasse esse valor
apropriadamente. Isso funcionaria se os programas funcionassem corretamente, e se
você não se esquecesse de que o valor precisaria ser atualizado.

Infelizmente à medida que novos programadores são adicionados a um projeto e à

medida que o número de programas que precisam atualizar esse valor aumenta, a
probabilidade de ocorrer um erro também aumenta. Os triggers fornecem um
mecanismo para centralizar o código para atualizar um contador como esse.

Como você tem de lidar com inserts, updates e deletes, três triggers são necessários para
atualizar a conta de empregado de departamento

Tipo do trigger

Insert - Quando um empregado é adicionado, este trigger precisa incrementar a

contagem do departamento apropriado.

Update - Quando o departamento de um empregado muda, este trigger precisa

decrementar a contagem dos departamentos anteriores e incrementar a contagem de
departamento novo.

Delete - Quando um empregado é excluído, este trigger precisa decrementar a contagem

do departamento apropriado.

O exemplo abaixo mostra o código para criar os três triggers necessários para atualizar
as contas de empregado de cada departamento.

1: CREATE OR REPLACE TRIGGER emp_dept_ins - INSERIR

2: AFTER INSERT ON emp_dept
3: FOR EACH ROW
4: BEGIN
5: --Incrementa a contagem de empregados do departamento
6: --referenciada pelo registro que acabou de ser inserido.
7: UPDATE department
8: SET no_of_emps = NVL(no_of_emps,O)+1
9: WHERE dept id = :NEW.dept_id;
10: END;
11: /
12:
13: CREATE OR REPLACE TRIGGER emp_dept_del - DELETAR
14: AFTER DELETE ON emp_dept
15: FOR EACH ROW
16: BEGIN
17: --Decrementa a contagem de empregados do departamento
18: --referenciada pelo registro que acabou de ser excluído.
19: UPDATE department
20: SET no_ of+_emps = no_of_emps-1
21: WHERE dept_id = :OLD.dept_id;
22: END;
23: /
24:
25: CREATE OR REPLACE TRIGGER emp_dept_upd - UPDATE
26: AFTER UPDATE OF dept id ON emp_dept
27:FOR EACH ROW
28: BEGIN
29: --Incrementa a contagem de empregados para o departamento novo do empregado
30: UPDATE department
31: SET no _of_emps = NVL(no_of_emps,0)+1
32: WHERE dept_id = :NEW.dept_id;
33:
34: --Decrementa a contagem de empregados para o departamento
35: --anterior do empregado.
36: UPDATE department
37: SET no_of_emps = no_of_emps - 1
38: WHERE dept_id = :OLD.dept_id;
39: END;
40: /

Agora que você criou os triggers necessários e inicializou os contadores pode fazer
algumas consultas para testar o seu código. Um exemplo de registros de empregados
sendo inseridos:

1: --Cria alguns departamentos.

2: INSERT INTO department (dept_id, dept_name, no_of_emps)
3: VALUES (10,'Márcio Novelli',0);
4: 1 row created.