[PDF] Premier pas en MySQL support de cours approfondi | Formation mysql

(1)

Bases de données MySQL

Une base de données est en quelque sorte un gros fichier oû sont stockées des données modifiables dynamiquement. L'avantage de ce système est que l'on modifie simplement les données contenues dans la base pour modifier dynamiquement des pages web (par exemple les articles du site sont contenus dans une base de données et la page "article.php" est générée dynamiquement en fonction du numéro de l'article demandé). Conséquences : au lieu de modifier un nombre de pages égal aux nombres d'articles, je ne modifie aucune page, simplement la base de données, via des requêtes. Une requête est une commande qui permet d'effectuer diverses actions sur une base de données :

 Des calculs

 Une recherche de données  Une sélection de données

 Un ajout, une modification ou une suppression de données  Une maintenance de la base (optimisation, réparation)

Schéma d'un exemple d'architecture faisant intervenir les bases de données :

Dans notre exemple les PC clients consultent le contenu de la base de données, l'affichage est ainsi toujours à jour, quel que soit le poste client. Une base de données contient des tables. Qu'est ce qu'une table ? une table est en fait un comme un classeur sur un bureau, elle structure les différentes données qu'elle contient. Il peut y avoir plusieurs tables dans une base de données, contenant des données ayant un rapport radicalement différent entre elles.

(2)

Une table contient des champs. Chaque champ pourra recevoir des données. Exemple d'une table appelée membres :

ID pseudo passe email

1 webmaster password mail@fai.fr

Cette table contient 4 champs :

 ID : ce champ est de type MEDIUMINT (par exemple) et comporte l'option nommée AUTOINCREMENT. Cette option va incrémenter directement le chiffre sans que nous ayons à nous en soucier. Ceci est très pratique pour différencier chaque membre

 pseudo : ce champ est de type VARCHAR. Il peut contenir un pseudo de 30 caractères maximum.

 passe : ce champ est de type VARCHAR. Il peut contenir un mot de passe de 20 caractères maximum.

 email : ce champ est de type VARCHAR. Il peut contenir un email de 60 caractères maximum.

Pour effectuer des requêtes sur la base, nous utiliserons

l'outil phpMyAadmin. Vous pouvez le trouver ici : phpMyAdmin. La syntaxe de création de cette table sera la suivante :

CREATE TABLE `membres` (

`ID` MEDIUMINT UNSIGNED NOT NULL, `pseudo` VARCHAR(30) NOT NULL, `passe` VARCHAR(20) NOT NULL, `email` VARCHAR(60) NOT NULL );

Se connecter à une base de données en PHP:

Pour se connecter à une base de données, il faut tout d'abord se connecter au serveur MySQL. On utilise pour cela la fonction mysql_connect().

Voici sa syntaxe : <?php

mysql_connect('Votre_serveur_mysql','nom_utilisateur','mot_de_passe'); ?>

Une fois la connexion ouverte vous devez sélectionner la base de données à utiliser pour vos futures requêtes. On utilise la fonction mysql_select_db(). Voici sa syntaxe :

(3)

<?php

mysql_select_db('base'); ?>

Vous pouvez ensuite effectuer des requêtes sur votre base à l'aide de la fonction mysql_query(). Pour se déconnecter de la base de données (très important sous peine de monopoliser les ressources mysql et de provoquer des erreurs de max_user_connections on utilise la fonction mysql_close() Voici sa syntaxe :

<?php

mysql_close(); ?>

Les types de données - MySQL

Les types de données :

Les tables peuvent contenir différents types de données. Afin d'optimiser la place prise par vos données et la rapidité de traitement, il convient de choisir avec efficacité le type de données que contiendront les différents champs de la table.

Pour les champs de type numérique, l'option UNSIGNED va vous permettre en économisant de la place (on ne stocke plus le bit de signe) de stocker des nombres plus grands (positifs). Vous ne pourrez par contre plus stocker de nombres négatifs. L'attribut [M] définit le nombre de caractères maximum que le champ pourra contenir. Voici les différents types de données :

 TINYINT [M] [UNSIGNED]

Occupe 1 octet. Ce type peut stocker des nombres entiers de -128 à 127 si il ne porte pas l'attribut UNSIGNED, dans le cas contraire il peut stocker des entiers de 0 à 255.

 SMALLINT [M] [UNSIGNED]

Occupe 2 octets. Ce type de données peut stocker des nombres entiers de -32 768 à 32 767 si il ne porte pas l'attribut UNSIGNED, dans le cas contraire il peut stocker des entiers de 0 à 65 535.  MEDIUMINT [M] [UNSIGNED]

Occupe 3 octets. Ce type de données peut stocker des nombres entiers de -8 388 608 à 8 388 607 si il ne porte porte pas

l'attribut UNSIGNED, dans le cas contraire il peut stocker des entiers de 0 à 16 777 215.

 INT [M] [UNSIGNED]

Occupe 4 octets. Ce type de données peut stocker des nombres entiers de -2 147 483 648 à 2 147 483 647 si il ne porte pas

l'attribut UNSIGNED, dans le cas contraire il peut stocker des entiers de 0 à 4 294 967 295.

 INTEGER [M] [UNSIGNED] Même chose que le type INT.  BIGINT [M] [UNSIGNED]

Occupe 8 octets. Ce type de données stocke les nombres entiers allant de -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807 sans l'attribut UNSIGNED, et de 0 à 18 446 744 073 709 551 615 avec.

 FLOAT (précision simple de 0 à 24 et précision double de 25 à 53) [UNSIGNED]

Occupe 4 octets si la précision est inférieure à 24 ou 8 au delà. Stocke un nombre de type flottant.

(4)

 FLOAT[(M,D)] [UNSIGNED]

Occupe 4 octets. M est le nombre de chiffres et D est le nombre de décimales.

Ce type de données permet de stocker des nombres flottants à précision simple. Va de -1.175494351E-38 à 3.402823466E+38. SiUNSIGNED est activé, les nombres négatifs sont retirés mais ne permettent pas d'avoir des nombres positifs plus grands.

 DOUBLE PRECISION[(M,D)]

Occupe 8 octets. Même chose que le type DOUBLE  DOUBLE [(M,D)]

Occupe 8 octets. Stocke des nombres flottants à double précision de -1.7976931348623157E+308 à -2.2250738585072014E-308, 0, et de 2.2250738585072014E-308 à 1.7976931348623157E+308. Si UNSIGNED est activé, les nombres négatifs sont retirés mais ne permettent pas d'avoir des nombres positifs plus grands.

 REAL[(M,D)]

Occupe 8 octets. Même chose que le type DOUBLE  DECIMAL[(M[,D])]

Occupe M+2 octets si D > 0, M+1 octets si D = 0

Contient des nombres flottants stockés comme des chaînes de caractères.

 NUMERIC [(M,D)]

Même chose que le type DECIMAL  DATE

Occupe 3 octets. Stocke une date au format 'AAAA-MM-JJ' allant de '1000-01-01' à '9999-12-31'

 DATETIME

Occupe 8 octets. Stocke une date et une heure au format 'AAAA-MM-JJ HH:MM:SS' allant de '1000-01-01 00:00:00' à '9999-12-31

23:59:59'  TIMESTAMP [M]

Occupe 4 octets. Stocke une date sous forme numérique allant de '1970-01-01 00:00:00' à l'année 2037. L'affichage dépend des valeurs de M : AAAAMMJJHHMMSS, AAMMJJHHMMSS, AAAAMMJJ, ou AAMMJJ pour M égal respectivement à 14, 12, 8, et 6

 TIME

Occupe 3 octets. Stocke l'heure au format 'HH:MM:SS', allant de '-838:59:59' à ''-838:59:59'

 YEAR

Occupe 1 octet. Année à 2 ou 4 chiffres allant de 1901 à 2155 ( 4 chiffres) et de 1970-2069 (2 chiffres).

 [NATIONAL] CHAR(M) [BINARY]

Occupe M octets, M allant jusqu'à 255

Chaîne de 255 caractères maximum remplie d'espaces à la fin. L'option BINARY est utilisée pour tenir compte de la casse.  BIT

Occupe 1 octet. Même chose que CHAR(1)  BOOL

Occupe 1 octet. Même chose que CHAR(1)  CHAR (M)

Occupe M octets. Stocke des caractères. Si vous stockez un caractère et que M vaut 255, la donnée prendra 255 octets. Autant donc

employer ce ce type de données pour des mots de longueur identique.

(5)

 VARCHAR (M) [BINARY]

Occupe L+1 octets (ou L représente la longueur de la chaîne).

Ce type de données stocke des chaînes de 255 caractères maximum. L'option BINARY permet de tenir compte de la casse.

 TINYBLOB (L représente la longueur de la chaîne) Occupe L+1 octets.

Stocke des chaînes de 255 caractères maximum. Ce champ est sensible à la casse.

 TINYTEXT

Occupe L+1 octets.

Stocke des chaînes de 255 caractères maximum. Ce champ est insensible à la casse.

 BLOB

Occupe L+1 octets.

Stocke des Chaînes de 65535 caractères maximum. Ce champ est sensible à la casse.

 TEXT

Occupe L+2 octets.

Stocke des chaînes de 65535 caractères maximum. Ce champ est insensible à la casse.

 MEDIUMBLOB

Occupe L+3 octets.

Stocke des chaînes de 16777215 caractères maximum.  MEDIUMTEXT

Occupe L+3 octets.

Chaîne de 16 777 215 caractères maximum. Ce champ est insensible à la casse.

 LONGBLOB

Occupe L+4 octets.

Stocke des chaînes de 4 294 967 295 caractères maximum. Ce champ est sensible à la casse.

 LONGTEXT

Occupe L+4 octets.

Stocke des chaînes de 4 294 967 295 caractères maximum.  ENUM('valeur_possible1','valeur_possible2','valeur_possible3',...)

Occupe 1 ou 2 octets (la place occupée est fonction du nombre de solutions possibles : 65 535 valeurs maximum.

 SET('valeur_possible1','valeur_possible2',...)

Occupe 1, 2, 3, 4 ou 8 octets, selon de nombre de solutions possibles (de 0 à 64 valeurs maximum)

Mysql - Requêtes SELECT et

optimisation

Pour sélectionner des données contenues dans une base de données Mysql, on utilise les requêtes de type SELECT.

Nous allons utiliser la table membres que nous avons créée tout à l'heure (j'ai rajouté des données pour l'exemple) :

Table membres

(6)

1 webmaster password mail@fai.fr

2 test 1234 test@essai.fr

3 Anthony passe anthony@fai.fr

Nous allons rajouter une deuxième table qui s'intitule profil (vous verrez pourquoi nous avons crée une deuxième table plus bas). Voici sa structure :

Table profil

ID abonne_newsletter signature config 1 1 C'est moi le web ;-) P4P800...

3 1 Test anthony@fai.fr

Commençons les sélections de base :

Imaginions que nous souhaitons sélectionner tous les champs de la

table membres où le pseudo est 'webmaster'. La requête sera la suivante : SELECT pseudo,passe,mail FROM membres WHERE pseudo='webmast er'

On aurait pu aussi faire ceci (pour sélectionner tous les champs). Ceci est à titre d'exemple, ne l'utilisez pas sur votre serveur mysql car vous perdriez en performances :

SELECT * FROM membres WHERE pseudo='webmaster'

Pour effectuer une requête sur une base de données, on utilise la fonction mysql_query("requete");

Exemple avec la requête que je viens de vous présenter :

$requete=mysql_query("SELECT pseudo,passe,mail FROM membres WHERE pseudo='webmaster'");

Les jointures :

Une jointure est une sélection de données sur plusieurs tables. Cette solution évite la redondance des données et permet donc d'économiser de la place, voire de gagner des performances si elle est bien utilisée.

Exemple :

Nous voulons pour chaque membre obtenir son email, sa signature et sa config. Les deux tables ont en commun un champ : ID (les ID de la table membrescorrespondent à l'ID du profil)

La requête sera celle-ci :

$requete=mysql_query("SELECT membres.mail,profil.signature,profil .config FROM membres LEFT JOIN profil ON membres.id=profil.id");

L'ordre du LEFT JOIN est important. Si l'ID dans la table profil n'existe pas (par exemple l'ID numéro 2 ici), l'enregistrement est quand même retourné (avec une valeur de type NULL). Si nous avions inversé l'ordre de jointure et avions écrit FROM profil LEFT JOIN membres, l'enregistrement n'aurait pas été retourné puisque rien ne se trouve dans la table profil avec un ID de 2.

Les opérations mathématiques :

Mysql permet de retourner des calculs mathématiques. Par exemple l'addition de 5+9 :

mysql_query("SELECT 5+9");

Cette requête va retourner 14.

Sélectionner la valeur maximum d'un champ :

mysql_query("SELECT max(champ) FROM table");

Sélectionner la valeur minimum d'un champ :

(7)

Sélectionner la valeur moyenne d'un champ :

mysql_query("SELECT AVG(champ) FROM table");

Sélectionner la somme de toutes les valeurs d'un champ :

mysql_query("SELECT SUM(champ) FROM table");

Compter le nombre de valeurs d'une table (ici on compte le nombre de lignes qui ont la valeur "1" sur le champ "champ":

mysql_query("SELECT COUNT(*) FROM table WHERE champ=1");

On aurait pu aussi faire ceci :

$requete=mysql_query("SELECT * FROM table WHERE champ=1"); $nbre_lignes=mysql_num_rows($requete);

Les opérations sur les chaînes :

Plutôt que de joindre avec un peu de texte et PHP deux valeurs retournées par Mysql, autant clarifier le code PHP et utiliser l'option CONCATde Myql :

mysql_query("SELECT CONCAT('valeur du premier champ: ', champ1 ,'valeur du deuxième champ :', champ2) FROM table");

La clause GROUP BY :

La clause GROUP BY se combine avec COUNT et permet d'effectuer des calculs sur chaque itération. Je m'explique :

Prenons une table nommée forum. Voici sa structure :

Table forum

topic_id reponse sujet message

1 0 test Ceci est un test

1 1 test Ah bon ?

2 0 le site vulgarisation-informatique Un autre test

Lorsque un nouveau topic est créé, le champ "reponse" prend pour valeur 0, dans le cas contraire (lorsqu'on répond à un topic), le champ "reponse" vaut 1. Le champ "topic_id" représente le numéro de topic.

Nous voulons compter le nombre de messages par topic. Nous ferons donc une requête comme ceci :

mysql_query('SELECT COUNT(reponse) FROM forum GROUP BY topic_id');

La clause LIMIT :

La clause LIMIT permet de ne pas retourner tous les enregistrements d'une table. Par exemple si vous souhaitez afficher les 10 premières news de votre site, voici un exemple de requête :

mysql_query('SELECT titre,date FROM news LIMIT 0,10');

Dans la clause LIMIT, le premier nombre (ici 0) représente l'enregistrement de départ à afficher, et le deuxième nombre (ici 10), le nombre

d'enregistrements à retourner.

La clause DISTINCT :

Elle permet d'éviter de retourner des doublons. Dans notre cas nous souhaitons retourner tous les numéros de topic mais une seule fois(pas de doublons) :

mysql_query('SELECT DISTINCT topic_id FROM forum'); Optimisation des requêtes SELECT :

Optimiser Mysql est une opération facile. La rapidité de traitement en suivant ces conseils peut être multipliée par plus de 1000 !

La clause SQL_SMALL_RESULT - SQL_BIG_RESULT :

Cette clause permet avec les clauses DISTINCT et GROUP BY de dire à Mysql qu'il y aura surement peu ou beaucoup d'enregistrements à retourner.

(8)

mysql_query('SELECT

SQL_SMALL_RESULT DISTINCT topic_id FROM forum LIMIT 20');

Nous n'avons ici que 20 enregistrements à retourner, la clause SQL_SMALL_RESULT convient parfaitement. Les index :

Un index est en quelque sorte une table des matières. Lorsque une table contient un nombre suffisant d'enregistrements (plus de 50), un index est la solution ultime pour doper les performances de Mysql.

Les index sont à placer sur les colonnes utilisées dans les clauses WHERE, GROUP BY, et LEFT JOIN notamment. Nous pouvons par exemple ajouter un index sur le champ ID dans les tables membres et profil.

Mysql_fetch_row(), mysql_fetch_array(),

mysql_fetch_object()

Pour traiter via PHP des données contenues dans une base de données Mysql (et récupérées via une requête), on peut utiliser la fonction

mysql_fetch_row("requete");

Cette fonction retourne un tableau contenant les valeurs pour la ligne de résultat en cours de traitement.

Pour obtenir toutes les valeurs récupérées via la requête, on fait donc une boucle (sauf si vous savez que votre requête ne va retourner qu'un seul enregistrement).

Exemple avec la fonction mysql_fetch_row() :

$requete=mysql_query("SELECT membres.mail,profil.signature,profil .config FROM membres LEFT JOIN profil ON membres.id=profil.id"); while($resultat=mysql_fetch_row($requete)) { $mail=$resultat[0]; $signature=$resultat[1]; $config=$resultat[2]; }

On voit que mysql_fetch_row() retourne un tableau à indices numériques. L'ordre de ce tableau (ici $resultat[]) est donné par l'ordre de sélection des champs dans la requête. Ici le premier champ sélectionné est mail, ensuite signature et ensuite config.

Exemple avec mysql_fetch_array() :

mysql_fetch_array() est légèrement moins rapide que mysql_fetch_row() sur certains calculs. Elle retourne un tableau avec le nom des champs

sélectionnés comme indice. L'option MYSQL_ASSOC permet de ne générer qu'un tableau associatif (et non un tableau numérique et un tableau associatif, ce qui améliore les performances) :

$requete=mysql_query("SELECT membres.mail,profil.signature,profil .config FROM membres LEFT JOIN profil ON membres.id=profil.id"); while($resultat=mysql_fetch_array($requete,MYSQL_ASSOC)) { $mail=$resultat['mail']; $signature=$resultat['signature']; $config=$resultat['config']; }

Exemple avec mysql_fetch_object() :

mysql_fetch_object() est aussi rapide que mysql_fetch_array. Elle retourne le résultat de la requête sous forme d'objets :

(9)

$requete=mysql_query("SELECT membres.mail,profil.signature,profil .config FROM membres LEFT JOIN profil ON membres.id=profil.id"); while($resultat=mysql_fetch_object($requete)) { $mail=$resultat->mail; $signature=$resultat->signature; $config=$resultat->config; }

INSERT INTO : Insérer des données avec MySQL

Il existe différentes manières d'insérer des données dans une table MySQL. Pour tous ces exemples, nous allons partir d'une table de membres telle que vous pourriez la trouver sur la plupart des sites web, et ne contenant que quelques champs :

 L'identifiant unique du membre : id  Son pseudo : pseudo

 Son adresse email : email

La structure de la table est la suivante :

Si vous souhaitez reproduire cette table, vous pouvez exécuter le code SQL suivant (un outil tel que PHPMyAdmin est recommandé car plus pratique) :

CREATE TABLEIF NOTEXISTS `membres` ( `id` int(11) NOTNULL AUTO_INCREMENT, `pseudo` varchar(30) NOTNULL,

`passe` varchar(40) NOTNULL, `email` varchar(100) NOTNULL, PRIMARYKEY(`id`)

) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Nous allons insérer un membre dont le pseudo est Pierre, le mot de passe sera dupont et sera encodé à l'aide de la fonction SHA1() de MySQL (afin de ne pas être en clair dans la base), et l'email sera pierre@dupont.fr.

(10)

Remarquez que la valeur du champ id est vide, car il s'agit d'un champ auto-incrémenté, c'est à dire que MySQL va lui attribuer une valeur

automatiquement supérieure à la dernière valeur insérée dans la table. Cela est très pratique et vous évite de devoir effectuer une requête de séletion pour récupérer le maximum du champ id puis de l'incrémenter de 1.

INSERT INTO table VALUES(...)

C'est une syntaxe qui se révèle plutôt courte mais qui, en contrepartie, vous oblige à spécifier les valeurs de tous les champs, dans l'ordre dans lequel ils sont implémentés dans la table MySQL.

Pour notre exemple ci-dessus, nous sommes donc obligés de spécifier les valeurs des champs id, pseudo, passe, email en respectant

scrupuleusement cet ordre.

La syntaxe à utiliser est la suivante :

INSERT INTO `membres` VALUES("", "Pierre", SHA1("dupont"), "pierre@dupont.fr");

Remarquez que le nom de la table est entouré du caractère d'échappement `. Ceci n'est pas obligatoire dans le cas où le nom de votre table ne contient pas de caractères spéciaux (ce qui est conseillé). Remarquez également l'absence de guillemets doubles autour de la fonction SHA1(). Ceci est normal car il s'agit d'une fonction de MySQL.

Vous pouvez, via l'onglet SQL de PHPMyAdmin, saisir entièrement cette syntaxe via l'onglet SQL.

INSERT INTO table(champs ...) VALUES(...)

Cette syntaxe est à privilégier car :

 Elle vous permet de spécifier les seuls champs que vous souhaitez remplir (les autres devant avoir une valeur par défaut).

(11)

 Elle vous permet de vous affranchir de l'ordre des champs dans la table, vous pouvez donc rajouter ou enlever des colonnes ultérieurement sans toucher à vos requêtes.

 Elle vous permet de savoir ce que vous allez insérer comme données, sans devoir afficher la structure de la table, ce qui est bien plus pratique, surtout avec des tables comportant de nombreux champs.

 Elle vous offre une compatibilité améliorée avec les

autres SGBDR (systèmes de gestion de base de données relationnelles), tels PostgreSQL par exemple. Cela vous évite de devoir réécrire vos requêtes si vous décidez de changer de SGBDR.

La syntaxe à utiliser est la suivante :

INSERT INTO `membres` (`pseudo`, `passe`, `email`) VALUES("Pierre", SHA1("dupont"), "pierre@dupont.fr");

Remarquez la présence du caractère d'échappement entourant les noms de champs. Il n'est pas obligatoire si les noms de vos champs n'ont pas de caractères spéciaux.

Insertion de caractères spéciaux, champs spéciaux et syntaxe

Guillemets doubles

Imaginions que vous souhaitiez insérer un enregistrement contenant des guillemets doubles, par exemple comme pseudo Pierre "le fou", vous devez échapper les guillemets doubles à l'aide du caractère d'échappement

antislash \. Voici un exemple :

INSERT INTO `membres` (`id`, `pseudo`, `passe`, `email`) VALUES

(NULL, "Pierre \"le fou\"", SHA1("pierre"), "pierrelefou@fous.fr");

Champs numériques

Les champs numériques (INT, FLOAT, etc.) n'ont pas besoin d'être entourés de guillemets lorsque vous effectuez vos requêtes d'insertion. Le caractère séparateur de milliers est généralement le point. Prenons l'exemple d'une table articles dont la structure est la suivante :

CREATE TABLEIF NOTEXISTS `articles` ( `id` int(11)NOT NULL AUTO_INCREMENT, `libelle` varchar(200)NOT NULL,

`prix` floatNOT NULL, PRIMARYKEY(`id`)

) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Remarquez le champ prix de type FLOAT. Vous souhaitez insérer un article dont le libellé est Mon article et le prix est de 50.25 €. La syntaxe à utiliser est la suivante :

INSERT INTO `articles` (`libelle`, `prix`) VALUES ('mon article', 50.25);

UPDATE table : Modifier des données dans une table MySQL

Dans l'article précédent, nous avons vu comment insérer des données dans une table avec MySQL. Voyons maintenant comment mettre à jour ces données.

Pour mettre à jour des données en MySQL (et plus généralement en SQL), vous devrez utiliser la commande UPDATE. Celle-ci permet de mettre à jour des enregistrements. Bien entendu, vous allez pouvoir spécifier quels

(12)

Nous reprendrons notre exemple vu dans l'article précédent de la table des membres dont voici (pour rappel) la structure :

Voici les quelques données qui figurent dans notre table membres :

Vous pouvez les insérer en exécutant les requêtes suivantes :

(1, 'Pierre', 'fe1fb20ff84babba7e6ea3dcc4d1ad541d52a675', 'pierre@dupont.fr'),

(2, 'Dupont', 'ff019a5748a52b5641624af88a54a2f0e46a9fb5', 'dupont@etdupont.fr');

Syntaxe de la requête UPDATE

La syntaxe des requêtes UPDATE est relativement simple. En premier, vous devez toujours spécifier le mot UPDATE, suivi du nom de votre table. Dans notre cas, cela donnera UPDATE `membres`. Vous pouvez omettre les caractères d'échappement ` si votre table ne contient pas de caractères spéciaux, ce qui est généralement le cas.

Ensuite, vous devez spécifier quels sont les champs que vous souhaiteriez modifier. Cela se fait avec le mot clé SET lui-même suivi des noms de champs (séparés par des virgules) et des valeurs à remplacer. Imaginions que nous souhaitions modifier le pseudo du membre Pierre (identifié par le numéro 1) et que nous souhaitions modifier le champ email pour y mettre la valeur contact@pierre.fr. La requête à effectuer est la suivante :

UPDATE `membres` SET `email`="p@pierre.fr" WHERE `id`=1;

Vous pouvez constater la présence du mot-clé WHERE. Ce mot-clé est important puisque c'est lui qui va dire à MySQL de ne modifier que le membre dont le champ id vaut 1. Vous constatez par là l'importance d'avoir pour chaque enregistrement une clé unique, représentée par un champ dont la

(13)

valeur est toujours différente pour chacune des lignes. C'est le cas de notre champ id qui est auto-incrémenté.

Modifier plusieurs champs simultanément

Vous n'êtes pas obligé(e) d'effectuer plusieurs requêtes en modifiant un champ à la fois. Imaginions que nous souhaitions modifier le champ email et le champ pseudo du membre dont l'identifiant unique est 1. Pour ce faire, la requête aurait pris la forme suivante :

UPDATE `membres` SET `email`="jacques@monfai.fr", `pseudo`="Jacques" WHERE `id`=1;

Notre membre dont l'identifiant est 1 porte désormais le pseudo Jacques et l'email jacques@monfai.fr.

Utilisation des fonctions dans les requêtes UPDATE

L'utilisation des fonctions se fait de la même façon que dans les requêtes INSERT, vues précédemment. Nous allons mettre tous nos pseudonymes en majuscules. La fonction MySQL permettant de faire cela s'appelle UPPER() et prend en paramètre la chaîne de caractères souhaitée.

UPDATE `membres` SET `pseudo`=UPPER(`pseudo`);

Remarquez que nos pseudos sont désormais tous en majuscules :

L'absence de clause WHERE indique que vous allez mettre à jour tous les enregistrements de la table.

Attention à ne pas confondre le caractère d'échappement ` avec une guillemet simple, qui n'a pas du tout la même signification ! Essayez de remplacer ce caractère par une guillemet simple dans la fonction UPPER() et voyez le résultat ... UPDATE `membres` SET `pseudo`=UPPER('pseudo');

Horreur ! tous vos membres s'appellent désormais PSEUDO !

DELETE FROM : Supprimer des données d'une table MySQL

Dans l'article précédent, nous avons vu comment mettre à jour les données d'une table MySQL. Voyons maintenant comment supprimer ces données. Pour supprimer des données en MySQL (et plus généralement en SQL), vous devrez utiliser la commande DELETE FROM. Celle-ci permet de supprimer des enregistrements. Bien entendu, vous allez pouvoir spécifier quels

enregistrements vous souhaiterez supprimer, au moyen de conditions. Nous reprendrons notre exemple vu dans l'article précédent de la table des membres dont voici (pour rappel) la structure :

(14)

Voici les quelques données qui figurent dans notre table membres :

Vous pouvez les insérer en exécutant les requêtes suivantes :

(1, 'Pierre', 'fe1fb20ff84babba7e6ea3dcc4d1ad541d52a675', 'pierre@dupont.fr'),

(2, 'Dupont', 'ff019a5748a52b5641624af88a54a2f0e46a9fb5', 'dupont@etdupont.fr');

Syntaxe de la requête DELETE

La syntaxe de la requête DELETE est assez simple, elle commence

par DELETE FROM et est suivie du nom de la table, puis de la condition de suppression.

Attention : si vous ne mettez pas de condition, vous viderez toute la table ! Imaginions que nous souhaitions supprimer le membre dont l'identifiant (champ id) vaut 1. La requête est alors la suivante :

DELETE FROM `membres` WHERE `id`=1;

Pour supprimer tous les membres, la requête est utilisée sans condition WHERE :

DELETE FROM `membres`;

Attention ! la requête DELETE FROM table ne réinitialise pas les valeurs d'auto-incrément. Si vous insérez un nouveau membre, son identifiant unique ne sera pas 1 mais le nombre qu'il aurait été avec la table contenant l'ensemble des enregistrements précédents.

Syntaxe de la requête TRUNCATE

Pour effacer l'ensemble des enregistrements d'une table et réinitialiser les valeurs d'auto-incrément, vous pouvez utiliser la syntaxe TRUNCATE TABLE table. Pour la table membres, cela donnerait la syntaxe suivante :

TRUNCATE TABLE `membres`;

Attention : si votre table contient des clés étrangères, vous pourriez avoir une erreur de suppression des enregistrements. Vous devrez alors utiliser la syntaxe ci-dessous pour ne pas vérifier l'intégrité durant l'opération de suppression de la table.

SET FOREIGN_KEY_CHECKS=0;

TRUNCATE `membres`;

(15)

Vous pourriez être tentés d'utiliser TRUNCATE à chaque fois que vous

souhaitez vider une table. Attention, si vous utilisez les clés étrangères, vous pourriez avoir des erreurs qui vous empêchent de supprimer les

enregistrements.

TRUNCATE TABLE ne respecte pas les transactions mais vous permet d'accélérer la suppression des enregistrements, elle peut être plus rapide qu'un simple DELETE FROM `membres`.