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 constraintSuggerimento: 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=1DEFAULT 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 primariefk_<table>_<column>— chiavi esterneuq_<table>_<column(s)>— vincoli univocichk_<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ù
NULLvalori in unUNIQUEcolonna perchéNULLnon è uguale a nulla — nemmeno a se stesso. SQL Server fa eccezione e trattaNULLcome 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
CHECKvincoli. 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
CHECKi vincoli hanno un sovraccarico trascurabile. Evita di incorporare sottoquery o chiamate a funzioni inCHECK— potrebbero persino non essere supportate e possono nascondere una logica lenta. - Modifica dei vincoli su tabelle di grandi dimensioni: Aggiunta di un
NOT NULLvincolo 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 unCHECK (column IS NOT NULL) NOT VALIDper 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.



