Télécharger le PDF du cours
Il va être beaucoup plus rare d’intervenir directement sur la structure d’une table qui devrait normalement être fixe mais cependant cela peut arriver dans des cas de refonte ou de mise en conformité avec de nouvelles fonctionnalités, lois, etc.
Nous allons apprendre à faire tout cela dans cette nouvelle leçon !
Mettre à jour des données dans une table
Nous allons utiliser l’instruction SQL UPDATE suivie du nom de la table pour mettre à jour des données dans une table.
Cette instruction va toujours être accompagnée de SET qui va nous servir à préciser la colonne à mettre à jour ainsi que la nouvelle valeur pour la colonne.
En s’arrêtant là, en effet, nous allons mettre à jour toutes les valeurs d’une colonne d’un coup ! Ce sera très rarement ce que nous voudrons faire en pratique, et c’est pour cela que nous allons généralement également utiliser la clause WHERE pour spécifier quelles entrées doivent être mises à jour.
Prenons immédiatement pour voir en pratique comment nous allons pouvoir mettre à jour des données dans une table en utilisant PDO.
Pour cet exemple, je vais cette fois-ci m’appuyer sur une table nommée « Users » qui appartient à ma base de données « pdodb » et contient 4 colonnes :
- Une colonne « Id », type INT, UNISGNED, PRIMARY KEY, AUTO_INCREMENT
- Une colonne « Prenom », type VARCHAR(30) NOT NULL
- Une colonne « Nom », type VARCHAR(30) NOT NULL
- Une colonne « Mail », type VARCHAR(30) NOT NULL
Nous allons pour le moment nous contenter d’ajouter 3 entrées dans cette table.
<!DOCTYPE html>
<html>
<head>
<title>Cours PHP / MySQL</title>
<meta charset='utf-8'>
</head>
<body>
<h1>Bases de données MySQL</h1>
<?php
$servname = "localhost"; $dbname = "pdodb"; $user = "root"; $pass = "root";
try{
$dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
$dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
//Crée la table Users
$sql = "CREATE TABLE Users (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
Prenom VARCHAR(30) NOT NULL,
Nom VARCHAR(30) NOT NULL,
Mail VARCHAR(50) NOT NULL
)";
$dbco->exec($sql);
//On prépare la requête et on lie les paramètres
$sth = $dbco->prepare("
INSERT INTO Users (Prenom, Nom, Mail)
VALUES (:prenom, :nom, :mail)
");
$sth->bindParam(':prenom', $prenom);
$sth->bindParam(':nom', $nom);
$sh->bindParam(':mail', $mail);
//Insère une première entrée
$prenom = "Pierre"; $nom = "Giraud"; $mail = "pierre.giraud@edhec.com";
$sth->execute();
//Insère une deuxième entrée
$prenom = "Victor"; $nom = "Durand"; $mail = "v.durandd@edhec.com";
$sth->execute();
//Insère une troisième entrée
$prenom = "Julia"; $nom = "Joly"; $mail = "july@gmail.com";
$sth->execute();
echo "Parfait, tout s'est bien passé";
}
catch(PDOException $e){
echo "Erreur : " . $e->getMessage();
}
?>
</body>
</html>
Et voici ce que vous devriez donc avoir en visualisant la structure et le contenu de votre table via phpMyAdmin :
On s’aperçoit qu’il y a un « d » en trop dans l’adresse mail de notre utilisateur « Victor Durand », utilisons donc UPDATE pour SET une nouvelle valeur pour la colonne mail de cet utilisateur.
Pour ne mettre à jour que la valeur du mail correspondant à cette entrée, nous allons également utiliser WHERE en donnant une condition sur l’id.
WHERE sur la colonne « id », nous pouvons tout aussi bien donner une condition sur n’importe quelle autre colonne. Cependant, en pratique, nous nous appuierons très souvent sur cette fameuse colonne « id » car c’est un moyen simple et infaillible d’isoler une entrée en particulier.<!DOCTYPE html>
<html>
<head>
<title>Cours PHP / MySQL</title>
<meta charset='utf-8'>
</head>
<body>
<h1>Bases de données MySQL</h1>
<?php
$servname = "localhost"; $dbname = "pdodb"; $user = "root"; $pass = "root";
try{
$dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
$dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
//On prépare la requête et on l'exécute
$sth = $dbco->prepare("
UPDATE Users
SET mail='v.durand@edhec.com'
WHERE id=2
");
$sth->execute();
//On affiche le nombre d'entrées mise à jour
$count = $sth->rowCount();
print('Mise à jour de ' .$count. ' entrée(s)');
}
catch(PDOException $e){
echo "Erreur : " . $e->getMessage();
}
?>
</body>
</html>
Le script ci-dessus est assez transparent : on prépare notre requête pour mettre à jour l’adresse mail de l’utilisateur portant l’id 2 dans notre table puis on exécute cette requête.
On utilise ensuite la méthode rowCount() pour obtenir le nombre d’entrées affectées par notre dernière requête. En effet, rowCount() retourne le nombre de lignes affectées par la dernière requête DELETE, INSERT ou UPDATE exécutée par l’objet de la classe PDOStatement correspondant (en l’occurrence ici $sth.
On peut également aller vérifier dans phpMyAdmin que notre la valeur mail de notre entrée à bien été mise à jour.
Modifier la structure d’une table
Pour modifier la structure d’une table en soi, nous allons utiliser l’instruction SQL ALTER TABLE.
Cette commande va nous permettre d’ajouter, de supprimer ou de modifier une colonne dans une table.
Ajouter une colonne dans une table
Pour ajouter une colonne, nous allons également devoir utiliser ADD avec le nom de la colonne à ajouter et le type de données attendu.
Par exemple, on pourrait ajouter une colonne « DateInscription » dans notre table Users qui stockerait automatiquement la date d’inscription de nos utilisateurs.
<!DOCTYPE html>
<html>
<head>
<title>Cours PHP / MySQL</title>
<meta charset='utf-8'>
</head>
<body>
<h1>Bases de données MySQL</h1>
<?php
$servname = "localhost"; $dbname = "pdodb"; $user = "root"; $pass = "root";
try{
$dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
$dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
/*Un utilisateur ne pourra jamais changer la structure d'une table,
*pas la peine donc d'utiliser de requête préparée*/
$sql = "
ALTER TABLE Users
ADD DateInscription TIMESTAMP
";
$dbco->exec($sql);
echo 'Colonne ajoutée';
}
catch(PDOException $e){
echo "Erreur : " . $e->getMessage();
}
?>
</body>
</html>
Notez que sans plus d’informations, les entrées déjà présentes dans la table vont recevoir la date correspondant à la création de la colonne.
Supprimer une colonne dans une table
Pour maintenant supprimer une colonne dans une table, nous allons cette fois-ci utiliser ALTER TABLE de concert avec l’instruction DROP COLUMN.
Attention ici : à la différence de l’instruction SQL ADD + nom de colonne pour ajouter une colonne, il faut bien pour supprimer une colonne utiliser l’instruction DROP COLUMN + le nom de la colonne.
En revanche, il n’y a bien évidemment pas besoin de préciser le type de données de la colonne lorsqu’on souhaite la supprimer.
On peut par exemple essayer de supprimer la colonne « DateInscription » que nous venons juste de créer dans notre table Users.
<!DOCTYPE html>
<html>
<head>
<title>Cours PHP / MySQL</title>
<meta charset='utf-8'>
</head>
<body>
<h1>Bases de données MySQL</h1>
<?php
$servname = "localhost"; $dbname = "pdodb"; $user = "root"; $pass = "root";
try{
$dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
$dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
/*Le changement de structure d'une table ne dépendra jamais des
*utilisateurs, pas la peine donc d'utiliser de requête préparée*/
$sql = "
ALTER TABLE Users
DROP COLUMN DateInscription
";
$dbco->exec($sql);
echo 'Colonne supprimée';
}
catch(PDOException $e){
echo "Erreur : " . $e->getMessage();
}
?>
</body>
</html>
Modifier une colonne dans une table
Pour finalement modifier le type de donnée d’une colonne dans une table, il faudra utiliser ALTER TABLE avec l’instruction MODIFY COLUMN si vous évoluez dans un environnement MySQL (la syntaxe de cette commande n’est pas encore standardisée et peut changer selon le système de bases de données utilisé).
Notez ici que s’il y a incompatibilité entre le type de données de départ et le nouveau type de données que doit accepter la colonne, votre table peut se trouver totalement dégradée ou corrompue.
Il faut donc faire très attention lors de la modification d’une colonne. En pratique, cette opération n’est pas recommandée et on ne l’utilisera qu’en dernier recours sauf cas particulier, par exemple pour « étendre » un type de données qu’une colonne peut accepter (passer d’un texte court à un texte long, d’un petit nombre à un nombre plus grand, etc.).
Essayons par exemple de modifier la colonne « Prenom » de notre table « Users » pour qu’elle puisse accepter des valeurs allant jusqu’à 50 caractères (pour le moment celle-ci est limitée à 30).
<!DOCTYPE html>
<html>
<head>
<title>Cours PHP / MySQL</title>
<meta charset='utf-8'>
</head>
<body>
<h1>Bases de données MySQL</h1>
<?php
$servname = "localhost"; $dbname = "pdodb"; $user = "root"; $pass = "root";
try{
$dbco = new PDO("mysql:host=$servname;dbname=$dbname", $user, $pass);
$dbco->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
/*Le changement de structure d'une table ne dépendra jamais des
*utilisateurs, pas la peine donc d'utiliser de requête préparée*/
$sql = "
ALTER TABLE Users
MODIFY COLUMN Prenom VARCHAR(50)
";
$dbco->exec($sql);
echo 'Colonne mise à jour';
}
catch(PDOException $e){
echo "Erreur : " . $e->getMessage();
}
?>
</body>
</html>
