Guida introduttiva per MySQL

1.  Cominciare con MySQL

Introduzione

MySQL è un popolare server di database usato in varie applicazioni. SQL significa (S)tructured (Q)uery (L)anguage, ed è ciò che MySQL usa per comunicare con altri programmi. Sovrapposto a questo, MySQL ha la sue funzioni SQL estese per fornire funzionalità aggiuntive agli utenti. In questo documento, vedremo come effettuare l'installazione di MySQL, configurare il database e le tabelle, e creare nuovi utenti. Cominciamo con l'installazione.

Installazione di MySQL

Per prima cosa assicuratevi di avere installato MySQL nel vostro sistema, Nel caso abbiate bisogno di specifiche funzionalità da MySQL, controllate di aver abilitato le opzioni USE richieste che vi aiuteranno a regolare l'installazione.

(Vedere le flag USE disponibili)
# emerge --pretend --verbose mysql
(Installare MySQL)
# emerge mysql

Alla fine dell'installazione, vedrete la notifica seguente:

You might want to run:
"emerge --config =dev-db/mysql-[version]"
if this is a new install.

Siccome questa è una nuova installazione, eseguiamo il comando. Dovete premere INVIO quando richiesto mentre configurate il database MySQL. La configurazione prepara il database principale di MySQL, contenente le informazioni amministrative quali i database, le tabelle, gli utenti, i permessi e altro ancora. La configurazione raccomanda di cambiare la password di root il prima possibile. Noi lo faremo senza indugiare, altrimenti c'è il rischio che qualcuno acceda casualmente e comprometta la configurazione standard del nostro server MySQL.

(Sostituire [versione] con il numero della versione che si ha appena
installato.)
# emerge --config =dev-db/mysql-[version]
 * MySQL DATADIR is /var/lib/mysql
 * Press ENTER to create the mysql database and set proper
 * permissions on it, or Control-C to abort now...

   Preparing db table
   Preparing host table
   Preparing user table
   Preparing func table
   Preparing tables_priv table
   Preparing columns_priv table
   Installing all prepared tables

   To start mysqld at boot time you have to copy support-files/mysql.server
   to the right place for your system

   PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER !
   To do so, issue the following commands to start the server
   and change the applicable passwords:
(Notare le seguenti 3 linee)
   /etc/init.d/mysql start
   /usr/bin/mysqladmin -u root -h pegasos password 'new-password'
   /usr/bin/mysqladmin -u root password 'new-password'
   Depending on your configuration, a -p option may be needed
   in the last command. See the manual for more details.

(Qualche informazione di MySQL non inerente in modo specifico agli
ebuild è stata rimossa da qui per mantenere il documento il più consistente
possibile)

   * For security reasons you should set your MySQL root
   * password as soon as possible.

Lo script di configurazione ha già stampato a video i comandi necessari per impostare la password di root, non ci resta che eseguirli.

# /etc/init.d/mysql start
 * Re-caching dependency info (mtimes differ)...
 * Starting mysqld (/etc/mysql/my.cnf) ...        [ ok ]
(Sostituite nuova-password con la password che
desiderate)
# /usr/bin/mysqladmin -u root -h localhost password 'nuova-password'

Ora potete testare se la password di root è stata configurata correttamente provando ad accedere al server MySQL:

$ mysql -u root -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

L'opzione -u imposta l'utente che effettuerà il login. L'opzione -h imposta l'host. Solitamente equivale a localhost a meno che non stiate configurando un server remoto. Infine, -p dice al client mysql che digiterete una password per accedere al database. Osservate il prompt mysql>. Lì andranno digitati tutti i comandi. Ora che ci troviamo nel prompt mysql come utenti root, possiamo cominciare ad impostare il nostro database.

2.  Impostare il database

Creare un database

Abbiamo effettuato il login e viene visualizzato un prompt mysql. Per prima cosa diamo un'occhiata ai databasi attualmente disponibili, Per fare ciò, usiamo il comando SHOW DATABASES.

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql    |
| test     |
+----------+
2 rows in set (0.09 sec)

Anche se un database di test è già stato creato, andiamo a crearne uno nostro. I database si creano usando il comando CREATE DATABASE. Ne creeremo uno chiamato "gentoo".

mysql> CREATE DATABASE gentoo;
Query OK, 1 row affected (0.08 sec)

La risposta del server ci fa sapere che il comando è stato eseguito senza nessun errore. In questo caso, è stata modificata 1 riga. Questa modifica è riferita al database MySQL principale, contenente una lista di tutti i database. Non preoccupatevi eccessivamente dei dettagli dietro a ciò. L'ultimo numero indica la velocità con la quale la query è stata eseguita. Possiamo verificare la creazione del database eseguendo di nuovo il comando SHOW DATABASES.

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| gentoo   |
| mysql    |
| test     |
+----------+
3 rows in set (0.00 sec)

Il nostro database è stato effettivamente creato. Per poter creare delle tabelle al suo interno, dobbiamo selezionarlo come database corrente. Per fare questo, usiamo il comando USE. Il comando USE richiede il nome del database sul quale desiderate operare. Un'altro modo è specificarlo sulla riga di comando dopo l'opzione -D. Proseguiamo e selezioniamo il database "gentoo".

mysql> USE gentoo;
Database changed

Ora il database corrente è "gentoo", quello che abbiamo precedentemente creato. Adesso che lo stiamo usando, possiamo cominciare a creare delle tabelle e inserirvi qualche informazione.

3.  Lavorare con le tabelle in MySQL

Creare una tabella

Nella struttura di MySQL, ci sono database, tabelle, record e campi. I Database contengono un insieme di tabelle, le tabelle contengono un insieme di record, i record contengono un insieme di campi, i quali contengono le informazioni effettive. Questa struttura permette agli utenti di scegliere come accedere a queste informazioni. Prima abbiamo avuto a che fare con i database, adesso lavoriamo con le tabelle. Come prima cosa, possono essere elencate similmente ai database usando il comando SHOW TABLES. Al momento non ci sono tabelle nel database "gentoo", come visualizzato dall'esecuzione del comando:

mysql> SHOW TABLES;
Empty set (0.00 sec)

È quindi necessario crearle. Per farlo, useremo il comando CREATE TABLE. Tuttavia questo comando è abbastanza differente dal semplice comando CREATE DATABASE. Questo comando richiede una lista di argomenti. La sintassi è la seguente:

CREATE TABLE [nome_tabella] ([nome_campo] [tipo_dato_campo]([dimensione]));

nome_tabella è il nome della tabella che vogliamo creare. In questo caso, andremo a crearne una chiamata developers. Essa conterrà il nome dello sviluppatore, l'e-mail e l'occupazione. nome_campo conterrà il nome del campo. Ce ne servono 3 in questo caso: name, email e job. tipo_data_campo identifica che tipo di informazione verrà memorizzata. I diversi formati disponibili potrete trovarli su MySQL Column Types Page. Per i nostri scopi, useremo il tipo di dato VARCHAR per tutti i campi. VARCHAR è uno dei dei tipi di dato più semplici nell'utilizzo delle stringhe. dimensione identifica quanti dati può contenere il singolo campo. In questo caso, useremo 128. Questo significa che il campo può contenere dati VARCHAR lunghi 128 bytes. Per ora potete pensarli come 128 caratteri, tuttavia ci sono delle spiegazioni più tecniche che il sito sopraccitato vi fornirà. Ora che sappiamo come fare, creiamo la tabella.

mysql> CREATE TABLE developers ( name VARCHAR(128), email VARCHAR(128), job VARCHAR(128));
Query OK, 0 rows affected (0.11 sec)

La tabella sembra essere stata creata correttamente. Controlliamo con il comando SHOW TABLES:

mysql> SHOW TABLES;
+------------------+
| Tables_in_gentoo |
+------------------+
| developers       |
+------------------+
1 row in set (0.00 sec)

La nostra tabella viene correttamente elencata. Tuttavia, non riceviamo alcuna informazione sui tipi di campo che abbiamo impostato. Per ottenere ciò usiamo il comando DESCRIBE (o DESC in forma abbreviata), che richiede il nome della tabella come argomento. Guardiamo cosa fornisce per la tabella "developers".

mysql> DESCRIBE developers;
+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name  | varchar(128) | YES  |     | NULL    |       |
| email | varchar(128) | YES  |     | NULL    |       |
| job   | varchar(128) | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Ci vengono mostrati i differenti campi e la loro tipologia. Inoltre viene visualizzato qualche attributo extra la cui spiegazione esula dallo scopo di questa guida. Fate pure riferimento al MySQL Reference Manual per ulteriori informazioni. Ora abbiamo una tabella sulla quale lavorare. Proseguiamo e popoliamola.

Popolare il nostro database MySQL

Popoliamo una tabella (o aggiungiamo dei dati) usando il comando INSERT. Come il comando CREATE TABLE, esso ha una sintassi specifica:

INSERT INTO tabella (col1, col2, ...) VALUES('valore1', 'valore2', ...);

Questo comando serve ad inserire un record in una tabella. "tabella" contiene il nome della tabella MySQL nella quale volete inserire le informazioni. Il nome della tabella può essere seguito dall'elenco delle colonne nelle quali inserire i dati; infine VALUES() contiene i valori che volete inserire nella tabella. Potete omettere la lista delle colonne se inserite un valore in ognuna e se scrivete i valori nello stesso ordine con cui avete definito le colonne. In questo caso, vogliamo inserire i dati nella tabella "developers". Inseriamo un record d'esempio:

mysql> INSERT INTO developers VALUES('Joe Smith', 'joesmith@gentoo.org',
'toolchain');
Query OK, 1 row affected (0.06 sec)
(Se non conoscete l'ordine delle colonne nella tabella o volete
inserire un record incompleto)
mysql> INSERT INTO developers (job, name) VALUES('outsourced', 'Jane Doe')
Query OK, 1 row affected (0.01 sec)

In base alla risposta del server, sembra che il nostro record sia stato inserito correttamente. E se volessimo inserire più informazioni invece che un solo record? E' qui che il comando LOAD DATA entra in gioco. Esso carica dei record da un file di testo avente tabulazioni come separatori di campo. Proviamo a farlo creando un file, nella nostra home directory, contenente dei record. Chiameremo questo file records.txt. Ecco un esempio:

John Doe  johndoe@gentoo.org  portage
Chris White  chriswhite@gentoo.org  documentation
Sam Smith  samsmith@gentoo.org  amd64

Il comando LOAD DATA ha una definizione alquanto allungata, ma noi qui useremo la forma più semplice.

LOAD DATA LOCAL INFILE '/percorso/al/nome_file' INTO TABLE tabella;

/percorso/al/nome_file è la directory e il nome del file che verrà usato. "tabella" è il nome della nostra tabella. In questo caso, il nostro file è ~/record.txt e la tabella è "developers".

mysql> LOAD DATA LOCAL INFILE '~/records.txt' INTO TABLE developers;
Query OK, 3 rows affected (0.00 sec)
Records: 3  Deleted: 0  Skipped: 0  Warnings: 0

Ha funzionato correttamente. Tuttavia questo comando carica semplicemente dei record, e non dà nessun tipo di controllo su MySQL. Diverse applicazioni web usano script sql per configurare MySQL in modo facile e veloce. Se volete usare uno script mysql, dovete eseguire mysql in modalità batch, o effettuare il source dello script (leggerne il contenuto e far eseguire direttamente i comandi). Ecco un esempio di esecuzione in modalità batch di mysql:

$ mysql -u root -h localhost -p < sqlfile

Come con LOAD DATA, controllate cosa fa lo script sqlfile. Se non lo fate rischiate di compromettere il database! Un altro modo per eseguire uno script sql è usare il comando SOURCE. Questo comando eseguirà direttamente comandi mysql contenuti in un file, mentre mysql è in modalità interattiva. Si effettua il source di uno script sql in questo modo:

mysql> source sqlfile;

Se un'applicazione web ti richiede di eseguire uno script sql, puoi compiere l'operazione utilizzando i 2 metodi appena visti. Abbiamo impostato la nostra tabella, ma ora come facciamo a verificare i campi che contiene? Lo possiamo fare cercando nella tabella tramite le Query.

Visualizzare il contenuto delle tabelle MySQL tramite le Query

Le Query sono una delle caratteristiche principali di ogni database SQL. Ci aiutano a trasformare i dati nelle tabelle in qualcosa di maggiormente utilizzabile. La maggior parte delle query vengono eseguite con il comando SELECT. Il comando SELECT è abbastanza complesso, per cui daremo uno sguardo, in questo documento, solamente alle tre forme principali del comando.

(Seleziona tutte i record inseriti in una tabella)
SELECT * FROM tabella;
(Seleziona determinati record in una tabella)
SELECT * FROM tabella WHERE campo=valore;
(Seleziona dei determinati campi)
SELECT campo1,campo2,campo3 FROM tabella [WHERE campo=valore];

Diamo un rapido sguardo alla prima forma. È relativamente semplice e vi dà una visione d'insieme della tabella. Proseguiamo ed eseguiamo il comando per vedere quali dati abbiamo inserito prima.

mysql> SELECT * FROM developers;
+-------------+-----------------------+----------------+
| name        | email                 | job            |
+-------------+-----------------------+----------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain      |
| John Doe    | johndoe@gentoo.org    | portage        |
| Chris White | chriswhite@gentoo.org | documentation  |
| Sam Smith   | samsmith@gentoo.org   | amd64          |
| Jane Doe    | NULL                  | Outsourced job |
+-------------+-----------------------+----------------+
5 rows in set (0.00 sec)

Vediamo sia i dati inseriti tramite INSERT sia quelli inseriti tramite LOAD DATA. Adesso decidiamo di voler vedere solamente il record relativo a Chris White. Possiamo farlo con la seconda forma di select, come mostrato qui di seguito.

mysql> SELECT * FROM developers WHERE name = 'Chris White';
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| Chris White | chriswhite@gentoo.org | documentation |
+-------------+-----------------------+---------------+
1 row in set (0.08 sec)

Come previsto, la voce specifica che stavamo cercando è stata selezionata. Ora decidiamo di voler sapere solo il lavoro della persona e il suo indirizzo e-mail, non il suo nome. Possiamo farlo con la terza forma di SELECT mostrata qui sotto:

mysql> SELECT email,job FROM developers WHERE name = 'Chris White';
+-----------------------+---------------+
| email                 | job           |
+-----------------------+---------------+
| chriswhite@gentoo.org | documentation |
+-----------------------+---------------+
1 row in set (0.04 sec)

Questo metodo di selezione è molto più semplice da gestire, specialmente per quantità maggiori di informazioni, come vedremo più avanti. Al momento, essendo utenti root di mysql, abbiamo permessi illimitati per fare quello che vogliamo con il database MySQL. In un ambiente server, un utente con questi privilegi può creare abbastanza problemi. Per controllare chi fa cosa con i database, impostiamo i privilegi.

4.  Privilegi di MySQL

Concedere Privilegi con GRANT

I Privilegi stabiliscono che tipo di accesso debbano avere gli utenti ai database, alle tabelle, praticamente a qualsiasi cosa. Al momento nel database "gentoo" l'account root di MySQL è l'unico che può accedervi, come stabilito dai suoi permessi. Ora andiamo a creare due utenti piuttosto generici, "guest" e "admin", i quali accederanno al database "gentoo" e lavoreranno con le informazioni ivi contenute. L'account guest sarà limitato. Tutto quello che potrà fare sarà ottenere informazioni dal database. admin avrà lo stesso livello di controllo di root, ma solo per il database "gentoo" (non per il database principale "mysql"). Prima di cominciare, diamo uno sguardo più approfondito a questa forma un po' semplificata del comando GRANT.

GRANT [privilegi] ON database.* TO '[utente]'@'[host]' IDENTIFIED BY
'[password]';

Il primo parametro si riferisce ai privilegi che desideriamo assegnare. Ricordando quello che abbiamo appreso precedentemente, alcuni dei privilegi che possiamo impostare sono:

• ALL - Dà tutti i privilegi di controllo sul database
• CREATE - Permette agli utenti di creare tabelle
• SELECT - Permette agli utenti di effettuare query su tabelle
• INSERT - Permette agli utenti di inserire dati nelle tabelle
• SHOW DATABASES - Permette agli utenti di vedere una lista dei database
• USAGE - L'utente non ha privilegi
• GRANT OPTION - Permette agli utenti di concedere privilegi

Per il nostro utente admin, useremo ALL. Per l'utente guest, SELECT sarà sufficiente per l'accesso in sola lettura. "database" è il database sul quale vogliamo l'utente abbia il permesso. In questo esempio, il database è "gentoo". Il simbolo .* significa "tutte le tabelle". Se lo desiderate, potete applicare gli accessi per tabella. "utente" è il nome dell'utente e "host" è l'hostname dal quale l'utente accederà. Nella maggior parte dei casi sarà localhost. Infine "password" è la password dell'utente. Date queste informazioni, proseguiamo e creiamo i nostri utenti.

(admin)
mysql> GRANT ALL ON gentoo.* TO 'admin'@'localhost' IDENTIFIED BY 'password';
(guest)
mysql> GRANT SELECT ON gentoo.* TO 'guest'@'localhost' IDENTIFIED BY 'password';

Adesso che abbiamo impostato gli utenti, testiamoli. Per prima cosa usciamo da mysql digitando quit al prompt dei comandi:

mysql> quit

Siamo tornati alla console. Ora che gli utenti sono configurati, andiamo avanti e vediamo che cosa possono fare.

Testare i Permessi degli Utenti

Proveremo ad accedere come utente guest. Attualmente, l'utente guest ha solamente il privilegio SELECT. Basilarmente si è abilitati a cercare e nient'altro. Andiamo avanti e accediamo con l'account guest:

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 6 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Testiamo le restrizioni dell'utente. Spostiamoci sul database "gentoo":

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Ora facciamo qualcosa non precedentemente ipotizzato. Proviamo a creare una tabella.

mysql> CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

Come potete vedere, questa funzione fallisce, poichè l'utente non ha l'accesso appropriato. Tuttavia, un accesso di cui abbiamo l'autorizzazione è la dichiarazione SELECT. Proseguiamo e proviamo:

mysql> SELECT * FROM developers;
+-------------+-----------------------+----------------+
| name        | email                 | job            |
+-------------+-----------------------+----------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain      |
| John Doe    | johndoe@gentoo.org    | portage        |
| Chris White | chriswhite@gentoo.org | documentation  |
| Sam Smith   | samsmith@gentoo.org   | amd64          |
| Jane Doe    | NULL                  | Outsourced job |
+-------------+-----------------------+----------------+
5 rows in set (0.00 sec)

Il comando viene eseguito correttamente, facendoci intravedere le potenzialità dei permessi sugli utenti. È stato creato pure un account admin, comunque, per mostrare che perfino gli utenti con privilegi assoluti possono avere limitazioni. Proseguiamo e usciamo da MySQL ed accediamo come admin.

mysql> quit
Bye
$ mysql -u admin -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 7 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Per iniziare, proviamo a creare un nuovo database. L'utente admin avrà un accesso simile all'account root di MySQL, e potrà scegliere di fare qualunque tipo di modifica al database "gentoo". Questo testerà l'accesso dell'utente al database MySQL principale. Ricordate che precedentemente abbiamo impostato i permessi solo su uno specifico database.

mysql> CREATE DATABASE gentoo2;
ERROR 1044: Access denied for user: 'admin@localhost' to database 'gentoo2'

Effettivamente l'utente admin non può creare database nel database principale di MySQL, malgrado tutti i permessi che gli abbiamo assegnato sul database "gentoo". Tuttavia, possiamo ancora usare l'account admin per modificare il database "gentoo", come mostrato in questo semplice esempio d'inserimento.

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> INSERT INTO developers VALUES('Bob Simmons',
'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)

L'utente admin può gestire il database a suo piacimento. Talvolta c'è la necessità di rimuovere qualche permesso utente. Potrebbe essere di un utente problematico, o di un dipendente andato in pensione. Diamo un'occhiata su come disabilitare i permessi utente con il comando REVOKE.

Rimuovere l'accesso utente con il comando REVOKE

Il comando REVOKE ci permette di negare l'accesso ad un utente. Possiamo sia negare un accesso completo, o uno specifico. Difatti, il formato è molto simile a GRANT

REVOKE [privilegi] ON database.* FROM '[utente]'@'[host]';

Le opzioni usate qui sono spiegate nella sezione del comando GRANT. In questa sezione comunque, andremo a negare l'accesso completo ad un utente. Supponiamo di aver scoperto che l'utente guest sta causando qualche problema di sicurezza. Decidiamo di revocargli tutti i privilegi. Accediamo come root ed eseguiamo i comandi necessari:

mysql> REVOKE ALL ON gentoo.* FROM 'guest'@'localhost';
Query OK, 0 rows affected (0.00 sec)

Adesso usciamo e proviamo ad accedere come utenti guest.

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Youra MySQL connection id is 9 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Sebbene riusciamo ad accedere, l'accesso al database "gentoo" ci è negato.

mysql> USE gentoo;
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

E così il problematico utente non può più accedere al database "gentoo". Notate però che può ancora effettuare il login. Questo perchè è rimasto nell'elenco degli utenti nel database MySQL principale. Guardiamo come si fa a rimuovere completamente un account tramite DELETE e la tabella utenti di MySQL.

Rimuovere gli Account usando DELETE

La tabella utenti di MySQL è un elenco di tutti gli utenti e le informazioni ad essi correlate. Assicuratevi di avere effettuato il login come root. Procedete e selezionate il database principale di MySQL.

mysql> USE mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql>

Ora guardiamo quali sono le tabelle appartenenti al database "mysql":

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv    |
| db              |
| func            |
| host            |
| tables_priv     |
| user            |
+-----------------+
6 rows in set (0.00 sec)

La tabella "user" è quella che ci interessa. Comunque essa contiene 30 campi differenti, rendendola molto difficile da leggere. Per permettere una lettura migliore, proseguiamo e usiamo la terza versione della dichiarazione SELECT. I campi che utilizzeremo sono Host e User.

mysql> SELECT Host,User FROM user WHERE User = 'guest';
+-----------+-------+
| Host      | User  |
+-----------+-------+
| localhost | guest |
+-----------+-------+
1 row in set (0.00 sec)

Adesso che abbiamo le informazioni, possiamo sbarazzarci dell'utente guest. Ciò viene fatto con il comando DELETE, avente la sintassi seguente.

DELETE FROM tabella WHERE campo='valore';

Potete notare che il comando DELETE è alquanto simile alla dichiarazione SELECT nel formato. In questo caso, il campo sarà "User", e il valore "guest". Verrà eliminato il record nella tabella utenti relativo all'utente "guest", cancellando definitivamente l'account. Proseguiamo ed eseguiamo il comando:

mysql> DELETE FROM user WHERE User='guest';
Query OK, 1 row affected (0.07 sec)
(FLUSH PRIVILEGES è necessario per aggiornare i privilegi)
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Sembra aver funzionato correttamente. Testiamo il tutto disconnettendoci e provando ad effettuare il login come utenti guest.

mysql> quit
Bye
$ mysql -u guest -h localhost -p
Enter password:
ERROR 1045: Access denied for user: 'guest@localhost' (Using password: YES)

Il nostro utente è stato definitivamente cancellato!

Conclusione

Sebbene questa guida si focalizzi principalmente nella configurazione di MySQL tramite riga di comando, c'è la possibilità di utilizzare delle alternative con interfaccia grafica:

• phpMyAdmin - Popolare strumento di amministrazione di MySQL basato su php.
• mysqlnavigator - Interfaccia QT per MySQL.
• gmyclient - Un client MySQL per GNOME.
• knoda - Un client MySQL per KDE.

Con questo termina il tutorial introduttivo a MySQL. Spero vi dia una migliore comprensione sui fondamenti di MySQL e su come configurare un database. Per qualsiasi commento a riguardo, contattatemi pure tramite e-mail a Chris White.

I contenuti di questo documento sono rilasciati sotto la licenza Creative Commons - Attribution / Share Alike.