Aggiunta di constraints quando crei le tabelle: NOT NULL, UNIQUE

I dati possono essere tanti, ma non tutti sono utili. Per non trasformare la tabella in una discarica, PostgreSQL ti permette di impostare dei constraints. Sono tipo delle regole semplici, così nessuno può scrivere numeri nel campo "nome" o lasciarlo vuoto.

Che cosa sono i constraints?

I constraints in PostgreSQL sono come le regole di comportamento nell'esercito. Se non ci sono, ognuno fa quello che vuole: puoi mettere l'età dell'utente come -999, aggiungere una stringa vuota invece del nome o registrare due volte lo stesso studente con id diversi. Per evitare tutto questo, PostgreSQL ti offre dei meccanismi di controllo chiamati constraints.

I constraints ti permettono di:

1. Far sì che i tuoi dati restino validi e coerenti.
2. Assicurarti che i dati rispettino certe regole (tipo: l'età di una persona non può essere negativa).
3. Velocizzare la ricerca degli errori se i dati non sono come ti aspetti.

Oggi vediamo i due constraints più usati: NOT NULL e UNIQUE.

Constraint NOT NULL

Il constraint NOT NULL dice a PostgreSQL: "Ehi, questo campo deve sempre avere un valore. Niente indecisioni qui!". Se provi ad aggiungere una riga con NULL in questo campo, PostgreSQL ti darà errore. È super utile per i campi obbligatori, tipo il nome o la data di nascita di uno studente.

Esempio di utilizzo di NOT NULL

CREATE TABLE teachers (
    id SERIAL PRIMARY KEY,          -- Identificatore univoco
    name VARCHAR(100) NOT NULL,     -- Nome del docente (obbligatorio)
    subject VARCHAR(50) NOT NULL    -- Materia che insegna (obbligatorio)
);

In questo esempio le colonne name e subject non possono essere vuote. Se provi a inserire una riga senza questi valori, avrai un errore.

INSERT INTO teachers (name, subject)
VALUES (NULL, 'Matematica');

Risultato: errore! Non hai inserito il nome del docente, e name richiede un valore.

Constraint UNIQUE: serve unicità

Il constraint UNIQUE garantisce che i valori in una colonna o in una combinazione di colonne non si ripetano. È utile, per esempio, se vuoi essere sicuro che due studenti non abbiano lo stesso numero di libretto.

Se NOT NULL è come dire "tutti gli ospiti devono essere vestiti", UNIQUE è "niente vestiti uguali alla festa".

Esempio di utilizzo di UNIQUE

CREATE TABLE departments (
    id SERIAL PRIMARY KEY,      -- Identificatore univoco
    name VARCHAR(100) UNIQUE    -- Il nome del dipartimento deve essere unico
);

Ora non puoi aggiungere due dipartimenti con lo stesso nome.

INSERT INTO departments (name) VALUES ('Matematica');
INSERT INTO departments (name) VALUES ('Matematica');

Risultato: errore! Hai provato a inserire una riga con un valore duplicato nella colonna name.

Constraint UNIQUE combinato

Puoi anche impostare l'unicità su una combinazione di due (o più) colonne. Per esempio:

CREATE TABLE enrollments (
    id SERIAL PRIMARY KEY,          -- Identificatore univoco per la riga
    student_id INTEGER NOT NULL,    -- Identificatore dello studente
    course_id INTEGER NOT NULL,     -- Identificatore del corso
    UNIQUE (student_id, course_id)  -- Uno studente non può iscriversi due volte allo stesso corso
);

Ora ogni coppia student_id e course_id deve essere unica. Se qualcuno prova a iscrivere due volte lo stesso studente allo stesso corso, PostgreSQL lo blocca.

Combinare constraints: NOT NULL e UNIQUE

Puoi combinare NOT NULL e UNIQUE su una colonna. Per esempio:

CREATE TABLE users (
    username VARCHAR(50) NOT NULL UNIQUE, -- Login unico, obbligatorio
    email VARCHAR(100) NOT NULL UNIQUE -- Email unica, obbligatoria
);

Qui login ed email devono essere unici e non possono essere vuoti.

Errori tipici con i constraints

Se usi UNIQUE su una colonna ma non aggiungi NOT NULL, puoi inserire più righe con valori NULL, perché PostgreSQL considera che NULL non è uguale a un altro NULL. Se vuoi vietare i valori vuoti, aggiungi anche NOT NULL.

Se provi a inserire un valore duplicato in una colonna con UNIQUE, avrai errore. Controlla sempre i dati prima di fare INSERT.

Usare troppi constraints può rallentare le operazioni di inserimento.

Perché serve tutto questo?

Usare i constraints ti evita un sacco di problemi, tipo dati duplicati, righe vuote e altri errori che possono capitare per sbaglio umano. Rendono il tuo database "auto-protetto", e nei progetti grandi ti fanno risparmiare un sacco di tempo. Ai colloqui spesso chiedono dei constraints, quindi sapere NOT NULL e UNIQUE non è solo utile, ma può anche impressionare i futuri datori di lavoro.

Nella prossima lezione vediamo il constraint DEFAULT, che ti permette di impostare valori di default per le colonne se l'utente non scrive niente. Ci vediamo!