Os gatilhos são entidades de banco de dados no SQL Server. Tecnicamente, eles são uma classe específica de chamadas de função que respondem a operações específicas do banco de dados.
Este guia essencial fornecerá informações detalhadas sobre SQL Triggers que podem ser bastante úteis em sua profissão. Vamos começar!
últimas postagens
O que são gatilhos SQL?
A palavra “trigger” descreve uma declaração de que um servidor executa automaticamente a consulta cada vez que o conteúdo do banco de dados é alterado.
Um gatilho é um grupo de consultas SQL especialmente nomeadas que são armazenadas no espaço de memória. É um tipo específico de chamada de função que é imediatamente invocado sempre que ocorre qualquer evento de banco de dados. Cada gatilho tem uma tabela atribuída a ele.
Por exemplo, um gatilho pode ser ativado sempre que uma nova coluna for adicionada a uma tabela específica ou se registros específicos forem alterados.
De acordo com o Microsoft Developer Network, os gatilhos são uma classe específica de procedimentos armazenados. Em uma instrução de gatilho, inicialmente definimos quando o gatilho deve ser executado e, em seguida, fornecemos a ação que deve ser executada após a ativação do gatilho.
Sintaxe:
CREATE TRIGGER trigger_name BEFORE/AFTER INSERT/UPDATE/DELETE ON tableName FOR EACH ROW SET operation [trigger_body];
Explicação de cada parâmetro
- CREATE TRIGGER trigger_name – É usado para construir um trigger ou para alterar o nome de um trigger existente.
- BEFORE/AFTER – Esta consulta é utilizada para definir o tempo de execução do trigger (antes ou depois de um determinado evento).
- INSERT/UPDATE/DELETE – Isso descreve a ação que desejamos realizar nas tabelas.
- ON tableName – Aqui, definimos o nome da tabela para configurar um gatilho.
- FOR EACH ROW – Esta instrução está relacionada ao gatilho de linha, o que significa que os gatilhos serão executados sempre que uma linha for alterada.
- trigger_body – Especifica a ação a ser tomada quando o gatilho é ativado.
Triggers são funções armazenadas com identidades distintas que nos permitem reutilizar consultas que já foram executadas e armazenadas de forma segura na memória. Agora vamos tentar entender por que o SQL precisa deles.
Os gatilhos são usados principalmente para regular a implantação de código sempre que um evento ocorre. Em outras palavras, usar gatilhos é a escolha ideal se você precisar que um fragmento de código específico seja executado constantemente em resposta a um evento especificado.
A seguir estão alguns benefícios da utilização de gatilhos em operações de banco de dados SQL.
A integridade referencial é uma propriedade fundamental dos sistemas de banco de dados relacionais. Isso significa que os dados mantidos no sistema de banco de dados devem sempre ser precisos para cada transação e cada operação.
Se duas tabelas estiverem localizadas em bancos de dados ou sistemas separados, não há como garantir a validação de dados dentro delas usando valores de restrição. Em tal situação, os gatilhos são a única opção para execução.
Combinação de argumentos de gatilho
Para cada tabela, podemos especificar seis tipos de gatilhos diferentes. Estes são a combinação de argumentos Trigger incluídos em Triggers de nível de linha SQL.
BEFORE INSERT: Esses gatilhos executam a ação nas linhas antes de realizar qualquer operação INSERT na tabela especificada ou no banco de dados.
AFTER INSERT: Executa a ação nas linhas imediatamente após qualquer atividade INSERT do banco de dados.
BEFORE UPDATE: Com esses gatilhos, uma função nas linhas é executada antes de uma ação UPDATE ser executada no banco de dados.
AFTER UPDATE: Executa a ação nas linhas imediatamente após qualquer atividade UPDATE de banco de dados ou tabela específica.
BEFORE DELETE: Executa uma determinada operação nas linhas antes mesmo que o banco de dados ou tabela seja submetido a uma ação DELETE.
AFTER DELETE: Esses gatilhos executam a ação nas linhas após cada transação DELETE.
Tipos de gatilhos SQL
Os gatilhos SQL são funções armazenadas que são executadas imediatamente quando ocorrem eventos específicos. Assemelha-se ao agendamento orientado a eventos. As situações subsequentes podem iniciar a execução de triggers.
DML Triggers – DML significa Linguagem de Manipulação de Dados. A execução de código em reação à modificação de dados é possível usando DML Triggers. Este gatilho é ativado quando comandos DML como INSERT, UPDATE e DELETE são executados. Estes também são chamados de “Triggers de nível de tabela”.
DDL Triggers – DDL significa Linguagem de Definição de Dados. Os DDL Triggers nos permitem executar código em reação a mudanças no esquema do banco de dados, como adicionar ou excluir tabelas, ou eventos do servidor, como quando um usuário faz check-in. Eles são chamados de “Triggers de nível de banco de dados”.
Esses Triggers podem ser ativados quando certas instruções DDL como CREATE, ALTER ou DROP são executadas no banco de dados ativo. Estes também podem ser utilizados para acompanhar e gerenciar as atividades que são executadas.
Acionadores de LOGON – Sempre que ocorre qualquer evento de LOGON (inicialização, login, logout, desligamento), os acionadores de logon são imediatamente invocados. Eles são realizados apenas após um processo de autenticação do usuário antes mesmo que a transação do usuário seja iniciada. Os gatilhos LOGON não serão acionados se a autorização falhar.
Esses gatilhos podem ser usados para registrar o histórico de login ou estabelecer uma restrição de evento para um login específico, entre outras funções de auditoria e gerenciamento de identidade para conexões de servidor.
CLR Triggers – CLR significa Common Language Runtime. Os gatilhos CLR são, de fato, um subconjunto exclusivo de gatilhos construídos principalmente no CLR dentro da tecnologia .NET. Esses gatilhos são úteis se o gatilho precisar realizar muitos cálculos ou precisar se relacionar com uma entidade diferente do SQL.
De fato, os gatilhos DML e DDL podem ser construídos habilitando a codificação de gatilhos CLR suportados em tecnologias .NET, incluindo Visual Basic, C# e F-sharp.
Exemplo de gatilho do SQL Server
Vamos entender esses conceitos de gatilho com um exemplo.
Primeiro, vamos criar um banco de dados usando instruções SQL.
CREATE DATABASE testdb; use testdb;
Aqui, dei um “testdb” como o nome do banco de dados. E o próximo passo é criar uma tabela.
CREATE TABLE student( name varchar(25), id int(2), maths int(2), physics int(2), biology int(2), social int(2), total int(2) );
Eu criei uma tabela para armazenar os detalhes do aluno. E aqui está o comando para descrever a estrutura da tabela. Aqui “aluno” é o nome da tabela que dei.
DESC student;
Abaixo está a estrutura da tabela que criei.
+---------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------+-------------+------+-----+---------+-------+ | name | varchar(25) | YES | | NULL | | | id | int | YES | | NULL | | | maths | int | YES | | NULL | | | physics | int | YES | | NULL | | | biology | int | YES | | NULL | | | social | int | YES | | NULL | | | total | int | YES | | NULL | | +---------+-------------+------+-----+---------+-------+ 7 rows in set (0.00 sec)
Depois de criar uma tabela, o próximo passo é configurar um gatilho. Vamos tentar usar o argumento BEFORE INSERT.
O nome do gatilho que criei é “marks”. Assim que a tabela for modificada com as notas do aluno, o gatilho abaixo tenta determinar a nota geral do aluno automaticamente.
CREATE TRIGGER marks BEFORE INSERT ON student FOR EACH ROW set new.total=new.maths+new.physics+new.biology+new.social;
Como somos obrigados a substituir os dados das linhas em vez de trabalhar com os antigos, definimos “total” usando um novo nome de classe e todas as expressões subsequentes são prefixadas com novas palavras-chave após total usando o operador ponto. Agora, adicionaremos valores a cada linha e veremos os resultados. Inicialmente, a nota total é 0 para cada aluno.
INSERT INTO student VALUES("George",02,99,87,92,91,0);
INSERT INTO student VALUES("James",03,91,81,94,90,0);
INSERT INTO student VALUES("Harry",04,86,70,73,88,0);
INSERT INTO student VALUES("John",05,73,89,78,92,0);
INSERT INTO student VALUES("Lisa",01,94,75,69,79,0);
A instrução de gatilho será acionada automaticamente quando os dados forem inseridos na tabela do aluno neste caso. As notas totais de cada aluno serão calculadas pelo gatilho. Agora, vamos ver se o gatilho é invocado ou não usando uma instrução SELECT.
SELECT * FROM table_name;
E aqui está o resultado final.
mysql> select * from student; +--------+------+-------+---------+---------+--------+-------+ | name | id | maths | physics | biology | social | total | +--------+------+-------+---------+---------+--------+-------+ | George | 2 | 91 | 81 | 94 | 90 | 356 | | James | 3 | 86 | 70 | 73 | 88 | 317 | | Harry | 4 | 73 | 89 | 78 | 92 | 332 | | John | 5 | 94 | 75 | 69 | 79 | 317 | | Lisa | 1 | 99 | 87 | 92 | 91 | 369 | +--------+------+-------+---------+---------+--------+-------+ 5 rows in set (0.00 sec)
No resultado acima, você pode ver que todas as notas de disciplina são adicionadas automaticamente para cada aluno. Assim, podemos concluir que o gatilho foi invocado com sucesso.
Operações de gatilho adicionais
Podemos realizar muitas operações usando gatilhos. Alguns podem ser simples e alguns podem ser um pouco complexos, mas uma vez que passamos pelas consultas é fácil de entender. Ao empregar instruções Transact-SQL, você pode habilitar, desabilitar ou excluir os gatilhos usando os comandos a seguir.
Consulta para verificar se um Trigger específico existe ou não
Este comando verifica o gatilho especificado em todo o banco de dados.
SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'
Consulta para exibir acionadores
Todos os gatilhos disponíveis no banco de dados ativo serão mostrados pela instrução a seguir.
SHOW TRIGGERS;
Consulta para desativar o gatilho
O comando abaixo desativa o gatilho no banco de dados de trabalho.
DISABLE TRIGGER trigger_name ON DATABASE;
Você também pode especificar um determinado nome de tabela para desabilitar um gatilho.
DISABLE TRIGGER trigger_name ON table_name;
Consulta para ativar o gatilho
O comando a seguir desativa primeiro um gatilho específico que foi definido na tabela especificada no banco de dados ativo antes de reativá-lo.
ALTER TABLE table_name DISABLE TRIGGER trigger_name ALTER TABLE table_name ENABLE TRIGGER trigger_name
O gatilho deve estar desabilitado, antes de tentar habilitá-lo,
Consulta para habilitar ou desabilitar todos os gatilhos em uma tabela
Usando a instrução SQL acima, podemos desativar ou ativar todos os gatilhos de tabela de uma vez substituindo “ALL” no lugar de um nome de gatilho específico.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Consulta para excluir ou soltar o gatilho
Um gatilho pode ser eliminado excluindo-o ou toda a tabela. Cada gatilho relacionado também é excluído quando uma tabela é excluída.
DROP TRIGGER [trigger_name];
Sempre que um gatilho é excluído, os dados relacionados são eliminados da tabela de dados sys.objects.
Vantagens dos gatilhos
- É simples construir gatilhos e o próprio gatilho pode invocar funções e métodos armazenados.
- Os usuários podem implementar auditorias simples usando gatilhos.
- Tragicamente, você não pode criar restrições entre entidades em sistemas de banco de dados com o SQL Server, embora possa emular a operação de restrições utilizando gatilhos.
- As restrições de integridade podem ser implementadas em bancos de dados usando gatilhos.
- Quando a validação do grupo é necessária em vez da verificação linha por linha de dados recém-inseridos ou alterados, os acionadores podem ser úteis.
Desvantagens dos gatilhos
Os SQL Triggers podem não ser a melhor escolha em algumas situações devido às suas limitações.
- Os gatilhos devem ser documentados com precisão.
- Devido à execução simultânea do banco de dados que pode não ser acessível aos componentes do aplicativo, os gatilhos podem ser difíceis de depurar.
- As instruções DML tornam-se mais complexas quando são usados gatilhos.
- Mesmo um pequeno problema de gatilho tem o potencial de levar a falhas lógicas na instrução.
Conclusão
Triggers são componentes muito úteis do Transact-SQL e SQL, e você também pode usá-los no Oracle. O uso de gatilhos é crucial ao chamar métodos armazenados. Esses gatilhos SQL nos permitem analisar os cronogramas de atividade e determinar como responder a eles, se necessário. Também podemos verificar uma determinada tabela que está conectada a um gatilho para adquirir dados.
A recursão pode ser habilitada por gatilhos. Sempre que um gatilho em uma tabela executa um comando na tabela pai, a segunda iteração do gatilho é acionada, e isso é conhecido como gatilho recursivo. Isso ajuda ao tentar resolver uma correlação de identidade.
Além disso, os gatilhos regulam o padrão de atualização que o banco de dados tem permissão para aceitar. É altamente benéfico manter as restrições de integridade de dados no sistema de banco de dados se as chaves de restrição SQL não existirem, principalmente a chave primária e a chave estrangeira.
Espero que você tenha achado este artigo útil para aprender sobre SQL Triggers.
Se você deseja aprender em profundidade os bancos de dados, aqui estão alguns recursos excelentes para aprender SQL e NoSQL.