[successivo] [precedente] [inizio] [fine] [indice generale] [violazione licenza] [translators] [docinfo] [indice analitico] [volume] [parte]
MySQL (1) è un DBMS (Data base management system) relazionale. Il nome contiene la sigla «SQL», a indicare che si tratta di un DBMS in grado di comprendere le istruzioni SQL.
L'installazione del servente MySQL può essere molto laboriosa, se non si dispone di un pacchetto già pronto per la propria distribuzione GNU. La descrizione di come installare MySQL viene omessa, perché questa appare nella documentazione di MySQL in modo molto dettagliato. Qui si fa riferimento a una situazione relativamente «comune», a seguito dell'installazione automatica di un pacchetto pronto.
In generale, il servente MySQL è costituito dal demone mysqld, avviato attraverso uno script della procedura di inizializzazione del sistema, che potrebbe corrispondere a /etc/init.d/mysql. Assieme a questo demone ci sono altri programmi di servizio che servono principalmente per l'amministrazione e la manutenzione delle basi di dati, il più importante dei quali è mysqladmin.
L'installazione del servente MySQL richiede, nell'ambito del sistema operativo, la preparazione di un utente e un gruppo speciali, entrambi con il nome mysql. Questa utenza dovrebbe essere già disponibile oppure potrebbe essere creata automaticamente dal sistema di installazione dei pacchetti della propria distribuzione. La directory personale associata a questo utente speciale dovrebbe rappresentare il contenitore dei file che compongono le basi di dati gestite da MySQL: ~mysql/.
Il servente MySQL è sottoposto al controllo di un file di configurazione, che in condizioni normali potrebbe corrispondere a /etc/mysql/my.cnf, oppure solo /etc/my.cnf. Tuttavia, questo file è suddiviso in sezioni e contiene anche la configurazione relativa ai programmi clienti, mentre una configurazione specifica del solo servente può essere collocata nel file ~mysql/my.cnf.
Il DBA (Data base administrator) di MySQL si chiama convenzionalmente root e si prevede che in un sistema Unix coincida con l'utente root, ma ciò non è strettamente necessario. L'accesso da parte di questo utente, come degli altri, è sottoposto alla presentazione di una parola d'ordine che viene stabilita con l'ausilio di mysqladmin, o attraverso istruzioni SQL appropriate; pertanto, anche se ci può essere una corrispondenza tra utenze di MySQL e utenze del sistema operativo, le parole d'ordine usate non sono collegate tra loro.
MySQL ha una gestione particolare delle proprie utenze, distinguendole in base alla provenienza degli accessi. A seconda del contesto può capitare di utilizzare notazioni del tipo tizio@dinkel.brot.dg, dove si intende fare riferimento all'utente denominato tizio che accede dal nodo dinkel.brot.dg. Deve essere subito chiaro che non si tratta di un indirizzo di posta elettronica e nemmeno di un'utenza Unix. Pertanto, anche l'utente root (il DBA), deve essere qualificato meglio e solitamente si fa riferimento a root@localhost (l'utente root che accede al servente attraverso lo stesso elaboratore che offre il servizio.
Come accennato, la configurazione generale di MySQL è contenuta nel file /etc/mysql/my.cnf, oppure /etc/my.cnf, a seconda dell'organizzazione della propria distribuzione GNU, con la possibilità di usare il file ~mysql/my.cnf per ciò che riguarda strettamente il funzionamento del servente. Molto probabilmente, il file di configurazione generale è già predisposto per consentire un accesso locale al servente MySQL; di solito può essere utile verificare o ritoccare solo alcune direttive, specialmente per ciò che riguarda l'abilitazione dell'accesso attraverso la rete.
Il file di configurazione contiene direttive che assomigliano in pratica all'assegnamento di variabili, nella forma seguente:
|
|
Queste direttive sono suddivise in sezioni, dichiarate tra parentesi quadre:
|
|
È attraverso la presenza di queste sezioni che è possibile distinguere le direttive relative al servente da quelle di altre componenti.
Come spesso accade nei file di configurazione comuni, il simbolo # introduce un commento, fino alla fine della riga; inoltre, le righe bianche o vuote sono ignorate.
Le direttive che riguardano il funzionamento del servente sono contenute nelle sezioni [mysqld_safe] e [mysqld]. Per il momento conviene soffermarsi solo su alcune della seconda di queste sezioni:
|
Si comprende intuitivamente il significato di queste direttive: il demone mysqld viene avviato con i privilegi dell'utente mysql; viene usato il file /var/run/mysqld/mysqld.pid per annotare il numero PID del demone in funzione; viene utilizzato il file /var/run/mysqld/mysqld.sock come socket di dominio Unix per le comunicazioni locali, oppure la porta 3 306 per le comunicazioni attraverso la rete; nel file /var/log/mysql.log vengono annotate le informazioni relative al suo funzionamento; la directory /usr/ è il punto di partenza dell'installazione dei programmi e di altre componenti; la directory /var/lib/mysql/ è il punto di inizio dei file che compongono le basi di dati (equivale a ~mysql/); la directory usata per i file temporanei è /tmp/; infine, i messaggi mostrati dal demone sono quelli contenuti nella directory /usr/share/mysql/english/, ovvero quelli espressi in lingua inglese.
Alcune direttive particolari non hanno la forma dell'assegnamento e contengono una sola stringa, nella forma seguente:
|
|
La presenza di queste direttive indica la disabilitazione di ciò che viene descritto sinteticamente dalla parte finale del loro nome; per esempio, la direttiva skip-networking serve a disabilitare l'accesso attraverso la rete. Di solito, la configurazione predefinita di MySQL prevede proprio l'uso di questa direttiva per impedire l'accesso attraverso la rete, rendendo necessaria la modifica di questo file per consentirlo in modo esplicito.
Un altro tipo di direttiva, che comunque rientra nel genere normale di assegnamento, serve a dichiarare delle variabili, intese come opzioni di funzionamento, a cui si assegna anche un valore. Si tratta di direttive che hanno l'aspetto seguente:
|
|
L'utilizzo di queste variabili può dipendere dal modo in cui si compilano i sorgenti di MySQL; pertanto può essere necessario stabilire su cosa si può intervenire, avviando il demone mysqld con l'opzione --help, anche senza privilegi particolari:
$ /usr/bin/mysql --help[Invio]
Oltre alla sintassi relativa alla riga di comando, si dovrebbe osservare la presenza dell'elenco seguente, che qui viene abbreviato:
Variables (--variable-name=value)
and boolean options {FALSE|TRUE} Value (after reading options)
--------------------------------- -----------------------------
auto-rehash TRUE
character-sets-dir (No default value)
default-character-set (No default value)
compress FALSE
database (No default value)
...
net_buffer_length 16384
select_limit 1000
max_join_size 1000000
|
L'avvio e l'arresto del servente dovrebbe essere gestito da uno script della procedura di inizializzazione del sistema, che in generale potrebbe corrispondere a /etc/init.d/mysql. Se le cose stanno così, è sufficiente avviare il servizio con il comando seguente:
# /etc/init.d/mysql start[Invio]
Nello stesso modo, per arrestare il servizio basta il comando seguente:
# /etc/init.d/mysql stop[Invio]
Può essere interessante approfondire cosa succede realmente all'interno di questo script per comprendere come è organizzato MySQL nell'ambito del proprio sistema operativo.
In generale ci sono da considerare due aspetti: il demone mysqld non viene avviato direttamente, ma attraverso un altro programma, mysqld_safe; in secondo luogo, l'arresto del funzionamento del servente avviene attraverso mysqladmin, che richiede l'indicazione di una parola d'ordine.
L'avvio del servente attraverso mysqld_safe non richiede la comprensione di altre questioni, a parte la necessità di accertarsi che non ci sia già un servente MySQL in funzione. Comunque, la presenza di questo programma (mysqld_safe) fa sì che esista anche una sezione apposita nella configurazione, denominata nello stesso modo:
|
Il problema dell'arresto del servizio è invece più complesso, in quanto si deve usare un altro programma, mysqladmin, che può portare a termine l'operazione soltanto se si utilizzano i privilegi dell'amministratore del servizio, per ottenere i quali occorre fornire la parola d'ordine relativa:
# mysqladmin --password="ciaociao" shutdown[Invio]
L'amministratore di MySQL ha il nome root (in questo caso sarebbe precisamente root@localhost), che, come accennato nella premessa, coincide volutamente con il nome dell'amministrazione di un sistema Unix, pur non essendo la stessa cosa. Dal momento che ogni utente di MySQL può predisporre nella propria directory personale un file di configurazione personalizzato, corrispondente a ~/.my.cnf, in questo file si può anche inserire la propria parola d'ordine, con una direttiva della sezione [client], che in questo caso è riferita all'utente root:
|
Così facendo, come viene chiarito in seguito, quando un utente del sistema operativo accede a un servente MySQL locale, se l'utenza di MySQL coincide con il nominativo usato nell'ambito del sistema operativo, può fare a meno di fornire la propria parola d'ordine perché già definita nella configurazione personale. Secondo questo principio, l'utente root del sistema operativo potrebbe fare altrettanto per consentire a script che vengono avviati automaticamente di svolgere il loro compito.
Esistono comunque dei raggiri differenti, per evitare di costringere l'utente root del sistema operativo a inserire la parola d'ordine nel file di configurazione ~/.my.cnf. In particolare, la distribuzione GNU/Linux Debian definisce un utente speciale, denominato debian-sys-maint (debian-sys-maint@localhost), con i privilegi necessari, a cui associa il file di configurazione /etc/mysql/debian.cnf, avviando poi mysqladmin con l'opzione --defaults-extra-file:
# mysqladmin --defaults-extra-file=/etc/mysql/debian.cnf ...[Invio]
Naturalmente, il file /etc/mysql/debian.cnf non deve essere leggibile agli utenti comuni del sistema operativo, dal momento che contiene la parola d'ordine per le funzioni amministrative gestite in modo automatico dal sistema operativo:
|
MySQL distingue le proprie utenze in base a un nominativo e al nome dell'elaboratore da cui questi accedono. Il nominativo può anche essere assente e in tal caso si parla di utenze anonime. L'accesso può essere sottoposto al controllo di una parola d'ordine; inoltre, può anche essere consentito l'accesso a una base di dati senza essere utenti conosciuti.
Un primo controllo di accesso si ottiene con la configurazione del servente MySQL, dove è possibile escludere l'accesso attraverso la rete con la direttiva skip-networking, cosa che è utile fare quando il sistema di utenze e dei privilegi relativi non è ancora stato definito.
Per poter iniziare a organizzare le basi di dati e le utenze di MySQL, occorre agire con i privilegi dell'utente root. Quando si installa MySQL per la prima volta, è molto probabile che questo utente risulti essere sprovvisto di parola d'ordine, consentendo in pratica a qualunque utente di dichiararsi root, senza bisogno di altre forme di riconoscimento (ecco perché inizialmente è bene che la configurazione impedisca almeno l'accesso dall'esterno, attraverso la rete). Per attribuire una parola d'ordine all'utente root presso l'elaboratore che ospita il servente MySQL (quindi root@localhost) quando questo ne è ancora sprovvisto, basta usare il comando seguente:
# mysqladmin -u root password 'ciaociao'[Invio]
Come si intende, la parola d'ordine che appare nell'esempio è proprio «ciaociao».
A partire dal momento in cui la parola d'ordine è stata definita, ogni accesso al servente compiuto da questo utente richiede la sua indicazione, salvo il caso in cui la parola d'ordine viene inserita nel file di configurazione personale ~/.my.cnf:
|
In questo caso, facendo riferimento alla sezione [client], la configurazione riguarda qualunque situazione in cui si accede al servente; in pratica riguarda qualunque programma. Eventualmente, si possono definire contesti più precisi; per esempio come nel caso seguente, in cui si consente di non specificare la parola d'ordine solo quando si utilizza il programma mysqladmin:
|
Il sistema di gestione delle utenze di MySQL è abbastanza complesso, dove per esempio, è possibile anche concedere dei privilegi di accesso a utenti qualunque provenienti da un certo nodo, o da un certo gruppo di nodi.
Per quanto riguarda l'indicazione dei nominativi-utente, esistono solo due possibilità: indicare un nome preciso, oppure non indicarlo affatto. Nel secondo caso si intende fare riferimento a qualunque utente nell'ambito del nodo o del gruppo di nodi a cui la definizione dei privilegi è associata.
Il nodo di accesso può essere indicato per nome, per numero, oppure si può fare riferimento a un gruppo di nodi con l'uso di caratteri jolly oppure associando a un indirizzo una maschera di rete. I caratteri jolly in questione sono il simbolo di percentuale (%) e il trattino basso (_). Segue una tabellina che descrive alcuni esempi di associazione tra utenti e nodi di accesso.
A seconda del contesto, le coordinate di un utente si indicano come nella tabella, inserendo il carattere @ per separare le due parti, oppure in campi distinti. In molti casi, nell'ambito delle istruzioni di MySQL è necessario proteggere il nome dell'utente e l'indicazione del nodo o dei nodi di accesso attraverso apici singoli. Per esempio, per poter indicare qualunque utente, come nel secondo esempio della tabella, è necessario delimitare la stringa nulla: ''@dinkel.brot.dg. Così, quando si usa il carattere jolly % è indispensabile delimitare l'indicazione riferita al nodo: tizio@'%.brot.dg'. In generale non si sbaglia se si delimitano sempre queste due componenti, anche se non dovesse servire: 'tizio'@'dinkel.brot.dg'.
Prima di poter definire delle politiche di accesso, è necessario prendere un po' di confidenza con il programma mysql, che consente di interagire con il servente MySQL. Si è già accennato al fatto che inizialmente dovrebbe risultare permesso l'accesso da parte di qualunque utente, inoltre dovrebbe essere disponibile la base di dati test, a cui qualunque utente può accedere.
|
|
|
|
I modelli sintattici mostrano la possibilità di indicare delle opzioni ed eventualmente il nome di una base di dati da aprire inizialmente. Nel secondo modello, si vede in particolare come si può alimentare il programma mysql con uno script SQL. La tabella successiva descrive alcune delle opzioni che possono essere utilizzate.
Il programma mysql è uno di quelli che prende in considerazione la configurazione di MySQL, soprattutto per quanto riguarda il file ~/.my.cnf, dove gli utenti possono inserire il proprio nominativo-utente da utilizzare con MySQL e la parola d'ordine, per non dover ogni volta utilizzare le opzioni -u e -p:
|
Per esempio, se un certo utente del sistema operativo ha la necessità di identificarsi con il nominativo tizio e la sua parola d'ordine:
$ mysql -u tizio -p ...[Invio]
Enter password: digitazione_all'oscuro[Invio]
Oppure, disponendo del file ~/.my.cnf mostrato sopra, può fare a meno di queste opzioni e dell'indicazione della parola d'ordine.
Viene mostrato un esempio riferito all'utente tizio che accede a un servente MySQL locale:
$ mysql -u tizio[Invio]
Molto probabilmente non è necessario inserire alcuna parola d'ordine, dal momento che inizialmente dovrebbe essere stata inserita automaticamente l'utenza anonima @localhost senza parola d'ordine:
Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 14 to server version: 4.0.13-log Type 'help;' or '\h' for help. Type '\c' to clear the buffer. |
Da questo momento appare un invito speciale, rappresentato dalla stringa mysql>. La prima cosa che può essere conveniente fare è verificare la disponibilità di basi di dati a cui si può accedere:
mysql> SHOW DATABASES;[Invio]
Molto probabilmente si ottiene precisamente quanto segue, ovvero il riferimento all'unica base di dati, test, a cui è consentito accedere con questo utente:
+----------+ | Database | +----------+ | test | +----------+ 1 row in set (0.03 sec) |
Si può selezionare la base di dati con il comando seguente:
mysql> USE test;[Invio]
Database changed |
Quindi si può tentare di consultare l'elenco delle tabelle disponibili, con il comando seguente, ma inizialmente la basi di dati test non ne contiene alcuna:
mysql> SHOW TABLES;[Invio]
Empty set (0.00 sec) |
A titolo di esempio si vuole creare la tabella Indirizzi con il codice SQL seguente:
|
Con il programma mysql si può fare così:
mysql> CREATE TABLE Indirizzi ([Invio]
-> Codice INTEGER,[Invio]
-> Cognome CHAR(40),[Invio]
-> Nome CHAR(40),[Invio]
-> Indirizzo VARCHAR(60),[Invio]
-> Telefono VARCHAR(40)[Invio]
-> );[Invio]
Query OK, 0 rows affected (0.06 sec) |
Come si può osservare, finché l'istruzione SQL non risulta completa, appare un invito differente: ->.
Per completare l'esempio si può inserire qualche dato e poi si può visualizzare il contenuto della tabella:
mysql> INSERT INTO Indirizzi VALUES (01, 'Pallino', 'Pinco',[Invio]
-> 'Via Biglie 1', '0222,222222');[Invio]
Query OK, 1 row affected (0.06 sec) |
mysql> SELECT * FROM Indirizzi;[Invio]
+--------+---------+-------+--------------+-------------+ | Codice | Cognome | Nome | Indirizzo | Telefono | +--------+---------+-------+--------------+-------------+ | 1 | Pallino | Pinco | Via Biglie 1 | 0222,222222 | +--------+---------+-------+--------------+-------------+ 1 row in set (0.00 sec) |
Per concludere il funzionamento di mysql basta il comando interno quit, che si può esprimere anche come \q:
mysql> \q[Invio]
Bye |
MySQL gestisce le proprie informazioni amministrative all'interno della base di dati mysql, a cui si dovrebbe poter accedere soltanto in qualità di utente root (possibilmente root@localhost), o comunque solo attraverso utenze speciali.
# mysql -u root -p[Invio]
Enter password: digitazione all'oscuro[Invio]
In questo modo si vuole accedere al servente MySQL locale, in qualità di utente root (root@localhost), fornendo anche la parola d'ordine.
Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 15 to server version: 4.0.13-log Type 'help;' or '\h' for help. Type '\c' to clear the buffer. |
Si controlla la disponibilità di basi di dati esistenti:
mysql> SHOW DATABASES;[Invio]
+----------+ | Database | +----------+ | mysql | | test | +----------+ 2 rows in set (0.01 sec) |
Si accede alla base di dati mysql:
mysql> USE mysql;[Invio]
Database changed |
Si elencano le tabelle disponibili:
mysql> SHOW TABLES;[Invio]
+-----------------+ | Tables_in_mysql | +-----------------+ | columns_priv | | db | | func | | host | | tables_priv | | user | +-----------------+ 6 rows in set (0.00 sec) |
Il significato dettagliato di queste tabelle può essere studiato nella documentazione originale che accompagna MySQL. Ciò che è importante comprendere è che non si può consentire l'accesso a queste tabelle a utenti che non hanno un ruolo amministrativo. Tuttavia, durante la fase di studio di MySQL da parte di chi deve poi amministrarne il servizio, è utile imparare a consultare queste tabelle. Per esempio, è utile essere al corrente delle utenze che sono effettivamente previste:
mysql> SELECT User, Host, Password FROM user;[Invio]
+------------------+-----------+------------------+ | user | host | password | +------------------+-----------+------------------+ | root | localhost | 576gtd435e967361 | | root | dinkel | | | | localhost | | | | dinkel | | | debian-sys-maint | localhost | 69b3c178kbvcd325 | +------------------+-----------+------------------+ 5 rows in set (0.00 sec) |
Quello che si vede qui è quanto si potrebbe ottenere dopo aver installato MySQL in una distribuzione GNU/Linux Debian, attraverso pacchetti appositi, in un elaboratore dove il comando hostname restituisce il nome dinkel. Si può notare la presenza dell'utente speciale debian-sys-maint, a cui si è già accennato, ma si deve portare attenzione alle utenze «normali». Si può osservare che ci sono due utenti root; precisamente si tratta di root@localhost e di root@dinkel. La seconda di queste due utenze rappresenta l'utente root che accede localmente, ma attraverso la rete, da un'interfaccia che è associata al nome dell'elaboratore (in questo caso dinkel.brot.dg). Può anche darsi che un'utenza annotata in questo modo non risulti funzionante, ma rimane il problema, dato il fatto che si tratta di un'utenza importante e senza parola d'ordine per accedere (per quanto riguarda l'utenza root@localhost è già stato mostrato come definire la parola d'ordine ed è per questo che appare qualcosa nella colonna password). Eventualmente, si possono fare considerazioni simili per l'utenza anonima @dinkel.
Probabilmente è superfluo precisare che nella colonna password, se esiste una parola d'ordine associata all'utenza, appare una stringa che rappresenta la parola d'ordine cifrata.
mysql> \q[Invio]
Bye |
Durante la fase della prima installazione di MySQL uno script si occupa di creare le directory che devono ospitare i file che compongono le basi di dati, inserendo le basi di dati iniziali (mysql e test). In pratica, è questo script che definisce anche le utenze iniziali, senza parola d'ordine. Questo script è mysql_install_db.
Il modo normale per creare un'utenza con MySQL è quello di attribuirle dei privilegi di accesso, attraverso l'istruzione GRANT; se poi quell'utenza esiste già, i privilegi in questione vengono solo aggiunti a quelli già esistenti. Per eliminare un'utenza, invece, non è sufficiente privarla di tutti i privilegi con l'istruzione REVOKE, perché occorre anche eliminare la riga corrispondente all'utenza nella tabella user della base di dati mysql.
Gli schemi seguenti mostrano la sintassi semplificata per l'uso delle istruzioni GRANT e REVOKE con MySQL:
|
|
|
|
I privilegi che possono essere concessi o revocati sono espressi attraverso una parola chiave. Alcuni di questi privilegi sono descritti nell'elenco seguente:
| Privilegio | Descrizione |
|
| attribuisce tutti i privilegi disponibili; |
|
| consente la modifica delle tabelle; |
|
| consente la creazione delle tabelle; |
|
| consente la cancellazione dei dati contenuti nelle tabelle; |
|
| consente l'eliminazione delle tabelle; |
|
| consente di creare ed eliminare degli indici; |
|
| consente l'inserimento di dati nelle tabelle; |
|
| consente la lettura dei dati nelle tabelle; |
|
| consente la modifica dei dati all'interno delle tabelle; |
|
| serve solo a creare un utente senza privilegi; |
|
| consente di dare ad altri i propri privilegi. |
Si osservi che MySQL prevede anche privilegi «particolari», che dipendono dalle proprie particolarità rispetto allo standard ANSI. In generale, si può considerare che l'utente root deve possedere tutti i privilegi, mentre possono esistere delle utenze amministrative fittizie (come nel caso di debian-sys-maint) con privilegi particolari legati alla possibilità di arrestare il funzionamento del servente MySQL.
Lo standard ANSI prevede la concessione di privilegi su tabelle singole, mentre MySQL permette di fare riferimento a basi di dati complete. Pertanto, nel modello sintattico mostrato sono apparse delle notazioni speciali:
Come già accennato altre volte, l'utenza tiene conto anche della provenienza dell'accesso, secondo la forma seguente:
|
|
Pertanto, l'indicazione del nominativo è obbligatoria, mentre si può omettere la specificazione del nodo di provenienza, se si vuole fare riferimento a qualunque origine.
Sono già stati descritti i modi in cui si può rappresentare un utente secondo il modello utente@nodo; in particolare è già stato descritto l'utilizzo dei caratteri jolly (anche se sono stati mostrati soltanto esempi con il simbolo %).
|
Si ricorda comunque che si possono usare i caratteri jolly soltanto nella parte che descrive i nodi di provenienza |
Infine, è già stata indicata la necessità di usare gli apici singoli per delimitare separatamente il nominativo e la specificazione del nodo di provenienza quando questi nomi contengono caratteri «particolari», compresi i caratteri jolly % e _.
|
Si possono presentare delle ambiguità nell'individuazione dei privilegi delle utenze. Per esempio, può esistere l'utente anonimo ''@dinkel.brot.gd, l'utente tizio@'%' e l'utente tizio@dinkel.brot.gd: quando un utente accede valgono per lui i privilegi più specifici che gli si possono attribuire, altrimenti, in presenza di utenze anonime, i privilegi di queste prenderebbero il sopravvento. |
Come si vede dal modello sintattico dell'istruzione GRANT, è possibile specificare una parola d'ordine. Quando si attribuiscono dei privilegi a un utente che non è ancora stato definito e non si stabilisce la parola d'ordine, l'utenza in questione rimane priva di parola d'ordine; pertanto, per accedere non deve essere fornita. Se invece l'utenza esiste già, i privilegi vengono aggiunti e la presenza dell'eventuale parola d'ordine serve solo per cambiare quella preesistente. Tuttavia, è possibile cambiare una parola d'ordine anche con l'istruzione SET PASSWORD, se si tratta della propria o se si hanno i privilegi dell'amministratore:
|
|
In alternativa, è anche possibile usare il comando mysqladmin (dal sistema operativo), ma solo per cambiare la propria parola d'ordine:
$ mysqladmin password 'supersegreta'[Invio]
Se si utilizza l'opzione GRANT OPTION, o WITH GRANT OPTION, si permette all'utenza a cui si fa riferimento di concedere ad altri gli stessi privilegi di cui si dispone.
Come accennato, l'eliminazione di un'utenza richiede prima l'eliminazione di tutti i privilegi e quindi la cancellazione dalla tabella User della base di dati mysql.
Nel seguito vengono descritti alcuni esempi attraverso una sequenza lineare di operazioni, a cominciare dall'avvio del programma mysql per interagire con il servente.
$ mysql -u root -p[Invio]
Enter password: parola_d'ordine[Invio]
Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 6 to server version: 4.0.13-log Type 'help;' or '\h' for help. Type '\c' to clear the buffer. |
Si crea una base di dati nuova:
mysql>CREATE DATABASE Magazzino;[Invio]
Query OK, 1 row affected (0.26 sec) |
Si crea un utente amministratore per la base di dati appena creata, che può accedere da dove vuole:
mysql>GRANT ALL ON Magazzino.* TO amministratore@'%' \
\IDENTIFIED BY 'segreta' WITH GRANT OPTION;[Invio]
Query OK, 0 rows affected (0.35 sec) |
Si osservi che se esiste un'utenza anonima riferita al nodo locale (utenza che verrebbe indicata come ''@localhost), se l'utente appena creato volesse accedere localmente, non verrebbe identificato come amministratore, ma solo come utente anonimo. Per risolvere il problema si potrebbe aggiungere l'utente amministratore@localhost, ma in questo caso si preferisce eliminare l'utenza anonima che interferisce e non si vuole mantenere:
mysql>REVOKE ALL ON *.* FROM ''@localhost;[Invio]
Query OK, 0 rows affected (0.15 sec) |
mysql> USE mysql;[Invio]
Database changed |
mysql>DELETE FROM user WHERE user = '' AND host = 'localhost';[Invio]
Query OK, 0 rows affected (0.15 sec) |
Si crea un'altra utenza in grado di consultare e di modificare i dati delle tabelle che deve contenere la base di dati Magazzino; anche in questo caso si consente l'accesso da qualunque nodo:
mysql>GRANT DELETE, INSERT, SELECT, UPDATE ON Magazzino.* \
\TO tizio@'%' IDENTIFIED BY 'ottimo';[Invio]
Query OK, 0 rows affected (0.05 sec) |
Supponendo di avere installato MySQL nell'elaboratore dinkel.brot.dg, dovrebbero essere presenti anche le utenze ''@dinkel e root@dinkel, che si preferisce eliminare:
mysql>REVOKE ALL ON *.* FROM ''@dinkel;[Invio]
Query OK, 0 rows affected (0.15 sec) |
mysql>REVOKE ALL ON *.* FROM root@dinkel;[Invio]
Query OK, 0 rows affected (0.15 sec) |
mysql> USE mysql;[Invio]
Database changed |
mysql>DELETE FROM user WHERE user = '' AND host = 'dinkel';[Invio]
Query OK, 0 rows affected (0.15 sec) |
mysql>DELETE FROM user WHERE user = 'root' AND host = 'dinkel';[Invio]
Query OK, 0 rows affected (0.15 sec) |
mysql>\q[Invio]
Bye |
La documentazione di MySQL descrive anche come compiere tutte queste operazioni amministrative intervenendo direttamente nella base di dati mysql. Nel caso si preferisca intervenire in quel modo, è necessario concludere le operazioni di modifica o aggiornamento delle tabelle amministrative con l'istruzione FLUSH PRIVILEGES.
In questo capitolo si è fatto riferimento più volte al programma mysqladmin a proposito della possibilità di attribuire e modificare la parola d'ordine di un utente. Questo programma ha anche altre funzionalità; in particolare consente di creare ed eliminare una base di dati e di arrestare il funzionamento del servente MySQL, senza bisogno di utilizzare istruzioni SQL. Vengono sintetizzate le sintassi da utilizzare per le varie occasioni:
MySQL AB, MySQL reference manual
Appunti di informatica libera 2004.10.10 --- Copyright © 2000-2004 Daniele Giacomini -- <daniele (ad) swlibero·org>, <daniele·giacomini (ad) poste·it>
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome mysql_introduzione.html
[successivo] [precedente] [inizio] [fine] [indice generale] [violazione licenza] [translators] [docinfo] [indice analitico]