Voltar a todos os guias
SQL··7 min de leitura

Restrições SQL explicadas: NOT NULL, UNIQUE, CHECK, DEFAULT e mais

Domine as restrições SQL para proteger a integridade dos Dados. Aprenda NOT NULL, UNIQUE, CHECK, DEFAULT, PRIMARY KEY e FOREIGN KEY com exemplos claros.

Tabela de produtos com NOT NULL, UNIQUE, CHECK de preço não negativo e DEFAULT zero
Neste guia
  1. O que são restrições SQL?
  2. NOT NULL
  3. UNIQUE
  4. CHECK
  5. DEFAULT
  6. Restrições PRIMARY KEY & FOREIGN KEY
  7. Restrições ao nível da coluna vs ao nível da tabela
  8. Restrições nomeadas e por que são importantes
  9. Combinar Restrições e Padrões Comuns
  10. Armadilhas Comuns
  11. Referências e leitura adicional

Os exemplos de SQL utilizam PostgreSQL, a menos que outro dialeto seja mencionado. Excertos curtos pressupõem que as suas tabelas referenciadas já existem. Valide o DDL na sua base de dados de destino antes de o aplicar.

O que são restrições SQL?

Restrições são regras impostas pelo motor da base de dados para garantir a precisão e a fiabilidade dos dados numa tabela. Atuam como barreiras de proteção — prevenindo inserções, atualizações e eliminações inválidas nos limites da base de dados. Protegem as regras declaradas; a validação da aplicação e o design das transações continuam a ser importantes.

O SQL define vários tipos de restrições. Neste guia, abordaremos cada uma em profundidade, mostraremos quando utilizá-las e destacaremos armadilhas comuns.

NOT NULL

O NOT NULL a restrição garante que uma coluna tem sempre um valor. Qualquer INSERT ou UPDATE que tenta definir a coluna como NULL será rejeitado. Uma cadeia de caracteres vazia continua a ser um valor; adicione um CHECK quando o texto em branco for proibido.

CREATE TABLE products (
    id    SERIAL       PRIMARY KEY,
    name  VARCHAR(150) NOT NULL,   -- every product MUST have a name
    price NUMERIC(10,2) NOT NULL   -- every product MUST have a price
);

-- This will fail:
INSERT INTO products (name, price) VALUES (NULL, 9.99);
-- ERROR: null value in column "name" violates not-null constraint

Dica: Predefinir para NOT NULL para cada coluna e remova-a apenas quando tiver uma razão de negócio clara para permitir valores nulos. Os nulos introduzem lógica de três valores nas consultas e são uma fonte comum de erros subtis.

UNIQUE

A UNIQUE a restrição garante que nenhumas duas linhas contêm o mesmo valor na coluna restringida (ou combinação de colunas). Ao contrário de uma chave primária, uma UNIQUE coluna pode conter NULL. O PostgreSQL e o MySQL normalmente permitem múltiplos nulos numa coluna única; o SQL Server permite um numa restrição única de coluna única. Esta é uma regra de unicidade, não o resultado da avaliação de NULL = NULL.

CREATE TABLE users (
    id       SERIAL       PRIMARY KEY,
    email    VARCHAR(255) NOT NULL UNIQUE,
    username VARCHAR(50)  NOT NULL UNIQUE
);

-- Multi-column unique constraint
CREATE TABLE reservations (
    id        SERIAL PRIMARY KEY,
    room_id   INT    NOT NULL,
    date      DATE   NOT NULL,
    CONSTRAINT uq_room_date UNIQUE (room_id, date)
);

O multi-coluna UNIQUE a restrição acima garante que a mesma sala não pode ser reservada duas vezes na mesma data.

CHECK

CHECK as restrições validam que um valor satisfaz uma expressão booleana antes de ser armazenado. Elas impõem regras ao nível da linha que o sistema de tipos por si só não consegue expressar. Um CHECK aceita TRUE ou UNKNOWN; combine-o com NOT NULL quando um valor é obrigatório.

CREATE TABLE employees (
    id     SERIAL       PRIMARY KEY,
    name   VARCHAR(100) NOT NULL,
    age    INT          NOT NULL CHECK (age >= 18 AND age <= 120),
    salary NUMERIC(12,2) NOT NULL CHECK (salary > 0)
);

-- Named CHECK constraint with multiple columns
CREATE TABLE events (
    id         SERIAL      PRIMARY KEY,
    start_date DATE        NOT NULL,
    end_date   DATE        NOT NULL,
    CONSTRAINT chk_dates CHECK (end_date >= start_date)
);

Atenção: Nas versões do MySQL anteriores à 8.0.16,CHECK as restrições são analisadas mas ignorado silenciosamente. Verifique sempre se a versão da sua base de dados as impõe realmente.

DEFAULT

O DEFAULT fornece um valor quando uma coluna é omitida de um INSERT ou DEFAULT é solicitado explicitamente. Um NULL explícito não invoca o valor predefinido. Os valores predefinidos reduzem o código repetitivo no código da aplicação e tornam os esquemas auto-documentados.

CREATE TABLE orders (
    id         SERIAL       PRIMARY KEY,
    status     VARCHAR(20)  NOT NULL DEFAULT 'pending',
    created_at TIMESTAMPTZ  NOT NULL DEFAULT now(),
    quantity   INT          NOT NULL DEFAULT 1
);

-- Inserting without specifying status, created_at, or quantity
INSERT INTO orders DEFAULT VALUES;
-- Result: status='pending', created_at=<current time>, quantity=1

DEFAULT com Expressões

O PostgreSQL e o SQL Server permitem expressões e chamadas de função em valores padrão. O MySQL suporta isto desde a versão 8.0.13 para alguns tipos.

-- PostgreSQL: UUID default
CREATE TABLE tokens (
    id    UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    value TEXT NOT NULL
);

Restrições PRIMARY KEY & FOREIGN KEY

Estas são as restrições mais estruturais em bases de dados relacionais. Uma PRIMARY KEY identifica de forma única cada linha e adiciona implicitamente NOT NULL + UNIQUE. Um FOREIGN KEY liga uma tabela a outra e impõe a integridade referencial.

CREATE TABLE departments (
    id   SERIAL      PRIMARY KEY,
    name VARCHAR(80) NOT NULL UNIQUE
);

CREATE TABLE employees (
    id            SERIAL      PRIMARY KEY,
    name          VARCHAR(100) NOT NULL,
    department_id INT          NOT NULL,
    CONSTRAINT fk_emp_dept
        FOREIGN KEY (department_id)
        REFERENCES departments (id)
        ON DELETE RESTRICT
        ON UPDATE CASCADE
);

Consulte o nosso guia aprofundado sobre Chaves Primárias vs Chaves Estrangeiras para ações em cascata, chaves compostas e melhores práticas. Também pode modelar estas relações visualmente no Editor do Erd Go.

Restrições ao nível da coluna vs ao nível da tabela

As restrições podem ser definidas em linha (nível de coluna) ou como uma cláusula separada após todas as colunas (nível de tabela). O resultado é idêntico — mas o nível de tabela é obrigatório quando a restrição abrange várias colunas.

-- Column-level (single column)
CREATE TABLE items (
    id    SERIAL PRIMARY KEY,
    code  VARCHAR(20) NOT NULL UNIQUE,
    price NUMERIC(10,2) NOT NULL CHECK (price >= 0)
);

-- Table-level (multi-column constraint)
CREATE TABLE shipments (
    id          SERIAL PRIMARY KEY,
    origin      VARCHAR(3) NOT NULL,
    destination VARCHAR(3) NOT NULL,
    CONSTRAINT chk_different_locations CHECK (origin <> destination),
    CONSTRAINT uq_route UNIQUE (origin, destination)
);

Restrições nomeadas e por que são importantes

Nomeie sempre as suas restrições explicitamente utilizando o CONSTRAINT palavra-chave. Quando uma restrição é violada, a base de dados devolve o nome da restrição na mensagem de erro — um nome significativo como chk_positive_salary é infinitamente mais útil do que um hash gerado automaticamente.

-- Good: named constraint
ALTER TABLE products
    ADD CONSTRAINT chk_positive_price CHECK (price > 0);

-- You can also drop a constraint by name
ALTER TABLE products
    DROP CONSTRAINT chk_positive_price;

Uma convenção de nomenclatura consistente torna as migrações, a depuração e a integração da equipa muito mais fluidas. Um padrão comum é:

  • pk_<table> — chaves primárias
  • fk_<table>_<column> — chaves estrangeiras
  • uq_<table>_<column(s)> — restrições de unicidade
  • chk_<table>_<rule> — restrições de verificação (check constraints)

Combinar Restrições e Padrões Comuns

Na prática, as colunas carregam várias restrições ao mesmo tempo. Aqui estão padrões que usará repetidamente:

CREATE TABLE accounts (
    id         SERIAL       PRIMARY KEY,
    email      VARCHAR(255) NOT NULL,
    role       VARCHAR(20)  NOT NULL DEFAULT 'user'
                   CHECK (role IN ('user', 'admin', 'moderator')),
    balance    NUMERIC(12,2) NOT NULL DEFAULT 0.00
                   CHECK (balance >= 0),
    is_active  BOOLEAN      NOT NULL DEFAULT TRUE,
    created_at TIMESTAMPTZ  NOT NULL DEFAULT now(),
    deleted_at TIMESTAMPTZ           -- nullable: NULL means "not deleted"
);

Padrão de Soft-Delete

O deleted_at coluna acima implementa um eliminação lógica. Em vez de remover linhas, define deleted_at = now(). Combine isto com um índice único parcial para evitar duplicados "ativos", permitindo simultaneamente linhas eliminadas com o mesmo email. A tabela deliberadamente não tem uma restrição UNIQUE global no email; manter uma também rejeitaria duplicados entre as linhas eliminadas:

-- PostgreSQL: unique email only among active accounts
CREATE UNIQUE INDEX uq_accounts_active_email
    ON accounts (email)
    WHERE deleted_at IS NULL;

Armadilhas Comuns

  • NULL e UNIQUE: A maioria das bases de dados permite múltiplos NULL valores num UNIQUE coluna porque NULL não é igual a nada — incluindo a si próprio. O SQL Server é a exceção e trata NULL como um duplicado por predefinição; utilize um índice filtrado para contornar isto.
  • CHECK em MySQL mais antigo: Como referido acima, o MySQL anterior a 8.0.16 analisa mas ignora CHECK restrições. Valide a sua versão do MySQL ou imponha regras no código da aplicação.
  • Restrições diferidas: O PostgreSQL suporta a verificação diferida para chaves estrangeiras, restrições de unicidade, chave primária e exclusão declaradas DEFERRABLE INITIALLY DEFERRED. CHECK e NOT NULL não podem ser diferidos. Isto é útil para referências circulares, mas pode tornar a depuração mais difícil.
  • Desempenho de CHECK: Simples CHECK as restrições têm um overhead insignificante. Evite incorporar subconsultas ou chamadas de função em CHECK — podem nem sequer ser suportadas e podem ocultar lógica lenta.
  • Alterar restrições em tabelas grandes: A adicionar um NOT NULL a restrição no PostgreSQL pode exigir uma varredura de tabela, a menos que um CHECK validado existente prove que a coluna não contém nulos. Em tabelas muito grandes, considere adicionar uma CHECK (column IS NOT NULL) NOT VALID primeiro, e depois validando-o separadamente.

Reveja as restrições no SQL e no diagrama em conjunto no Editor SQL para ERD, depois valide o seu comportamento na base de dados de destino. Um diagrama não impõe a integridade dos Dados.

Referências e leitura adicional

Mais publicações