5. Le relazioni tra tabelle
Andrea Pastore 29/11/2020 0
Ad ogni tabella di un database corrisponde un’entità (ad esempio la tabella auto, la tabella attori, la tabella cinema, la tabella utenti e cosi via), ma le tabelle possono aver bisogno di essere collegate le une alle altre. Per fare questo esiste
Abbiamo diversi tipi di relazioni
- relazione 1 a 1
Supponiamo che un’azienda voglia memorizzare gli indirizzi di residenza dei propri utenti. Questa è una relazione 1 a 1 perché ad ogni utente corrisponde un indirizzo. Per fare questa associazione possiamo inserire nella tabella utenti l’id dell’indirizzo, e nella tabella indirizzo l’id dell’utente. - relazione 1 a N
supponiamo di avere una tabella utenti e una tabella ordini. Ad ogni ordine corrisponde un solo utente, ovviamente un utente può aver fatto più ordini. Per fare questa associazione inseriamo nella nostra tabella ordini un campo idUtente, dove memorizzeremo l’id dell’utente che ha eseguito l’ordine - relazioni N a N
supponiamo di avere una tabella ordini e una tabella prodotti. In ogni ordine è possibile inserire più prodotti, e ovviamente un prodotto può comparire in più ordini. Per fare questa associazione ci serve una nuova tabella, contenente l’id dell’ordine e l’id del prodotto. Il codice MySQL per creare questa tabella potrebbe essere:
CREATE TABLE `associazioneOrdiniProdotto` (
`idOrdine` INT( 11 ) NOT NULL ,
`idProdotto` INT( 11 ) NOT NULL ,
) ENGINE=InnoDB DEFAULT CHARACTER SET=utf8;
è possibile aggiungere degli attributi alle relazioni N a N, ad esempio potremmo voler memorizzare la quantità di un determinato prodotto in un ordine. In questo caso la query per la creazione diventerebbe:
CREATE TABLE `associazioneOrdiniProdotto` (
`idOrdine` INT( 11 ) NOT NULL ,
`idProdotto` INT( 11 ) NOT NULL ,
`quantita` INT( 11 ) NOT NULL ,
) ENGINE=InnoDB DEFAULT CHARACTER SET=utf8;
Potrebbero interessarti anche...
Andrea Pastore 29/11/2020
3. Il linguaggio SQL
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.
Andrea Pastore 29/11/2020
6. Recuperare dati da più tabelle: la clausola JOIN
Può capitare di dover recuperare le informazioni da più di una tabella, ad esempio supponiamo di dover recuperare le informazioni di un articolo e quelle della sua categoria. Tra la tabella articolo e la tabella categoria che è una relazione 1 a N, nella tabella articoli c’è un campo categoria che contiene l’id della categoria. Potremmo pensare di fare due query, la prima per recuperare i dati dell’articolo, la seconda per recuperare i dati della categoria.
Questo però è inefficiente, perché possiamo creare un’unica query che ci consente di recuperare tutte le informazioni che ci servono, grazie alla clausola JOIN. Vediamo un esempio
SELECT * FROM articoli AS a JOIN categorie AS c
ON a.categoria = c.id
La parola chiave AS serve per facilitare la scrittura della query, per riferirsi alle tabelle con un alias più compatto. Ad esempio quando scriviamo … articoli AS a … stiamo comunicando al database che d’ora in avanti nella query ci riferiremmo alla tabella articoli con la parola a. Analogamente la scritta … categorie AS c … indica che d’ora in avanti nella query ci riferiremmo alla tabella categoria con la parola chiave c.
La clausola JOIN comunica al database che deve restituire i valori di entrambe le tabelle. La parola chiave ON serve per specificare qual è la relazione tra le due tabelle.
Nota bene: quando usiamo la clausola JOIN MySQL restituirà solo le occorrenze che rispettano tale clausola.
Con riferimento alla query sopra supponiamo di avere queste tabelle:
Tabella articoli
id | titolo | testo | categoria | autore |
---|---|---|---|---|
1 | Titolo 1 | ... | 1 | Mario Rossi |
2 | Titolo 2 | ... | 1 | Mario Rossi |
3 | Titolo 3 | ... | 0 | Mario Rossi |
Tabella categorie
id | nome | categoriaMadre |
---|---|---|
1 | Categoria 1 | ... |
2 | Categoria 2 | ... |
In questo caso la query di inizio pagina restituirà solamente due righe, perché non troverà alcuna corrispondenza nella tabella categorie per l’articolo con id = 3. Per lo stesso motivo non verrà mostrata l’occorrenza Categoria 2, perché nella tabella articoli non c’è nessun articolo che è collegato ad essa.
Usare WHERE nelle query con JOIN
Come in altri contesti possiamo trovarci a voler estrarre solo poche righe e non l’intero contenuto della tabella. Anche in questo caso possiamo usare la parola chiave WHERE., ad esempio:
SELECT * FROM articoli AS a JOIN categorie AS c
ON a.categoria = c.id
WHERE a.id = 3
Dal momento che stiamo cercando tra più tabelle, le limitazioni devono indicare di quale tabella si tratta, per questo le colonne di una tabella vengono precedute dal carattere (o parola) indicato all’inizio della query dopo la parola AS.
NOTA: anche in questo caso vale la regola descritta a pagina precedente, se eseguissimo la query in database con le tabelle descritte non otterremmo alcun risultato perché un articolo con id 3 è presente, ma MySQL non troverebbe alcuna corrispondenza per categoria = 0
Selezionare i dati in output
Osserviamo la query fatta sopra: notiamo che inizia con SELECT * … il che significa che stiamo chiedendo al database di recuperare tutti i dati. Essendo un JOIN il risultato di questa query restituirà tutte le colonne di entrambe le tabelle. Possiamo impostare la query in modo che ci restituisca solo una parte di questi dati, ad esempio:
SELECT a.id, a.titolo, c.nome FROM articoli AS a JOIN categorie AS c
ON a.categoria = c.id
WHERE a.id = 3
con questa query cosi fatta stiamo chiedendo al database di darci solo tre elementi: l’id dell’articolo, il titolo dell’articolo e il nome della categoria
SELECT a.id, c.* FROM articoli AS a JOIN categorie AS c
ON a.categoria = c.id
WHERE a.id = 3
con quest’altra query invece abbiamo chiesto al database di restituirci l’id dell’articolo e tutte le colonne della tabella categorie.
Ci sono dei casi in cui vogliamo dare un nome diverso alla colonna, ad esempio perché ci sono due colonne che hanno lo stesso nome. Possiamo farlo aggiungendo la parola chiave AS seguita dal nome che vogliamo assegnare. Ad esempio:
SELECT a.id, a.titolo, c.id AS idCategoria, c.nome FROM articoli AS a JOIN categorie AS c
ON a.categoria = c.id
WHERE a.id = 3
Andrea Pastore 29/11/2020
4. Gli operatori AND, OR e NOT
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.