Imparare SQL: un’in­tro­du­zio­ne con esempi

La sintassi del lin­guag­gio di pro­gram­ma­zio­ne SQL si basa sull’algebra re­la­zio­na­le e quindi si dif­fe­ren­zia da altri linguaggi di pro­gram­ma­zio­ne per molti aspetti. Per imparare SQL, la co­no­scen­za di questa sintassi e gli esempi il­lu­stra­ti­vi sono estre­ma­men­te utili.

Nozioni di base sulla sintassi SQL

In generale, la sintassi è la “scrittura” di un lin­guag­gio di pro­gram­ma­zio­ne, che determina quali tipi di costrutti di base del codice esistono e come possono essere collegati tra loro. La sua com­pren­sio­ne è un pre­re­qui­si­to fon­da­men­ta­le per leggere e scrivere codice nel ri­spet­ti­vo lin­guag­gio.

I costrutti sin­tat­ti­ci più im­por­tan­ti di SQL sono le di­chia­ra­zio­ni SQL e le clausole che possono contenere. Anche se tec­ni­ca­men­te non è del tutto corretto, entrambe vengono ge­ne­ral­men­te indicate come “comandi SQL”. Esistono inoltre altri costrutti sin­tat­ti­ci, che pre­sen­tia­mo 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 ese­cu­zio­ne adatto. Il codice sorgente viene letto da un in­ter­pre­te SQL e tradotto in azioni di un RDBMS. Per farlo esistono due approcci di base:

1. Ese­cu­zio­ne del codice SQL in una sessione in­te­rat­ti­va

Questo approccio prevede che il codice SQL venga di­ret­ta­men­te immesso o copiato in una finestra di testo, viene quindi eseguito e mostrato il risultato. Si ha ora la pos­si­bi­li­tà di adattare il codice ed eseguirlo nuo­va­men­te. Grazie a una veloce suc­ces­sio­ne di ma­ni­po­la­zio­ne del codice e vi­sua­liz­za­zio­ne dei risultati, questo approccio è par­ti­co­lar­men­te adatto all’ap­pren­di­men­to e alla rea­liz­za­zio­ne di richieste complesse.

2. Ese­cu­zio­ne 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’ese­cu­zio­ne. Questa procedura è l’ideale per au­to­ma­tiz­za­re 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 lin­guag­gio di pro­gram­ma­zio­ne è usarlo. Di seguito creeremo un mini database e lo con­sul­te­re­mo con delle query. Per farlo ci serviremo di Online SQL in­ter­pre­ter del sito web sql.js. Apri il sito web nel link e so­sti­tui­sci il codice inserito SQL con quello dei nostri esempi. Per vi­sua­liz­za­re i risultati esegui il codice pezzo per pezzo.

Approccio di base per la co­stru­zio­ne di un database SQL

A titolo di esempio co­strui­re­mo una gestione di prodotto com­mer­cia­le, la stessa che ser­vi­reb­be per un negozio fisico o uno online. Sta­bi­lia­mo ve­lo­ce­men­te qualche criterio:

• Esiste una serie di prodotti e di­spo­nia­mo di una de­ter­mi­na­ta quantità di ciascuno di essi in magazzino.
• La clientela fissa è composta da una mol­ti­tu­di­ne 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.

In­nan­zi­tut­to, tra­du­cia­mo questi obiettivi in una de­scri­zio­ne astratta e infine in codice SQL ri­spet­tan­do il seguente schema:

1. Creazione di un modello
2. De­fi­ni­zio­ne dello schema
3. In­se­ri­men­to dei record
4. De­fi­ni­zio­ne di query

Creare un modello delle entità e delle relazioni

Il primo passaggio avviene sulla carta, ovvero si serve di strumenti di mo­del­la­zio­ne speciali. Rac­co­glia­mo in­for­ma­zio­ni sul sistema da modellare e ne astraiamo entità e relazioni. Spesso questo passaggio si con­cre­tiz­za in termini di Entity Re­la­tion­ship (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 pe­cu­lia­ri­tà del modello re­la­zio­na­le si ag­giun­go­no ulteriori tabelle per modellare le relazioni. Per ri­co­no­scer­lo e ap­pli­car­lo cor­ret­ta­men­te è ne­ces­sa­ria una certa espe­rien­za.

La domanda centrale è come sono in­ter­con­nes­se le entità con­si­de­ran­do entrambe le direzioni di una relazione e dif­fe­ren­zian­do tra singolare e plurale. Ad esempio nella relazione persona–au­to­mo­bi­le:

1. “A una persona ap­par­ten­go­no po­ten­zial­men­te diverse au­to­mo­bi­li”
2. “Un’au­to­mo­bi­le ap­par­tie­ne solo a una persona”

Da due entità derivano tre possibili scenari re­la­zio­na­li:

Im­ple­men­ta­re i prodotti

Per co­min­cia­re, im­ple­men­tia­mo la tabella dei prodotti. Per farlo, definiamo uno schema, inseriamo i record ed eseguiamo un paio di query di prova. A seguire ap­pro­fon­dia­mo 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 sta­bi­li­sce proprietà per le colonne. Allo stesso modo vengono definiti tipi di dati ed even­tual­men­te li­mi­ta­zio­ni 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 ve­ri­fi­ca­re lo stato della tabella dei prodotti for­mu­lia­mo una semplice in­ter­ro­ga­zio­ne. Ado­pe­ria­mo il comando SELECT FROM ed emettiamo l’intera tabella:

SELECT * FROM Products;

In aggiunta com­pi­lia­mo una query un po’ più complessa, che calcola il valore com­ples­si­vo dei prodotti in magazzino:

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

Im­ple­men­ta­re le altre tabelle

Nel corso della procedura ci occupiamo delle restanti tabelle ne­ces­sa­rie 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');

Ve­ri­fi­chia­mo emettendo la tabella clienti:

SELECT * FROM Customers;

Suc­ces­si­va­men­te, 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 con­te­nen­te 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 sce­glien­do 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);

Ve­ri­fi­chia­mo 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 in­ter­ro­ga­zio­ni più complesse che mettono in evidenza la potenza di SQL. Per prima cosa for­mu­lia­mo una query che riunisce dati diffusi su più tabelle. Uti­liz­zia­mo il comando JOIN di SQL per collegare i dati della tabella clienti e quelli della tabella ordini. Diamo un nome ad alcune colonne e sta­bi­lia­mo una cor­ri­spon­den­za degli ID clienti come con­di­zio­ne JOIN. Tieni presente che ci serviamo di iden­ti­fi­ca­to­ri qua­li­fi­ca­ti per di­stin­gue­re 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 con­clu­de­re, uti­liz­zia­mo 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;