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:

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.

2. 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.

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:

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 );

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);

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;

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;

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 );

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');

Verifichiamo emettendo la tabella clienti:

SELECT * FROM Customers;

Successivamente, formiamo la tabella ordini:

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

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');

Testiamo quindi gli ordini:

SELECT * FROM Orders;

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 );

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);

Verifichiamo emettendo i prodotti ordinati:

SELECT * FROM OrderItems;

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;

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;