Um gatilho (trigger) é um mecanismo de banco de dados que executa uma instrução SQL automaticamente quando um determinado evento ocorrer. Você pode criar um gatilho em uma tabela para executar um SELECT, INSERT, UPDATE ou DELETE.
Quando se cria um gatilho com a declaração CREATE TRIGGER, o database server coloca informações sobre a trigger no system catalog (systriggers). O server coloca a declaração de que o gatilho é executado dentro do system catalog (systrigbody). Além disso, tabelas de dicionário são armazenados na memoria para indicar se a tabela possui gatilhos definidos para ele. Sempre que o servidor executa uma declaração SELECT, INSERT, UPDATE ou DELETE, verifica se um gatilho esta definido para o tipo de declaração e a tabela e coluna na qual a instrução opera. Se uma declaração requer um gatilho pra ser executado, o server recupera o texto de instrução de systrigbody e executa a rotina SPL, quando necessário, antes, durante e apos a instrução.
SINTAXE:
>>-CREATE TRIGGER--+---------------------+--trigger------------->
| (1) |
'-| Owner Name |------'
>--+---------------------------------------------------+-------->
| (2) |
+-| Trigger on a Table |----------------------------+
| (3) |
'--------INSTEAD OF--+----------------------------+-'
| (4) |
'-| Trigger on a View |------'
(3) .-ENABLED--.
>---------+-DISABLED-+-----------------------------------------><
Um gatilho, exceto se for desativado, executa automaticamente um conjunto de instruções SQL, chamada trigger action, quando um evento especifico de gatilho ocorrer.
Quando se dispara um gatilho
Pode-se utilizar a declaração CREATE TRIGGER de duas maneiras distintas:
- Pode-se definir um gatilho em um tabela no banco de dados corrente;
- Para o IDS, pode-se também definir um gatilho INSTEAD OF em uma view no banco de dados corrente.
Qualquer instrução SQL que é uma instancia do evento da trigger é chamado de instrução de acionamento (triggering statement), quando o evento ocorre, gatilhos definidos em tabelas e gatilhos definidos em view são tratadas de maneiras diferentes quando executada:
- Para tabelas, o trigger event e o trigger action são executados
- Para views, somente o trigger action é executado, ao invés do evento.
A declaração CREATE TRIGGER pode suportar a integridade dos dados no banco através de definição de regras pelas operações DML (o triggering events) o que faz com que o servidor tome ações especificas.
pode suportar a integridade dos dados no banco de dados através da definição de regras pelas quais especificado operações DML (a fatos geradores) fazer com que o servidor de banco de dados para tomar ações especificadas.
Exemplo de gatilho em uma tabela:
|--+-+-DELETE----------------------------+--ON--table--| DELETE and SELECT Subclauses |-+--|
| | (1) | |
| '--------SELECT--+----------------+-' |
| | .-,------. | |
| | V | | |
| '-OF----column-+-' |
+-UPDATE--+----------------+--ON--table--| UPDATE Subclauses |-----------------------+
| | .-,------. | |
| | V | | |
| '-OF----column-+-' |
| (2) (3) |
'-INSERT--ON--table--+-| NEW Declaration |-------| Correlated Table Action |------+--'
| (4) |
'-| Action Clause |------------------------------------------'
Sub-clausula DELETE e SELECT:
(4)
|--+-| Action Clause |--------------------------------------------------------------------+--|
| (5) (3) |
+-| OLD Declaration |-------| Correlated Table Action |--------------------------------+
| (5) (2) (3) |
'-| OLD Declaration |-------| NEW Declaration |-------| Correlated Table Action |------'
Gatilho em uma View:
(1)
|--------------------------------------------------------------->
>--+-INSERT ON--view--+------------------------------+------------------------+-->
| '-REFERENCING NEW--+----+--new-' |
| '-AS-' |
+-DELETE ON--view--+-------------------------------+-----------------------+
| '-REFERENCING--OLD--+----+--old-' |
| '-AS-' |
'-UPDATE ON--view--+-----------------------------------------------------+-'
+-REFERENCING--OLD--+----+--old--+------------------+-+
| '-AS-' '-NEW--+----+--new-' |
| '-AS-' |
'-REFERENCING--NEW--+----+--new--+------------------+-'
'-AS-' '-OLD--+----+--old-'
'-AS-'
Restrições dos Gatilhos
Para criar uma trigger em uma tabela ou uma View, deve-se possuir direitos sobre a tabela ou view, ou ter status de DBA.
A tabela na qual esta criando o gatilho deve existir no banco de dados. Não pode criar uma trigger em qualquer das seguintes situações:
- Uma tabela de diagnostico, uma tabela violada ou uma tabela em outro banco de dados;
- uma raw table, uma tabela temporária ou tabela do system catalog.
No DB-Acess, se você quiser definir um gatilho como parte de uma esquema, coloque a declaração CREATE TRIGGER dentro de uma declaração CREATE SCHEMA.
Se você estiver incorporando uma instrução CREATE TRIGGER em um programa de ESQL/C, não se pode utilizar uma variável na definição da trigger.
Não pode usar a declaração DROP TRIGGER para remover uma trigger existente. Se você usar DROP TABLE ou DROP VIEW para remover gatilhos em tabelas ou view do banco de dados, todas as triggers nessa tabela ou view serão dropadas.
Nenhum comentário:
Postar um comentário