Guide de démarrage rapide pour MySQL

1.  Faire ses premiers pas avec MySQL

Contexte

MySQl est un serveur de bases de données populaire et est utilisé dans de nombreuses applications. Il utilise SQL qui signifie Structured Query Language, langage de requête structuré, et l'étend avec ses propres fonctions. Ce document vous aide à créer une installation de base avec des bases de données, des tables et des utilisateurs.

Installer MySQL

Commencez par installer MySQL. Vous devriez vérifier que les options de la variable USE correspondent à vos besoins.

(Voir les options USE)
# emerge --pretend --verbose mysql
(Installer MySQL)
# emerge mysql

À la fin de l'installation, le message suivant sera affiché :

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

Vous devez exécuter la commande emerge --config =mysql-[version] pour configurer votre base de données. Cette configuration comprend la base principale qui contient les données administratives telles que la listes des bases, des tables, des utilisateurs, des permissions, etc. Il est recommandé de modifier le mot de passe de l'utilisateur root dès que possible. C'est ce que nous allons faire.

# emerge --config =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:
(Prenez note des 3 lignes suivantes)
   /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.

(D'autres messages apparaissent)

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

Les commandes requises ont été affichées par le script de configuration.

# /etc/init.d/mysql start
 * Re-caching dependency info (mtimes differ)...
 * Starting mysqld (/etc/mysql/my.cnf) ...        [ ok ]
(Tapez le mot de passe de votre choix au lieu de new-password)
# /usr/bin/mysqladmin -u root -h localhost password 'new-password'

Testez votre mot de passe en essayant de vous connecter au serveur :

$ 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'option -u indique le nom d'utilisateur et -h indique le nom de la machine. Ce sera généralement localhost à moins que vous n'installiez le serveur sur une autre machine. De plus, -p indique au programme qu'il doit vous demander un mot de passe. Notez l'invite mysql>. Elle indique que vous êtes connecté, c'est là que vous allez taper vos commandes SQL. Créons la base de données.

2.  Créer la base de données

Puisque vous êtes connecté et que l'invite est affichée, affichons la liste des bases qui sont déjà créées avec la commande SHOW DATABASES.

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

Bien qu'une base de test ait déjà été créée, nous allons créer notre propre base de données que nous nommerons « gentoo ». On utilise la commande CREATE DATABASE.

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

La réponse indique que tout s'est bien passé. Le serveur indique qu'il a modifié une ligne dans la base, car l'ajout de la base de données a provoqué l'ajout d'une ligne dans une table interne à MySQL. Ne vous tracassez pas avec ces détails. Le serveur indique aussi le temps que l'action lui a pris. Vous pouvez vérifier que la base existe en lançant la commande CREATE DATABASE.

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

La base a bien été créée. Avant de créer des tables, il faut indiquer au serveur que l'on veut travailler avec celle-ci avec la commande USE. Cette commande accepte le nom de la base de données que vous allez utiliser. Il est aussi possible de spécifier le nom de la base de données via l'option -D sur la ligne de commande.

mysql> USE gentoo;
Database changed

Maintenant que la base de données gentoo a été sélectionnée, nous pouvons créer des tables et y enregistrer des données.

3.  Utiliser les tables avec MySQL

Créer une table

La structure de MySQL contient des bases de données, tables, des enregistrements et des champs. les bases contiennent des tables, les tables contiennent des enregistrements qui contiennent des champs qui accueillent les données. C'est le fonctionnement typique d'une base de données relationnelle. Passons à la création de tables. Comme pour les bases, les tables peuvent être listées, avec la commande SHOW TABLES. Comme il n'y a pas encore de tables dans notre base gentoo, la commande affchera :

mysql> SHOW TABLES;
Empty set (0.00 sec)

Créons des tables. Pour cela, nous utilisons la commande CREATE TABLE. Elle est plus complexe que CREATE DATABASE et prend la forme suivante :

CREATE TABLE [table_name] ([field_name] [field_data_type]([size]));

table_name est le nom de la table à créer. Choisissons developers. Cette table devra contenir le nom du développeur, son adresse email et son rôle. field_name est le nom d'un champ, nous en avons trois : name, email et job. field_data_type est le type de donnée à stocker dans chaque champ. Les différents formats sont disponibles sur la page Types de colonnes de MySQL. Nous utiliserons le type VARCHAR pour tous nos champs. C'est un type de donnée très simple qui contient des chaînes de caractères. La taille maximale de chaque champ est définie par size. Utilisons 128 qui, pour rester simple, correspond à 128 caractères. La page mentionnée ci-dessus explique pourquoi une taille de 128 ne signifie pas forcément 128 caractères.

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

La table vient d'être définie, vérifions avec SHOW TABLES :

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

Elle est bien là. Pour en savoir plus sur la structure de notre table, utilisons la commande DESCRIBE (ou DESC) :

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)

Cette commande affiche la liste des champs d'une table et leur type ainsi que quelques attributs que nous ne décrirons pas ici. N'hésitez pas à consulter le Manuel de référence de MySQL pour en savoir plus. Ajoutons des données dans notre table.

Ajouter des données dans une table

Pour ajouter des données dans une table, nous utilisons la commande INSERT. Son format est le suivant :

INSERT INTO table (col1, col2, ...) VALUES('value1', 'value2', ...);

Cette commande ajoute un enregistrement dans une table. table est le nom de la table. Il peut être suivi du nom des colonnes à remplir et les valeurs à ajouter suivent le mot-clé VALUES. Vous pouvez omettre la liste des colonnes si vous ajoutez une valeur dans chaque colonne et que vous spécifiez les valeurs dans le même ordre que les colonnes. Ajoutons des développeurs :

mysql> INSERT INTO developers VALUES('Joe Smith', 'joesmith@gentoo.org', 'toolchain');
Query OK, 1 row affected (0.06 sec)
(Si vous ne connaissez pas l'ordre des colonnes ou 
si vous voulez laisser des colonnes vides)
mysql> INSERT INTO developers (job, name) VALUES('outsourced', 'Jane Doe');
Query OK, 1 row affected (0.01 sec)

D'après les messages affichés, les données ont été enregistrées. Mais comment faire pour insérer plus qu'une ligne à la fois ? la commande LOAD DATA sert exactement à cela. Elle lit des enregistrements dans un fichier texte où les champs sont séparés par des tabulations et les insère dans une table. Créons un simple fichier texte que nous appelons records.txt :

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

La description de la commande LOAD DATA est assez longue, utilisons une forme simple :

LOAD DATA LOCAL INFILE '/path/to/filename' INTO TABLE table;

/path/to/filename est le fichier qui contient les données à insérer et table est le nom de la table qui doit accueillir les données. Essayons :

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

Ça a marché. Toutefois, ceci ne fait qu'insérer des données et ne vous donne que peu de contrôle sur la base. Beaucoup d'applications Web utilisent des scripts SQL pour configurer MySQL facilement. Pour utiliser un script SQL, vous pouvez utiliser mysql en mode batch, par exemple :

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

Comme avec LOAD DATA, soyez bien sûr de ce que contient sqlfile. Ne pas vérifier les actions qui vont être faites peut compromettre votre base. Un autre moyen est d'utiliser la commande source à l'invite mysql>, par exemple :

mysql> source sqlfile;

Si une application Web nécessite d'exécuter un fichier SQL, une des deux méthodes ci-dessus peut être utilisée. Maintenant que nous avons des données, comment faire pour les utiliser ?

Accéder aux données grâce à des requêtes

Les requêtes sont une des fonctionnalités les plus importantes d'une base de données. Elles permettent d'extraire des données et de les utiliser. La plupart des requêtes utilisent le mot-clé SELECT. Cette commande peut être complexe. Voyons trois formes simples.

(Sélectionner tous les enregistrements d'une table)
SELECT * FROM table;
(Sélectionner les enregistrements dont un champ contient une valeur donnée)
SELECT * FROM table WHERE field=value;
(Sélectionner quelques champs)
SELECT field1,field2,field3 FROM table [WHERE field=value];

Essayons le première forme. Elle est très simple et affiche tout le contenu d'une table :

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)

Les données que nous avons ajoutées avec la commande INSERT et avec LOAD DATA sont présentes. Disons que nous ne voulons afficher que l'enregistrement de Chris White. Nous pouvons utiliser la deuxième forme :

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

Comme prévu, l'enregistrement recherché est affiché. Disons maintenant que nous ne voulons voir que le rôle et l'adresse email, mais pas le nom. Nous pouvons utiliser la troisième forme :

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

Cette méthode est très pratique sur des tables qui contiennent beaucoup de colonnes et de tables. Pour l'instant, en tant qu'utilisateur root, nous avons tous les droits sur notre base. Un tel utilisateur peut être source de problèmes. C'est pourquoi il est possible de créer des utilisateurs qui ont moins de droits.

4.  Les droits d'accès dans MySQL

Octroyer des droits d'accès avec GRANT

Les droits d'accès définissent quelles actions chaque utilisateur peut effectuer sur des bases, des tables, ou un peu tout. Jusqu'à présent, nous avons utilisé le compte root qui a accès à tout. Créons deux utilisateurs, guest et admin, et octroyons leur des droits d'accès différents. Le compte guest sera restreint et ne pourra que consulter les données, mais le compte admin pourra effectuer les mêmes actions que root, mais uniquement dans la base gentoo, pas dans la base principale de MySQL. Voyons une version simple de la commande GRANT :

GRANT [privileges] ON database.* TO '[user]'@'[host]' IDENTIFIED BY '[password]';

Quelques exemples de droits d'accès sont :

• ALL - Tous les droits pour une base
• CREATE - Création de tables
• SELECT - Consulter des tables
• INSERT - Ajouter des données dans des tables
• SHOW DATABASES - Afficher la liste des bases
• USAGE - Aucun droit
• GRANT OPTION - Attribuer des droits à d'autres utilisateurs

Le droit ALL suffit à notre utilisateur admin. Notre utilisateur guest se contentera du droit SELECT qui lui permet juste de consulter les tables. La syntaxe database.* donne le nom de la base de données suivie du nom d'une table si vous voulez donner des droits sur une ou plusieurs tables. « .* » signie toutes les tables de cette base. user et hostname indiquent respectivement le nom de l'utilisateur et le nom de la machine qu'il utilise pour se connecter. La commande GRANT spécifie aussi le mot de passe de l'utilisateur.

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

Essayons maintenant de nous connecter avec les noms d'utilisateur que nous venons de créer :

mysql> quit

Tester les permissions des utilisateurs

Connectons-nous avec le nom d'utilisateur guest. Seul le droit SELECT a été octroyé. Cet utilisateur devrait pouvoir consulter les données et rien d'autre.

$ 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>

Vérifions ce que peut faire cet utilisateur. D'abord, il faut se brancher sur la base 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

Essayons une action interdite, par exemple créer une table.

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

Comme vous le voyez, cette action a échoué, car l'utilisateur guest n'a pas les autorisations suffisantes. Essayons maintenant, une action autorisée, le SELECT :

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)

La commande a réussi. Vous avez ainsi un aperçu de ce que sont les droits d'accès. Essayons maintenant notre utilisateur 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>

Commençons par créer une nouvelle base de données. Notre utilisateur admin est similaire à l'utilisateur root puisqu'il a tous les droits sur la base gentoo, mais pas ailleurs.

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

Effectivemement, admin n'a reçu des droits que pour la base gentoo ;il ne peut pas créer d'autres bases de données, mais il peut modifier ce qu'il veut au sein de la base 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
mysql> INSERT INTO developers VALUES('Bob Simmons', 'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)

L'utilisateur admin a tous les droits sur notre base. Parfois, il est souhaitable de supprimer un droit d'accès, par exemple un utilisateur abuse de ses droits, ou il a quitté la société. La commande REVOKE est utilisée.

Supprimer des droits d'accès avec REVOKE

La commande REVOKE permet de supprimer un droit d'accès, ou tous les droits. En fait, son format est très semblable à celui de GRANT.

REVOKE [privileges] ON database.* FROM '[user]'@'[host]';

Les options sont les mêmes que pour la commande GRANT. Supprimons par exemple tous les droits de notre utilisateur guest. Nous devons nous connecter en tant que root.

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

Quittons et essayons de nous connecter en tant que 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>

Bien que nous puissions nous connecter, tous nos droits ont été supprimés.

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

Notre utilisateur ne peut plus abuser de ses droits, mais il peut encore se connecter, car il reste défini dans notre base. Il est possible de le supprimer définitivemement avec la commande DELETE.

Supprimer des utilisateurs avec DELETE

La table des utilisateurs (nommée user) contient la liste des utilisateurs et leurs informations. Toujours en tant que root, utilisez la base principale de 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>

Voyons quelles tables existent dans cette base :

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

La table qui nous intéresse s'appelle user. Elle contient plus de 30 colonnes et n'est pas facile à lire. Essayons une commande SELECT dont le résultat est plus facile à lire. Les colonnes qui nous intéressent s'appellent Host et User.

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

Nous en savons assez pour supprimer définitivement notre utilisateur guest avec la commande DELETE.

DELETE FROM table WHERE field='value';

La commande DELETE ressemble à SELECT. Dans notre exemple, field sera le champ User et la valeur sera le nom de notre utilisateur, guest. La commande qui suit supprimera la ligne de la table et notre utilisateur guest aura totalement disparu.

mysql> DELETE FROM user WHERE User='guest';
Query OK, 1 row affected (0.07 sec)
(FLUSH PRIVILEGES est requis pour enregistrer la mise à jour des droits)
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

La commande a fonctionné. Vérifions en essayant de nous connecter en tant que guest

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

Ça ne marche plus ;l'utilisateur guest n'est plus reconnu.

Conclusion

Ce guide s'est contenté d'utiliser la ligne de commande, mais des interfaces graphiques existent, par exemple :

• phpMyAdmin - Outil d'administration de MySQL populaire basé sur php
• mysqlnavigator - Interface graphique basée sur QT
• gmyclient - Un client basé sur GNOME
• knoda - Un client KDE

Ceci termine ce tutoriel MySQL. J'espère que vous en savez assez pour demarrer avec MySQL et créer votre première base de données. N'hésitez pas à faire parvenir vos commentaires à l'auteur (en anglais).

Ce document est protégé par la licence Creative Commons : Paternité - Partage des Conditions Initiales à l'Identique 2.5.