Riassunto - Operatori Relazionali

🛠️ Setup: Le Nostre Tabelle di Esempio

📋 Scenario

Database con Studenti, Corsi e Esame (tabella di collegamento).

👤 STUDENTI

id	nome	città	età
1	Mario	Roma	22
2	Laura	Milano	20
3	Luca	Roma	23
4	Anna	Napoli	21

📚 CORSI

id_corso	nome_corso	docente
101	Database	Rossi
102	Programmazione	Bianchi
103	Reti	Verdi
104	Yoga	Aldi

📝 ESAME

id_studente	id_corso	voto
1	101	28
1	102	30
2	101	25
3	103	27

📜 SQL - Creazione Tabelle

-- Creazione del database
CREATE DATABASE IF NOT EXISTS universita;
USE universita;

CREATE TABLE studenti (
    id INT PRIMARY KEY,
    nome VARCHAR(50),
    citta VARCHAR(50),
    eta INT
);

CREATE TABLE corsi (
    id_corso INT PRIMARY KEY,
    nome_corso VARCHAR(50),
    docente VARCHAR(50)
);

CREATE TABLE ESAME (
    id_studente INT,
    id_corso INT,
    voto INT,
    PRIMARY KEY (id_studente, id_corso),
    FOREIGN KEY (id_studente) REFERENCES studenti(id),
    FOREIGN KEY (id_corso) REFERENCES corsi(id_corso)
);

📌 Operatori Unari (su una sola tabella)

SELEZIONE (σ - sigma)

📖 Definizione

La selezione filtra le righe di una tabella in base a una condizione. Restituisce solo le tuple che soddisfano la condizione. Opera sulle RIGHE (orizzontalmente). Il numero di colonne resta invariato.

σ_condizione(Tabella)

🎯 Esempio: Studenti di Roma

STUDENTI

id	nome	città	età
1	Mario	Roma	22
2	Laura	Milano	20
3	Luca	Roma	23
4	Anna	Napoli	21

➜

✅ RISULTATO

id	nome	città	età
1	Mario	Roma	22
3	Luca	Roma	23

📜 MariaDB SQL

-- Selezione semplice
SELECT * FROM studenti WHERE citta = 'Roma';

-- Con AND: Roma E più di 21 anni
SELECT * FROM studenti
WHERE citta = 'Roma' AND eta > 21;

-- Con OR / IN: Roma o Milano
SELECT * FROM studenti
WHERE citta IN ('Roma', 'Milano');

PROIEZIONE (π - pi)

📖 Definizione

La proiezione seleziona solo alcune colonne dalla tabella, eliminando le altre. Opera sulle COLONNE (verticalmente). Il numero di righe può diminuire con DISTINCT.

π_{colonna1, colonna2}(Tabella)

🎯 Esempio: Solo nome e città degli studenti

✅ RISULTATO

nome	città
Mario	Roma
Laura	Milano
Luca	Roma
Anna	Napoli

📜 MariaDB SQL

-- Proiezione semplice
SELECT nome, citta FROM studenti;

-- Eliminare duplicati (come in algebra relazionale)
SELECT DISTINCT citta FROM studenti;
-- Risultato: Roma, Milano, Napoli (3 righe, non 4)

-- Combinazione Selezione + Proiezione: σ città='Roma' → π nome
SELECT nome FROM studenti WHERE citta = 'Roma';

🔗 Prodotto Cartesiano e JOIN

PRODOTTO CARTESIANO (×)

📖 Definizione

Combina ogni riga della prima tabella con ogni riga della seconda. Genera tutte le combinazioni possibili. Il computer non sa quali righe appartengono a chi: sarà poi compito del JOIN filtrare solo quelle dove gli ID corrispondono.

Studenti × ESAMI

STUDENTI

id	nome
1	Mario
2	Laura

ESAMI

id_studente	voto
1	28
2	30

RISULTATO (2 × 2 = 4 righe)

id	nome	id_studente	voto
1	Mario	1	28
1	Mario	2	30
2	Laura	1	28
2	Laura	2	30

👀 Chiave

Il JOIN è un Prodotto Cartesiano filtrato: elimina le righe dove gli ID non corrispondono e tiene solo quelle valide.

📜 MariaDB SQL

SELECT * FROM studenti CROSS JOIN esami;

INNER JOIN (Theta Join / Equi-Join) ⋈

📖 Definizione

Prodotto cartesiano filtrato da una condizione. Restituisce solo le righe dove la condizione è soddisfatta. JOIN e INNER JOIN sono equivalenti (la parola INNER è opzionale).

Tabella1 ⋈_condizione Tabella2

📌 Esempio 1: Join Base (Studenti → Esami)

✅ RISULTATO INNER JOIN (id = id_studente)

id	nome	id_studente	id_corso	voto
1	Mario	1	101	28
1	Mario	1	102	30
2	Laura	2	101	25
3	Luca	3	103	27

👀 Nota

Anna (id=4) non appare perché non ha esami. Mario appare 2 volte perché ha 2 esami.

📜 MariaDB SQL

-- INNER JOIN base
SELECT *
FROM studenti s
INNER JOIN esami e ON s.id = e.id_studente;

-- Equivalente (JOIN senza INNER = stesso risultato)
SELECT *
FROM studenti s
JOIN esami e ON s.id = e.id_studente;

📌 Esempio 2: Join tra 3 Tabelle

🎯 Nome studente, nome corso e voto (3 tabelle collegate).

📜 MariaDB SQL

SELECT s.nome, c.nome_corso, e.voto
FROM studenti s
JOIN esami e ON s.id = e.id_studente
JOIN corsi c ON e.id_corso = c.id;

📌 Esempio 3: Join con Condizioni Multiple (AND)

🎯 Abbinare dipendenti ai turni per reparto E sede.

📜 MariaDB SQL

-- Join su DUE colonne per evitare errori
SELECT d.nome, d.reparto, d.sede, t.giorno, t.orario
FROM dipendenti d
JOIN turni t
    ON d.reparto = t.reparto
    AND d.sede = t.sede;

📌 Esempio 4: Theta Join (condizione ≠ uguaglianza)

🎯 Prodotti nel budget del cliente (budget ≥ prezzo). Il Theta Join usa qualsiasi operatore (=, <, >, <=, >=, <>, LIKE, BETWEEN). L'Equi-Join è il caso particolare con "=".

📜 MariaDB SQL

SELECT c.nome AS cliente, c.budget, p.nome AS prodotto, p.prezzo
FROM clienti c
JOIN prodotti p ON c.budget >= p.prezzo;

📌 Esempio 5: Join + Filtro WHERE

⚠️ ON vs WHERE

ON: condizione per collegare le tabelle (relazione) | WHERE: filtro sui risultati (selezione)

📜 MariaDB SQL

-- Esami con voto >= 28 di studenti il cui nome inizia per 'M'
SELECT s.nome, e.voto
FROM studenti s
JOIN esami e ON s.id = e.id_studente
WHERE s.nome LIKE 'M%'
  AND e.voto >= 28;

LEFT JOIN ⟕

📖 Definizione

Restituisce tutte le righe della tabella di SINISTRA + le corrispondenze dalla destra. Se non c'è corrispondenza, le colonne della destra sono NULL.

🎯 Esempio: Tutti gli studenti CON i loro esami (anche chi non ha esami)

✅ RISULTATO LEFT JOIN

id	nome	id_corso	voto
1	Mario	101	28
1	Mario	102	30
2	Laura	101	25
3	Luca	103	27
4	Anna	NULL	NULL

👀 Nota

Anna appare! Anche senza esami, viene inclusa con NULL perché è nella tabella di SINISTRA.

📜 MariaDB SQL

-- LEFT JOIN: tutti gli studenti, anche senza esami
SELECT s.id, s.nome, i.id_corso, i.voto
FROM studenti s
LEFT JOIN iscrizioni i ON s.id = i.id_studente;

-- Trovare studenti SENZA esami (filtro su NULL)
SELECT s.*
FROM studenti s
LEFT JOIN iscrizioni i ON s.id = i.id_studente
WHERE i.id_studente IS NULL;

RIGHT JOIN ⟖

📖 Definizione

Restituisce tutte le righe della tabella di DESTRA + le corrispondenze dalla sinistra. Se non c'è corrispondenza, le colonne della sinistra sono NULL.

🎯 Esempio: Tutti i corsi con chi è iscritto (incluso Yoga senza iscritti)

✅ RISULTATO RIGHT JOIN

nome_corso	id_studente	voto
Database	1	28
Database	2	25
Programmazione	1	30
Reti	3	27
Yoga	NULL	NULL

📜 MariaDB SQL

-- RIGHT JOIN: tutti i corsi, anche senza iscritti
SELECT c.nome_corso, i.id_studente, i.voto
FROM iscrizioni i
RIGHT JOIN corsi c ON i.id_corso = c.id_corso;

-- Equivalente: LEFT JOIN invertendo l'ordine delle tabelle
SELECT c.nome_corso, i.id_studente, i.voto
FROM corsi c
LEFT JOIN iscrizioni i ON c.id_corso = i.id_corso;

💡 Consiglio Pratico

Scrivere iscrizioni RIGHT JOIN corsi è identico a scrivere corsi LEFT JOIN iscrizioni. In entrambi i casi il risultato contiene tutti i corsi (incluso Yoga) + le iscrizioni abbinate.

Per questo motivo, molti programmatori preferiscono usare sempre LEFT JOIN e, quando servirebbe RIGHT JOIN, invertono semplicemente l'ordine delle tabelle: invece di A RIGHT JOIN B scrivono B LEFT JOIN A — il risultato è identico ma la query è più leggibile.

FULL JOIN ⟗

📖 Definizione

Restituisce tutte le righe di ENTRAMBE le tabelle. Se non c'è corrispondenza, le colonne mancanti sono NULL. Nessun dato viene perso!

⚠️ MariaDB/MySQL NON supporta FULL JOIN!

Si simula con UNION di LEFT JOIN e RIGHT JOIN.

📜 MariaDB SQL - Simulazione FULL JOIN

SELECT s.id, s.nome, i.id_studente, i.id_corso, i.voto
FROM studenti s
LEFT JOIN iscrizioni i ON s.id = i.id_studente
UNION
SELECT s.id, s.nome, i.id_studente, i.id_corso, i.voto
FROM studenti s
RIGHT JOIN iscrizioni i ON s.id = i.id_studente;

-- In altri DBMS: SELECT * FROM studenti s FULL OUTER JOIN iscrizioni i ON s.id = i.id_studente;

📊 Riepilogo dei JOIN

JOIN

Solo righe con match in entrambe

LEFT JOIN

Tutto A + match da B (o NULL)

RIGHT JOIN

Match da A (o NULL) + tutto B

FULL JOIN

Tutto A + match + tutto B

NATURAL JOIN - Alternativa a JOIN...ON...

📖 Definizione

Join automatico (non serve ON): unisce le tabelle basandosi sulle colonne con lo stesso nome. Elimina automaticamente le colonne duplicate.

📜 MariaDB SQL

-- NATURAL JOIN: unisce automaticamente sulle colonne con lo stesso nome
SELECT * FROM studenti NATURAL JOIN voti;
-- Equivale a: JOIN voti ON studenti.id = voti.id

⚠️ Perché Evitare NATURAL JOIN

Problema	Conseguenza
Colonne omonime per coincidenza	Join su campi non correlati → risultati vuoti o errati
Schema che evolve	Query funzionanti oggi si rompono domani senza preavviso
Perdita dati silenziosa	Righe escluse senza errori, impossibile debuggare
Mancanza di chiarezza	Impossibile capire su quali colonne avviene il join leggendo la query

✅ Best Practice

Usa sempre JOIN esplicito con ON: è più verboso ma chiaro, prevedibile, manutenibile e sicuro.

Clausola USING - Alternativa a ON

📖 Definizione

Alternativa a ON per specificare le condizioni di join quando le colonne di collegamento hanno lo stesso nome in entrambe le tabelle. La colonna appare una sola volta nel risultato (più pulito).

⚠️ Attenzione: nomi diversi → niente USING!

Nel nostro setup, la tabella ESAME ha la colonna id_studente (chiave esterna), mentre STUDENTI ha id (chiave primaria). Avendo nomi diversi, USING non può essere usato — bisogna usare ON:

❌ Il nostro setup: nomi diversi → OBBLIGATORIO usare ON

-- STUDENTI ha la colonna "id", ESAME ha la colonna "id_studente"
-- I nomi sono diversi → non si può usare USING, serve ON
SELECT *
FROM studenti s
JOIN esame e ON s.id = e.id_studente;

📌 Quando USING funziona: colonne con lo STESSO nome

Se entrambe le tabelle hanno una colonna chiamata id che si riferisce alla stessa entità (es. l'id dello studente), allora USING è più pulito:

STUDENTI

id	nome
1	Mario
2	Laura

id = chiave primaria dello studente

VOTI

id	voto
1	28
1	30

id = chiave esterna → studente (stesso significato!)

⚖️ ON vs USING: confronto visivo

🔴 Risultato con ON

studenti.id	nome	voti.id	voto
1	Mario	1	28

❌ La colonna id appare due volte (valori identici → ridondanza)

🟢 Risultato con USING

id	nome	voto
1	Mario	28

✅ La colonna id appare una sola volta → più pulito

📜 MariaDB SQL

-- Metodo 1: JOIN con ON (funziona sempre, anche con nomi diversi)
SELECT * FROM studenti
JOIN voti ON studenti.id = voti.id;

-- Metodo 2: JOIN con USING (solo se la colonna ha lo STESSO nome in entrambe le tabelle)
SELECT * FROM studenti
JOIN voti USING (id);

-- USING con LEFT JOIN
SELECT * FROM studenti LEFT JOIN voti USING (id);

-- USING con PIÙ colonne (se entrambe le tabelle hanno col1 e col2)
SELECT * FROM tabella1
JOIN tabella2 USING (colonna1, colonna2);

📋 Quando Usare Cosa

Scenario	Clausola
Colonne con nomi diversi (es. `id` vs `id_studente`)	❌ ON (obbligatorio — USING darebbe errore)
Colonne con stesso nome e stesso significato	✅ USING (più pulito)
Condizioni complesse (AND/OR)	❌ ON (necessario)
Evitare colonne duplicate nel risultato	✅ USING (colonna mostrata una sola volta)

🎯 Operazioni Insiemistiche

📋 Requisito Fondamentale

Per UNION, INTERSECT e EXCEPT le tabelle devono essere union-compatibili: stesso numero di colonne e tipi compatibili.

STUDENTI_ROMA

id	nome
1	Mario
3	Luca

STUDENTI_DB

id	nome
1	Mario
2	Laura

UNIONE (∪ - UNION)

📖 Definizione

Combina i risultati di due query, restituendo tutte le righe di entrambe senza duplicati (per default).

A ∪ B

STUDENTI_ROMA

id	nome
1	Mario
3	Luca

∪

STUDENTI_DB

id	nome
1	Mario
2	Laura

RISULTATO

id	nome
1	Mario
2	Laura
3	Luca

📜 MariaDB SQL

-- UNION: senza duplicati
SELECT * FROM studenti_roma
UNION
SELECT * FROM studenti_db;

-- UNION ALL: mantenendo i duplicati (Mario appare 2 volte)
SELECT * FROM studenti_roma
UNION ALL
SELECT * FROM studenti_db;

INTERSEZIONE (∩ - INTERSECT)

📖 Definizione

Restituisce solo le righe che appaiono in entrambe le query.

A ∩ B

STUDENTI_ROMA

id	nome
1	Mario
3	Luca

∩

STUDENTI_DB

id	nome
1	Mario
2	Laura

RISULTATO

id	nome
1	Mario

⚠️ MariaDB NON supporta INTERSECT direttamente!

Si simula con JOIN o subquery.

📜 MariaDB SQL - Simulazione INTERSECT

-- Con IN: trova studenti presenti in ENTRAMBE le tabelle
SELECT * FROM studenti_roma
WHERE id IN (SELECT id FROM studenti_db);

-- Con JOIN: alternativa più efficiente
SELECT a.* FROM studenti_roma a
JOIN studenti_db b ON a.id = b.id;

DIFFERENZA (− - EXCEPT)

📖 Definizione

Restituisce le righe che sono nella prima tabella ma NON nella seconda.

A − B

STUDENTI_ROMA

id	nome
1	Mario
3	Luca

−

STUDENTI_DB

id	nome
1	Mario
2	Laura

RISULTATO

id	nome
3	Luca

⚠️ MariaDB NON supporta EXCEPT direttamente!

Si simula con LEFT JOIN + WHERE NULL o NOT IN.

📜 MariaDB SQL - Simulazione EXCEPT

-- Con NOT IN: studenti presenti SOLO nella prima tabella
SELECT * FROM studenti_roma
WHERE id NOT IN (SELECT id FROM studenti_db);

-- Con LEFT JOIN + IS NULL: alternativa più efficiente
SELECT a.* FROM studenti_roma a
LEFT JOIN studenti_db b ON a.id = b.id
WHERE b.id IS NULL;

📋 Riepilogo Completo

σ SELEZIONE

Filtra righe

WHERE condizione

π PROIEZIONE

Seleziona colonne

SELECT col1, col2

× PRODOTTO CARTESIANO

Tutte le combinazioni possibili

CROSS JOIN

⋈ INNER JOIN

Solo righe con match in entrambe

JOIN ... ON

NATURAL JOIN

Join automatico (⚠️ pericoloso)

NATURAL JOIN

USING

Join su colonne con stesso nome

JOIN ... USING(col)

⟕ LEFT JOIN

Tutto A + match B (o NULL)

LEFT JOIN ... ON

⟖ RIGHT JOIN

Match A (o NULL) + tutto B

RIGHT JOIN ... ON

⟗ FULL JOIN

Tutto A + tutto B (simulato)

LEFT UNION RIGHT

∪ UNIONE

Combina righe di A e B

UNION / UNION ALL

∩ INTERSEZIONE

Righe in comune (simulato)

IN / JOIN

− DIFFERENZA

Righe di A non in B (simulato)

NOT IN / LEFT JOIN + IS NULL

📜 Cheat Sheet Completo

-- ═══════════════════════════════════════════════════════════
--              OPERATORI RELAZIONALI - MARIADB
-- ═══════════════════════════════════════════════════════════

-- SELEZIONE (σ) - filtra righe
SELECT * FROM tabella WHERE condizione;

-- PROIEZIONE (π) - seleziona colonne
SELECT col1, col2 FROM tabella;
SELECT DISTINCT col1 FROM tabella;  -- senza duplicati

-- PRODOTTO CARTESIANO (×)
SELECT * FROM A CROSS JOIN B;
SELECT * FROM A, B;  -- equivalente

-- INNER JOIN (⋈) - solo match
SELECT * FROM A JOIN B ON A.id = B.id;

-- JOIN con USING - quando le colonne hanno lo stesso nome
SELECT * FROM A JOIN B USING (id);

-- NATURAL JOIN - join automatico (sconsigliato)
SELECT * FROM A NATURAL JOIN B;

-- LEFT JOIN (⟕) - tutto A + match B
SELECT * FROM A LEFT JOIN B ON A.id = B.id;

-- RIGHT JOIN (⟖) - match A + tutto B (equivale a B LEFT JOIN A)
SELECT * FROM A RIGHT JOIN B ON A.id = B.id;

-- FULL JOIN (⟗) - simulato in MariaDB
SELECT * FROM A LEFT JOIN B ON A.id = B.id
UNION
SELECT * FROM A RIGHT JOIN B ON A.id = B.id;

-- UNIONE (∪)
SELECT * FROM A UNION SELECT * FROM B;       -- senza duplicati
SELECT * FROM A UNION ALL SELECT * FROM B;   -- con duplicati

-- INTERSEZIONE (∩) - simulata in MariaDB
SELECT * FROM A WHERE id IN (SELECT id FROM B);

-- DIFFERENZA (−) - simulata in MariaDB
SELECT * FROM A WHERE id NOT IN (SELECT id FROM B);
SELECT A.* FROM A LEFT JOIN B ON A.id = B.id WHERE B.id IS NULL;