Inserindo dados em tabelas com restrições: NOT NULL, DEFAULT

Hoje a gente vai mergulhar em mais um ponto importante quando se trabalha com bancos de dados — como inserir dados em tabelas que têm restrições NOT NULL e DEFAULT. Nessa altura do campeonato, você já manja o básico do comando INSERT INTO e já entende como adicionar linhas em tabelas com uma estrutura definida. Agora é hora de ir mais fundo — porque lidar com restrições costuma ser uma dor de cabeça pra muita gente que programa. Mas relaxa, até o fim da aula você vai tirar isso de letra!

O que são restrições?

Restrições são regras que você coloca nas colunas da tabela. Elas ajudam a manter os dados de um jeito lógico e certinho. Por exemplo, não dá pra deixar vazio um campo que é obrigatório (NOT NULL), ou você pode não informar um valor pra uma coluna se já tiver um valor padrão definido (DEFAULT).

Tipos de restrições: - NOT NULL — diz que a coluna não pode ter NULL. - DEFAULT — define um valor que vai ser inserido automaticamente na coluna se você não informar nada.

Restrições ajudam a manter a integridade dos dados. Imagina que você guarda uma lista de estudantes na tabela students, e uma das regras é que todo estudante tem que ter um nome (NOT NULL). Sem essa restrição, alguém pode esquecer de colocar o nome e aí aparece um "estudante sem nome" no banco. Outro exemplo: você decidiu que o valor padrão pra quantidade de créditos de um novo curso é 0 (DEFAULT), assim não precisa pensar nisso toda vez.

Trabalhando com a restrição NOT NULL

A restrição NOT NULL obriga você a informar um valor naquela coluna quando for adicionar um registro. Se tentar inserir NULL ou nem informar nada pra essa coluna, o banco vai "reclamar" (vai dar erro). Bora ver um exemplo.

Vamos criar uma tabela simples students:

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

Repara: a coluna name tem a restrição NOT NULL, mas a coluna age não tem restrição nenhuma.

Exemplo de inserção com NOT NULL

Agora vamos tentar adicionar estudantes:

-- Exemplo de inserção bem-sucedida
INSERT INTO students (name, age) VALUES ('Alice', 23);
-- Sucesso: nome informado, campo atende à restrição NOT NULL

-- Exemplo de erro:
INSERT INTO students (age) VALUES (30);
-- Erro: campo name não pode ser NULL, pois tem restrição NOT NULL

Quando aparecer um erro tipo null value in column "name" violates not-null constraint, não se assusta — é só o PostgreSQL te lembrando pra ficar esperto.

Usando valores padrão (DEFAULT)

A restrição DEFAULT diz pro banco: "Se esquecerem de informar um valor pra essa coluna, usa esse aqui". Isso facilita a vida de quem programa, porque não precisa preencher tudo na mão.

Exemplo de tabela com restrição DEFAULT

Vamos criar a tabela courses:

CREATE TABLE courses (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    credits INT DEFAULT 0   -- Valor padrão pra coluna credits é 0
);

Exemplo de inserção com DEFAULT

Agora vamos adicionar cursos:

-- Informou valor pra credits
INSERT INTO courses (name, credits) VALUES ('Mathematics', 5);

-- Não informou valor pra credits — vai usar o valor padrão (0)
INSERT INTO courses (name) VALUES ('History');

-- Vamos ver como ficou
SELECT * FROM courses;

Resultado:

Repara: quando adicionamos o curso History não informamos a quantidade de créditos. O PostgreSQL preencheu a coluna credits com 0 automaticamente.

Usando NOT NULL e DEFAULT juntos

Essas colunas exigem um valor, mesmo que você não informe nada. Por exemplo, na tabela courses a coluna credits pode ser DEFAULT e NOT NULL ao mesmo tempo, pra garantir que ninguém deixe ela vazia (NULL).

CREATE TABLE courses (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    credits INT NOT NULL DEFAULT 0
);

Exemplo de inserção

Imagina que todo curso novo tem que começar com 0 créditos, mas NULL não é permitido.

-- Sucesso: créditos ficam com valor padrão
INSERT INTO courses (name) VALUES ('Physics');

-- Erro: tentou inserir NULL numa coluna NOT NULL
INSERT INTO courses (name, credits) VALUES ('Chemistry', NULL);

Exemplo: Adicionando estudante com nome obrigatório

Vamos criar a tabela students com restrições:

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,                         -- Nome obrigatório
    enrollment_date DATE DEFAULT CURRENT_DATE   -- Data de matrícula padrão é a data de hoje
);

Agora vamos adicionar estudantes nela:

-- Nome informado, data de matrícula vai ser preenchida automaticamente
INSERT INTO students (name) VALUES ('Bob');

-- Tentou não informar o nome (vai dar erro)
INSERT INTO students (enrollment_date) VALUES ('2024-10-01');

Ótimo exemplo de como o PostgreSQL ajuda a garantir dados corretos: todo estudante tem nome obrigatório e a data de matrícula não precisa ser informada sempre.

Dicas e "pegadinhas"

Quando você trabalha com NOT NULL e DEFAULT, tem que lembrar de algumas coisas importantes. Por exemplo, se seus dados costumam ter muito NULL, a restrição NOT NULL pode virar um problemão. E se você definir valor padrão pra tudo, pode acabar com dados errados (tipo 0 no lugar de um valor real).

Normalmente, se você adiciona uma coluna nova numa tabela que já existe, as células dessa coluna pras linhas antigas vão ficar como NULL. Mas se você colocar DEFAULT X, toda a coluna vai ser preenchida com o valor X. Isso é bem útil e ajuda a manter a integridade do banco.

Por exemplo, uma coluna nova pode ser uma FOREIGN KEY pra outra tabela. E ela não pode ter NULL ou 0. Tem que apontar pra linhas que já existem na outra tabela.

O que fazer se esqueceu de colocar restrições?

Relaxa — você pode adicionar restrições depois usando o comando ALTER TABLE. Tipo assim:

-- Adiciona restrição DEFAULT numa coluna que já existe
ALTER TABLE courses ALTER COLUMN credits SET DEFAULT 0;

-- Adiciona restrição NOT NULL numa coluna que já existe
ALTER TABLE students ALTER COLUMN name SET NOT NULL;

Essas queries não vão quebrar os dados que já existem — pode usar tranquilo em tabelas que já têm coisa importante.

Agora você já pode usar o poder do PostgreSQL pra controlar restrições! Seus dados vão ficar mais organizados, protegidos contra erros e suas queries vão ser mais lógicas e previsíveis.