Attachment 77401 Details for Bug 119386 – MySQL Howto Italian Translation

MySQL Howto Italian Translation

mysql-howto.xml (text/plain), 33.24 KB, created by Davide Cendron (RETIRED) on 2006-01-18 00:34:34 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Davide Cendron (RETIRED)

Created: 2006-01-18 00:34:34 UTC

Size: 33.24 KB

patch

obsolete

>ï»¿<?xml version="1.0" encoding="UTF-8"?>
><!DOCTYPE guide SYSTEM "/dtd/guide.dtd">
>
>
><guide link="/doc/it/mysql-howto.xml" lang="it">
><title>Guida introduttiva per MySQL</title>
>
><author title="Autore">
> <mail link="chriswhite@gentoo.org">Chris White</mail>
></author>
><author title="Revisione">
> <mail link="fox2mike@gentoo.org">Shyam Mani</mail>
></author>
><author title="Revisione">
> <mail link="neysx@gentoo.org">Xavier Neys</mail>
></author>
><author title="Traduzione">
>	Davide Cendron
></author>
>
><abstract>
>Questo documento aiuta un utente a configurare ed usare MySQL.
></abstract>
>
>
>
><license/>
>
><version>1.3</version>
><date>2005-12-15</date>
>
><chapter>
><title>Cominciare con MySQL</title>
><section>
><title>Introduzione</title>
><body>
>
>
>MySQL Ã¨ un popolare server di database usato in varie applicazioni. SQL
>significa (S)tandard (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.
>
>
></body>
></section>
><section>
><title>Installazione di MySQL</title>
><body>
>
>
>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.
>
>
><pre caption="Installare MySQL">
><comment>(Vedere le flag USE disponibili)</comment>
># emerge --pretend --verbose mysql
><comment>(Installare MySQL)</comment>
># emerge mysql
></pre>
>
>
>Alla fine dell'installazione, vedrete la notifica seguente:
>
>
><pre caption="messaggio einfo MySQL">
>You might want to run:
>"emerge --config =dev-db/mysql-[version]"
>if this is a new install.
></pre>
>
>
>Siccome questa Ã¨ una nuova installazione, eseguiamo il comando. Dovete premere
><c>INVIO</c> 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.
>
>
><pre caption="Configurazione di MySQL">
># ebuild /var/db/pkg/dev-db/mysql-[version]/mysql-[version].ebuild config
> * 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:
><comment>(Notare le seguenti 3 linee)</comment>
> /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.
>
><comment>(Qualche informazione di MySQL non inerente in modo specifico agli
>ebuild Ã¨ stata rimossa da qui per mantenere il documento il piÃ¹ consistente
>possibile)</comment>
>
> * For security reasons you should set your MySQL root
> * password as soon as possible.
></pre>
>
><impo>
>Da mysql-4.0.24-r2, le password vengono immesse durante la fase di
>configurazione, rendendo l'inserimento della password di root piÃ¹ sicuro.
></impo>
>
>
>Lo script di configurazione ha giÃ  stampato a video i comandi necessari per
>impostare la password di root, non ci resta che eseguirli.
>
>
><pre caption="Impostare la password di root per MySQL">
># /etc/init.d/mysql start
> * Re-caching dependency info (mtimes differ)...
> * Starting mysqld (/etc/mysql/my.cnf) ... [ ok ]
><comment>(Sostituite nuova-password con la password che
>desiderate)</comment>
># /usr/bin/mysqladmin -u root -h localhost password 'nuova-password'
></pre>
>
>
>Ora potete testare se la password di root Ã¨ stata configurata correttamente
>provando ad accedere al server MySQL:
>
>
><pre caption="Accesso al server MySQL usando 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&gt;
></pre>
>
>
>L'opzione <c>-u</c> imposta l'utente che effettuerÃ  il login. L'opzione
><c>-h</c> imposta l'host. Solitamente equivale a <c>localhost</c> a meno che
>non stiate configurando un server remoto. Infine, <c>-p</c> dice al client
>mysql che digiterete una password per accedere al database. Osservate il
>prompt <c>mysql&gt;</c>. LÃ¬ andranno digitati tutti i comandi. Ora che ci
>troviamo nel prompt mysql come utenti root, possiamo cominciare ad impostare
>il nostro database.
>
>
></body>
></section>
></chapter>
>
><chapter>
><title>Impostare il database</title>
><section>
><title>Creare un database</title>
><body>
>
>
>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 <c>SHOW DATABASES</c>.
>
>
><pre caption="Visualizzare i database MySQL">
>mysql&gt; SHOW DATABASES;
>+----------+
>| Database |
>+----------+
>| mysql |
>| test |
>+----------+
>2 rows in set (0.09 sec)
></pre>
>
><impo>
>Ricordate che i comandi di MySQL devono terminare con un punto e virgola --
><c>;</c>
></impo>
>
>
>Anche se un database di test Ã¨ giÃ  stato creato, andiamo a crearne uno
>nostro. I database si creano usando il comando <c>CREATE DATABASE</c>. Ne
>creeremo uno chiamato "gentoo".
>
>
><pre caption="Creare il database gentoo">
>mysql&gt; CREATE DATABASE gentoo;
>Query OK, 1 row affected (0.08 sec)
></pre>
>
>
>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
><c>SHOW DATABASES</c>.
>
>
><pre caption="Verificare la creazione del database">
>mysql&gt; SHOW DATABASES;
>+----------+
>| Database |
>+----------+
>| gentoo |
>| mysql |
>| test |
>+----------+
>3 rows in set (0.00 sec)
></pre>
>
>
>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 <c>USE</c>. Il comando <c>USE</c> richiede il
>nome del database sul quale desiderate operare. Un'altro modo Ã¨ specificarlo
>sulla riga di comando dopo l'opzione <c>-D</c>. Proseguiamo e selezioniamo il
>database "gentoo".
>
>
><pre caption="Selezionare il database">
>mysql&gt; USE gentoo;
>Database changed
></pre>
>
>
>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.
>
>
></body>
></section>
></chapter>
>
><chapter>
><title>Lavorare con le tabelle in MySQL</title>
><section>
><title>Creare una tabella</title>
><body>
>
>
>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 <c>SHOW TABLES</c>. Al
>momento non ci sono tabelle nel database "gentoo", come visualizzato
>dall'esecuzione del comando:
>
>
><pre caption="Database gentoo vuoto">
>mysql&gt; SHOW TABLES;
>Empty set (0.00 sec)
></pre>
>
>
>Ã quindi necessario crearle. Per farlo, useremo il comando <c>CREATE
>TABLE</c>. Tuttavia questo comando Ã¨ abbastanza differente dal semplice
>comando <c>CREATE DATABASE</c>. Questo comando richiede una lista di
>argomenti. La sintassi Ã¨ la seguente:
>
>
><pre caption="Sintassi CREATE TABLE">
>CREATE TABLE [nome_tabella] ([nome_campo] [tipo_dato_campo]([dimensione]));
></pre>
>
>
>nome_tabella Ã¨ il nome della tabella che vogliamo creare. In questo
>caso, andremo a crearne una chiamata <c>developers</c>. 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 <uri
>link="http://dev.mysql.com/doc/mysql/en/column-types.html">MySQL Column
>Types Page</uri>. Per i nostri scopi, useremo il tipo di dato <c>VARCHAR</c>
>per tutti i campi. <c>VARCHAR</c> Ã¨ 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 <c>VARCHAR</c> 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.
>
>
><pre caption="Creare la tabella">
>mysql&gt; CREATE TABLE developers ( name VARCHAR(128), email VARCHAR(128), job VARCHAR(128));
>Query OK, 0 rows affected (0.11 sec)
></pre>
>
>
>La tabella sembra essere stata creata correttamente. Controlliamo con il
>comando <c>SHOW TABLES</c>:
>
>
><pre caption="Controllare la creazione della tabella">
>mysql&gt; SHOW TABLES;
>+------------------+
>| Tables_in_gentoo |
>+------------------+
>| developers |
>+------------------+
>1 row in set (0.00 sec)
></pre>
>
>
>La nostra tabella viene correttamente elencata. Tuttavia, non riceviamo
>alcuna informazione sui tipi di campo che abbiamo impostato. Per ottenere ciÃ²
>usiamo il comando <c>DESCRIBE</c> (o <c>DESC</c> in forma abbreviata), che
>richiede il nome della tabella come argomento. Guardiamo cosa fornisce per la
>tabella "developers".
>
>
><pre caption="Descrizione della tabella 'developers'">
>mysql&gt; 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)
></pre>
>
>
>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 <uri
>link="http://dev.mysql.com/doc/mysql/en/">MySQL Reference Manual</uri> per
>ulteriori informazioni. Ora abbiamo una tabella sulla quale lavorare.
>Proseguiamo e popoliamola.
>
>
></body>
></section>
><section>
><title>Popolare il nostro database MySQL</title>
><body>
>
>
>Popoliamo una tabella (o aggiungiamo dei dati) usando il comando <c>INSERT</c>.
>Come il comando <c>CREATE TABLE</c>, esso ha una sintassi specifica:
>
>
><pre caption="Sintassi INSERT">
>INSERT INTO tabella (col1, col2, ...) VALUES('valore1', 'valore2', ...);
></pre>
>
>
>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 <c>VALUES()</c> 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:
>
>
><pre caption="Inserire informazioni nella tabella 'developers'">
>mysql&gt; INSERT INTO developers VALUES('Joe Smith', 'joesmith@gentoo.org',
>'toolchain');
>Query OK, 1 row affected (0.06 sec)
><comment>(Se non conoscete l'ordine delle colonne nella tabella o volete
>inserire un record incompleto)</comment>
>mysql&gt; INSERT INTO developers (job, name) VALUES('outsourced', 'Jane Doe')
>Query OK, 1 row affected (0.01 sec)
></pre>
>
>
>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 <c>LOAD DATA</c> 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 <path>records.txt</path>. Ecco
>un esempio:
>
>
><pre caption="~/records.txt">
>John Doe johndoe@gentoo.org portage
>Chris White chriswhite@gentoo.org documentation
>Sam Smith samsmith@gentoo.org amd64
></pre>
>
><impo>
>Assicuratevi di sapere che dati state trattando. E' molto insicuro usare
><c>LOAD DATA</c> quando si Ã¨ incerti sul contenuto del file!
></impo>
>
>
>Il comando <c>LOAD DATA</c> ha una definizione alquanto allungata, ma noi qui
>useremo la forma piÃ¹ semplice.
>
>
><pre caption="Sintassi LOAD DATA">
>LOAD DATA LOCAL INFILE '/percorso/al/nome_file' INTO TABLE tabella;
></pre>
>
>
><path>/percorso/al/nome_file</path> Ã¨ la directory e il nome del file che
>verrÃ  usato. "tabella" Ã¨ il nome della nostra tabella. In questo caso, il
>nostro file Ã¨ <path>~/record.txt</path> e la tabella Ã¨ "developers".
>
>
><pre caption="Caricare i dati">
>mysql&gt; 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
></pre>
>
><impo>
>Se doveste incappare in qualunque strano comportamento del comando,
>assicuratevi che i campi nel file siano separati da delle tabulazioni. Se
>incollate le informazioni nel file da un'altra fonte, le tabulazioni
>potrebbero venire convertite in spazi.
></impo>
>
>
>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:
>
>
><pre caption="MySQL in modalitÃ  batch">
>$ mysql -u root -h localhost -p &lt; sqlfile
></pre>
>
>
>Come con <c>LOAD DATA</c>, controllate cosa fa lo script <path>sqlfile</path>.
><e>Se non lo fate rischiate di compromettere il database!</e> Un altro modo per
>eseguire uno script sql Ã¨ usare il comando <c>SOURCE</c>. 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:
>
>
><pre caption="Eseguire uno script sql">
>mysql&gt; source sqlfile;
></pre>
>
>
>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.
>
>
></body>
></section>
><section>
><title>Visualizzare il contenuto delle tabelle MySQL tramite le Query</title>
><body>
>
>
>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
><c>SELECT</c>. Il comando <c>SELECT</c> Ã¨ abbastanza complesso, per cui daremo
>uno sguardo, in questo documento, solamente alle tre forme principali del
>comando.
>
>
><pre caption="Forme di SELECT">
><comment>(Seleziona tutte i record inseriti in una tabella)</comment>
>SELECT * FROM tabella;
><comment>(Seleziona determinati record in una tabella)</comment>
>SELECT * FROM tabella WHERE campo=valore;
><comment>(Seleziona dei determinati campi)</comment>
>SELECT campo1,campo2,campo3 FROM tabella [WHERE campo=valore];
></pre>
>
>
>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.
>
>
><pre caption="Contenuti della tabella">
>mysql&gt; 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)
></pre>
>
>
>Vediamo sia i dati inseriti tramite <c>INSERT</c> sia quelli inseriti
>tramite <c>LOAD DATA</c>. 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.
>
>
><pre caption="Selezionare un record specifico usando SELECT">
>mysql&gt; SELECT * FROM developers WHERE name = 'Chris White';
>+-------------+-----------------------+---------------+
>| name | email | job |
>+-------------+-----------------------+---------------+
>| Chris White | chriswhite@gentoo.org | documentation |
>+-------------+-----------------------+---------------+
>1 row in set (0.08 sec)
></pre>
>
>
>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 <c>SELECT</c>
>mostrata qui sotto:
>
>
><pre caption="Selezionare uno specifico record e specifici campi usando SELECT">
>mysql> SELECT email,job FROM developers WHERE name = 'Chris White';
>+-----------------------+---------------+
>| email | job |
>+-----------------------+---------------+
>| chriswhite@gentoo.org | documentation |
>+-----------------------+---------------+
>1 row in set (0.04 sec)
></pre>
>
>
>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.
>
>
></body>
></section>
></chapter>
>
><chapter>
><title>Privilegi di MySQL</title>
><section>
><title>Concedere Privilegi con GRANT</title>
><body>
>
>
>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 pÃ² semplificata del comando
><c>GRANT</c>.
>
>
><pre caption="Sintassi GRANT">
>GRANT [privilegi] ON database.* TO '[utente]'@'[host]' IDENTIFIED BY
>'[password]';
></pre>
>
><note>
><c>GRANT</c> Ã¨ da considerarsi la modalitÃ  con la quale creare un utente. Le
>ultime versioni di MySQL, tuttavia, contengono una funzione <c>CREATE_USER</c>,
>sebbene sia ancora preferibile usare <c>GRANT</c>.
></note>
>
>
>Il primo parametro si riferisce ai privilegi che desideriamo assegnare.
>Ricordando quello che abbiamo appreso precedentemente, alcuni dei privilegi che
>possiamo impostare sono:
>
>
><ul>
> <li><c>ALL</c> - DÃ  tutti i privilegi di controllo sul database</li>
> <li><c>CREATE</c> - Permette agli utenti di creare tabelle</li>
> <li><c>SELECT</c> - Permette agli utenti di effettuare query su tabelle</li>
> <li><c>INSERT</c> - Permette agli utenti di inserire dati nelle tabelle</li>
> <li><c>SHOW DATABASES</c> - Permette agli utenti di vedere una lista dei
> database
> </li>
> <li><c>USAGE</c> - L'utente non ha privilegi</li>
> <li><c>GRANT OPTION</c> - Permette agli utenti di concedere privilegi</li>
></ul>
>
><note>
>Se state eseguendo MySQL per trasmettere dati ad un'applicazione web,
><c>CREATE</c>,<c>SELECT</c>, <c>INSERT</c> (discussi qui), <c>DELETE</c> e
><c>UPDATE</c> (per ulteriori informazioni leggete la sezione <uri
>link="http://dev.mysql.com/doc/mysql/en/grant.html"> MySQL Reference Manual
>-GRANT and REVOKE Syntax</uri>) sono gli unici permessi di cui avrete bisogno
>nella maggior parte dei casi. Molte persone commettono l'errore di assegnare
>tutti i privilegi anche se non Ã¨ realmente necessario. Controllate con lo
>sviluppatore dell'applicazione se tali permessi possono causare problemi con
>operazioni di ordine generale.
></note>
>
>
>Per il nostro utente admin, useremo ALL. Per l'utente guest, <c>SELECT</c>
>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.
>
>
><pre caption="Creare l'utente admin e guest">
><comment>(admin)</comment>
>mysql&gt; GRANT ALL ON gentoo.* TO 'admin'@'localhost' IDENTIFIED BY 'password';
><comment>(guest)</comment>
>mysql&gt; GRANT SELECT ON gentoo.* TO 'guest'@'localhost' IDENTIFIED BY 'password';
></pre>
>
>
>Adesso che abbiamo impostato gli utenti, testiamoli. Per prima cosa usciamo da
>mysql digitando <c>quit</c> al prompt dei comandi:
>
>
><pre caption="Uscire da MySQL">
>mysql&gt; quit
></pre>
>
>
>Siamo tornati alla console. Ora che gli utenti sono configurati, andiamo avanti
>e vediamo che cosa possono fare.
>
>
></body>
></section>
><section>
><title>Testare i Permessi degli Utenti</title>
><body>
>
>
>Proveremo ad accedere come utente guest. Attualmente, l'utente guest ha
>solamente il privilegio <c>SELECT</c>. Basilarmente si Ã¨ abilitati a cercare e
>nient'altro. Andiamo avanti e accediamo con l'account guest:
>
>
><pre caption="Accedere 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&gt;
></pre>
>
>
>Testiamo le restrizioni dell'utente. Spostiamoci sul database "gentoo":
>
>
><pre caption="Spostarsi sul database 'gentoo'">
>mysql&gt; 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
></pre>
>
>
>Ora facciamo qualcosa non precedentemente ipotizzato. Proviamo a creare
>una tabella.
>
>
><pre caption="Creare una tabella con l'utente 'guest'">
>mysql&gt; CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));
>ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'
></pre>
>
>
>Come potete vedere, questa funzione fallisce, poichÃ¨ l'utente non ha l'accesso
>appropriato. Tuttavia, un accesso di cui abbiamo l'autorizzazione Ã¨ la
>dichiarazione <c>SELECT</c>. Proseguiamo e proviamo:
>
>
><pre caption="Provare la dichiarazione SELECT">
>mysql&gt; 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)
></pre>
>
>
>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.
>
>
><pre caption="Accedere come admin">
>mysql&gt; 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&gt;
></pre>
>
>
>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.
>
>
><pre caption="Tentativo di creazione di un nuovo database">
>mysql&gt; CREATE DATABASE gentoo2;
>ERROR 1044: Access denied for user: 'admin@localhost' to database 'gentoo2'
></pre>
>
>
>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.
>
>
><pre caption="Permessi di admin nel database gentoo">
>mysql&gt; 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&gt; INSERT INTO developers VALUES('Bob Simmons',
>'bobsimmons@gentoo.org', 'python');
>Query OK, 1 row affected (0.08 sec)
></pre>
>
>
>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 <c>REVOKE</c>.
>
>
></body>
></section>
><section>
><title>Rimuovere l'accesso utente con il comando REVOKE</title>
><body>
>
>
>Il comando <c>REVOKE</c> ci permette di negare l'accesso ad un utente. Possiamo
>sia negare un accesso completo, o uno specifico. Difatti, il formato Ã¨ molto
>simile a <c>GRANT</c>
>
>
><pre caption="Sintassi REVOKE">
>REVOKE [privilegi] ON database.* FROM '[utente]'@'[host]';
></pre>
>
>
>Le opzioni usate qui sono spiegate nella sezione del comando <c>GRANT</c>. 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:
>
>
><pre caption="Revocare permessi utente">
>mysql&gt; REVOKE ALL ON gentoo.* FROM 'guest'@'localhost';
>Query OK, 0 rows affected (0.00 sec)
></pre>
>
><note>
>In questo caso l'accesso utente coinvolge solamente un database, di conseguenza
>revocare i permessi non Ã¨ un'operazione problematica. Tuttavia, in casi piÃ¹
>complessi, Ã¨ preferibile usare *.* invece di gentoo.* per rimuovere l'accesso
>utente su tutti i database esistenti.
></note>
>
>
>Adesso usciamo e proviamo ad accedere come utenti guest.
>
>
><pre caption="Tentativo di accesso con l'utente 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&gt;
></pre>
>
>
>Sebbene riusciamo ad accedere, l'accesso al database "gentoo" ci Ã¨ negato.
>
>
><pre caption="Accesso negato all'account guest">
>mysql&gt; USE gentoo;
>ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'
></pre>
>
>
>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 <c>DELETE</c> e la tabella
>utenti di MySQL.
>
>
></body>
></section>
><section>
><title>Rimuovere gli Account usando DELETE</title>
><body>
>
>
>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.
>
>
><pre caption="Selezionare il database mysql principale">
>mysql&gt; 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&gt;
></pre>
>
>
>Ora guardiamo quali sono le tabelle appartenenti al database "mysql":
>
>
><pre caption="Elenco tabelle database mysql">
>mysql&gt; SHOW TABLES;
>+-----------------+
>| Tables_in_mysql |
>+-----------------+
>| columns_priv |
>| db |
>| func |
>| host |
>| tables_priv |
>| user |
>+-----------------+
>6 rows in set (0.00 sec)
></pre>
>
>
>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
><c>SELECT</c>. I campi che utilizzeremo sono Host e User.
>
>
><pre caption="Trovare il nostro utente 'guest' nella tabella utenti">
>mysql&gt; SELECT Host,User FROM user WHERE User = 'guest';
>+-----------+-------+
>| Host | User |
>+-----------+-------+
>| localhost | guest |
>+-----------+-------+
>1 row in set (0.00 sec)
></pre>
>
>
>Adesso che abbiamo le informazioni, possiamo sbarazzarci dell'utente guest.
>CiÃ² viene fatto con il comando <c>DELETE</c>, avente la sintassi seguente.
>
>
><pre caption="Sintassi DELETE">
>DELETE FROM tabella WHERE campo='valore';
></pre>
>
>
>Potete notare che il comando <c>DELETE</c> Ã¨ alquanto simile alla
>dichiarazione <c>SELECT</c> 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:
>
>
><pre caption="Eliminazione dell'account guest">
>mysql&gt; DELETE FROM user WHERE User='guest';
>Query OK, 1 row affected (0.07 sec)
><comment>(FLUSH PRIVILEGES Ã¨ necessario per aggiornare i privilegi)</comment>
>mysql&gt; FLUSH PRIVILEGES;
>Query OK, 0 rows affected (0.00 sec)
></pre>
>
>
>Sembra aver funzionato correttamente. Testiamo il tutto disconnettendoci e
>provando ad effettuare il login come utenti guest.
>
>
><pre caption="Tentativo di login come utente guest">
>mysql&gt; quit
>Bye
>$ mysql -u guest -h localhost -p
>Enter password:
>ERROR 1045: Access denied for user: 'guest@localhost' (Using password: YES)
></pre>
>
>
>Il nostro utente Ã¨ stato definitivamente cancellato!
>
>
></body>
></section>
><section>
><title>Conclusione</title>
><body>
>
>
>Sebbene questa guida si focalizzi principalmente nella configurazione di
>MySQL tramite riga di comando, c'Ã¨ la possibilitÃ  di utilizzare delle
>alternative con interfaccia grafica:
>
>
><ul>
> <li>
>		<uri link="http://www.phpmyadmin.net/home_page/">phpMyAdmin</uri> -
>		Popolare strumento di amministrazione di MySQL basato su php.
> </li>
> <li>
> <uri
> link="http://sourceforge.net/projects/mysqlnavigator/">mysqlnavigator</uri>
> - Interfaccia QT per MySQL.
> </li>
> <li>
> <uri link="http://gmyclient.sourceforge.net/">gmyclient</uri> - Un client
> MySQL per GNOME.
> </li>
> <li>
>	 <uri link="http://www.knoda.org/">knoda</uri> - Un client MySQL per KDE.
> </li>
></ul>
>
>
>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
><mail>chriswhite@gentoo.org</mail>.
>
>
></body>
></section>
></chapter>
></guide>

Actions: View

Attachments on bug 119386: 77401