Criando triggers no PostgreSQL

Olá, pessoal!

As triggers ("gatilhos" no português literal) são procedures ativadas por determinada ação realizada em alguma tabela na base dados. São funções de forma propriamente dita, que diferem de funções comuns apenas na forma de trabalhar com os dados e a forma na qual são "ativadas".

Enquanto em funções comuns você pode programar para que sejam recebidos valores e armazenados em variáveis para serem trabalhados no corpo da função, a trigger vai trabalhar com os objetos (variáveis) que armazenam os dados de acordo com determinada ação programada na trigger.

As ações são:

• Insert;
• Update;
• Delete;

Para cada ação os objetos que ficam disponíveis são:

• Insert: NEW;
• Update: NEW e OLD;
• Delete: OLD;

Os objetos trabalham da seguinte forma:

• NEW: Todos os dados que foram inseridos ou atualizados (insert e update, respectivamente);
• OLD: Todos os dados que foram deletados ou sobrescritos (delete e update, respectivamente);

Existem outras variáveis que são disponíveis quando se trabalha com triggers. Você pode conferi-las AQUI.

Vamos então entender como funciona a criação de uma trigger:

        CREATE OR REPLACE FUNCTION nome_da_funcao()
        RETURNS trigger
        AS $$
            begin 
                --// CORPO DE AÇÕES DA FUNÇÃO
                return new;
            end;
        $$ LANGUAGE plpgsql;
    

Onde:

• "Returns trigger" está diretamente declarando que sua função irá trabalhar com uma trigger;
• "$$" delimitam o corpo da trigger. Você pode trabalhar também com $BODY$ (o $$ é automaticamente convertido para $BODY$ no momento da criação);
• BEGIN e END demarcam o início e fim do corpo da sua procedure;
• "Return new" especifica qual o tipo de retorno da trigger você deseja trabalhar no corpo da procedure (NEW ou OLD);
• plpgsql é a linguagem nativa do PostgreSQL. Você também pode configurar outras linguagens para programar suas procedures;

Um bom exemplo de utilização é uma procedure que armazena o dado do usuário excluído numa tabela de backup. Vejamos como ficaria:

        CREATE OR REPLACE FUNCTION backup_usuario_excluido()
        RETURNS trigger
        AS $$
            begin 
                insert into tb_bkp_usuarios (id_usuario, nome_usuario)values(OLD.id_usuario, OLD.nome_usuario);
                return OLD;
            end;
        $$ LANGUAGE plpgsql;
    

Após termos a função já criada, podemos então criar a trigger em si.

• Uma trigger pode ser ativada em dois momentos: BEFORE (antes) ou AFTER (depois) de alguma ação;
• Uma trigger pode ser executada em dois modos de execução: uma vez a cada registro afetado pela ação que ativou a trigger (FOR EACH ROW), ou apenas uma vez por execução da ação (FOR EACH STATEMENT);

Vejamos:

    	CREATE TRIGGER nome_da_trigger
        [BEFORE/AFTER] [INSERT/UPDATE/DELETE] ON tb_tabela_de_atuacao_da_trigger
            FOR EACH [ROW/STATEMENT] EXECUTE PROCEDURE nome_da_funcao();
    

Vejamos agora como poderíamos programar a trigger para a função de backup de usuários que criamos logo ali acima:

    	CREATE TRIGGER executa_backup_usuarios
        AFTER DELETE ON tb_usuarios
            FOR EACH ROW EXECUTE PROCEDURE backup_usuario_excluido();
    

Pronto! Dessa forma, para cada usuário deletado da tb_usuarios, a trigger irá inserir na tb_bkp_usuarios o registro desse usuário.

Vamos ver agora como criar uma trigger que guardaria um log dos dados de alteração de cada registro de usuário:

        CREATE OR REPLACE FUNCTION log_edicao_usuario()
        RETURNS trigger
        AS $$
            begin 
                insert into tb_log_edicao_usuarios (id_usuario, nome_usuario_antigo)values(OLD.id_usuario, OLD.nome_usuario);
                return OLD;
            end;
        $$ LANGUAGE plpgsql;
        
        CREATE TRIGGER executa_log_edicao_usuarios
        AFTER UPDATE ON tb_usuarios
            FOR EACH ROW EXECUTE PROCEDURE log_edicao_usuario();
    

Agora um exemplo de uma trigger que cria o login do usuário no mento da criação dele:

        CREATE OR REPLACE FUNCTION cria_login_usuario()
        RETURNS trigger
        AS $$
            begin 
                insert into tb_logins (id_usuario, login, senha)values(NEW.id_usuario, NEW.email, '7110EDA4D09E062AA5E4A390B0A572AC0D2C0220');
                return NEW;
            end;
        $$ LANGUAGE plpgsql;
        
        CREATE TRIGGER executa_criacao_login_usuario
        AFTER INSERT ON tb_usuarios
            FOR EACH ROW EXECUTE PROCEDURE cria_login_usuario();
    

• Estamos especificando que o login do usuário será seu próprio email cadastrado;
• O hash alfanumérico é 1234 em criptografia SHA1. Estamos especificando como senha padrão;

Podemos também trabalhar com estruturas lógicas dentro das procedures, tais como tomadas de decisões.

Vejamos então um exemplo de backup de usuário apenas quando o usuário é um administrador:

        CREATE OR REPLACE FUNCTION backup_admin_excluido()
        RETURNS trigger
        AS $$
            begin
            	if(OLD.id_cargo = 1)
                	then insert into tb_bkp_admins (id_usuario, nome_usuario)values(OLD.id_usuario, OLD.nome_usuario);
                end if;
                return OLD;
            end;
        $$ LANGUAGE plpgsql;
        
        CREATE TRIGGER executa_backup_admin_excluido
        AFTER DELETE ON tb_usuarios
            FOR EACH ROW EXECUTE PROCEDURE backup_admin_excluido();
    

• Estamos especificando que 1 (um) é o id do cardo Administrador;

Maravilha! Agora já sabemos como criar nossas Triggers dentro do PostgreSQL!

No próximo post veremos como passar parâmetros para as procedures.

Você pode acessar o próximo post AQUI.