Laboratorio di
“Basi di dati”
Venerdì 6 Dicembre 2002
Venerdì 20 Dicembre 2002
Vaccaro Valerio
[email protected]
http://web.tiscali.it/Vaccaro
Pag.1
Indice generale
0. Introduzione a MySQL.....................................................................................................................3
1. Ambiente Client-Server....................................................................................................................4
1.1. Avvio del server........................................................................................................................4
1.2. Avvio del client.........................................................................................................................4
2. Creazione di un database..................................................................................................................5
2.1. Creiamo il nostro db.................................................................................................................5
2.2 Aggiungiamo le tabelle..............................................................................................................6
2.3 Popolazione delle tabelle...........................................................................................................6
3. Interrogazione del database..............................................................................................................8
3.1. Interrogazioni complesse..........................................................................................................8
4. Dumping del database....................................................................................................................14
4.1. Ridirezione dell'input e dell'output.........................................................................................15
5. Interfacce grafiche..........................................................................................................................15
Bibliografia e software.......................................................................................................................18
Pag.2
0. Introduzione a MySQL
MySQL è un database di grande successo e multipiattaforma infatti, come descritto nel manuale
ufficiale, è disponibile per le seguenti piattaforme:
AIX 4.x with native threads.
Amiga.
BSDI 2.x with the included MIT-pthreads package.
BSDI 3.0, 3.1 and 4.x with native threads.
DEC Unix 4.x with native threads.
FreeBSD 2.x with the included MIT-pthreads package.
FreeBSD 3.x and 4.x with native threads.
HP-UX 10.20 with the included MIT-pthreads package.
HP-UX 11.x with the native threads.
Linux 2.0+ with LinuxThreads 0.7.1+ or glibc 2.0.7+.
Mac OS X Server.
NetBSD 1.3/1.4 Intel and NetBSD 1.3 Alpha (Requires GNU make).
OpenBSD > 2.5 with native therads. OpenBSD < 2.5 with the included MIT-pthreads package.
OS/2 Warp 3, FixPack 29 and OS/2 Warp 4, FixPack 4.
SGI Irix 6.x with native threads.
Solaris 2.5 and above with native threads on SPARC and x86. S
SunOS 4.x with the included MIT-pthreads package.
SCO OpenServer with a recent port of the FSU Pthreads package.
SCO UnixWare 7.0.1.
Tru64 Unix
Win95, Win98, NT, and Win2000.
La licenza a cui MySQL si attiene e la GPL dunque nulla è richiesto oltre al rispetto della licenza
per usarlo su tutti i computers che si hanno a disposizione, un bel vantaggio rispetto ai prodotti
commerciali! MySQL si attiene alle specifiche di SQL '92 (SQL 2) tuttavia è ancora un prodotto in
via di sviluppo e miglioramento quindi nulla vieta che prossime versioni supporteranno
completamente SQL 2 e magari anche dettagli di SQL 3.
Le doti principali di MySQL sono la leggerezza e la semplicità d'uso. La leggerezza si tramuta in
velocità di esecuzione ecco perché spesso tale DB è usato in internet, per la realizzazione di portali,
siti dinamici, cataloghi on-line in accoppiata con linguaggi server-side quali php. La semplicità
d'uso riguarda invece l'opera monumentale di software, manuali, interfacce che è possibile trovare
in internet (e anche nei CD della vostra distribuzione preferita). Volete realizzare un portale in
pochi minuti? Volete un'interfaccia che vi colleghi al vostro DB? Volete creare un sito dinamico da
cui accedere ai dati del vostro DB? O magari vi volete collegare solo per amministrarlo? Tutto
questo con MySQL è di una rapidità sconcertante e vi lascia molto tempo per progettare il vostro
spazio, la grafica ed anche per giocare a “frozen bubble” o a “pingus”. E' ovvio che tutta questa
velocità bisogna pagarla in qualche modo.
Attualmente MySQL NON supporta:
• le query annidate (e chi le sopporta ...)
• le transazioni
• l'integrità referenziale
• altri costrutti di SQL2
Sono in corso vari progetti per dotare MySQLdi tutto ciò ed in particolare dovrebbe attualmente
essere possibile esprimere l'integrità referenziale e le transazioni tuttavia per ciò che ci
aggiungiamo a fare ingnoreremo le transazioni e scriveremo comunque l'integrità referenziale che
eventualmente sarà ignorata da MySQL.
La versione utilizzata per gli esempi descritti successivamente è la 3.23.52-MAX distribuita
assieme alla distribuzione Mandrake 9.0, tuttavia la generalità degli esercizi consente l'uso di
qualsiasi altra release e di qualsiasi sistema operativo supportato.
Pag.3
1. Ambiente Client-Server
MySQL è stato sviluppato sotto sistemi GNU/Linux dunque è ovvio aspettarsi anche in questo
prodotto due caratteristiche che sono onnipresenti nel mondo Linux:
1. L'integrazione con la rete.
MySQL possiede infatti numerose caratteristiche atte all'uso in rete ed in particolare ben si
accorda con php e apache creando in pochi click un sistema web server affidabile, sicuro e
gratuito.
2. La scissione client-server.
MySQL si compone infatti di:
un demone o server cioè il sistema di database e un client o interfaccia che può essere di vari
tipi e principalmente viene classificata in base al tipo di interfaccia che può essere grafica o a
caratteri mentre tutte supportano il collegamento a database locali cioè sulla medesima macchina
oppure remoti cioè su una macchina diversa dalla propria e connessa mediante un tipo di rete che
supporti il protocollo TCP o UDP.
In particolare la soluzione client-server rappresenta un interessante alternativa anche a i cosiddetti
database personali che, per quanto semplici o complessi, non godono della pulizia di un sistema che
separi l'interfaccia di lavoro (client) dal servizio database vero e proprio (server).
1.1. Avvio del server
La prima operazione è ovviamente installare i pacchetti di MySQL, si valuti la possibilità di
installare la documentazione che risiede in un pacchetto a parte. Se si possiedono i pacchetti di
sorgenti occorre anche compilare MySQL per il proprio hardware altrimenti scaricate i pacchetti
compilati per il processore in vostro possesso e per la distribuzione che è installate sul vostro
computer. Fatto ciò occorre creare l'ambiente a MySQl, per far ciò aprire un terminale e digitare :
mysql_install_db
Tale comando crea i file necessari a MySQL e ricorda di settare la password per l'amministratore
della base di dati oltre a dare preziosi spunti su come testare il database installato. Ora siete pronti a
digitare come utente di root:
safe_mysqld &
e quindi pronti a far partire il server. Ovviamente c'è il modo per automatizzare l'avvio del demone
di MySQL, basta aggiungere uno script che richiami tale comando nel runlevel utilizzato.
Utenti Win, non disperate, la vostra versione non necessita inizializzazione e il demone può essere
fatto partire mediante un'icona posta nella cartella /bin all'interno della cartella predefinita di
MySQL. Io preferisco la soluzione offerta da Linux che, sebbene più complessa, è più flessibile ed
adattabile ai proprio gusti.
1.2. Avvio del client
Il primo e forse il meno intuitivo client che analizziamo è mysql che è a caratteri e possiamo
avviare dal terminale semplicemente digitando:
mysql
da cui otteniamo una scarna interfaccia totalmente rivolta alla comunicazione con il database
mediante i comandi di SQL.
Ora si può digitare qualsiasi comando SQL ricordandosi che il programma interpreterà concluso il
comando quando si digiterà il carattere terminatore ; seguito da un invio.
E' anche possibile connettersi a host remoti mediante il parametro -h <indirizzo IP del server>,
occorre però assicurarsi di avere i permessi necessari presso il server che si intende contattare
altrimenti è possibile che ci venga cortesemente ricordato che non siamo bene accetti su quella
Pag.4
particolare macchina. Questa è la potenza che muove il modello client-server, non occorre essere
fisicamente davanti alla macchina per programmarne il funzionamento, aggiungere dati, sapere
situazioni aggiornate da qualsiasi parte del mondo. Insomma datemi un nodo di acceso e vi
programmerò il mondo (a patto di averne i diritti di accesso e magari di root).
2. Creazione di un database
Il database su cui ci concentreremo per gli esempi di questo capitolo è rappresentato dal seguente
schema:
STUDENTE(matr, nome, cognome)
ESAME(matr, codicecorso, data, voto)
CORSO(codice, docentecorso, nome)
dove sono sottolineate le chiavi primarie della tabella e scritti in corsivo i termini più deboli dei due
vincoli di integrità referenziale che il buon senso suggerisce tra le tabelle.
2.1. Creiamo il nostro db
Apriamo un terminale ed avviata l'interfaccia di mysql digitiamo:
create database labdb;
ciò equivale a predisporre nel sistema un nuovo database.
Attenzione ci potrebbe venire risposto che non disponiamo delle autorizzazioni per creare il
database e quindi la nostra azione verrà rifiutata. Appena installato infatti MySQL conosce un solo
utente, il root o amministratore delle base di dati la cui password e per default nulla. Occorre quindi
specificare una password se si considera di esporre il DB a potenziali attacchi e creare i nuovi
utenti. Si consideri che richiamare l'interfaccia mysql senza specificare il parametro –-user=<nome
utente> corrisponde ad accedere al database con un utente del tipo <nome utente loggato>@<nome
dell'host da cui parte la richiesta> ad esempio se mi connetto sul mio computer di casa da una
finestra dello stesso sarò riconosciuto dal database come valerio@localhost. Occorre dunque dare
al mio utente i permessi di utilizzo del database, in particolare nel mio caso setterò tutti i privilegi
su tutti i database cioè setterò l'utente valerio@localhost come un utente amministratore del
database. Incominciamo a connetterci al database mysql (database di gestione del sistema)come
root con:
mysql --user=root --password mysql
e digitando l'eventuale password. A tale punto un comando \
GRANT ALL PRIVILEGES ON *.* TO valerio@localhost WITH GRANT OPTION;
assicura permessi su tutto il Db anche a valerio@localhost.
Siamo ora pronti per creare lo schema del database, possiamo fare ciò interattivamente all'interno
della stessa finestra di mysql che questa volta richiameremo senza specificare il nome ed avendo
l'accortezza di creare il database se non presente. Una lista dei database presenti si ottiene da
qualsiasi terminale con il comando
mysqlshow
con cui otterremo nel terminale lista dei database presenti.
[valerio@sirio valerio]$ mysqlshow
+------------+
| Databases |
+------------+
| labdb
|
| mysql
|
| test
|
+------------+
Pag.5
Occorre ora discutere sulla notazione da usare con le tabelle infatti MySQL accetta il formato
pèuntato del tipo <nome database>.<nome tabella> come pure il formato <nome tabella> a patto di
aver specificato il database da usare all'aperuta dell'interfaccia. Per MySQL è indifferente mentre
per alcuni di noi la notazione puntata è più chiara mentre per altri è solo più faticosa da scrivere.
Lascio a voi capire quale sia la mia soluzione... Dopo aver digitato:
use labdb;
siamo pronti a dichiarare lo schema delle tabelle.
2.2 Aggiungiamo le tabelle
Assicuriamoci di lavorare sul database giusto e incominciamo a dichiarare prima lo schema delle
tabelle che non contengano vincoli di integrità referenziale in quanto la dichiarazione di vincoli su
tabelle inesistenti è rifiutata dal sistema. Cominciamo con la tabella studente:
create table studente(
matr char(6) not null,
nome varchar(50) not null,
cognome varchar(50) not null,
primary key (matr)
);
Aggiungiamo poi la tabella corso
create table corso(
codice varchar(10) not null,
docentecorso varchar(22) not null,
nome varchar(30) not null,
primary key (codice)
);
E quindi la tabella esame
create table esame(
matr char(6) not null,
codicecorso varchar(10) not null,
data varchar(10),
voto enum('18', '19','20','21','22','23','24','25','26','27','28','29','30'),
lode integer default 0,
primary key (matr, codicecorso),
foreign key (matr) references studente,
foreign key (codicecorso) references corso(codice)
);
dove il voto è confinato in un dominio mediante una enumerazione che non poteva essere altrimenti
espresso visto che le check non sono riconosciute da MySQL e così pure per i domini espliciti che
non sono ancora contemplati nella struttura di MySQL. Si ponga attenzione al fatto che sono stati
espressi i vincoli di integrità ma il database ignorerà tali comandi, la loro presenza consente
compatibilità dello schema con SQL 2 e portabilità sotto altri DB che supportino i vincoli di
integrità referenziale.
2.3 Popolazione delle tabelle
Occorre ora aggiungere i dati alle tabelle cioè popolare le stesse con dati significativi per poter poi
effettuare una sessione di testing del database stesso. L'operazione da utilizzare è ovviamente la
insert.
Incominciamo inserendo due studenti:
Pag.6
insert into studente values ('000001','Ciccio','Riccio');
insert into studente values ('000002','Fabio','Rossi');
effettuiamo un rapido controllo la banale query
select * from studenti;
che restituirà
mysql> select * from studente;
+-----------+-------+------------+
| matr
| nome | cognome |
+-----------+-------+------------+
| 000001 | Ciccio | Riccio
|
| 000002 | Fabio | Rossi
|
+-----------+--------+-----------+
2 rows in set (0.01 sec)
Inseriamo ora due corsi:
insert into corso values ('0A001-02','Franco Talponi','Matemastica');
insert into corso values ('0A002-02','Guglielmo Cancelli','Deformatica');
effettuiamo un rapido controllo la banale query
select * from corso;
che restituirà
mysql> select * from corso;
+-------------+-----------------------+---------------+
| codice
| docentecorso
| nome
|
+-------------+-----------------------+---------------+
| 0A001-02 | Franco Talponi
| Matemastica |
| 0A002-02 | Guglielmo Cancelli | Deformatica |
+-------------+-----------------------+---------------+
2 rows in set (0.00 sec)
Siamo ora pronti per inserire tre esami di test :
insert into esame values ('000001','0A001-02','07/12/02','30',1);
insert into esame values ('000001','0A002-02','08/12/02','25',0);
insert into esame values ('000002','0A001-02','07/12/02','18',0);
effettuiamo un rapido controllo la banale query
select * from esame;
che restituirà
mysql> select * from esame;
+-----------+-----------------+-------------+------+------+
| matr
| codicecorso | data
| voto | lode |
+-----------+-----------------+-------------+------+------+
| 000001 | 0A001-02 | 07/12/02 | 30 | 1 |
| 000002 | 0A001-02 | 07/12/02 | 18 | 0 |
| 000001 | 0A002-02 | 08/12/02 | 25 | 0 |
+-----------+-----------------+-------------+------+------+
3 rows in set (0.00 sec)
che forse è poco significativo ma ci segnala la correttezza dei nostri inserimenti e quindi conviene
farlo almeno una volta nelle vita.
Pag.7
3. Interrogazione del database
Avete presente quel bel linguaggio che avete studiato per il corso di basi di dati ed in particolare la
parte di DML (data manipulation language) ??? E' ora di rispolverarla con una semplice query che
ci dia la certezza di non aver costruito un database per niente. Cerchiamo quindi la tabella che
descriva tutti gli esami con un minimo di chiarezza ordinati per nome e cognome dello studente.
mysql> select s.cognome,s.nome,c.nome as titolo,c.docentecorso,e.data,e.voto,e.lode
-> from studente s, corso c, esame e
-> where e.matr=s.matr
-> and e.codicecorso=c.codice
-> order by s.cognome,s.nome;
+-----------+----------+-------------+----------------------+-------------+-------+------+
| cognome | nome | tito lo
| docentecorso
| data
| voto | lode |
+-----------+----------+-------------+-----------------------+------------+-------+------+
| Riccio
| Ciccio | Deformatica | Guglielmo Cancelli | 08/12/02 | 25 | 0 |
| Riccio
| Ciccio | Matemastica | Franco Talponi | 07/12/02 | 30 | 1 |
| Rossi
| Fabio | Matemastica | Franco Talponi | 07/12/02 | 18 | 0 |
+-----------+----------+-------------+-----------------------+------------+-------+------+
3 rows in set (0.04 sec)
3.1. Interrogazioni complesse
Per lavorare con qualche query interessante introduciamo un nuovo database, tale database è
contenuto nel file di dump f1.sql e contiene lo schema e le istanze di un database inerente ai
campionati di formula uno.
Per creare sul vostro computer lo stesso database è necessario leggere il capitolo 4 che spiega come
ricreare l'ambiente per provare le query. Se i concetti di dumping dei database vi sono già chiari
oppure vi basta provare il database, digitate:
[valerio@sirio valerio]$ mysql < f1.sql
Questa istruzione crea il database contenente tutti i dati necessari a provare le query. Per assicuraci
che il database sia stato creato digitiamo:
[valerio@sirio valerio]$ mysqlshow
+------------+
| Databases |
+------------+
| f1
|
| labdb
|
| mysql
|
| test
|
+------------+
[valerio@sirio valerio]$ mysqlshow f1
Database: f1
+--------------+
| Tables
|
+--------------+
| Campionato |
| GranPremio |
| Motore
|
| Pilota
|
| Scuderia |
+--------------+
Pag.8
Ora siamo pronti per effettuare qualche query, apriamo mysql e digitalmo use f1; per suser il
database corrispondente.
• Visualizzare tutti i piloti di nazionalità italiana che hanno corso per una scuderia italiana.
mysql> select Pilota.Nome
-> from Pilota, Scuderia
-> where Scuderia.Nome=Pilota.Scuderia
-> and Pilota.Nazione='Italia'
-> and Scuderia.Nazione='Italia';
+----------------------+
| Nome
|
+----------------------+
| Luca Badoer
|
| Pierluigi Martini
|
+----------------------+
2 rows in set (0.04 sec)
•
•
•
Visualizzare tutti i piloti che corrono per scuderie italiane.
mysql> select Pilota.Nome
-> from Pilota, Scuderia
-> where Scuderia.Nome=Pilota.Scuderia
-> and Scuderia.Nazione='Italia';
+----------------------+
| Nome
|
+----------------------+
| Gerhard Berger |
| Jean Alesi
|
| Luca Badoer
|
| Pedro Diniz
|
| Pedro Lamy
|
| Pierluigi Martini
|
| Roberto Moreno |
+----------------------+
7 rows in set (0.00 sec)
Visualizzare le scuderie che hanno sede nella stessa nazione dove si è disputato un gran premio.
mysql> select Scuderia.Nome
-> from Campionato, Scuderia
-> where Scuderia.Sede=Campionato.Citta;
+----------+
| Nome |
+----------+
| Ligier |
+----------+
1 row in set (0.00 sec)
Visualizzare la classifica dei motori in base al numero di ritiri.
mysql> select Scuderia.Motore, count(*) as num
-> from GranPremio,Pilota, Scuderia
-> where GranPremio.Pilota=Pilota.Nome
-> and Scuderia.Nome=Pilota.Scuderia
-> group by Scuderia.Nome
Pag.9
-> order by num desc;
+-----------+------+
| Motore | num |
+-----------+------+
| Hart
| 34 |
| Ford
| 34 |
| Peugeot | 34 |
| Ford
| 34 |
| Ford
| 34 |
| Ferrari | 34 |
| Renault | 34 |
| Ford
| 34 |
| Renault | 34 |
| Mercedes | 33 |
| Yamaha | 33 |
| Mugen | 33 |
| Ford
| 10 |
+-----------+------+
13 rows in set (0.01 sec)
•
Visualizzare i motivi di ritiro da un gran premio più frequenti.
mysql> select GranPremio.MotivoRitiro, count(GranPremio.MotivoRitiro) as somma
-> from GranPremio
-> where GranPremio.Ritirato=1
-> group by GranPremio.MotivoRitiro
-> order by somma desc;
+----------------------------+----------+
| MotivoRitiro
| somma |
+----------------------------+----------+
| Cambio
| 37 |
| Testacoda
| 32 |
| Motore
| 31 |
| Incidente
| 29 |
| Uscita di pista
| 10 |
| Impianto elettrico
|
6|
| Non partito
|
6 |
| Collisione
|
5 |
| Freni
|
4 |
| Pressione benzina
|
4 |
| Incendio
|
3 |
| Sospensione
|
3 |
| Batteria
|
2 |
| Perdita olio
|
2|
| Non classificato
|
2 |
| Acceleratore
|
2 |
| Trasmissione
|
2 |
| Elettronica
|
2|
| Problemi elettrici
|
1|
| Radiatore olio
|
1|
| Cuscinetto ruota
|
1|
| Tenuta di strada
|
1|
Pag.10
| Bandiera nera
|
1|
| Cerchio ruota
|
1|
| Distacco ruota
|
1|
| Rottura semiasse
|
1|
| Leva cambio
|
1|
| Incendio al rifornimento |
1|
| Cuscinetto semiasse
|
1|
| Foratura
|
1|
| Differenziale
|
1|
| Impianto Idraulico
|
1|
| Problemi fisici (crampi) |
1|
| Fine benzina
|
1|
| Semiasse e freni
|
1|
| Semiasse
|
1|
| Alimentazione
|
1|
| Cuscinetto
|
1|
| Cedimento fisico
|
1|
+----------------------------+--------+
39 rows in set (0.04 sec)
•
Visualizzare la classifica dei piloti in base al numero di ritiri.
mysql> select Pilota.Nome, count(*) as somma
-> from Pilota, GranPremio
-> where Pilota.Nome=GranPremio.Pilota
-> and GranPremio.Ritirato=1
-> group by Pilota.Nome
-> order by somma desc;
+----------------------------+---------+
| Nome
| somma |
+----------------------------+---------+
| Andrea Montermini
| 14 |
| Taki Inoue
| 12 |
| Roberto Moreno
| 12 |
| Ukyo Katayama
| 11 |
| Mika Hakkinen
|
9|
| Bertrand Gachot
|
9|
| Rubens Barrichello
|
9|
| Pedro Diniz
|
8|
| David Coulthard
|
8|
| Jean Alesi
|
8|
| Luca Badoer
|
8|
| Damon Hill
|
7|
| Gerhard Berger
|
7|
| Eddie Irvine
|
7|
| Martin Brundle
|
6|
| Olivier Panis
|
6|
| Mark Blundell
|
5|
| Pierluigi Martini
|
5|
| Massimiliano Papis
|
5|
| Mika Salo
|
5|
| Heinz Harald Frentzen |
5|
Pag.11
| Johnny Herbert
|
4|
| Michael Schumacher
|
4|
| Jos Verstappen
|
4|
| Jean Christophe Boullion |
4|
| Karl Wendlinger
|
4|
| Gianni Morbidelli
|
4|
| Giovanni Lavaggi
|
4|
| Mimmo Schiattarella
|
3|
| Pedro Lamy
|
2|
| Aguri Suzuki
|
2|
| Jean Denis Deletraz
|
1|
| Nigel Mansell
|
1|
+----------------------------+-------+
33 rows in set (0.01 sec)
•
•
Elencare i motori in base alla potenza unitaria (potenza per cilindro)
mysql> select Motore.CasaProduttrice,(Motore.Potenza/Motore.NCilindri) as potun
-> from Motore
-> order by potun desc;
+-------------------+-------+
| CasaProduttrice | potun |
+-------------------+-------+
| Ford
| 86.25 |
| Hart
| 82.50 |
| Renault
| 71.00 |
| Mercedes
| 69.50 |
| Peugeot
| 69.00 |
| Mugen
| 67.50 |
| Yamaha
| 63.00 |
| Ferrari
| 60.83 |
+------------------+-------+
8 rows in set (0.00 sec)
Elencare i gran premi con motori a 12 cilindri in pole position.
mysql> select distinct Campionato.Nome_Circuito
-> from GranPremio, Pilota, Scuderia, Motore, Campionato
-> where Campionato.Numero=GranPremio.NumGP
-> and GranPremio.Pilota=Pilota.Nome
-> and Pilota.Scuderia=Scuderia.Nome
-> and Motore.NCilindri=12
-> and GranPremio.PosGriglia=1;
+----------------------+
| Nome_Circuito
|
+----------------------+
| Interlagos
|
| Oscar A. Galvez |
| Enzo e Dino Ferrari|
| Catalunya
|
| Monaco
|
| Gilles Villeneuve |
| Magny Cours
|
Pag.12
| Silverstone
|
| Hockenheim
|
| Hungaroring
|
| Spa-Francorchamps|
| Monza
|
| Estoril
|
| Nurburgring
|
| Aida
|
| Suzuka
|
| Adelaide
|
+---------------------+
17 rows in set (0.00 sec)
•
•
Elencare i GP in cui si sono ritirati piloti mentre stavano conducendo la gara
mysql> select Campionato.Nome_Circuito, Pilota.Nome
-> from GranPremio, Pilota, Campionato
-> where Campionato.Numero=GranPremio.NumGP
-> and GranPremio.Pilota=Pilota.Nome
-> and GranPremio.PosRitiro=1;
+----------------------+-------------------------+
| Nome_Circuito
| Nome
|
+----------------------+-------------------------+
| Interlagos
| Damon Hill
|
| Silverstone
| Michael Schumacher |
| Hockenheim
| Damon Hill
|
| Hockenheim
| Jean Alesi
|
| Spa-Francorchamps| David Coulthard
|
| Monza
| David Coulthard
|
| Monza
| Jean Alesi
|
| Adelaide
| David Coulthard
|
+----------------------+------------------------+
8 rows in set (0.01 sec)
Classifica campionato piloti eliminando chi non ha preso nemmeno un punto
mysql> select GranPremio.Pilota, sum(GranPremio.Punti) as tot
-> from GranPremio
-> group by GranPremio.Pilota
-> having tot>0
-> order by tot desc;
+-----------------------------+-------+
| Pilota
| tot |
+-----------------------------+-------+
| Michael Schumacher
| 102 |
| Damon Hill
| 69 |
| David Coulthard
| 49 |
| Johnny Herbert
| 45 |
| Jean Alesi
| 42 |
| Gerhard Berger
| 31 |
| Mika Hakkinen
| 17 |
| Olivier Panis
| 16 |
| Heinz Harald Frentzen | 15 |
Pag.13
| Mark Blundell
| 13 |
| Rubens Barrichello
| 11 |
| Eddie Irvine
| 10 |
| Martin Brundle
| 7|
| Gianni Morbidelli
| 5|
| Mika Salo
| 5|
| Jean Christophe Boullion | 3 |
| Pedro Lamy
| 1|
| Aguri Suzuki
| 1|
+----------------------------+-------+
18 rows in set (0.00 sec)
•
Lunghezza in chilometri dei gran premi.
mysql> select distinct Campionato.Nome_GP,(Campionato.Lunghezza*NumGiri/1000) as lung
-> from Campionato
-> order by lung desc;
+------------------+----------+
| Nome_GP
| lung |
+------------------+----------+
| Giappone
| 310.792 |
| Portogallo
| 309.56 |
| Gran Bretagna | 308.477 |
| San Marino | 308.385 |
| Pacifico
| 307.349 |
| Brasile
| 307.075 |
| Spagna
| 307.06 |
| Germania
| 307.035 |
| Belgio
| 306.856 |
| Argentina
| 306.648 |
| Australia
| 306.18 |
| Francia
|
306 |
| Italia
| 305.81 |
| Canada
| 305.67 |
| Ungheria
| 305.536 |
| Europa
| 305.252 |
| Monaco
| 259.584 |
+---------------.+-----------+
17 rows in set (0.00 sec)
4. Dumping del database
Qualora dopo aver giocato con MySQL ed aver creato il database labdb il nostro migliore amico ci
viene a supplicare di dargli una mano e di caricargli il nostro DB sulla sua sessione di MySQL,
oltretutto ingiunge di non avere i permessi di lettura sulla nostra sessione e quindi di non poter
vedere il database da remoto (è consigliabile per l'esamino di laboratorio prendere confidenza con i
comandi di rete!!!), oppure qualora decidessimo di cambiare un database creandolo, aggiornandolo
e testandolo sulla nostra macchina e poi di esportarlo sul computer di lavoro o sul database server
aziendale o ancora qualora decidessimo di distribuire in qualsiasi forma il database da noi realizzato
come ci comporteremo? Escludiamo una copia brutale della directory dei dati che esporrebbe più
informazioni del dovuto e mancherebbe al requisito di portabilità INDISPENSABILE nei casi
precedentemente descritti, infatti non esisteranno mai due sistemi identici e la duplicazione del
Pag.14
database mediante copia delle directory dati potrebbe farci venire il mal di testa. Incredibile ma
vero la soluzione si trova nella shell ed in particolare nella ridirezione dell'input o dell'output verso
file di testo contenenti comandi SQL. Tale caratteristica è presente universalmente in tutte le
interfacce a caratteri dei sistemi operativi ma negli utenti Windows è sopita nello stanzino buio dei
Dos-ricordi.
4.1. Ridirezione dell'input e dell'output
La ridirezione dell'input e dell'output di un sistema avvine in shell mediante i caratteri > e <.
Facciamo subito un esempio, qualora volessimo utilizzare l'interfaccia mysql per creare un nuovo
database, delle tabelle e popolarlo di valori possiamo creare un file che io chiamerò labdb.sql che
contenga tutto l'SQL necessaio a definire lo schema del database e le istanze.
Appare subito evidente che se trovassimo un modo più veloce alla scrittura diretta del codice SQL
potremmo creare un database identico a quello descritto nel file in pochi secondi. Il modo c'è, basta
digitare in un terminale
mysql < labdb.sql
che autonomamente aprirà l'interfaccia di mysql e digiterà tutti i comandi contenuti in labdb.sql
come se fossero stati digitati direttamente dalla tastiera (ridirezione dell'input da tastiera a file).
Occorre ora analizzare come si può semplicemente esportare un database di MySQL in un file di
testo, per far ciò esiste una applicazione appositamente creata e chiamata mysqldump <nome
database>. Eseguendo
mysqldump labdb
si ottiene la descrizione in SQL del database labdb con tanto di commenti che il programma
assicura prima di ogni definizione. Noi però volevamo la stessa descrizione su file. Come fare ???
In questi casi ci viene in aiuto la ridirezione dell'output da terminale (standard output) verso un file.
Con grande fantasia il comando che consente tale operazione è
mysqldump labdb > labdb.sql
che creerà il file lab.sql nella directory attuale.
5. Interfacce grafiche
Parlando di interfacce grafiche analizzeremo tre tipi di interfacce dell'ambiente windows che spesso
accompagnano il pacchetto MySQL e i tools a corredo di tale pacchetto. Le interfacce per database
che supportano SQL sono comunque diffusissime e parecchi progetti stanno lavorando in questo
campo senza tuttavia affermare nessun prodotto in maniera efficace. Per gli utilizzatori di
PostgreSQL invece esistono interfacce molto belle e semplici da usare, pgaccess è probabilmente la
più bella e semplice per chi ha già conosciuto i programmi commerciali (non vi ricorda nulla il
nome ???).
Per la gestione del server MySQL esiste winmysqladmin che fornisce un ambiente grafico di
gestione e crea report sul funzionamento del server stesso.
Pag.15
Per la gestione dello schema esiste invece l'interfaccia mysqlmanager che tuttavia non offre molto
di più di ciò che già fa l'accoppiata mysql e mysqlshow. Accetta input solo in linguaggio SQL e non
dispone di un ambiente grafico attivo, anzi ci si può chiedere a cosa serva che questo tool sia
grafico (io non l'ho ancora capito)
Il terzo e ultimo ambiente grafico proposto per windows è mysqlfront, sicuramente più potente del
Pag.16
precedente gestisce anche il trasferimento di schemi ed istanze (tabelle e dati) tra i database più
diffusi mediante ODBC o tramite file di testo formattato opportunamente. Supporta anche la
connessione a host diversi dal proprio, la creazione di database,di tabelle, il popolamento di
quest'ultime e l'esecuzione di query SQL supportate da MySQL.
Per linux le interfacce grafiche sono molteplici e con molteplici caratteristiche tuttavia se avete
installato apache e php potrebbe essere una buona idea installare anche PhpMyAdmin una
interfaccia grafica centralizzata (risiede sul server) da cui gestire il proprio database.
Pag.17
Bibliografia e software.
Testi consultati e di utile consultazione:
Guida ufficiale di MySQL
“Appunti di informatica libera”
“Linux domande e risposte”
“Linux facile”
Atzeni, Ceri, Paraboschi,Torlone “Basi di dati” McGraw-Hill
Kevin Kline, Daniel Kline “SQL Guida di riferimento” Apogeo
Per la realizzazione di questo testo sono stati usati SOLAMENTE programmi open source
strettamente attinenti alla licenza GPL, l'impaginazione è stata effettuata mediante OpenOffice 1.0,
l'elaborazione delle immagine mediante GIMP ed il sistema di riferimento è la distribuzione
Mandrake 9.0.
Pag.18
