Database SQL

Da ER a MySQL: Il Tuo Percorso Completo

Dal diagramma ER al database MySQL: relazioni Uno-a-Molti, Molti-a-Molti, Uno-a-Uno, JOIN, foreign key e query di aggregazione.

Descrizione del corso

Dal foglio di carta al database — come si fa davvero

Progettare un database non vuol dire solo scrivere CREATE TABLE. Significa capire le relazioni tra i dati, modellarle in un diagramma ER e poi tradurle correttamente in SQL. In questo percorso completo facciamo esattamente questo: partiamo dagli schemi Entity-Relationship e arriviamo a MySQL con JOIN, foreign key e query di analisi.

Cosa imparerai

  • Analisi delle entità e creazione del database MySQL
  • Tipi di colonna: NOT NULL, UNIQUE, PRIMARY KEY e AUTO INCREMENT
  • Relazione Uno a Molti: modello ER, simulazione in Excel, traduzione SQL e JOIN
  • Relazione Molti a Molti: tabella di appoggio, attributi aggiuntivi e JOIN avanzati
  • Relazione Uno ad Uno: casi d'uso reali, implementazione SQL e LEFT/RIGHT JOIN
  • Integrità referenziale, Foreign Key e ON DELETE CASCADE
  • Query Language: SELECT, WHERE, ORDER BY, BETWEEN, funzioni di aggregazione COUNT/AVG/SUM/MIN/MAX
  • GROUP BY, HAVING e DISTINCT per analisi e raggruppamenti

A chi è rivolto

A studenti, sviluppatori e chiunque lavori con i dati e voglia capire davvero come si progetta un database relazionale — non solo come si scrivono le query, ma perché il database è strutturato in quel modo.

La simulazione in Excel

Prima di scrivere SQL, per ogni tipo di relazione simuliamo in Excel cosa succederebbe con i dati senza un database corretto. È un approccio che rende tutto molto più concreto: vedi il problema prima di vedere la soluzione SQL.

Elenco delle lezioni

Partiamo dall'inizio: analizziamo insieme l'entità Studente come primo esempio concreto, creiamo il database MySQL con CREATE DATABASE e vediamo come gestirlo correttamente con DROP DATABASE IF EXISTS per evitare errori nelle sessioni successive.

Guarda lezione

Creiamo la prima tabella MySQL e approfondiamo due vincoli fondamentali: NOT NULL per rendere un campo obbligatorio e UNIQUE per garantire che non esistano due record con lo stesso valore in una colonna — con esempi pratici su dati reali come email e codice fiscale.

Guarda lezione

Approfondiamo la gestione delle chiavi univoche in MySQL: vediamo la differenza tra un vincolo UNIQUE su singola colonna e una PRIMARY KEY, come modificare una tabella esistente con ALTER TABLE e perché ogni tabella deve avere un identificatore univoco non modificabile.

Guarda lezione

Vediamo le Primary Key AUTO INCREMENT in MySQL: come definirle nella CREATE TABLE, come MySQL assegna automaticamente un valore crescente a ogni nuovo record, inseriamo i primi dati con INSERT INTO e verifichiamo il comportamento dell'auto-incremento con SELECT.

Guarda lezione

Introduco la relazione Uno a Molti nel diagramma Entity Relationship: ti spiego il concetto con un esempio concreto (un corso con molti studenti), come si rappresenta graficamente nel diagramma ER e quali regole determinano il verso della cardinalità tra le entità.

Guarda lezione

Prima di scrivere SQL, simuliamo in Excel come si gestirebbe una relazione Uno a Molti senza un database relazionale: vediamo i problemi di ridondanza, le difficoltà di aggiornamento e perché questa simulazione rende immediatamente chiaro il valore delle foreign key.

Guarda lezione

Ti mostro come tradurre in SQL una relazione Uno a Molti: creiamo le due tabelle in MySQL, definiamo la foreign key nella tabella figlia con REFERENCES e inseriamo dati con INSERT INTO rispettando i vincoli di integrità referenziale tra le tabelle.

Guarda lezione

Vediamo come interrogare due tabelle collegate da una relazione Uno a Molti con INNER JOIN: ti spiego la sintassi, come specificare la condizione di join sulla foreign key e come usare gli alias per rendere le query più leggibili quando i nomi delle colonne si ripetono.

Guarda lezione

Esploriamo le differenze tra LEFT JOIN, RIGHT JOIN e INNER JOIN in una relazione Uno a Molti: ti spiego quando usare ciascun tipo di join, cosa succede ai record senza corrispondenza nell'altra tabella e come leggere i risultati con valori NULL nei campi non abbinati.

Guarda lezione

Ti spiego l'integrità referenziale in MySQL: cosa garantisce una foreign key, cosa succede se si tenta di eliminare un record padre con figli collegati e come configurare ON DELETE CASCADE per propagare automaticamente la cancellazione alle righe dipendenti.

Guarda lezione

Introduco la relazione Molti a Molti nel diagramma ER: ti spiego quando si usa (studenti e corsi, prodotti e ordini), come si rappresenta nel diagramma e perché non è possibile implementarla direttamente in SQL senza una tabella di appoggio intermedia.

Guarda lezione

Simuliamo in Excel una relazione Molti a Molti senza tabella di appoggio: vediamo i problemi concreti che emergono — duplicazione dei dati, impossibilità di mantenere l'integrità e difficoltà di aggiornamento — così da capire subito perché la soluzione SQL è strutturata in quel modo.

Guarda lezione

Traduciamo in SQL la relazione Molti a Molti: creiamo la tabella di appoggio (junction table) con due foreign key che puntano alle tabelle principali, definiamo la chiave primaria composta e inseriamo dati di esempio per verificare il funzionamento dei vincoli.

Guarda lezione

Eseguiamo operazioni JOIN in una relazione Molti a Molti: ti mostro come combinare le tre tabelle con due INNER JOIN in sequenza per estrarre i dati correlati, e come usare alias e ORDER BY per rendere i risultati chiari e ordinati.

Guarda lezione

Vediamo LEFT JOIN, RIGHT JOIN e FULL JOIN in una relazione Molti a Molti: ti mostro come variano i risultati quando un record non ha corrispondenza nella tabella di appoggio, con esempi pratici che chiariscono il comportamento dei NULL nelle query multi-tabella.

Guarda lezione

Scopriamo come arricchire la tabella di appoggio di una relazione Molti a Molti con attributi aggiuntivi: ti spiego perché certi dati appartengono alla relazione e non alle entità, come aggiungerli nella junction table e come recuperarli nelle query JOIN.

Guarda lezione

Introduco la relazione Uno ad Uno nel diagramma ER: ti spiego i casi d'uso reali dove un record di una tabella corrisponde a esattamente un record di un'altra (es. utente e profilo), come si rappresenta graficamente e quando conviene usarla invece di unire le colonne in una sola tabella.

Guarda lezione

Simuliamo in Excel una relazione Uno ad Uno per rendere concreto il problema prima di passare a SQL: vediamo come i dati si collegano, perché tenerli separati ha senso in certi scenari e come questa simulazione aiuta a comprendere la struttura che creeremo in MySQL.

Guarda lezione

Traduciamo in SQL la relazione Uno ad Uno in MySQL: creiamo la tabella secondaria con una foreign key verso la tabella principale e aggiungiamo il vincolo UNIQUE su quella colonna per garantire che ogni record possa essere collegato a uno e un solo record dell'altra tabella.

Guarda lezione

Concludiamo il percorso sulle relazioni Uno ad Uno applicando LEFT JOIN e RIGHT JOIN: ti mostro come interrogare le due tabelle per estrarre record con e senza corrispondenza, come interpretare i NULL nel risultato e quando ogni tipo di join restituisce esattamente ciò che ti serve.

Guarda lezione

Vediamo le query di lettura in MySQL: come usare SELECT con la proiezione delle colonne, filtrare i risultati con WHERE combinando condizioni AND e OR, ordinare i dati con ORDER BY e applicare il filtro per intervalli di date con l'operatore BETWEEN.

Guarda lezione

Scopriamo le funzioni di aggregazione di MySQL: ti mostro come usare COUNT per contare i record, AVG per calcolare la media, SUM per sommare valori, MIN e MAX per trovare il minimo e il massimo, con query concrete su dataset reali.

Guarda lezione

Ti spiego come raggruppare i risultati in MySQL con GROUP BY: vediamo come combinarlo con COUNT, SUM e AVG per produrre statistiche per categoria, con esempi pratici che mostrano come passare da dati grezzi a informazioni aggregate e leggibili.

Guarda lezione

Impariamo a filtrare i risultati dopo un'aggregazione con HAVING — la clausola che fa ciò che WHERE non può fare sui dati raggruppati — e a usare DISTINCT per eliminare i valori duplicati da una SELECT, con esempi che chiariscono quando usare l'uno e quando l'altro.

Guarda lezione
Giovanni Pace

Giovanni Pace

Ingegnere Informatico · Pratola Peligna

  • 107 Corsi
Mi presento brevemente

Sono un ingegnere informatico con oltre 15 anni di esperienza nel settore ICT. Mi occupo di sviluppo software, cybersecurity, data science e intelligenza artificiale, con particolare attenzione all’innovazione e all’automazione dei processi aziendali. Da anni svolgo anche attività di docenza e formazione, creando percorsi pratici e coinvolgenti su programmazione, DevOps, AI e sicurezza informatica.

Questo corso include

  • Lezioni 24
  • Durata 3h 13m
  • Difficoltà base
  • Lingua it
  • Certificato No

Visti di recente