La commande UPDATE en SQL modifie les données existantes dans une table de base de données. Cette instruction cible des lignes spécifiques via une clause WHERE et remplace les valeurs des colonnes désignées par la clause SET. Les développeurs utilisent UPDATE pour corriger des erreurs, actualiser des prix, changer des statuts ou synchroniser des informations entre tables SQL.
Son utilité réside dans la maintenance continue des données métier. Les bases de données sans mise à jour des enregistrements deviendraient rapidement obsolètes : prix périmés, adresses erronées, stocks faux. UPDATE fait partie des commandes SQL les plus utilisées , car toute application nécessite des corrections regulières. Sans cette commande, les administrateurs devraient recréer entièrement les tables pour chaque modification, paralysant les opérations critiques.
Table des matières
Syntaxe de base pour la commande SQL UPDATE
Une requête de mise à jour doit spécifier le nom de la table et les colonnes à modifier via le mot-clé SET. Les développeurs combinent la syntaxe UPDATE SQL de base en y ajoutant des clauses pour contrôler l’étendue des changements.
UPDATE table SET field = value WHERE condition;Table initiale produits :
| id | nom | prix | stock | statut |
|---|---|---|---|---|
| 1 | Ordinateur | 1000.00 | 10 | actif |
| 2 | Souris | 25.00 | 50 | actif |
| 3 | Clavier | 80.00 | 150 | inactif |
Syntaxe SQL 1 : spécifier l’identifiant quand on cible un enregistrement unique
UPDATE produits SET prix = 1100.00 WHERE id = 1;Après UPDATE :
| id | nom | prix | stock | statut |
|---|---|---|---|---|
| 1 | Ordinateur | 1100.00 | 10 | actif |
| 2 | Souris | 25.00 | 50 | actif |
| 3 | Clavier | 80.00 | 150 | inactif |
Syntaxe SQL 2 : Multiples colonnes
UPDATE produits SET prix = 90.00, statut = 'actif' WHERE stock > 100;Après UPDATE :
| id | nom | prix | stock | statut |
|---|---|---|---|---|
| 1 | Ordinateur | 1100.00 | 10 | actif |
| 2 | Souris | 25.00 | 50 | actif |
| 3 | Clavier | 90.00 | 150 | actif |
La clause WHERE détermine les lignes touchées. Une omission de cette clause modifie toutes les lignes de la table. Les développeurs vérifient toujours cette condition avant exécution.
WHERE : Votre filet de sécurité
La clause WHERE filtre précisément les lignes à modifier dans une table. Cette condition utilise des opérateurs comme =, >, LIKE ou IN pour cibler les enregistrements exacts. Une clause SQL WHERE mal formulée rend le résultat de la requête inexploitable .Cette clause protège contre les modifications massives accidentelles.
Exemples WHERE courants :
-- Par ID unique
UPDATE produits SET prix = prix * 1.1 WHERE id = 2;
-- Condition numérique
UPDATE produits SET statut = 'en_promo' WHERE prix < 100;
-- LIKE pour motifs texte
UPDATE produits SET nom = CONCAT(nom, ' Pro') WHERE nom LIKE 'Clavier%';
-- IN pour liste
UPDATE produits SET stock = 0 WHERE id IN (1, 3);Après WHERE LIKE :
| id | nom | prix | stock | statut |
|---|---|---|---|---|
| 1 | Ordinateur | 1100.00 | 10 | actif |
| 2 | Souris | 27.50 | 50 | en_promo |
| 3 | Clavier Pro | 90.00 | 150 | actif |
8 erreurs à éviter en utilisant la commande SQL UPDATE
Voici les 8 erreurs les plus fréquentes avec leur cause et leur correction.
Oubli du WHERE
L’absence du mot-clé WHERE modifie toutes les lignes de la table. Un prix égal à 0 sur 1 million de produits paralyse le site e-commerce.Il faut toujours tester en sélectionnant les données avec une requête SELECT avant la mise à jour pour être sûr que ce sont les bonnes données qui seront ciblées.
Mauvaise requête :
UPDATE produits SET prix = 0;
-- ⚠️ TOUS les prix deviennent 0 !Bonne pratique :
-- Test d'abord
SELECT * FROM produits WHERE categorie = 'électronique';
-- Puis UPDATE
UPDATE produits SET prix = prix * 1.1 WHERE categorie = 'électronique';Mauvaise condition WHERE
Une condition trop large touche des lignes non prévues. WHERE age > 18 modifie aussi les employés sur une table clients. Le comptage préalable valide l’étendue exacte.
Mauvaise requête :
UPDATE clients SET statut = 'majeur' WHERE age > 18;
-- 95% des clients modifiés au lieu de 5% VIP !Bonne requête :
-- Compter d'abord
SELECT COUNT(*) FROM clients WHERE vip = 1 AND age > 18;
-- 15 lignes → OK
UPDATE clients SET statut = 'majeur' WHERE vip = 1 AND age > 18;Guillemets manquants autour des chaines de caractères
Les chaînes de caractères exigent des guillemets simples. Statut sans guillemets provoque une erreur de colonne inconnue. En revanche, les nombres restent sans guillemets.
Mauvaise requête :
UPDATE produits SET statut = actif WHERE id = 1;
-- Erreur : Unknown column 'actif'Bonne requête :
UPDATE produits SET statut = 'actif' WHERE id = 1;Types de données incompatibles
Une chaine de caractères dans une colonne DECIMAL génère une troncature ou erreur. Le moteur refuse la conversion automatique car trop risquée. Vérifiez toujours la définition de la table avec DESCRIBE.
Mauvaise requête :
UPDATE produits SET prix = 'cent euros' WHERE id = 2;
-- Erreur : Incorrect decimal valueBonne requête :
UPDATE produits SET prix = 100.00 WHERE id = 2;Violations des clés étrangères
Une clé étrangère vers une table inexistante bloque la mise à jour. Le moteur maintient l’intégrité référentielle de la Bdd. Vérifiez les références avant modification.
Mauvaise requête :
UPDATE commandes SET client_id = 999 WHERE id = 1;
-- Erreur : Cannot add foreign key constraintBonne requête :
-- Vérifier existence
SELECT COUNT(*) FROM clients WHERE id = 999; -- 0
-- Corriger
UPDATE commandes SET client_id = 5 WHERE id = 1;Permissions insuffisantes
L’utilisateur sans les droits nécessaires voit que l’exécution de la requête a échoué avec le motif suivant:’accès refusé’. Les privilèges définissent strictement les actions autorisées. GRANT UPDATE résout ce problème administrateur.
Erreur :
Error 1142 (42000): UPDATE command denied to user 'guest'@'localhost'UPDATE avec une clause FROM incorrect
Certains SGBDR refusent la clause FROM lors de l’exécution de la requête de mise à jour sans syntaxe spécifique.
MySQL supporte, PostgreSQL exige une jointure explicite. Testez la syntaxe du SGBD cible en testant dans phpMyAdmin et son onglet SQL.
Mauvaise (PostgreSQL) :
UPDATE produits SET prix = f.prix_promo FROM fournisseurs f;Bonne (MySQL) :
UPDATE produits p JOIN fournisseurs f ON p.fournisseur_id = f.id
SET p.prix = f.prix_promo;Transaction sans ROLLBACK
Une mise à jour massive sans transaction rend les erreurs irréversibles. START TRANSACTION permet le retour en arrière avec un ROLLBACK si la requête échoue . Toujours tester en mode transaction.
Sécurisé :
START TRANSACTION;
UPDATE produits SET prix = 0 WHERE categorie = 'test';
SELECT COUNT(*) FROM produits WHERE prix = 0; -- Vérifier
-- ROLLBACK; ou COMMIT;Requêtes complexes de mise à jour sur plusieurs tables avec JOIN
UPDATE JOIN synchronise les données entre tables liées. Cette technique met à jour une table cible depuis une table source via une clé commune. Les prix des produits suivent ainsi les tarifs fournisseurs automatiquement.
Syntaxe MySQL :
UPDATE produits p
JOIN fournisseurs f ON p.fournisseur_id = f.id
SET p.prix = f.tarif_actuel
WHERE f.tarif_actuel > p.prix;Table avant :
| id | nom | prix | fournisseur_id |
|---|---|---|---|
| 1 | PC | 1100 | 10 |
| id | tarif_actuel |
|---|---|
| 10 | 1200 |
Après UPDATE JOIN :
| id | nom | prix | fournisseur_id |
|---|---|---|---|
| 1 | PC | 1200 | 10 |
Syntaxe PostgreSQL :
UPDATE produits
SET prix = f.tarif_actuel
FROM fournisseurs f
WHERE produits.fournisseur_id = f.id;Requête SQL UPDATE avec SELECT complexe
UPDATE SELECT insère des valeurs calculées via une sous-requête ou agrégation. Le résultat remplace directement la colonne cible. Les moyennes, maximums ou comptages s’appliquent ainsi à des milliers de lignes.
Exemple augmentation prix selon moyenne catégorie :
UPDATE produits
SET prix = prix * 1.1
WHERE categorie IN (
SELECT categorie FROM produits
GROUP BY categorie
HAVING AVG(prix) < 100
);Cas concret moyenne ventes :
UPDATE produits p
SET prix_recommande = (
SELECT AVG(montant) * 1.2
FROM ventes v
WHERE v.produit_id = p.id
);CASE WHEN : Plan d’exécution d’une mise à jour intelligente
CASE WHEN applique des règles conditionnelles ligne par ligne lors de l’exécution des requêtes de mise à jour. Chaque ligne reçoit un traitement personnalisé selon ses valeurs. Les stock bas déclenchent des hausses de prix automatiques.
Syntaxe SQL complète :
UPDATE produits SET prix = CASE
WHEN stock < 10 THEN prix * 1.5 -- Rupture : +50%
WHEN stock BETWEEN 10 AND 50 THEN prix * 1.2 -- Faible : +20%
WHEN stock > 50 THEN prix * 0.95 -- Abondant : -5%
ELSE prix
END
WHERE stock > 0;Avant CASE :
| id | nom | prix | stock |
|---|---|---|---|
| 1 | PC | 1200 | 5 |
| 2 | Souris | 25 | 60 |
Après CASE :
| id | nom | prix | stock |
|---|---|---|---|
| 1 | PC | 1800.00 | 5 |
| 2 | Souris | 23.75 | 60 |
Transactions sécurisées avec la clause LIMIT
Les transactions encapsulent les mises à jour risquées pour permettre le retour en arrière. LIMIT restreint le nombre de lignes traitées par le batch. Cette combinaison protège les bases de production critiques.
Séquence sécurisée :
START TRANSACTION;
-- 1. Compter
SELECT COUNT(*) FROM produits WHERE prix < 10;
-- 2. Test SELECT
SELECT * FROM produits WHERE prix < 10 LIMIT 5;
-- 3. UPDATE limité
UPDATE produits
SET prix = 10.00
WHERE prix < 10 LIMIT 1000;
-- 4. Vérifier
SELECT COUNT(*) FROM produits WHERE prix = 10.00;
-- 5. Valider
COMMIT; -- ou ROLLBACK;Batch 10 000 lignes :
-- Boucle applicative
UPDATE produits SET ... WHERE id BETWEEN 1 AND 1000;
UPDATE produits SET ... WHERE id BETWEEN 1001 AND 2000;
-- etc.Ces garde-fous permettent des modifications massives sans downtime. Des règles supplémentaires optimisent les performances en production.
7 règles d’or UPDATE en production
Avant tout UPDATE sur une base de production, appliquer ces sept règles réduit drastiquement le risque d’erreurs irréversibles.
Règle 1 : Exécuter un SELECT identique avant toute modification
Avant d’exécuter une requête UPDATE, lance d’abord une requête SELECT avec exactement la même clause WHERE. Cette vérification affiche les lignes qui seront modifiées et permet de confirmer que la condition cible bien les bons enregistrements. Un résultat inattendu à ce stade évite une modification catastrophique en production.
-- Toujours tester avec SELECT avant UPDATE
SELECT * FROM table WHERE condition_identique;
-- Si le résultat est correct, alors :
UPDATE table SET colonne = valeur WHERE condition_identique;Règle 2 : Mettre une limite sur les volumes supérieurs à 1 000 lignes
Sur les grandes tables, ajouter LIMIT découpe la mise à jour en lots contrôlés et réduit la charge sur le serveur. Cela évite de verrouiller la table entière pendant une opération longue, ce qui bloquerait les autres requêtes simultanées. En cas d’erreur, seul le dernier lot est affecté, pas l’intégralité des données.
UPDATE table SET colonne = valeur WHERE condition LIMIT 1000;Règle 3 : Effectuer une transaction pour tout UPDATE risqué
Encapsuler un UPDATE dans une transaction permet de valider les changements avec un COMMIT ou de les annuler intégralement avec un ROLLBACK si quelque chose ne se passe pas comme prévu. Sans transaction, une erreur en cours d’exécution laisse les données dans un état incohérent. C’est le filet de sécurité indispensable avant toute modification en production.
START TRANSACTION;
UPDATE table SET colonne = valeur WHERE condition;
-- Vérifier le résultat, puis :
COMMIT; -- ou ROLLBACK;Règle 4 : Créer un Index sur la colonne utilisée dans WHERE
Sans index, le moteur SQL parcourt toutes les lignes de la table pour trouver celles qui correspondent à la condition WHERE , c’est un Full Table Scan qui devient très lent sur les grandes tables. Créer un index sur la colonne filtrée permet au moteur d’accéder directement aux lignes concernées. L’impact sur les performances peut être considérable : une requête qui prenait plusieurs minutes s’exécute en quelques secondes.
CREATE INDEX idx_prix ON produits(prix);
-- L'UPDATE suivant sera désormais beaucoup plus rapide
UPDATE produits SET statut = 'promo' WHERE prix < 50;Règle 5 : Journaliser le nombre de lignes modifiées avec ROW_COUNT()
Après un UPDATE, la fonction ROW_COUNT() retourne le nombre exact de lignes effectivement modifiées par le moteur SQL. Si ce nombre ne correspond pas à ce que tu attendais (par exemple 0 au lieu de 15), c’est le signe que la condition WHERE n’a pas ciblé les bons enregistrements. Cette vérification immédiate permet de détecter silencieusement les mises à jour qui n’ont rien modifié.
UPDATE produits SET prix = 10.00 WHERE prix < 5;
-- Vérifier combien de lignes ont été touchées
SET @lignes = ROW_COUNT();
SELECT CONCAT('UPDATE a affecté ', @lignes, ' ligne(s)');Règle 6 : Utiliser des requêtes préparées pour les UPDATE dynamiques
Une requête préparée sépare le code SQL des données transmises par l’application, ce qui empêche les injections SQL, une faille critique si les valeurs proviennent d’un formulaire utilisateur. Les paramètres ? sont échappés automatiquement par le driver PDO avant l’exécution. C’est la pratique standard dans tout code PHP en production.
-- PHP PDO
$stmt = $pdo->prepare("UPDATE produits SET prix = ? WHERE id = ?");
$stmt->execute([99.99, 5]);Règle 7 : L’horodatage automatique pour l’audit des modifications
Ajouter une colonne updated_at avec ON UPDATE CURRENT_TIMESTAMP fait enregistrer automatiquement la date et l’heure de chaque modification d’enregistrement, sans aucun code applicatif supplémentaire. Cette colonne est indispensable pour auditer les changements, détecter des modifications inattendues ou résoudre des litiges sur l’état des données à un moment précis. Elle se met à jour seule à chaque UPDATE sur la ligne concernée.
ALTER TABLE produits
ADD COLUMN updated_at TIMESTAMP
DEFAULT CURRENT_TIMESTAMP
ON UPDATE CURRENT_TIMESTAMP;Ces sept règles forment un protocole complet applicable à tout environnement de production, quelle que soit la taille de la base de données.
Requête SQL UPDATE en masse sans downtime
Les volumes massifs nécessitent des stratégies batchées et optimisées. Désactiver temporairement les index accélère les modifications intensives.
Stratégie 1M lignes :
-- 1. Créer index temporaire si absent
CREATE INDEX idx_batch ON produits(id);
-- 2. Batch 10k par 10k
UPDATE produits SET statut='archivé'
WHERE id BETWEEN 1 AND 10000 AND statut='actif';
-- 3. Pause 1s, repeat
Éviter ces ralentissements :
❌ UPDATE SET prix = prix * 1.1 WHERE YEAR(date) = 2025;
✅ UPDATE SET prix = prix * 1.1 WHERE date >= '2025-01-01';Temporairement sans index (risqué) :
ALTER TABLE produits DISABLE KEYS;
UPDATE ...;
ALTER TABLE produits ENABLE KEYS;Compatibilité entre SGBDR
MySQL supporte UPDATE FROM et LIMIT natif. PostgreSQL exige FROM pour jointures et limite via sous-requête. SQL Server utilise MERGE pour logique complexe.
Tableau syntaxes clés :
| Fonctionnalité | MySQL | PostgreSQL | SQL Server |
|---|---|---|---|
| UPDATE JOIN | ✅ UPDATE t1 JOIN t2 | ✅ UPDATE t1 FROM t2 | ❌ MERGE |
| LIMIT rows | ✅ LIMIT 100 | ❌ Sous-requête | ✅ TOP(100) |
| RETURNING | ❌ | ✅ RETURNING * | ✅ OUTPUT |
| UPSERT | ON DUPLICATE | ON CONFLICT | MERGE |
SQLite tolère UPDATE FROM depuis v3.33. La portabilité exige des tests multi-SGBDR.
Sources: Postgresql , MySql