Tratamento de erros durante inserção e atualização de dados

Bora ver os erros mais comuns quando a gente tenta inserir novos dados numa tabela.

Erro 1: Tentativa de inserir NULL em campo obrigatório

O PostgreSQL fica de olho pra garantir que as regras do banco sejam respeitadas. Olha só exemplos de restrições que podem causar erro:

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL, -- Nome não pode ser NULL
    age INT
);

-- Erro: campo name é obrigatório
INSERT INTO students (name, age) VALUES (NULL, 20);

Resultado: erro null value in column "name" of relation "students" violates not-null constraint`.

Você precisa ficar ligado nos dados que tá inserindo. Pode ser que essa coluna aceitava NULL antes, mas agora virou obrigatória.

Erro 2: Duplicidade em coluna única.

CREATE TABLE courses (
    course_id SERIAL PRIMARY KEY,
    course_name TEXT UNIQUE -- Nome do curso tem que ser único
);

-- Primeira inserção ok
INSERT INTO courses (course_name) VALUES ('SQL Basics');

-- Segunda inserção dá erro
INSERT INTO courses (course_name) VALUES ('SQL Basics');

Resultado: erro duplicate key value violates unique constraint`.

Normalmente não é culpa sua, é o usuário tentando repetir uma ação sem querer. Não precisa fazer nada nesse caso.

Erro 3: Violação de integridade referencial.

CREATE TABLE enrollments (
    enrollment_id SERIAL PRIMARY KEY,
    student_id INT REFERENCES students(id), -- Tem que existir um estudante com esse ID
    course_id INT REFERENCES courses(course_id)
);

-- Erro: estudante com ID = 99 não existe
INSERT INTO enrollments (student_id, course_id) VALUES (99, 1);

Resultado: erro insert or update on table "enrollments" violates foreign key constraint`.

Na real, é ótimo que deu erro. Nada pior do que quebrar a integridade do banco. Provavelmente tem bug no código que mexe com o banco, ou algum dado ficou velho. De qualquer jeito, se o banco não deixou quebrar a integridade — isso é muito bom.

Tratamento de erros no PostgreSQL

Sim, erros acontecem. Mas o importante não é só perceber, é saber lidar com eles.

Transações como ferramenta de proteção

Quando mexemos com dados, a gente usa transações pra garantir a consistência. Se rolar erro, dá pra desfazer tudo.

Exemplo: inserindo dados em duas tabelas.

BEGIN; -- Começa a transação

-- Insere dados na tabela students
INSERT INTO students (name, age) VALUES ('Otto Lin', 21);

-- Insere registro na tabela enrollments
-- Aqui dá erro se não existir curso com ID=10
INSERT INTO enrollments (student_id, course_id) VALUES (1, 10);

-- Se tudo der certo
COMMIT;
-- Se der erro, desfaz tudo
ROLLBACK;

Se o curso com course_id = 10 não existir, a inserção na tabela students também vai ser desfeita.

Tratando erros em transações

No PostgreSQL dá pra prever erros e tratar eles direto nas queries usando blocos EXCEPTION.

Exemplo: adicionando estudante e matriculando ele num curso. Se der erro, a mensagem vai pro log.

DO $$
BEGIN
    -- Tentando inserir dados
    INSERT INTO students (name, age) VALUES ('Anna Song', 22);
    INSERT INTO enrollments (student_id, course_id) VALUES (2, 999); -- Erro

    -- Se tudo der certo
    RAISE NOTICE 'Registro adicionado com sucesso!';
EXCEPTION
    WHEN foreign_key_violation THEN
        -- Tratando violação de chave estrangeira
        RAISE WARNING 'Curso com o course_id informado não existe.';
END $$;

Checando unicidade com ON CONFLICT

Você pode evitar erro de violação de UNIQUE usando ON CONFLICT. Assim dá pra dizer o que fazer quando rolar conflito.

Exemplo: se tentar inserir curso duplicado, só ignora.

INSERT INTO courses (course_name)
    VALUES ('SQL Basics')
ON CONFLICT (course_name) DO NOTHING; -- Ignora dados duplicados

Ou então atualiza a linha existente:

INSERT INTO courses (course_name)
    VALUES ('SQL Basics')
ON CONFLICT (course_name) DO UPDATE     
    SET course_name = EXCLUDED.course_name || ' (Atualizado)';

Mais sobre o operador ON CONFLICT eu explico no próximo nível, quando a gente for ver carga de dados em massa :P

Erros comuns ao trabalhar com dados e como evitar

Você já viu que as principais fontes de erro são:

1. Violação de restrições (NOT NULL, UNIQUE, FOREIGN KEY).
2. Falta de condições nas queries (WHERE) ao atualizar ou deletar dados.
3. Erros na ordem das transações.

Pra se proteger:

• Use transações e ROLLBACK pra operações grandes.
• Sempre confira os dados antes de inserir.
• Logue os erros pra analisar depois.
• Use ON CONFLICT pra evitar registros duplicados.

Agora você tá pronto pra encarar os erros! Lembra: dev bom não é o que nunca erra, mas o que sabe resolver os bugs.