6. Recuperare dati da più tabelle: la clausola JOIN

Per gestire i database MySQL che creiamo possiamo utilizzare diversi programmi: il più comune è phpMyAdmin. Si tratta di una web application che consente di gestire i dati da un’interfaccia. Per scaricarla sul nostro computer dobbiamo installare Xampp, una piattaforma per creare un server locale sul nostro computer scaricabile gratuitamente dal sito https://www.apachefriends.org. Per accedere a phpMyAdmin ci basterà aprire un qualsiasi browser e digitare l’indirizzo localhost/phpMyAdmin.

L’interfaccia di phpMyAdmin

L’interfaccia grafica di phpMyAdmin consente di creare database, tabelle e modificare ogni sua parte. Nel nostro lavoro quotidiano useremo l’interfaccia solo per controllare i dati inseriti nel database e per piccole modifiche. Gli inserimenti, le modifiche più importanti verranno fatte con un linguaggio di scripting che vedremo più avanti.

Qui in basso possiamo vedere la home page di phpMyAdmin. A sinistra possiamo vedere i database presenti, accanto ad ogni database c’è un tasto + che permette di vedere le tabelle al suo interno. Notiamo che ci sono alcuni database necessari al funzionamento di phpMyAdmin.

Cliccando su un database vediamo l’elenco delle sue tabelle, come mostrato nella foto sottostante. Cliccando su una tabelle possiamo vederne il contenuto, modificarle o creare nuove tabelle.

Creiamo un nuovo database

Dalla home di phpMyAdmin clicchiamo sul link in alto Database e poi scriviamo il nome del database che vogliamo creare nel campo input che si trova sotto la scritta crea un nuovo database.

Creiamo una nuova tabella

Per creare una tabella di un database selezioniamo il database e cerchiamo nella pagina il form per creare una nuova tabella: si trova in fondo dopo l’elenco delle tabelle, chiaramente se non ci sono tabelle sarà in alto, come nella foto sottostante.

Dopo aver deciso il nome della tabella e il numero dei campi, apparirà una nuova schermata, che consente di definire il nome e il tipo di dato di ogni singolo campo.

Modificare una tabella

È possibile modificare le tabelle già create da phpMyAdmin cliccando sul nome della tabella dall’elenco delle tabelle del database. Si aprirà una schermata in cui si vedono i dati della tabella ed è possibile eseguire alcune operazioni, come rinominare la tabella. Come mostrato in figura dall’interno di una tabella cliccare su operazioni (il tasto evidenziato in figura) e tra le varie operazioni possiamo rinominarla modificando il valore accanto alla voce Rinomina la tabella in.

Ceare un utente con phpMyAdmin

Dalla home page di phpMyAdmin clicchiamo su utenti e poi su aggiungi account utente. Si aprirà la schermata sottostante:

Nel campo utente metteremo il nome del nostro utente, nel campo host dobbiamo selezionare locale, nel campo password dobbiamo inserire una qualsiasi password (essendo in locale e non in un  ambiente reale non dobbiamo preoccuparci della sicurezza di questa password) e possiamo lasciare il resto invariato. Fatto questo dobbiamo assegnare i privilegi di questo utente: scendiamo un po’ più giù e troveremo il form per effettuare questa operazione, mostrato in figura:

Selezioniamo la voce seleziona tutto accanto alla scritta privilegi globali e poi salviamo. Abbiamo il creato un utente che avrà accesso a tutti i database del nostro computer.

Tipi di dati principali inseribili in un database

Scelta del tipo di dato

Il tipo di dato da scegliere è sempre il più piccolo in base alle nostre esigenze. Ad esempio se devo scegliere il tipo di dato per una variabile numeroPostiAuto sceglierò TINYINT perché so che un’auto non potrà mai avere più di 128 posti auto.

Quando scegliamo un tipo di dato MySQL memorizzerà per ogni riga lo spazio che occupa quel tipo di dato, ad esempio se per la variabile che abbiamo avessimo scelto INT, MySQL avrebbe riservato 11 byte a parità di valore inserito.

Questi operatori consentono di fare query un po’ più elaborate, e quindi di selezionare quello che ci serve con maggiore precisione. Consentono infatti di aggiungere delle condizioni alla query.

Ad esempio, guardiamo questa query:

SELECT * FROM tabella1 WHERE id<5 AND nome LIKE ‘Carlo’

La prima parte di questa query è l’ultima query di esempio del campo SELECT, a cui abbiamo aggiunto questa condizione:

AND nome LIKE ‘Carlo’

con questa aggiunta non basta più che l’id sia maggiore di 5 per essere selezionato, ma si aggiunge la condizione  per cui nome deve essere uguale a ‘Carlo’.

Vediamo ora il costrutto OR, consideriamo la seguente query:

SELECT * FROM tabella1 WHERE id<5 OR nome LIKE ‘Carlo’

La query è uguale a quella di prima, tranne per un dettaglio: al posto della parola chiave AND c’è la parola chiave OR. Questo fa cambiare completamente quello che restituisce la query: mentre prima venivano restituite tutte le riche che avevano id maggiore di 5 e nome Carlo, mettendo l’OR al posto di AND restituirà tutti i campi che avranno o id maggiore di 5 o nome Carlo. Il comando OR infatti per recuperare la riga chiede che almeno una delle due condizioni sia soddisfatta, non entrambe.

Vediamo ora il caso in cui dobbiamo selezionare tutte le righe di una tabella tranne quelle che rispecchiano una determinata condizione. Ad esempio, predndere tutti gli elementi di tabella1 tranne  quelli che hanno come nome carlo. In questo caso dobbiamo utilizzare l’operatore NOT preceduto dal campo che non deve essere uguale al valore che vogliamo evitare. Questo operatore però potrebbe essere usato in due modi

1. confronto di una stringa, come l’esempio sopra. In tal caso dobbiamo far seguire l’operatore NOT dalla parola LIKE ‘valoreDaEvitare’.

Nel caso di prima, la query è:

SELECT * FROM tabella1 WHERE nome NOT LIKE ‘Carlo’

2. I valori da confrontare sono il risultato di un’altra query, ad esempio voglio prendere tutte le righe di tabella 1 il cui id non è in tabella 2. Un caso potrebbe essere selezionare gli utenti che non hanno già ottenuto un determinato servizio. Ogni volta che l’utente ottiene quel servizio viene registrato in tabella2. In questo caso si usa l’operatore NOT seguito da IN.

SELECT * FROM tabella1 WHERE id NOT IN (SELECT id FROM tabella2)

Creare query più complesse

Una query di solito prevede più condizioni, alcune delle quali devono essere verificate prima di altre. Supponiamo di avere una tabella utente con questi campi:

• id
• nome
• cognome
• tipo
• eta
• anniEsperienza
• residenza

Supponiamo ora di voler estrarre che un utente sia di tipo “operaio”, lavori da 10 anni, abbia un’età inferiore ai 35 anni e risieda a Catania o Palermo.

SELECT * FROM utente WHERE tipo LIKE ‘operaio’ AND eta <35 AND anniEsperienza >10 AND (residenza LIKE ‘Catania’ OR residenza LIKE ‘Palermo’)

Le parole chiave COUNT e SUM

Può capitare di dover semplicemente contare le occorrenze di una tabella, oppure di sommare un certo numero di valori (Ad esempio l’incasso di un giorno). Per questo ci vengono in aiuto i comandi MySQL COUNT e SUM.

Il comando COUNT consente di contare le occorrenze che rispettano le condizioni che vogliamo inserire, ad esempio la query:

SELECT COUNT(*) FROM articoli

restituirà il numero totale degli articoli nel database. Possiamo ovviamente creare query più complesse, come ad esempio:

SELECT COUNT(*) FROM articoli WHERE id=1

in questo caso la query restituirà solo il numero degli articoli con id categoria 1.

Il comando SUM consente di sommare i campi numerici delle occorrenze di una tabella, senza  costringerci ad elaborare queste operazioni con il linguaggio di programmazione che usiamo. Facciamo un esempio, supponiamo di avere questa tabella ordini (ovviamente molto semplificata):

CREATE TABLE `ordini` (

        `id` INT( 11 ) NOT NULL AUTO_INCREMENT ,

        `idUtente` INT( 11 ) NOT NULL ,

        `importo` INT( 11 ) NOT NULL ,

        `dataOrdine` DATE NOT NULL ,

        PRIMARY KEY ( `id` )

        ) ENGINE=InnoDB DEFAULT CHARACTER SET=utf8;

Per sapere l’incasso totale effettuato possiamo eseguire questa query:

SELECT SUM(importo) FROM ordini

Se invece vogliamo sapere solo l’incasso di un dato giorno (ad esempio il primo Gennaio 2020) possiamo scrivere questa query:

SELECT SUM(importo) FROM ordini WHERE dataOrdine LIKE ‘2020-01-01’

Cercare occorrenze nel database contenenti parte di una parola chiave

Molto spesso può capitare di cercare nel database righe che non presentano una corrispondenza esatta con la parola chiave. Si pensi ad esempio quando si scrivono i campi del motore di ricerca di un sito che parla di automobili: se un utente scrive come parola chiave “Ferrari” la query di ricerca non deve restituire gli articoli che hanno come titolo Ferrari, ma che contengono la parola Ferrari. Ad esempio potrebbe restituire risultati di questo tipo:

• Ferrari SF90: la nuova monoposto per il mondiale F1 2019
• Mick Schumacher in Ferrari Driver Academy: è ufficiale
• International GT Open 2018 a Monza con la Ferrari prima in classifica

Si tratta di titoli di articoli che contengono la parola Ferrari, ma anche molte altre. Questo si ottiene con la query di ricerca:

SELECT * FROM articoli WHERE titolo LIKE ‘%Ferrari%’

soffermiamoci un attimo ad osservare la parte finale della query: LIKE ‘%Ferrari%’: notiamo la presenza del simbolo % prima e dopo la parola Ferrari. Quel simbolo indica a MySQL che prima e dopo la parola chiave specificata possono esserci altre parole. Da una query di questo tipo possono scaturire i risultati visti sopra, altrimenti se avessimo scritto questa query:

SELECT * FROM articoli WHERE titolo LIKE ‘Ferrari’

non avremmo ottenuto alcun risultato, in quanto gli articoli visti sopra hanno titoli che contengono la parola Ferrari, ma non solo questa parola. 

Sono possibili anche due varianti di questa query:

SELECT * FROM articoli WHERE titolo LIKE ‘Ferrari%’

In questo caso il simbolo % sta solo dopo la parola Ferrari, quindi questa query cerca tutti gli articoli che iniziano con la parola Ferrari, e possono essere seguiti da un qualsiasi numero di parole.

SELECT * FROM articoli WHERE titolo LIKE ‘%Ferrari’

In questo caso il simbolo % sta solo prima della parola Ferrari, quindi questa query cerca tutti gli articoli che termineranno con la parola Ferrari, e possono essere preceduti da un qualsiasi numero di parole.

Il linguaggio SQL è un linguaggio di scripting che viene utilizzato dai programmi per interagire con il database. Quando un programma deve compiere un’operazione con il database esegue una richiesta in questo linguaggio. Le richieste di questo tipo vengono chiamate query.

Parole chiave nelle query

Le query devono essere costruite con dei comandi, di seguito vediamo i comandi fondamentali per eseguire le operazioni di base.

CREATE

Serve per creare una tabella o un intero database, viene utilizzata soprattutto per creare tabelle

CREATE TABLE `tabella1` (

        `id` INT( 11 ) NOT NULL AUTO_INCREMENT ,

        `campo1` VARCHAR( 255 ) NOT NULL ,

        `campo2` VARCHAR( 255 ) NOT NULL ,

        `campo3` VARCHAR( 255 ) NOT NULL ,

        PRIMARY KEY ( `id` )

        ) ENGINE=InnoDB DEFAULT CHARACTER SET=utf8;

La parola chiave NOT NULL indica al database che quella colonna non può non essere inserita. Significa che al momento dell’inserimento se un valore di una colonna NOT NULL non viene inviato il database non accetterà il dato.

La parola chiave AUTO_INCREMENT indica al database che quel valore deve incrementare in automatico ogni volta che ci sono inserimenti

La parola chiave PRIMARY KEY ( `id` ) indica al database che quel campo è univoco in quella tabella. Ciò significa che se il database riceve una richiesta di inserimento con un valore della variabile PRIMARY_KEY già presente, tale richiesta viene rifiutata.

Per ogni tabella possiamo scegliere il set di caratteri da utilizzare, specificandolo con il comando CHARACTER SET. In questo caso abbiamo scelto utf8 che comprende buona parte dei caratteri del mondo (anche i simboli speciali come &, %, gli alfabeti diversi da quello latino e tanto altro ancora).

Nota: se proviamo a creare una tabella già esistente MySQL restituirà un errore. Per evitare l’errore possiamo aggiungere la clausola IF NOT EXISTS, la tabella diventa

CREATE TABLE IF NOT EXISTS `tabella1` (

        `id` INT( 11 ) NOT NULL AUTO_INCREMENT ,

        `campo1` VARCHAR( 255 ) NOT NULL ,

        `campo2` VARCHAR( 255 ) NOT NULL ,

        `campo3` VARCHAR( 255 ) NOT NULL ,

        PRIMARY KEY ( `id` )

        ) ENGINE=InnoDB DEFAULT CHARACTER SET=utf8;

Finora abbiamo creato tabelle in cui tutti i campi erano obbligatori, quindi accanto ad ogni campo c’era la scritta NOT NULL. Creiamo ora una tabella in cui alcuni campi non sono obbligatori, basterà che non specifichiamo la scritta NOT NULL ad alcuni di essi:

CREATE TABLE `tabella3` (

        `id` INT( 11 ) NOT NULL AUTO_INCREMENT ,

        `campo1` VARCHAR( 255 ) NOT NULL ,

        `campo2` VARCHAR( 255 )  ,

        `campo3` VARCHAR( 255 )  ,

        PRIMARY KEY ( `id` )

        ) ENGINE=InnoDB DEFAULT CHARACTER SET=utf8;

in questa nuova query di creazione notiamo che accanto a campo2 e campo3 non ci sono i campi NOT NULL, questo farà si che il database accetti un valore nullo per questi due campi.

INSERT

Serve per inserire una nuova riga nella tabella

Es: INSERT INTO tabella1 VALUES(NULL,'val1','val2','val3')

NB: questa query ha come primo valore NULL, perché avendo dichiarato prima che il campo id è AUTO_INCREMENT sarà il database ad assegnare il valore

Esiste anche un altro modo di scrivere una query, che è quello di specificare i campi che vengono inseriti. Ad esempio:

INSERT INTO `tabella1` (`id`, `campo1`, `campo2`, `campo3`) VALUES (NULL, 'a', '23', '');

In questo caso stiamo comunicando a MySQL quali campi intendiamo popolare, può avere dei vantaggi quando non tutti i campi della query sono obbligatori. È possibile aggiungere più righe con un’unica query, ad esempio:

INSERT INTO `tabella1` (`id`, `campo1`, `campo2`, `campo3`) VALUES (NULL, 'a', '23', ''),(NULL, 'b', '24', ''),(NULL, 'c', '25', '');

I valori di ogni riga devono essere separati da una virgola, tranne il valore finale che deve essere seguito dal punto e virgola di chiusura.

Supponiamo ora di inserire una riga in una tabella dove alcuni campi possono essere vuoti, prendiamo in esame la tabella3 vista sopra. Per inserire i campi in questa tabella possiamo usare la seguente query:

INSERT INTO `tabella3` (`id`, `campo1`, `campo2`, `campo3`) VALUES (NULL, 'c', '25', '');

dal momento però che campo2 e campo3 possono essere NULL possiamo evitare di inserirli, quindi il database accetterà anche queste query:

INSERT INTO `tabella3` (`id`, `campo1`, `campo2`) VALUES (NULL, 'c', '25');

e

INSERT INTO `tabella3` (`id`, `campo1`) VALUES (NULL, 'd');

I primi due campi invece, id e campo1, sono obbligatori e non possiamo fare a meno di inserirli. Quando nel database un campo non è specificato viene impostato a NULL.

SELECT

Serve per estrarre informazioni da una tabella esistente.

Possiamo usare questo comando in modo generico, che restituisce tutte le informazioni all’interno della tabella, ad esempio:

SELECT * FROM tabella1

Oppure possiamo essere più specifici aggiungendo la parola chiave WHERE, ad esempio

SELECT * FROM tabella1 WHERE id=1

La query qui sopra restituisce solo una riga, ovvero la riga in cui l’id vale 1. Se non è presente una riga che soddisfa queste condizioni verrà restituito un insieme vuoto.

Vediamo questo ulteriore esempio

SELECT * FROM tabella1 WHERE id<5

In questo esempio verranno restituite tutte le righe in cui il campo id ha valore minore di 5, anche in questo caso se non ci sono righe che soddisfano queste condizioni verrà restituito un insieme vuoto.

Vediamo ora un esempio in cui cerco tutte le righe in cui una colonna abbia un determinato valore, ma quella colonna non è numero ma una stringa.

SELECT * FROM tabella1 WHERE campo1 LIKE ‘val1’

In questo caso vengono restituite tutte le righe che hanno come campo 1 il valore val. Essendo campo1 un campo VARCHAR invece di usare l’operatore = dobbiamo usare l’operatore LIKE seguito dal valore della stringa tra apici. 

Il simbolo * dopo la parola chiave SELECT indica che stiamo chiedendo al nostro database l’intera riga (quindi tutte le colonne della tabella).

Può capitare di avere la necessità di selezionare solo una o più colonne di una riga, ma non l’intera riga. In questo caso scriveremo il nome di ogni colonna che vogliamo ottenere. Ad esempio, supponiamo di voler recuperare solamente la colonna campo1 dalla tabella tabella1. La query sarebbe cosi:

SELECT campo1 FROM tabella1

In questo caso otterremmo tanti risultati quante sono le righe della tabella, ma avremmo solamente la colonna campo1.

Possiamo scegliere un qualsiasi numero di campi da recuperare, basta separarli con una virgola. Ad esempio:

SELECT campo1, campo2 FROM tabella1

In questo caso recuperiamo campo1 e campo2 dalla tabella 1, quindi avremmo un output composto da tante righe quante sono gli elementi inseriti nella tabella, e su ogni riga le due colonne campo1 e campo2.

UPDATE

Serve per aggiornare delle righe già presenti nella tabella. Bisogna specificare la tabella che si vuole aggiornare (con la parola chiave SET), i campi che si vogliono aggiornare e quali righe vanno aggiornate (parola chiave WHERE)

Es: UPDATE tabella1 SET campo1='nuovo valore' WHERE id=1

DELETE

Serve per eliminare una o più righe di una tabella. Il comando DELETE. deve essere seguito da FROM e il nome della tabella, poi con la parola chiave WHERE definiamo cosa eliminare

Es: DELETE FROM tabella1 WHERE id=1

Limitare il numero di risultati in una query

Una esigenza frequente quando si opera con i database è quella di dover limitare il numero di risultati che una query deve restituire. Per questo scopo esiste in MySQL il comando LIMIT.

Questa parola chiave va aggiunta alla fine della query, specificando il numero di elementi massimo che si vuole ricevere, ad esempio:

SELECT * FROM tabella1 WHERE campo1 LIKE ‘val1’ LIMIT 5

Questa query restituirà solo le prime cinque occorrenze del database che rispettano le condizioni (ovvero che la colonna campo1 abbia valore ‘val1’).

Paginazione dei risultati

Un altro utilizzo della parola chiave LIMIT è la creazione delle paginazioni. Quando i database sono molto grandi si ha spesso la necessità di ricevere un certo numero di dati per volta. Pensiamo agli articoli di un blog devono essere visualizzate in pagine da 10 elementi per volta. Alla prima pagina possiamo usare la query:

SELECT * FROM articoli LIMIT 10

per la seconda pagina e per le successive, però, questa query non va bene: dobbiamo infatti chiedere al nostro database di restituirci i 10 articoli successivi all’ultimo già mostrato. Questo si fa con la seguente query:

SELECT * FROM articoli LIMIT 10, 10

Per prendere i dati della terza pagina scriveremo:

SELECT * FROM articoli LIMIT 20, 10

e così via.