Imparare SQL: un’introduzione con esempi

La sintassi del linguaggio di programmazione SQL si basa sull’algebra relazionale e quindi si differenzia da altri linguaggi di programmazione per molti aspetti. Per imparare SQL, la conoscenza di questa sintassi e gli esempi illustrativi sono estremamente utili.

Nozioni di base sulla sintassi SQL

In generale, la sintassi è la “scrittura” di un linguaggio di programmazione, che determina quali tipi di costrutti di base del codice esistono e come possono essere collegati tra loro. La sua comprensione è un prerequisito fondamentale per leggere e scrivere codice nel rispettivo linguaggio.

I costrutti sintattici più importanti di SQL sono le dichiarazioni SQL e le clausole che possono contenere. Anche se tecnicamente non è del tutto corretto, entrambe vengono generalmente indicate come “comandi SQL”. Esistono inoltre altri costrutti sintattici, che presentiamo per chiarezza:

Termine Equivalente inglese Spiegazione Esempio
Dichiarazione Statement Dichiara che DBMS deve eseguire un’azione; termina con un punto e virgola CREATE TABLE People;
Clausola Clause Modifica un’istruzione; può essere presente solo all’interno di dichiarazioni WHERE, HAVING
Espressione Expression Restituisce un valore quando viene valutato 6 * 7
Identificatore Identifier Nome di un oggetto, di una variabile o di una procedura del database; può essere qualificato o non qualificato dbname.tablename / tablename
Predicato Predicate Espressione che dà come risultato TRUE, FALSE o UNKNOWN Age < 42
Interrogazione Query Istruzione speciale; restituisce un insieme di record SELECT Name FROM People WHERE Age < 42;
Funzione Function Esegue uno o più valori; di solito crea un nuovo valore UPPER('text') -- Restituisce 'TEXT'
Commento Comment Serve per commentare il codice SQL; ignorato da RDBMS -- Commento fino alla fine della riga / /*Commento su più righe, se necessario*/
N.B.

I comandi SQL come SELECT e CREATE TABLE sono di solito scritti in maiuscolo. In realtà, però, SQL non distingue tra maiuscole e minuscole. Si tratta semplicemente di una convenzione ampiamente diffusa.

Come si esegue il codice SQL?

Il codice SQL si trova in file di testo sotto forma di codice sorgente e prende vita solo tramite un ambiente di esecuzione adatto. Il codice sorgente viene letto da un interprete SQL e tradotto in azioni di un RDBMS. Per farlo esistono due approcci di base:

  1. Esecuzione del codice SQL in una sessione interattiva

Questo approccio prevede che il codice SQL venga direttamente immesso o copiato in una finestra di testo, viene quindi eseguito e mostrato il risultato. Si ha ora la possibilità di adattare il codice ed eseguirlo nuovamente. Grazie a una veloce successione di manipolazione del codice e visualizzazione dei risultati, questo approccio è particolarmente adatto all’apprendimento e alla realizzazione di richieste complesse.

  1. Esecuzione del codice SQL come script

In questo approccio un intero file di codice sorgente viene eseguito riga per riga. L’utente riceve un riscontro solo alla fine dell’esecuzione. Questa procedura è l’ideale per automatizzare processi e importare backup di database MySQL con MySQL dump.

Interfaccia Spiegazione Esempi
Interfaccia a riga di comando (CLI) Interfaccia basata su testo; il codice SQL viene inserito ed eseguito, il risultato mostrato come testo mysql, psql, mysqlsh
Interfaccia grafica (GUI) Il codice SQL viene inserito nella finestra di testo e/o generato come reazione a un’interazione utente; successivamente, viene eseguito, il risultato espresso in tabelle phpMyAdmin, MySQL Workbench, HeidiSQL
Interfaccia di programmazione (API) Permette la comunicazione diretta con un RDBMS; il codice SQL viene incluso ed eseguito come stringa nel rispettivo linguaggio di programmazione; i risultati sono a disposizione per un ulteriore utilizzo come strutture di dati PHP Data Objects (PDO), Connector/J (Java), Connector/Python, C API

Costruire una gestione di prodotto con SQL a titolo di esempio

Il modo migliore per imparare un linguaggio di programmazione è usarlo. Di seguito creeremo un mini database e lo consulteremo con delle query. Per farlo ci serviremo di Online SQL interpreter del sito web sql.js. Apri il sito web nel link e sostituisci il codice inserito SQL con quello dei nostri esempi. Per visualizzare i risultati esegui il codice pezzo per pezzo.

Approccio di base per la costruzione di un database SQL

A titolo di esempio costruiremo una gestione di prodotto commerciale, la stessa che servirebbe per un negozio fisico o uno online. Stabiliamo velocemente qualche criterio:

  • Esiste una serie di prodotti e disponiamo di una determinata quantità di ciascuno di essi in magazzino.
  • La clientela fissa è composta da una moltitudine di persone.
  • Una cliente o un cliente effettua un ordine che può contenere più articoli.
  • Per ciascun ordine salviamo la data e la persona che l’ha creato così come il tipo e la quantità di articoli.

Innanzitutto, traduciamo questi obiettivi in una descrizione astratta e infine in codice SQL rispettando il seguente schema:

  1. Creazione di un modello
  2. Definizione dello schema
  3. Inserimento dei record
  4. Definizione di query

Creare un modello delle entità e delle relazioni

Il primo passaggio avviene sulla carta, ovvero si serve di strumenti di modellazione speciali. Raccogliamo informazioni sul sistema da modellare e ne astraiamo entità e relazioni. Spesso questo passaggio si concretizza in termini di Entity Relationship (ER) Diagram.

Quali entità esistono e come sono collegate tra loro? Le entità sono classi di cose. Nel nostro esempio della gestione dei prodotti si trovano le entità prodotto, cliente e ordine. Per ciascuna entità occorre una tabella. A causa delle peculiarità del modello relazionale si aggiungono ulteriori tabelle per modellare le relazioni. Per riconoscerlo e applicarlo correttamente è necessaria una certa esperienza.

La domanda centrale è come sono interconnesse le entità considerando entrambe le direzioni di una relazione e differenziando tra singolare e plurale. Ad esempio nella relazione persona–automobile:

  1. “A una persona appartengono potenzialmente diverse automobili”
  2. “Un’automobile appartiene solo a una persona”

Da due entità derivano tre possibili scenari relazionali:

Relazione Entità Da sinistra Da destra
Relazione 1:1 Automobile:targa “Un’automobile dispone esattamente di una targa” “Una targa appartiene solo a un’automobile”
Relazione 1:n Persona:automobile “A una persona appartengono potenzialmente diverse automobili” “Un’automobile appartiene solo a una persona”
Relazione m:n Automobile:strada “Un’automobile viaggia su più strade” “Su una strada viaggiano più automobili”

Implementare i prodotti

Per cominciare, implementiamo la tabella dei prodotti. Per farlo, definiamo uno schema, inseriamo i record ed eseguiamo un paio di query di prova. A seguire approfondiamo i singoli passaggi.

Definire lo schema

Il comando SQL centrale per definire le tabelle di database è CREATE TABLE. Questo comando genera una tabella con nome e stabilisce proprietà per le colonne. Allo stesso modo vengono definiti tipi di dati ed eventualmente limitazioni per i valori da salvare:

DROP TABLE IF EXISTS Products;
CREATE TABLE Products ( product_id int, product_name text, stocked int, price int );
sql
N.B.

Prima della definizione delle tabelle utilizziamo un’istruzione DROP TABLE IF EXISTS. Questa rimuove eventuali tabelle esistenti e permette di eseguire il medesimo codice SQL più volte senza provocare messaggi di errore.

Inserire record

Creiamo un paio di record di prova. Per farlo ci serviamo del comando SQL INSERT INTO e della funzione VALUES per riempire i campi:

INSERT INTO Products VALUES (10, 'ABC Product', 74, 1050);
INSERT INTO Products VALUES (20, 'KLM Product', 23, 750);
INSERT INTO Products VALUES (30, 'XYZ Product', 104, 350);
sql

Definire le query

Per verificare lo stato della tabella dei prodotti formuliamo una semplice interrogazione. Adoperiamo il comando SELECT FROM ed emettiamo l’intera tabella:

SELECT * FROM Products;
sql

In aggiunta compiliamo una query un po’ più complessa, che calcola il valore complessivo dei prodotti in magazzino:

SELECT product_name AS 'Name', (stocked * price) AS 'Value' FROM Products;
sql

Implementare le altre tabelle

Nel corso della procedura ci occupiamo delle restanti tabelle necessarie seguendo il medesimo approccio della tabella di prodotti. Prima creiamo una tabella clienti:

DROP TABLE IF EXISTS Customers;
CREATE TABLE Customers ( customer_id int, customer_name text, contact text );
sql

Vi inseriamo record per due esempi di clienti:

INSERT INTO Customers VALUES (100, 'EDC Customer', 'ED@example.com');
INSERT INTO Customers VALUES (200, 'WVU Customer', 'WV@example.com');
sql

Verifichiamo emettendo la tabella clienti:

SELECT * FROM Customers;
sql

Successivamente, formiamo la tabella ordini:

DROP TABLE IF EXISTS Orders;
CREATE TABLE Orders ( order_id int, customer_id int, order_date text );
sql

Inseriamo ora tre esempi di ordine. Osserva come al primo valore del record abbiamo assegnato un ID come chiave primaria. Per quanto riguarda il secondo valore, invece, si tratta di un ID cliente già esistente come chiave esterna. A questo punto salviamo le date degli ordini:

INSERT INTO Orders VALUES (1000, 100, '2022-05-03');
INSERT INTO Orders VALUES (1001, 100, '2022-05-04');
INSERT INTO Orders VALUES (1002, 200, '2022-05-08');
sql

Testiamo quindi gli ordini:

SELECT * FROM Orders;
sql

Infine, ci serve una tabella per i prodotti contenuti in un ordine, inclusa la quantità. Si tratta di una relazione m:n, poiché un ordine può contenere più articoli e un articolo può essere presente in più ordini. Definiamo la tabella contenente gli ID degli ordini e dei prodotti come chiavi esterne:

DROP TABLE IF EXISTS OrderItems;
CREATE TABLE OrderItems ( orderitem_id int, order_id int, product_id int, count int );
sql

Inseriamo un paio di prodotti ordinati scegliendo gli ID degli ordini e dei prodotti in modo tale che risulti un ordine con due prodotti e un altro ordine con un solo prodotto:

INSERT INTO OrderItems VALUES (10001, 1000, 10, 3);
INSERT INTO OrderItems VALUES (10002, 1000, 20, 2);
INSERT INTO OrderItems VALUES (10003, 1002, 30, 12);
sql

Verifichiamo emettendo i prodotti ordinati:

SELECT * FROM OrderItems;
sql

Formulare query complesse

Una volta eseguite le stringhe di codice mostrate, dovresti riuscire a capire la struttura del nostro database di prova. Passiamo ora a interrogazioni più complesse che mettono in evidenza la potenza di SQL. Per prima cosa formuliamo una query che riunisce dati diffusi su più tabelle. Utilizziamo il comando JOIN di SQL per collegare i dati della tabella clienti e quelli della tabella ordini. Diamo un nome ad alcune colonne e stabiliamo una corrispondenza degli ID clienti come condizione JOIN. Tieni presente che ci serviamo di identificatori qualificati per distinguere tra le due tabelle:

SELECT customers.customer_name as 'Customer', customers.customer_id, orders.order_id, orders.order_date AS 'Date' FROM Customers JOIN Orders ON Orders.customer_id = Customers.customer_id ORDER BY Customers.customer_id;
sql

Per concludere, utilizziamo un ulteriore comando JOIN per calcolare i costi totali dei prodotti ordinati:

SELECT OrderItems.order_id, OrderItems.orderitem_id AS 'Order Item', Products.product_name AS 'Product', Products.price AS 'Unit Price', OrderItems.count AS 'Count', (OrderItems.count * Products.price) AS 'Total' FROM OrderItems JOIN Products ON OrderItems.product_id = Products.product_id;
sql
Consiglio

Se desideri saperne di più su cos’è esattamente SQL, se hai bisogno di aiuto per risolvere problemi specifici legati al linguaggio dei database o se desideri semplicemente ampliare le tue conoscenze, gli articoli della nostra Digital Guide potranno esserti d’aiuto:

Per offrirti una migliore esperienza di navigazione online questo sito web usa dei cookie, propri e di terze parti. Continuando a navigare sul sito acconsenti all’utilizzo dei cookie. Scopri di più sull’uso dei cookie e sulla possibilità di modificarne le impostazioni o negare il consenso.
Page top