WEBVTT

00:00:04.930 --> 00:00:08.430
Vamos a um outro uso muito 
importante das "Triggers",

00:00:08.430 --> 00:00:10.234
que é para uma função nobre

00:00:10.234 --> 00:00:13.236
muito utilizada por administradores 
de banco de dados,

00:00:13.236 --> 00:00:15.695
a auditoria do que está acontecendo.

00:00:15.695 --> 00:00:18.822
Então, eu posso criar uma tabela
que eu chamo de auditoria,

00:00:18.822 --> 00:00:22.919
e registrar quando alguém cadastrou 
alguma coisa, apagou ou removeu,

00:00:22.919 --> 00:00:25.791
guardando esses dados como 
backup, por exemplo,

00:00:25.791 --> 00:00:29.740
ou simplesmente podemos saber 
quem é que apagou o que e quando.

00:00:29.740 --> 00:00:31.837
São informações muito importantes,

00:00:31.837 --> 00:00:34.164
então, eu posso utilizar 
a "Trigger" para isso.

00:00:34.164 --> 00:00:35.053
Vamos a um exemplo.

00:00:35.053 --> 00:00:37.190
Eu tenho um exemplo aqui pronto 
para nós brincarmos, então.

00:00:37.190 --> 00:00:40.863
Vou criar tabela de auditoria,
portanto, agora no início,

00:00:40.863 --> 00:00:43.173
essa tabela vai guardar o "codigo"

00:00:43.173 --> 00:00:47.303
a "hora" que esta ação aconteceu,

00:00:47.303 --> 00:00:48.948
qual é a "operacao" em si,

00:00:48.948 --> 00:00:51.217
a antiga informação e a nova.

00:00:51.217 --> 00:00:55.321
Como eu mencionei, eu poderia
até mesmo guardar o usuário que fez isso,

00:00:55.321 --> 00:00:57.530
mas eu vou manter, então, o exemplo
exatamente como estava,

00:00:57.530 --> 00:01:00.360
vou criar aqui a tabela de auditoria.

00:01:00.360 --> 00:01:02.636
Muito bem, a tabela criada.

00:01:02.636 --> 00:01:06.135
E agora eu vou criar uma "PROCEDURE",

00:01:06.135 --> 00:01:09.302
então, na sequência aqui
eu vou criar uma "PROCEDURE"

00:01:09.302 --> 00:01:12.572
para dar uma automatizada nessa operação.

00:01:12.572 --> 00:01:16.788
E com a "PROCEDURE" eu também posso

00:01:16.788 --> 00:01:20.115
burlar, de certa maneira, se é que 
burlar é a palavra correta,

00:01:20.115 --> 00:01:24.457
mas eu posso com a "PROCEDURE"
fazer o "COMMIT" desse "INSERT",

00:01:24.457 --> 00:01:27.187
eu posso registrar de fato
o que está acontecendo,

00:01:27.187 --> 00:01:31.825
já que a "TRIGGER" me impede de chamar
esse tipo de operação dentro do seu corpo.

00:01:31.825 --> 00:01:33.945
Então, nós vamos criar 
uma "PROCEDURE" antes

00:01:33.945 --> 00:01:37.333
que vai registrar a operação 
na tabela de auditoria,

00:01:37.333 --> 00:01:40.428
então, eu tenho aqui um "CREATE OR
REPLACE PROCEDURE registra",

00:01:40.428 --> 00:01:43.780
"p_codigo, p_operacao, p_antigo, p_novo".

00:01:43.780 --> 00:01:47.482
Eu tenho até um "PRAGMA
AUTONOMOUS_TRANSACTION" aqui

00:01:47.482 --> 00:01:51.751
para que eu tenha certeza que a "TRIGGER" 
vai poder executar com sucesso.

00:01:51.751 --> 00:01:53.480
E aqui está a operação em si,

00:01:53.480 --> 00:01:57.945
"INSERT INTO auditoria", as cinco 
informações em si,

00:01:57.945 --> 00:02:02.318
as quatro delas eu vou passar 
como parâmetro,

00:02:02.318 --> 00:02:03.673
mas uma delas eu não preciso,

00:02:03.673 --> 00:02:05.625
uma delas é a data e hora atuais,

00:02:05.625 --> 00:02:08.895
e aí eu apelo para o "SYSDATE"
para me dar essa informação.

00:02:08.895 --> 00:02:12.195
Então, eu vou criar a "PROCEDURE",
vamos lá.

00:02:12.195 --> 00:02:17.027
Procedimento criado, esse procedimento
então, vai registrar informação,

00:02:17.027 --> 00:02:19.543
deixa eu trazer o "SET SERVEROUTPUT ON" 
para baixo.

00:02:19.543 --> 00:02:22.228
E agora sim eu vou 
fazer a "TRIGGER".

00:02:22.228 --> 00:02:27.117
Então, um "CREATE OR REPLACE 
TRIGGER mudancas_salariais",

00:02:27.117 --> 00:02:31.964
vou chamar sempre antes de "INSERT"
ou "UPDATE" ou mesmo "DELETE"

00:02:31.964 --> 00:02:34.211
informações da tabela de empregados,

00:02:34.211 --> 00:02:38.013
que é uma tabela sensível, tem 
salários e tudo mais.

00:02:38.013 --> 00:02:40.743
E para cada linha que 
eu for fazer uma mudança,

00:02:40.743 --> 00:02:42.919
eu vou fazer o seguinte procedimento,

00:02:42.919 --> 00:02:44.594
eu vou fazer uma alternância,

00:02:44.594 --> 00:02:46.370
então, tem um "CASE" bem aqui,

00:02:46.370 --> 00:02:49.239
no momento que eu estiver inserindo,
então, o "INSERTING",

NOTE Paragraph

00:02:49.239 --> 00:02:50.946
eu vou chamar o "registra",

00:02:50.946 --> 00:02:55.913
passando o código do novo funcionário,

00:02:55.913 --> 00:02:57.460
qual é a ação que eu quero registrar?

00:02:57.460 --> 00:02:58.845
O "INSERTING".

00:02:58.845 --> 00:03:02.015
A inserção, o ":OLD.sal" e o ":NEW.sal",

00:03:02.015 --> 00:03:05.322
embora, como é um "INSERTING",
eu não tenho o antigo aqui,

00:03:05.322 --> 00:03:07.752
essa informação vai ficar 
zerada no final das contas.

00:03:07.752 --> 00:03:10.790
O "UPDATING", 
e a única diferença aqui

00:03:10.790 --> 00:03:13.660
é que eu vou pegar código 
antigo como referência,

00:03:13.660 --> 00:03:17.030
e vai ser um "UPDATE"
e não uma "INSERT".

00:03:17.030 --> 00:03:19.899
E no "DELETING", eu tenho 
praticamente a mesma linha,

00:03:19.899 --> 00:03:23.136
a diferença é que eu vou registrar 
que a ação que aconteceu

00:03:23.136 --> 00:03:25.773
foi uma remoção,
foi apagar.

00:03:25.773 --> 00:03:26.873
E aqui eu vou executar,

00:03:26.873 --> 00:03:30.805
portanto, vou criar
essa minha "TRIGGER".

00:03:30.805 --> 00:03:33.466
Muito bem, então eu criei uma "TRIGGER",

00:03:33.466 --> 00:03:37.924
a grande lógica por trás dessa "TRIGGER"
é que na verdade é uma "PROCEDURE",

00:03:37.924 --> 00:03:40.473
e ela está sendo chamada 
aqui no "registra".

00:03:40.473 --> 00:03:44.023
Então, eu posso, portanto, ter uma
"TRIGGER" chamando "PROCEDURE",

00:03:44.023 --> 00:03:45.225
não tem problema nenhum.

00:03:45.225 --> 00:03:47.150
E agora sim eu vou fazer um teste,

00:03:47.150 --> 00:03:50.116
então, eu tenho o "SET SERVEROUTPUT ON",

00:03:50.116 --> 00:03:54.067
embora nesse exemplo ele se torne
desnecessário no final das contas.

00:03:54.067 --> 00:03:57.804
Eu vou colocar para ter certeza
de alterar o formato da data

00:03:57.804 --> 00:04:00.573
para um formato mais amigável
aqui no Brasil,

00:04:00.573 --> 00:04:04.660
então, isso aqui é só para eu poder ter 
a data e hora no formato mais interessante,

00:04:04.660 --> 00:04:06.145
pronto, alterado.

00:04:06.145 --> 00:04:09.111
E agora eu vou inserir um 
novo funcionário,

00:04:09.111 --> 00:04:11.443
eu estou inserindo aqui, 
ele vai ser o código "1000",

00:04:11.443 --> 00:04:15.347
e ele vai ter o salário 
de R$2780,00 reais.

00:04:15.347 --> 00:04:18.891
Quando eu clico aqui,
repare que uma linha foi inserida

00:04:18.891 --> 00:04:20.831
e, além da linha inserida,

00:04:20.831 --> 00:04:24.553
permita-me mostrar aqui
a tabela de funcionários

00:04:24.553 --> 00:04:29.000
com esse novo funcionário,
"empno=1000".

00:04:29.000 --> 00:04:34.440
Então, essa pessoa que eu acabei 
de inserir também aqui,

00:04:34.440 --> 00:04:36.490
repare que eu não passei 
as outras informações,

00:04:36.490 --> 00:04:39.545
eu só tenho o código e o salário
no final das contas,

00:04:39.545 --> 00:04:42.783
que é o que interessa para a minha
"PROCEDURE" de auditoria.

00:04:42.783 --> 00:04:44.350
Então, vou dar um 
"SELECT * FROM auditoria",

00:04:44.350 --> 00:04:48.015
repare que além da inserção 
na tabela de funcionários,

00:04:48.015 --> 00:04:50.872
essa linha aqui não existia,

00:04:50.872 --> 00:04:52.492
ele também deu "INSERT",

00:04:52.492 --> 00:04:56.029
ele disparou um "INSERT" automático
na minha tabela de auditoria.

00:04:56.029 --> 00:04:57.130
O código "1000",

00:04:57.130 --> 00:05:00.967
essa data e hora que eu acabei 
de fazer a função, "INSERT",

00:05:00.967 --> 00:05:06.139
o antigo salário não existe
e o novo salário é "2780".

00:05:06.139 --> 00:05:07.312
Eu posso fazer um "UPDATE",

00:05:07.312 --> 00:05:11.811
eu vou, então, atualizar 
o salário desse mesmo funcionário.

00:05:11.811 --> 00:05:15.279
Pronto, linha atualizada.

00:05:15.279 --> 00:05:18.223
Eu vou olhar agora na 
tabela de funcionário

00:05:18.223 --> 00:05:20.553
e repare que eu dobrei 
o salário dele.

00:05:20.553 --> 00:05:22.168
O salário era de R$2.780 reais,

00:05:22.168 --> 00:05:26.318
se tornou R$5.560 reais
agora da mesma pessoa "1000".

00:05:26.318 --> 00:05:28.294
E agora na tabela de auditoria

00:05:28.294 --> 00:05:31.638
eu tenho registrado não só o momento 
que eu inseri o funcionário,

00:05:31.638 --> 00:05:36.002
mas também o momento com data,
hora, minuto, tudo certinho

00:05:36.002 --> 00:05:39.872
de quando eu mudei o salário dele,
quando eu dobrei o salário dele.

00:05:39.872 --> 00:05:43.810
E pra terminar a demonstração,
por que não aproveitar

00:05:43.810 --> 00:05:46.612
e apagar esse funcionário
que eu acabei de criar?

00:05:46.612 --> 00:05:51.566
Então, um "empno = 1000"

00:05:51.566 --> 00:05:56.022
e vou apagar esse funcionário,
portanto, está apagado.

00:05:56.022 --> 00:05:59.192
E na tabela aqui no 
"SELECT * FROM auditoria",

00:05:59.192 --> 00:06:02.389
repare que eu tenho as três 
operações registradas,

00:06:02.389 --> 00:06:04.598
o momento que eu inseri o funcionário,

00:06:04.598 --> 00:06:06.400
o momento que eu atualizei

00:06:06.400 --> 00:06:08.067
e o momento que eu o removi.

00:06:08.067 --> 00:06:10.528
Então, eu consigo ter a informação

00:06:10.528 --> 00:06:13.539
e no código eu consigo saber
exatamente quem foi, não é?

00:06:13.539 --> 00:06:18.778
Então, essas três operações
aconteceram para o meu empregado "1000".

00:06:18.778 --> 00:06:24.484
Então, repare como acaba sendo simples
de criar uma tabela de auditoria

00:06:24.484 --> 00:06:28.921
e dentro dessa tabela, portanto,
eu posso guardar qualquer informação,

00:06:28.921 --> 00:06:34.426
para depois fazer algum tipo de acareação
ou saber se alguém apagou por engano,

00:06:34.426 --> 00:06:37.530
ou deu um aumento de salário 
que fosse indevido,

00:06:37.530 --> 00:06:39.997
eu consigo, portanto, ter uma boa visão

00:06:39.997 --> 00:06:42.226
do que acontece dentro 
do meu banco de dados.