Olá! Nesse artigo falaremos sobre Tratamento de Erros em PL/SQL. Hoje, vamos mergulhar nesse tema super importante que vai te ajudar a criar programas mais robustos e confiáveis. Vamos lá?
Por que o tratamento de erros é importante?
Imagine que você está cozinhando um bolo. Você segue a receita direitinho, mas e se acabar o açúcar no meio do processo? Ou se o forno parar de funcionar? É aí que entra o tratamento de erros. Na programação, ele é como um plano B para quando as coisas não saem como esperado.
O tratamento de erros é crucial porque:
- Melhora a experiência do usuário
- Previne a interrupção abrupta do programa
- Facilita a depuração e manutenção do código
- Aumenta a confiabilidade e robustez do seu software
Tipos de erros
Antes de aprendermos a lidar com os erros, precisamos entender que existem dois tipos principais:
- Erros de compilação
- Erros de execução (runtime)
Vamos ver cada um deles com mais detalhes.
Erros de compilação
Os erros de compilação são como erros de ortografia na sua receita de bolo. O computador olha para o seu código e diz: “Opa, tem algo errado aqui!”. Esses erros impedem que seu código seja convertido em um formato executável.
Vamos ver um exemplo:
|
1 2 3 4 5 6 7 8 |
DECLARE v_num1 INTEGER := &sv_num1; v_num2 INTEGER := &sv_num2; v_result NUMBER; BEGIN v_result = v_num1 / v_num2; DBMS_OUTPUT.PUT_LINE ('v_result: '||v_result); END; |
Se você tentar executar esse código, vai receber uma mensagem de erro parecida com esta:
|
1 2 3 4 |
ORA-06550: linha 6, coluna 13: PLS-00103: Encontrado o símbolo "=" quando se esperava := . ( @ % ; O símbolo ":=" foi inserido antes de "=" para continuar. |
Percebeu o problema? Na linha 6, usamos o sinal de igual (=) quando deveríamos usar o operador de atribuição (:=). É como se tivéssemos escrito “farinha igual 2 xícaras” em vez de “farinha: 2 xícaras” na nossa receita.
Para corrigir, basta mudar a linha 6 para:
|
1 |
v_result := v_num1 / v_num2; |
gora sim! O código vai compilar sem problemas.
Outros exemplos comuns de erros de compilação incluem:
- Esquecer de colocar ponto e vírgula no final das instruções
- Usar palavras-chave de forma incorreta (por exemplo, “BEGGIN” em vez de “BEGIN”)
- Declarar variáveis com tipos incompatíveis
Erros de execução (runtime)
Os erros de execução são mais traiçoeiros. O código parece perfeito, compila sem problemas, mas quando você tenta executar… boom! Algo dá errado.
Vamos usar o mesmo exemplo, mas agora corrigido:
|
1 2 3 4 5 6 7 8 |
DECLARE v_num1 INTEGER := &sv_num1; v_num2 INTEGER := &sv_num2; v_result NUMBER; BEGIN v_result := v_num1 / v_num2; DBMS_OUTPUT.PUT_LINE ('v_result: '||v_result); END; |
Se você executar esse código com v_num1 = 4 e v_num2 = 2, tudo funciona perfeitamente. O resultado será:
|
1 2 |
v_result: 2 |
Mas e se v_num2 for zero? Aí teremos um problema, porque não podemos dividir por zero!
Nesse caso, você vai ver uma mensagem de erro como esta:
|
1 2 3 4 |
ORA-01476: divisor é igual a zero ORA-06512: em linha 6 01476. 00000 - "divisor é igual a zero" |
É como se você tentasse dividir um bolo em zero pedaços. Não faz sentido, certo?
Outros exemplos de erros de execução incluem:
- Tentar acessar um índice de array que não existe
- Converter uma string para um número quando a string contém caracteres não numéricos
- Tentar inserir um valor em uma coluna com uma restrição de chave única quando o valor já existe
Como lidar com erros de execução
Aqui é onde entra a mágica do tratamento de erros. Vamos adicionar um bloco de exceção ao nosso código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
DECLARE v_num1 INTEGER := &sv_num1; v_num2 INTEGER := &sv_num2; v_result NUMBER; BEGIN v_result := v_num1 / v_num2; DBMS_OUTPUT.PUT_LINE ('v_result: '||v_result); EXCEPTION WHEN ZERO_DIVIDE THEN DBMS_OUTPUT.PUT_LINE ('Não é possível dividir um número por zero.'); WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE ('Ocorreu um erro inesperado: ' || SQLERRM); END; |
Agora, se alguém tentar dividir por zero, em vez de um erro assustador, verão uma mensagem amigável: “Não é possível dividir um número por zero.”
Vamos quebrar esse código em partes:
- O bloco EXCEPTION marca o início da seção de tratamento de erros.
- WHEN ZERO_DIVIDE THEN captura especificamente o erro de divisão por zero.
- WHEN OTHERS THEN é uma cláusula genérica que captura qualquer outro erro não tratado especificamente.
- SQLERRM é uma função que retorna a mensagem de erro associada ao erro Oracle mais recente.
Vantagens do tratamento de erros
- Mensagens mais amigáveis: Em vez de códigos de erro complicados, você pode mostrar mensagens que fazem sentido para os usuários. Por exemplo, em vez de “ORA-01476”, você mostra “Não é possível dividir por zero”.
- Execução completa: Seu programa não para no meio do caminho. Ele lida com o erro e continua funcionando. Isso é crucial em sistemas que precisam estar sempre disponíveis.
- Código mais organizado: Todas as rotinas de tratamento de erro ficam em um lugar só, tornando seu código mais fácil de entender e manter. Isso facilita muito quando você precisa fazer alterações ou debugar o código.
- Processamento baseado em eventos: Você pode definir ações específicas para cada tipo de erro que possa ocorrer. Por exemplo, você pode decidir registrar certos erros em um arquivo de log, enquanto outros podem exigir que você envie um e-mail para o administrador do sistema.
- Melhor experiência do usuário: Com tratamento de erros adequado, seu programa pode lidar graciosamente com situações inesperadas, fornecendo feedback útil ao usuário em vez de simplesmente travar.
Exemplos adicionais de tratamento de erros
Vamos ver mais alguns exemplos para solidificar nosso entendimento:
Exemplo 1: Tratando múltiplos erros
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
DECLARE v_emp_id employees.employee_id%TYPE := &sv_emp_id; v_emp_name employees.last_name%TYPE; BEGIN SELECT last_name INTO v_emp_name FROM employees WHERE employee_id = v_emp_id; DBMS_OUTPUT.PUT_LINE('Nome do empregado: ' || v_emp_name); EXCEPTION WHEN NO_DATA_FOUND THEN DBMS_OUTPUT.PUT_LINE('Nenhum empregado encontrado com o ID ' || v_emp_id); WHEN TOO_MANY_ROWS THEN DBMS_OUTPUT.PUT_LINE('Mais de um empregado encontrado com o ID ' || v_emp_id); WHEN OTHERS THEN DBMS_OUTPUT.PUT_LINE('Erro inesperado: ' || SQLERRM); END; |
Neste exemplo, tratamos três situações diferentes:
- Quando nenhum empregado é encontrado
- Quando mais de um empregado é encontrado (o que não deveria acontecer se employee_id for uma chave primária)
- Qualquer outro erro inesperado
Exemplo 2: Usando RAISE_APPLICATION_ERROR
Às vezes, você pode querer lançar seus próprios erros. O PL/SQL fornece a procedure RAISE_APPLICATION_ERROR para isso:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
DECLARE v_age NUMBER := &sv_age; BEGIN IF v_age < 0 THEN RAISE_APPLICATION_ERROR(-20001, 'A idade não pode ser negativa'); ELSIF v_age > 150 THEN RAISE_APPLICATION_ERROR(-20002, 'A idade parece ser muito alta'); ELSE DBMS_OUTPUT.PUT_LINE('A idade ' || v_age || ' é válida'); END IF; EXCEPTION WHEN OTHERS THEN IF SQLCODE = -20001 OR SQLCODE = -20002 THEN DBMS_OUTPUT.PUT_LINE('Erro de validação: ' || SQLERRM); ELSE DBMS_OUTPUT.PUT_LINE('Erro inesperado: ' || SQLERRM); END IF; END; |
Neste exemplo, criamos nossas próprias exceções para idades inválidas. Os números -20001 e -20002 são códigos de erro personalizados que escolhemos (o Oracle permite que usemos códigos de erro entre -20000 e -20999 para erros personalizados).
Melhores práticas no tratamento de erros
- Seja específico: Trate exceções específicas antes de usar WHEN OTHERS.
- Forneça informações úteis: As mensagens de erro devem ser informativas e acionáveis.
- Registre erros: Para erros críticos, considere registrá-los em uma tabela ou arquivo de log.
- Não ignore erros: Evite blocos de exceção vazios. Sempre faça algo com o erro, nem que seja apenas registrá-lo.
- Use exceções personalizadas: Para lógica de negócios complexa, crie e use suas próprias exceções.
Conclusão
Tratar erros é como ter um extintor de incêndio em casa. Você espera nunca precisar usar, mas se algo der errado, você está preparado. Com o tratamento de erros, seus programas PL/SQL ficam mais robustos, confiáveis e amigáveis.
Lembre-se: erros acontecem, mas com as técnicas que aprendemos hoje, você pode lidar com eles de forma elegante e eficiente. O tratamento de erros não é apenas sobre corrigir problemas, é sobre criar software que seja resiliente e forneça uma ótima experiência ao usuário, mesmo quando as coisas não saem como planejado.
