Gentoo Logo

Guide de démarrage rapide pour MySQL

Table des matières :

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.

Exemple de code 1.1 : Installer MySQL

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

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

Exemple de code 1.2 : Message à la fin de l'installation de MySQL

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.

Exemple de code 1.3 : Configuration de MySQL

# 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.

Important : À partir de la version 4.0.24-r2, les mots de passe sont entrés pendant la phase de configuration pour plus de sécurité.

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

Exemple de code 1.4 : Définir le mot de passe de root

# /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 :

Exemple de code 1.5 : Se connecter au serveur 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'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.

Exemple de code 2.1 : Afficher la liste des bases

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

Important : Notez que les commandes MySQL doivent se terminer par un point-virgule.

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.

Exemple de code 2.2 : Créer la base « gentoo »

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.

Exemple de code 2.3 : Vérifier que la base a été créée

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.

Exemple de code 2.4 : Sélectionner la base de données

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 :

Exemple de code 3.1 : Aucune table

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 :

Exemple de code 3.2 : Syntaxe de CREATE TABLE

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.

Exemple de code 3.3 : Crée une table

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 :

Exemple de code 3.4 : Vérifier la liste des 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) :

Exemple de code 3.5 : Décrire la structure d'une table

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 :

Exemple de code 3.6 : Syntaxe de la commande INSERT

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 :

Exemple de code 3.7 : Ajouter de 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 :

Exemple de code 3.8 : ~/records.txt

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

Important : Prenez garde quand vous utilisez la commande LOAD DATA avec des données dont vous n'êtes pas sûr.

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

Exemple de code 3.9 : Syntaxe de LOAD DATA

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 :

Exemple de code 3.10 : Charger des données

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

Important : Si des choses bizarres se passent, vérifiez que vos champs sont bien séparés par des tabulations. Si vous faites un copier-coller, il est possible que celles-ci aient été remplacées par des espaces.

Ç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 :

Exemple de code 3.11 : MySQL en mode batch

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

Exemple de code 3.12 : Exécuter un fichier SQL

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.

Exemple de code 3.13 : Exemples de commandes SELECT

(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 :

Exemple de code 3.14 : Afficher le contenu de notre 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 :

Exemple de code 3.15 : Sélectionner un enregistrement spécifique

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 :

Exemple de code 3.16 : Sélectionner une partie d'un enregistrement spécifique

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 :

Exemple de code 4.1 : Syntaxe de la commande GRANT

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

Note : GRANT est géneralement utilisé pour créer un utilisateur. Des versions récentes de MySQL ont une commande spécifique CREATE_USER, mais GRANT reste utilisée.

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

Note : Si vous utilisez MySQL pour servir une application Web, les droits CREATE, SELECT, INSERT, DELETE et UPDATE devraient suffire. Pour plus de détails, veuillez consulter la documentation sur la Syntaxe de GRANT et REVOKE. Beaucoup d'utilisateurs (s')octroient tous les droits inutilement. Demandez aux développeurs de l'application Web quels droits sont réllemement nécessaires.

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.

Exemple de code 4.2 : Créer les utilisateurs admin et guest

(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 :

Exemple de code 4.3 : Quitter MySQL

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.

Exemple de code 4.4 : Se connecter en tant que 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>

Vérifions ce que peut faire cet utilisateur. D'abord, il faut se brancher sur la base gentoo :

Exemple de code 4.5 : Utiliser 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.

Exemple de code 4.6 : Essayer de 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 :

Exemple de code 4.7 : Essayer la commande 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.

Exemple de code 4.8 : Se connecter en tant que 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.

Exemple de code 4.9 : Essayer de créer une nouvelle base

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.

Exemple de code 4.10 : Les droits de admin dans 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.

Exemple de code 4.11 : La syntaxe de REVOKE

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.

Exemple de code 4.12 : Supprimer tous les droits d'accès

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

Note : Dans notre cas, les droits sont simples et la suppression des droits dans une base ne pose pas de problèmes. Dans des installations plus importantes, vous utiliseriez sans doute *.* au lieu de gentoo.* pour supprimer tous les droits dans toutes les bases en une seule opération.

Quittons et essayons de nous connecter en tant que guest.

Exemple de code 4.13 : Se 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.

Exemple de code 4.14 : Plus de droits pour notre utilisateur guest

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.

Exemple de code 4.15 : Utiliser 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 :

Exemple de code 4.16 : mysql database table listing

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.

Exemple de code 4.17 : Trouver notre utilisateur guest dans la table 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.

Exemple de code 4.18 : Syntaxe de 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.

Exemple de code 4.19 : Supprimer l'utilisateur guest

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

Exemple de code 4.20 : Se 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 :

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).



Imprimer

Dernière mise à jour le 8 août 2006

La version originale de cette traduction n'est plus maintenue

Résumé : Ce document vous aide à installer et à faire vos premiers pas avec MySQL.

Chris White
Auteur

Shyam Mani
Correcteur

Xavier Neys
Correcteur, Traducteur

Donate to support our development efforts.

Copyright 2001-2014 Gentoo Foundation, Inc. Questions, Comments? Contact us.