0:00:04.930,0:00:08.430
Vamos a um outro uso muito [br]importante das "Triggers",

0:00:08.430,0:00:10.234
que é para uma função nobre

0:00:10.234,0:00:13.236
muito utilizada por administradores [br]de banco de dados,

0:00:13.236,0:00:15.695
a auditoria do que está acontecendo.

0:00:15.695,0:00:18.822
Então, eu posso criar uma tabela[br]que eu chamo de auditoria,

0:00:18.822,0:00:22.919
e registrar quando alguém cadastrou [br]alguma coisa, apagou ou removeu,

0:00:22.919,0:00:25.791
guardando esses dados como [br]backup, por exemplo,

0:00:25.791,0:00:29.740
ou simplesmente podemos saber [br]quem é que apagou o que e quando.

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

0:00:31.837,0:00:34.164
então, eu posso utilizar [br]a "Trigger" para isso.

0:00:34.164,0:00:35.053
Vamos a um exemplo.

0:00:35.053,0:00:37.190
Eu tenho um exemplo aqui pronto [br]para nós brincarmos, então.

0:00:37.190,0:00:40.863
Vou criar tabela de auditoria,[br]portanto, agora no início,

0:00:40.863,0:00:43.173
essa tabela vai guardar o "codigo"

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

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

0:00:48.948,0:00:51.217
a antiga informação e a nova.

0:00:51.217,0:00:55.321
Como eu mencionei, eu poderia[br]até mesmo guardar o usuário que fez isso,

0:00:55.321,0:00:57.530
mas eu vou manter, então, o exemplo[br]exatamente como estava,

0:00:57.530,0:01:00.360
vou criar aqui a tabela de auditoria.

0:01:00.360,0:01:02.636
Muito bem, a tabela criada.

0:01:02.636,0:01:06.135
E agora eu vou criar uma "PROCEDURE",

0:01:06.135,0:01:09.302
então, na sequência aqui[br]eu vou criar uma "PROCEDURE"

0:01:09.302,0:01:12.572
para dar uma automatizada nessa operação.

0:01:12.572,0:01:16.788
E com a "PROCEDURE" eu também posso

0:01:16.788,0:01:20.115
burlar, de certa maneira, se é que [br]burlar é a palavra correta,

0:01:20.115,0:01:24.457
mas eu posso com a "PROCEDURE"[br]fazer o "COMMIT" desse "INSERT",

0:01:24.457,0:01:27.187
eu posso registrar de fato[br]o que está acontecendo,

0:01:27.187,0:01:31.825
já que a "TRIGGER" me impede de chamar[br]esse tipo de operação dentro do seu corpo.

0:01:31.825,0:01:33.945
Então, nós vamos criar [br]uma "PROCEDURE" antes

0:01:33.945,0:01:37.333
que vai registrar a operação [br]na tabela de auditoria,

0:01:37.333,0:01:40.428
então, eu tenho aqui um "CREATE OR[br]REPLACE PROCEDURE registra",

0:01:40.428,0:01:43.780
"p_codigo, p_operacao, p_antigo, p_novo".

0:01:43.780,0:01:47.482
Eu tenho até um "PRAGMA[br]AUTONOMOUS_TRANSACTION" aqui

0:01:47.482,0:01:51.751
para que eu tenha certeza que a "TRIGGER" [br]vai poder executar com sucesso.

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

0:01:53.480,0:01:57.945
"INSERT INTO auditoria", as cinco [br]informações em si,

0:01:57.945,0:02:02.318
as quatro delas eu vou passar [br]como parâmetro,

0:02:02.318,0:02:03.673
mas uma delas eu não preciso,

0:02:03.673,0:02:05.625
uma delas é a data e hora atuais,

0:02:05.625,0:02:08.895
e aí eu apelo para o "SYSDATE"[br]para me dar essa informação.

0:02:08.895,0:02:12.195
Então, eu vou criar a "PROCEDURE",[br]vamos lá.

0:02:12.195,0:02:17.027
Procedimento criado, esse procedimento[br]então, vai registrar informação,

0:02:17.027,0:02:19.543
deixa eu trazer o "SET SERVEROUTPUT ON" [br]para baixo.

0:02:19.543,0:02:22.228
E agora sim eu vou [br]fazer a "TRIGGER".

0:02:22.228,0:02:27.117
Então, um "CREATE OR REPLACE [br]TRIGGER mudancas_salariais",

0:02:27.117,0:02:31.964
vou chamar sempre antes de "INSERT"[br]ou "UPDATE" ou mesmo "DELETE"

0:02:31.964,0:02:34.211
informações da tabela de empregados,

0:02:34.211,0:02:38.013
que é uma tabela sensível, tem [br]salários e tudo mais.

0:02:38.013,0:02:40.743
E para cada linha que [br]eu for fazer uma mudança,

0:02:40.743,0:02:42.919
eu vou fazer o seguinte procedimento,

0:02:42.919,0:02:44.594
eu vou fazer uma alternância,

0:02:44.594,0:02:46.370
então, tem um "CASE" bem aqui,

0:02:46.370,0:02:49.239
no momento que eu estiver inserindo,[br]então, o "INSERTING",

0:02:49.239,0:02:50.946
eu vou chamar o "registra",

0:02:50.946,0:02:55.913
passando o código do novo funcionário,

0:02:55.913,0:02:57.460
qual é a ação que eu quero registrar?

0:02:57.460,0:02:58.845
O "INSERTING".

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

0:03:02.015,0:03:05.322
embora, como é um "INSERTING",[br]eu não tenho o antigo aqui,

0:03:05.322,0:03:07.752
essa informação vai ficar [br]zerada no final das contas.

0:03:07.752,0:03:10.790
O "UPDATING", [br]e a única diferença aqui

0:03:10.790,0:03:13.660
é que eu vou pegar código [br]antigo como referência,

0:03:13.660,0:03:17.030
e vai ser um "UPDATE"[br]e não uma "INSERT".

0:03:17.030,0:03:19.899
E no "DELETING", eu tenho [br]praticamente a mesma linha,

0:03:19.899,0:03:23.136
a diferença é que eu vou registrar [br]que a ação que aconteceu

0:03:23.136,0:03:25.773
foi uma remoção,[br]foi apagar.

0:03:25.773,0:03:26.873
E aqui eu vou executar,

0:03:26.873,0:03:30.805
portanto, vou criar[br]essa minha "TRIGGER".

0:03:30.805,0:03:33.466
Muito bem, então eu criei uma "TRIGGER",

0:03:33.466,0:03:37.924
a grande lógica por trás dessa "TRIGGER"[br]é que na verdade é uma "PROCEDURE",

0:03:37.924,0:03:40.473
e ela está sendo chamada [br]aqui no "registra".

0:03:40.473,0:03:44.023
Então, eu posso, portanto, ter uma[br]"TRIGGER" chamando "PROCEDURE",

0:03:44.023,0:03:45.225
não tem problema nenhum.

0:03:45.225,0:03:47.150
E agora sim eu vou fazer um teste,

0:03:47.150,0:03:50.116
então, eu tenho o "SET SERVEROUTPUT ON",

0:03:50.116,0:03:54.067
embora nesse exemplo ele se torne[br]desnecessário no final das contas.

0:03:54.067,0:03:57.804
Eu vou colocar para ter certeza[br]de alterar o formato da data

0:03:57.804,0:04:00.573
para um formato mais amigável[br]aqui no Brasil,

0:04:00.573,0:04:04.660
então, isso aqui é só para eu poder ter [br]a data e hora no formato mais interessante,

0:04:04.660,0:04:06.145
pronto, alterado.

0:04:06.145,0:04:09.111
E agora eu vou inserir um [br]novo funcionário,

0:04:09.111,0:04:11.443
eu estou inserindo aqui, [br]ele vai ser o código "1000",

0:04:11.443,0:04:15.347
e ele vai ter o salário [br]de R$2780,00 reais.

0:04:15.347,0:04:18.891
Quando eu clico aqui,[br]repare que uma linha foi inserida

0:04:18.891,0:04:20.831
e, além da linha inserida,

0:04:20.831,0:04:24.553
permita-me mostrar aqui[br]a tabela de funcionários

0:04:24.553,0:04:29.000
com esse novo funcionário,[br]"empno=1000".

0:04:29.000,0:04:34.440
Então, essa pessoa que eu acabei [br]de inserir também aqui,

0:04:34.440,0:04:36.490
repare que eu não passei [br]as outras informações,

0:04:36.490,0:04:39.545
eu só tenho o código e o salário[br]no final das contas,

0:04:39.545,0:04:42.783
que é o que interessa para a minha[br]"PROCEDURE" de auditoria.

0:04:42.783,0:04:44.350
Então, vou dar um [br]"SELECT * FROM auditoria",

0:04:44.350,0:04:48.015
repare que além da inserção [br]na tabela de funcionários,

0:04:48.015,0:04:50.872
essa linha aqui não existia,

0:04:50.872,0:04:52.492
ele também deu "INSERT",

0:04:52.492,0:04:56.029
ele disparou um "INSERT" automático[br]na minha tabela de auditoria.

0:04:56.029,0:04:57.130
O código "1000",

0:04:57.130,0:05:00.967
essa data e hora que eu acabei [br]de fazer a função, "INSERT",

0:05:00.967,0:05:06.139
o antigo salário não existe[br]e o novo salário é "2780".

0:05:06.139,0:05:07.312
Eu posso fazer um "UPDATE",

0:05:07.312,0:05:11.811
eu vou, então, atualizar [br]o salário desse mesmo funcionário.

0:05:11.811,0:05:15.279
Pronto, linha atualizada.

0:05:15.279,0:05:18.223
Eu vou olhar agora na [br]tabela de funcionário

0:05:18.223,0:05:20.553
e repare que eu dobrei [br]o salário dele.

0:05:20.553,0:05:22.168
O salário era de R$2.780 reais,

0:05:22.168,0:05:26.318
se tornou R$5.560 reais[br]agora da mesma pessoa "1000".

0:05:26.318,0:05:28.294
E agora na tabela de auditoria

0:05:28.294,0:05:31.638
eu tenho registrado não só o momento [br]que eu inseri o funcionário,

0:05:31.638,0:05:36.002
mas também o momento com data,[br]hora, minuto, tudo certinho

0:05:36.002,0:05:39.872
de quando eu mudei o salário dele,[br]quando eu dobrei o salário dele.

0:05:39.872,0:05:43.810
E pra terminar a demonstração,[br]por que não aproveitar

0:05:43.810,0:05:46.612
e apagar esse funcionário[br]que eu acabei de criar?

0:05:46.612,0:05:51.566
Então, um "empno = 1000"

0:05:51.566,0:05:56.022
e vou apagar esse funcionário,[br]portanto, está apagado.

0:05:56.022,0:05:59.192
E na tabela aqui no [br]"SELECT * FROM auditoria",

0:05:59.192,0:06:02.389
repare que eu tenho as três [br]operações registradas,

0:06:02.389,0:06:04.598
o momento que eu inseri o funcionário,

0:06:04.598,0:06:06.400
o momento que eu atualizei

0:06:06.400,0:06:08.067
e o momento que eu o removi.

0:06:08.067,0:06:10.528
Então, eu consigo ter a informação

0:06:10.528,0:06:13.539
e no código eu consigo saber[br]exatamente quem foi, não é?

0:06:13.539,0:06:18.778
Então, essas três operações[br]aconteceram para o meu empregado "1000".

0:06:18.778,0:06:24.484
Então, repare como acaba sendo simples[br]de criar uma tabela de auditoria

0:06:24.484,0:06:28.921
e dentro dessa tabela, portanto,[br]eu posso guardar qualquer informação,

0:06:28.921,0:06:34.426
para depois fazer algum tipo de acareação[br]ou saber se alguém apagou por engano,

0:06:34.426,0:06:37.530
ou deu um aumento de salário [br]que fosse indevido,

0:06:37.530,0:06:39.997
eu consigo, portanto, ter uma boa visão

0:06:39.997,0:06:42.226
do que acontece dentro [br]do meu banco de dados.