Torna a tutte le guide
SQL··7 min di lettura

Vincoli SQL spiegati: NOT NULL, UNIQUE, CHECK, DEFAULT e altri

Padroneggia i vincoli SQL per proteggere l'integrità dei dati. Impara NOT NULL, UNIQUE, CHECK, DEFAULT, PRIMARY KEY e FOREIGN KEY con esempi chiari.

Tabella prodotti con NOT NULL, UNIQUE, CHECK sul prezzo non negativo e DEFAULT zero
In questa guida
  1. Cosa sono i vincoli SQL?
  2. NOT NULL
  3. UNIQUE
  4. CHECK
  5. DEFAULT
  6. Vincoli PRIMARY KEY e FOREIGN KEY
  7. Vincoli a livello di colonna vs a livello di tabella
  8. Vincoli denominati e perché sono importanti
  9. Combinazione di vincoli e pattern comuni
  10. Problemi comuni
  11. Riferimenti e letture aggiuntive

Gli esempi SQL utilizzano PostgreSQL a meno che non sia specificato un altro dialetto. Brevi frammenti presuppongono che le tabelle a cui fanno riferimento esistano già. Convalida il DDL nel tuo database di destinazione prima di applicarlo.

Cosa sono i vincoli SQL?

Vincoli sono regole imposte dal motore del database per garantire l'accuratezza e l'affidabilità dei Dati in una tabella. Agiscono come barriere di protezione — impedendo inserimenti, aggiornamenti ed eliminazioni non validi al limite del database. Proteggono le regole dichiarate; la validazione dell'applicazione e la progettazione delle transazioni contano ancora.

L'SQL definisce diversi tipi di vincoli. In questa guida li esamineremo ciascuno in dettaglio, mostreremo quando usarli e evidenzieremo le insidie più comuni.

NOT NULL

Il NOT NULL vincolo assicura che una colonna abbia sempre un valore. Qualsiasi INSERT o UPDATE che tenta di impostare la colonna su NULL verrà rifiutato. Una stringa vuota è comunque un valore; aggiungi un CHECK quando il testo vuoto è vietato.

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

Suggerimento: Predefinito a NOT NULL per ogni colonna e rimuovilo solo quando hai una chiara ragione aziendale per consentire i valori nulli. I valori nulli introducono una logica a tre valori nelle query e sono una fonte comune di bug sottili.

UNIQUE

A UNIQUE vincolo garantisce che non ci siano due righe contenenti lo stesso valore nella colonna vincolata (o combinazione di colonne). A differenza di una chiave primaria, un UNIQUE colonna può contenere NULL. PostgreSQL e MySQL normalmente consentono più valori null in una colonna unica; SQL Server ne consente uno in un vincolo unico a colonna singola. Questa è una regola di unicità, non il risultato della valutazione di 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)
);

Quello multicolonna UNIQUE vincolo sopra assicura che la stessa stanza non possa essere prenotata due volte nella stessa data.

CHECK

CHECK i vincoli convalidano che un valore soddisfi un'espressione booleana prima di essere memorizzato. Applicano regole a livello di riga che il solo sistema di tipi non può esprimere. Un CHECK accetta TRUE o UNKNOWN; combinalo con NOT NULL quando un valore è obbligatorio.

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)
);

Attenzione: Nelle versioni di MySQL precedenti alla 8.0.16,CHECK i vincoli vengono analizzati ma ignorato senza segnalazione. Verifica sempre che la versione del tuo database le applichi effettivamente.

DEFAULT

Il DEFAULT fornisce un valore quando una colonna viene omessa da un'istruzione INSERT o DEFAULT è richiesto esplicitamente. Un NULL esplicito non invoca il valore predefinito. I valori predefiniti riducono il codice boilerplate nell'applicazione e rendono gli schemi auto-documentanti.

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 con espressioni

PostgreSQL e SQL Server consentono espressioni e chiamate di funzione nei valori predefiniti. MySQL lo supporta dalla versione 8.0.13 per alcuni tipi.

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

Vincoli PRIMARY KEY e FOREIGN KEY

Questi sono i vincoli maggiormente strutturali nei database relazionali. Un PRIMARY KEY identifica in modo univoco ogni riga e aggiunge implicitamente NOT NULL + UNIQUE. Un FOREIGN KEY collega una tabella a un'altra e impone l'integrità referenziale.

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
);

Consulta la nostra guida approfondita su Chiavi primarie vs Chiavi esterne per azioni a cascata, chiavi composite e buone pratiche. Puoi anche modellare visivamente queste relazioni nell' Editor di Erd Go.

Vincoli a livello di colonna vs a livello di tabella

I vincoli possono essere definiti inline (a livello di colonna) o come clausola separata dopo tutte le colonne (a livello di tabella). Il risultato è identico, ma il livello di tabella è obbligatorio quando il vincolo si estende su più colonne.

-- 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)
);

Vincoli denominati e perché sono importanti

Dai sempre un nome esplicito ai tuoi vincoli usando il CONSTRAINT parola chiave. Quando un vincolo viene violato, il database restituisce il nome del vincolo nel messaggio di errore — un nome significativo come chk_positive_salary è infinitamente più utile di un hash generato 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;

Una convenzione di denominazione coerente rende le migrazioni, il debug e l'inserimento nel team molto più fluidi. Un pattern comune è:

  • pk_<table> — chiavi primarie
  • fk_<table>_<column> — chiavi esterne
  • uq_<table>_<column(s)> — vincoli univoci
  • chk_<table>_<rule> — vincoli CHECK

Combinazione di vincoli e pattern comuni

In pratica, le colonne presentano diversi vincoli contemporaneamente. Ecco i modelli che userai ripetutamente:

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"
);

Pattern Soft-Delete

Il deleted_at colonna sopra implementa un eliminazione logica. Invece di rimuovere righe, imposti deleted_at = now(). Abbina questo a un indice unico parziale per prevenire duplicati "attivi" consentendo comunque righe eliminate con la stessa email. La tabella deliberatamente non ha alcun vincolo UNIQUE globale sull'email; mantenerne uno rifiuterebbe anche i duplicati tra le righe eliminate:

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

Problemi comuni

  • NULL e UNIQUE: La maggior parte dei database consente più NULL valori in un UNIQUE colonna perché NULL non è uguale a nulla — nemmeno a se stesso. SQL Server fa eccezione e tratta NULL come duplicato per impostazione predefinita; usa un indice filtrato per aggirare questo problema.
  • CHECK nei MySQL più vecchi: Come notato sopra, MySQL precedente alla versione 8.0.16 analizza ma ignora CHECK vincoli. Verifica la versione di MySQL o applica le regole nel codice dell'applicazione.
  • Vincoli differiti: PostgreSQL supporta il controllo differito per vincoli di chiave esterna, univoci, chiave primaria ed esclusione dichiarati DEFERRABLE INITIALLY DEFERRED. CHECK e NOT NULL non possono essere posticipati. Questo è utile per i riferimenti circolari ma può rendere il debug più difficile.
  • Prestazioni di CHECK: Semplice CHECK i vincoli hanno un sovraccarico trascurabile. Evita di incorporare sottoquery o chiamate a funzioni in CHECK — potrebbero persino non essere supportate e possono nascondere una logica lenta.
  • Modifica dei vincoli su tabelle di grandi dimensioni: Aggiunta di un NOT NULL vincolo in PostgreSQL può richiedere una scansione della tabella a meno che un vincolo CHECK convalidato ed esistente non dimostri che la colonna non contiene valori nulli. Su tabelle molto grandi, considera di aggiungere un CHECK (column IS NOT NULL) NOT VALID per prima cosa, per poi convalidarlo separatamente.

Rivedi i vincoli nel SQL e nel diagramma insieme nel Editor SQL a ERD, quindi convalida il loro comportamento nel database di destinazione. Un diagramma non applica l'integrità dei dati.

Riferimenti e letture aggiuntive

Altri post