Introdução a Mariaadb e MySQL gatilhos

Objetivo

Entendendo e aprendendo a usar os gatilhos de mariadb e mysql.

Requisitos

• Nenhum requisito específico é necessário

Convenções

• # - exige que o comando linux seja executado com privilégios de raiz também
  diretamente como usuário root ou por uso de sudo comando
• $ - Dado o comando Linux a ser executado como um usuário não privilegiado regular

Introdução

Mysql/mariadb gatilhos são programas armazenados associados a uma tabela em um banco de dados e usados ​​para executar automaticamente algumas ações quando um INSERIR, EXCLUIR ou ATUALIZAR Evento é realizado na tabela. Um gatilho pode ser definido para executar uma ação antes ou depois do evento está associado a. Neste tutorial, veremos como criar e gerenciar um gatilho.

Um banco de dados de teste

Para o bem deste tutorial, criaremos um banco de dados com apenas uma e muito simples tabela, com uma lista de livros e seus respectivos gêneros. Vamos proceder:

Mariadb [(nenhum)]> Criar banco de dados book_test; Mariadb [(nenhum)]> Criar tabela book_test.livro ( -> id smallInt (1) não assinado não nulo auto_increment, -> nome varchar (25) não nulo, -> gênero varchar (25) não nulo, -> chave primária (id)); 

Criamos nossa tabela trivial, agora devemos preencher com alguns livros. Aqui estão alguns dos meus favoritos:

Mariadb [(nenhum)]> use book_test; Mariadb [book_test]> inserir no livro (nome, gênero) valores -> ('1984', 'distopian'), -> ('O Senhor dos Anéis', 'Fantasia'), -> ('na genealogia de Moralidade ',' filosofia '); 

Isso é o suficiente para o nosso exemplo. Aqui está a representação visual de nossa tabela:

+----+---------------------------+------------+ | id | nome | gênero | +----+---------------------------+------------+| 1 | 1984 | Distópico | | 2 | O Senhor dos Anéis | Fantasia | | 3 | Sobre a genealogia da moral | Filosofia | +----+---------------------------+------------+ 

Agora que preparamos nossa tabela de teste, podemos ver como criar e associar um acionar para isso.

Crie um gatilho

Como dito antes, ao criar um gatilho, podemos deixar nosso banco de dados executar automaticamente uma determinada ação sempre que o evento especificado, que pode ser um entre INSERIR, ATUALIZAR ou EXCLUIR, é realizado na mesa. Digamos, por exemplo, que, por algum motivo estranho, não queremos permitir mais de um livro de filosofia em nossa coleção, como podemos fazer cumprir esta regra? Embora a restrição possa ser implementada em um nível superior, podemos defini -lo diretamente no banco de dados, usando um gatilho. A sintaxe para criar uma é muito fácil:

Crie Trigger Trigger_Name # Atribua um nome ao gatilho antes | Depois # definido quando o gatilho deve ser executado insert | Excluir | ATUALIZAÇÃO # Defina a instrução associada ao gatilho no tabela_name # Defina a tabela associada ao gatilho para cada linha trigger_stmt # Declare o corpo do gatilho 

Após a sintaxe acima, podemos criar nosso gatilho:

Mariadb [book_test]> delimitador $ mariadb [book_test]> Criar gatilho no_more_philosophy antes de inserir no book_test.livro -> para cada linha começar -> se novo.gênero = "filosofia" e (selecione contagem (*) do book_test.livro onde gênero = "filosofia")> 0 Então -> sinalize sqlstate '45000' set message_text = 'apenas um livro de filosofia é permitido!'; -> final if; -> final $ mariadb [book_test]> delimiter; 

A primeira coisa que fizemos na linha 1 é instruir o banco de dados a usar o $ personagem como delimitador de declaração em vez do padrão ;. Isso ocorre porque o delimitador semicolon será usado dentro do corpo do gatilho.

Então criamos o gatilho usando o Criar gatilho declaração na linha 2, seguida pelo nome Queremos atribuir a ele: "No_more_philosophy" neste caso. Depois disso, especificamos que o gatilho deveria ser executado ANTES o INSERIR declaração. Imediatamente depois, associamos o gatilho à tabela "livro".

O corpo do gatilho começa com Para cada linha Na linha 3: usamos COMEÇAR Para marcar o início de nossas declarações compostas, as que devem ser executadas quando o gatilho é chamado, e marcamos o fim FIM, Assim como fazemos com outros procedimentos.

Depois que o gatilho estiver associado à tabela, ele será executado antes que cada inserção de linha seja realizada.

Quando um gatilho é realizado, dois pseud.Records estão preenchidos: VELHO e NOVO: Os valores atribuídos a eles varia de acordo com o tipo de evento. Para um INSERIR declaração, como a linha é nova, o VELHO Pseudorecord não conterá valores, enquanto NOVO conterá os valores de nova linha que devem ser inseridos. O oposto acontecerá para um EXCLUIR Declaração: Old conterá os valores antigos, e novo estará vazio. Finalmente para ATUALIZAR declarações, ambas serão preenchidas, pois o antigo conterá os valores antigos da linha, enquanto o novo conterá os novos.

Nosso gatilho na linha 4 verificará o valor do gênero coluna para a nova linha (identificada por NOVO): Se estiver definido como "filosofia", ele consultará livros com o gênero 'filosofia' e verifique se pelo menos um já existe. Se for o caso, ele levantará uma exceção com a mensagem 'Somente um livro de filosofia é permitido!'.

Como última coisa na linha 8, colocamos o delimitador de volta para ;.

Nosso gatilho em ação

Vamos verificar nosso gatilho em ação: tentaremos inserir um novo livro com o gênero "Filosofia" e ver o que acontece:

Mariadb [book_test]> inserir no livro (nome, gênero) valores ('republic', 'filosofia'); Erro 1644 (45000): Apenas um livro de filosofia é permitido! 

Como você pode ver, o gatilho funcionou e o servidor respondeu com a mensagem de erro que definimos quando tentamos adicionar outro livro de filosofia à nossa coleção.

Gerenciar gatilhos

Para verificar os gatilhos em um banco de dados, tudo o que precisamos fazer é executar o Mostrar gatilhos comando:

Mariadb [book_test]> show gatilhos \ g; *************************** 1. Linha *************************.gênero = "filosofia" e (selecione contagem (*) do book_test.livro onde gênero = "filosofia")> 0 Então sinalize sqlstate '45000' set message_text = 'apenas um livro de filosofia é permitido!'; FIM SE; Timing final: Antes criado: NULL SQL_MODE: NO_AUTO_CREATE_USER, NO_ENGINE_SUBSTITUTION DEFERTE: ROOT@LOCALHOST PARATHOR_SET_CLIENT: LATIN1 COLLAÇÃO_CONNEÇÃO: Latin1_swedish_ci Participação de banco de dados: latin1_swedish_ci 

Soltar um gatilho é tão fácil: tudo o que precisamos fazer é fazer referência ao gatilho pelo seu nome. Por exemplo, se gostaríamos de remover o gatilho "no_more_philosophy", deveríamos executar:

Mariadb [book_test]> gatilho de gota no_more_philosophy;

Se soubermos consultar o banco de dados para os gatilhos existentes, recebemos um conjunto vazio:

Mariadb [book_test]> show gatilhos; Conjunto vazio (0.01 seg) 

Conclusões

Neste tutorial, aprendemos o que é um gatilho e a sintaxe que deve ser usada para criar um. Também criamos uma tabela trivial e associamos o gatilho a ela, vendo como ela pode ser usada para garantir uma regra específica. Finalmente vimos como podemos verificar os gatilhos existentes em um banco de dados e como podemos excluir um. Embora isso deva ser suficiente para você começar, você pode verificar a documentação oficial do MariaDB/MySQL para obter um conhecimento mais aprofundado.

Tutoriais do Linux relacionados:

• Coisas para instalar no Ubuntu 20.04
• Uma introdução à automação, ferramentas e técnicas do Linux
• Instale o MySQL no Ubuntu 20.04 LTS Linux
• Mastering Bash Script Loops
• Como instalar o MySQL no Almalinux
• Ubuntu 20.04 WordPress com instalação do Apache
• OpenLITESPEED WordPress Instalação
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Instalação do Ampache Raspberry Pi
• Ubuntu 20.04: WordPress com instalação nginx