Errori tipici quando si lavora con le foreign key

Siamo tutti umani, e sbagliare è normale. Soprattutto quando si tratta delle sottigliezze delle foreign key nei database. In questa lezione ti aiuterò a evitare gli errori e le trappole più comuni. Un buon database è come un ponte solido: se sbagli qualcosa, tutta la struttura può crollare. Vediamo insieme come tenere in ordine i "ponti dei dati".

Errore 1: Mancanza di indice sulla foreign key

Quando aggiungi una foreign key, stai dicendo al database: "Collega queste tabelle tra loro". Però, se non crei esplicitamente un indice su quella foreign key, quando fai query complesse sulle tabelle collegate, le performance possono andare a picco.

Esempio del problema:

CREATE TABLE customers (
    customer_id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id)
);

A prima vista sembra tutto ok: tabelle create, foreign key presente. Ma se fai una query tipo:

SELECT * 
FROM orders 
JOIN customers ON orders.customer_id = customers.customer_id;

su grandi quantità di dati questa query può essere lentissima, perché PostgreSQL non trova un indice adatto per ottimizzare il join.

Come evitarlo:

Crea sempre un indice sulla colonna a cui punta la foreign key. A volte PostgreSQL lo fa da solo, ma meglio essere sicuri.

CREATE INDEX idx_customer_id ON orders(customer_id);

Errore 2: Sequenza sbagliata nella creazione delle tabelle

Immagina di creare le tabelle ma provare ad aggiungere una foreign key prima che esista la tabella a cui fai riferimento. PostgreSQL si ribella e ti lancia errori, perché non trova la tabella di destinazione.

Esempio del problema:

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id)
);

-- Ops, dov'è la tabella customers?..
CREATE TABLE customers (
    customer_id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

Risultato: PostgreSQL lancia un errore, perché la tabella customers non esiste ancora.

Come evitarlo:

Crea prima le tabelle a cui fai riferimento, poi aggiungi le foreign key. L'ordine conta! Ecco il modo giusto:

CREATE TABLE customers (
    customer_id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id)
);

Errore 3: Errori di sintassi nelle operazioni di cascata

Le foreign key spesso hanno opzioni come ON DELETE CASCADE o ON UPDATE RESTRICT. Ma se ti dimentichi di scrivere bene queste regole, il database può comportarsi in modo strano. Per esempio, cancellare dati in una tabella non si rifletterà sulle tabelle dipendenti.

Esempio del problema:

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id) ON DELETE CASCADEE
);

Un occhio attento nota subito il typo — la parola CASCADEE è scritta male. PostgreSQL non te la fa passare liscia.

Come evitarlo:

Scrivere bene è metà della vittoria. Se hai dubbi, controlla sempre la documentazione ufficiale di PostgreSQL.

Errore 4: Violazione dell'integrità dei dati

L'integrità dei dati è sacra in ogni database, e le foreign key aiutano a mantenerla. Ma a volte capita di dimenticare la foreign key, e tutto va storto.

Esempio del problema:

CREATE TABLE customers (
    customer_id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT
);

-- Inseriamo dati
INSERT INTO orders (customer_id) VALUES (999);

Qui abbiamo aggiunto un ordine per un cliente che non esiste. Questo rompe l'integrità dei dati e quell'ordine resta "appeso".

Come evitarlo:

Usa sempre le foreign key per evitare che una tabella punti a record inesistenti. Ecco la versione corretta:

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id)
);

Ora, se provi a inserire un record "appeso", otterrai un errore.

Errore 5: Soppressione degli errori delle foreign key

A volte gli sviluppatori cercano di forzare l'inserimento di dati incompatibili usando INSERT ... ON CONFLICT. Sembra una buona idea, ma con le foreign key può portare a risultati inaspettati.

Esempio del problema:

INSERT INTO orders (order_id, customer_id)
VALUES (1, 999)
ON CONFLICT DO NOTHING;

Risultato: i dati non vengono inseriti, ma il database non ti dice perché. Perdi il controllo della situazione.

Come evitarlo:

Se usi ON CONFLICT, controlla sempre i dati prima. Per esempio:

INSERT INTO orders (order_id, customer_id)
SELECT 1, 999
WHERE EXISTS (
    SELECT 1 FROM customers WHERE customer_id = 999
);

Errore 6: Eliminazione di record dipendenti senza ON DELETE

Se elimini un record dalla tabella a cui punta una foreign key, ma non hai impostato ON DELETE CASCADE, i record dipendenti restano nel database, rompendo il senso delle relazioni.

Esempio del problema:

DELETE FROM customers WHERE customer_id = 1;
-- I record in orders con customer_id = 1 restano ancora.

Come evitarlo:

Aggiungi ON DELETE CASCADE così i record collegati vengono eliminati automaticamente:

CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    customer_id INT REFERENCES customers(customer_id) ON DELETE CASCADE
);

Ora, quando elimini un cliente, anche i suoi ordini spariscono.

Errore 7: Difficoltà con le relazioni MANY-TO-MANY

Quando lavori con relazioni MANY-TO-MANY a volte ci si dimentica di aggiungere una primary key composta o un indice sulla tabella di collegamento.

Esempio del problema:

CREATE TABLE enrollments (
    student_id INT REFERENCES students(student_id),
    course_id INT REFERENCES courses(course_id)
);

-- Ops! Abbiamo dimenticato la PRIMARY KEY.

Come evitarlo:

Aggiungi una primary key composta o un indice unico:

CREATE TABLE enrollments (
    student_id INT REFERENCES students(student_id),
    course_id INT REFERENCES courses(course_id),
    PRIMARY KEY (student_id, course_id)
);

Errore 8: Riferimenti ciclici

I riferimenti ciclici si verificano quando due tabelle si puntano a vicenda con le foreign key. Questo crea un circolo vizioso e problemi nell'inserimento dei dati.

Esempio del problema:

CREATE TABLE table_a (
    id SERIAL PRIMARY KEY,
    table_b_id INT REFERENCES table_b(id)
);

CREATE TABLE table_b (
    id SERIAL PRIMARY KEY,
    table_a_id INT REFERENCES table_a(id)
);

Come evitarlo:

Usa DEFERRABLE INITIALLY DEFERRED così PostgreSQL può controllare l'integrità dei dati dopo la fine della transazione:

CREATE TABLE table_a (
    id SERIAL PRIMARY KEY,
    table_b_id INT REFERENCES table_b(id) DEFERRABLE INITIALLY DEFERRED
);

Gli errori con le foreign key non solo rallentano lo sviluppo, ma possono causare grossi problemi ai dati. Usa questa lista come promemoria per evitare le trappole più comuni. Ricorda: la foreign key è tua alleata, non un nemico. L'importante è usarla bene, e il tuo database sarà una base solida per qualsiasi progetto a lungo termine.