Besoin de modifier une information dans votre base de données SQL ? C’est le rôle de la commande UPDATE.
Ce guide vous montre la syntaxe exacte et les exemples pour le faire sans erreur, même si vous débutez.
Syntaxe de la commande UPDATE
La commande `UPDATE` en SQL sert à modifier des lignes existantes dans une table. Sa structure est simple. Elle utilise la clause `SET` pour définir la nouvelle valeur d’une colonne et, le plus souvent, une clause `WHERE` pour spécifier quelles lignes sont concernées.
Pour mettre à jour une seule colonne, la syntaxe de base est la suivante :
UPDATE nom_table
SET nom_colonne = 'nouvelle_valeur'
WHERE condition;Et si vous devez modifier plusieurs colonnes en une seule fois, il suffit de les séparer par une virgule dans la clause `SET`. La requête `UPDATE` se présente alors comme ça :
UPDATE nom_table
SET colonne_1 = 'valeur_1',
colonne_2 = 'valeur_2',
...
WHERE condition;Rappel important : La partie `WHERE condition` est cruciale. C’est elle qui dit à SQL quelles lignes il faut modifier. Si vous l’oubliez, la requête `UPDATE` s’appliquera à toutes les lignes de la table.
Exemples concrets de mise à jour de données
La meilleure façon de comprendre est de pratiquer. Pour tous les exemples qui suivent, nous allons travailler sur une table simple nommée `clients`.
Voici la table de départ que nous utiliserons :
| id | nom | prenom | ville | pays | statut_compte |
|---|---|---|---|---|---|
| 1 | Dubois | Marie | Paris | France | actif |
| 2 | Martin | Thomas | Lyon | France | actif |
| 3 | Garcia | Ana | Madrid | Espagne | inactif |
| 4 | Muller | Hans | Berlin | Allemagne | actif |
| 5 | Petit | Lucas | Lyon | France | actif |
Mettre à jour une seule ligne avec un critère précis
Imaginons que la cliente Ana Garcia (ID 3) ait déménagé. Elle n’habite plus à Madrid mais à Barcelone. On doit donc modifier la valeur de la colonne `ville` pour cette ligne uniquement.
Voici la requête `UPDATE` à utiliser. La clause `WHERE` est essentielle pour cibler la bonne personne grâce à son identifiant unique.
UPDATE clients
SET ville = 'Barcelone'
WHERE id = 3;Après l’exécution de cette requête, la table `clients` ressemble à ceci. On voit que seule la ligne 3 a été affectée.
| id | nom | prenom | ville | pays | statut_compte |
|---|---|---|---|---|---|
| 1 | Dubois | Marie | Paris | France | actif |
| 2 | Martin | Thomas | Lyon | France | actif |
| 3 | Garcia | Ana | Barcelone | Espagne | inactif |
| 4 | Muller | Hans | Berlin | Allemagne | actif |
| 5 | Petit | Lucas | Lyon | France | actif |
Mettre à jour plusieurs colonnes sur une seule ligne
Maintenant, le client Hans Muller (ID 4) change de nom de famille pour « Schmidt ». En même temps, son compte devient inactif. Il faut donc modifier deux colonnes (`nom` et `statut_compte`) pour une seule ligne.
On utilise une seule commande `UPDATE` et on sépare les modifications par une virgule dans la clause `SET`.
UPDATE clients
SET nom = 'Schmidt', statut_compte = 'inactif'
WHERE id = 4;Le résultat montre bien que les deux informations ont été mises à jour sur la ligne 4. Toutes les autres lignes sont intactes.
| id | nom | prenom | ville | pays | statut_compte |
|---|---|---|---|---|---|
| 1 | Dubois | Marie | Paris | France | actif |
| 2 | Martin | Thomas | Lyon | France | actif |
| 3 | Garcia | Ana | Barcelone | Espagne | inactif |
| 4 | Schmidt | Hans | Berlin | Allemagne | inactif |
| 5 | Petit | Lucas | Lyon | France | actif |
Mettre à jour plusieurs lignes avec une condition commune
On décide d’offrir un statut « premium » à tous nos clients qui habitent à Lyon. Ici, la condition dans la clause `WHERE` ne cible plus un ID unique mais une valeur partagée par plusieurs lignes (`ville = ‘Lyon’`).
La requête `UPDATE` est la suivante :
UPDATE clients
SET statut_compte = 'premium'
WHERE ville = 'Lyon';Comme on peut le voir, deux lignes ont été modifiées car elles correspondaient toutes les deux à la condition. Il s’agit des clients Thomas Martin (ID 2) et Lucas Petit (ID 5).
| id | nom | prenom | ville | pays | statut_compte |
|---|---|---|---|---|---|
| 1 | Dubois | Marie | Paris | France | actif |
| 2 | Martin | Thomas | Lyon | France | premium |
| 3 | Garcia | Ana | Barcelone | Espagne | inactif |
| 4 | Schmidt | Hans | Berlin | Allemagne | inactif |
| 5 | Petit | Lucas | Lyon | France | premium |
Attention : Mettre à jour toutes les lignes de la table
C’est le cas de figure le plus dangereux si ce n’est pas volontaire. Que se passe-t-il si on oublie complètement la clause `WHERE` ? La base de données considère que la mise à jour s’applique à tout le monde.
Par exemple, si on veut mettre le pays de tous les clients à « FRANCE » en majuscules, on peut écrire cette requête :
UPDATE clients
SET pays = 'FRANCE';Attention, opération irréversible ! Omettre la clause `WHERE` dans une requête `UPDATE` (ou `DELETE`) modifie toutes les lignes de la table. Utilisez cette syntaxe uniquement si vous êtes absolument certain de vouloir appliquer le changement à l’ensemble de vos données.
Le résultat est radical. La colonne `pays` a été réécrite pour chaque enregistrement de la table `clients`.
| id | nom | prenom | ville | pays | statut_compte |
|---|---|---|---|---|---|
| 1 | Dubois | Marie | Paris | FRANCE | actif |
| 2 | Martin | Thomas | Lyon | FRANCE | premium |
| 3 | Garcia | Ana | Barcelone | FRANCE | inactif |
| 4 | Schmidt | Hans | Berlin | FRANCE | inactif |
| 5 | Petit | Lucas | Lyon | FRANCE | premium |
Syntaxe Avancée de UPDATE en Transact-SQL
La commande `UPDATE` de base fonctionne sur presque tous les systèmes de gestion de bases de données (MySQL, PostgreSQL, etc.). L’écosystème de Microsoft, connu sous le nom de Transact-SQL (T-SQL), offre des fonctionnalités supplémentaires pour des mises à jour plus complexes.
Ces syntaxes avancées sont compatibles avec :
- SQL Server (à partir de 2008)
- Azure SQL Database
- Azure SQL Managed Instance
- Azure Synapse Analytics
- Microsoft Fabric
Utiliser la clause FROM pour des mises à jour basées sur une autre table
Il est souvent nécessaire de mettre à jour une table en se basant sur des informations contenues dans une autre. La clause `FROM` permet de réaliser une jointure directement dans la requête `UPDATE`.
Imaginons une deuxième table `commandes` qui contient le statut de livraison :
| id_commande | id_client | statut_livraison |
|---|---|---|
| 101 | 2 | livré |
| 102 | 5 | livré |
On veut mettre le `statut_compte` de la table `clients` à « prioritaire » pour tous les clients dont la commande a été livrée. On peut joindre les tables `clients` et `commandes` sur `id_client`.
UPDATE clients
SET statut_compte = 'prioritaire'
FROM clients
INNER JOIN commandes ON clients.id = commandes.id_client
WHERE commandes.statut_livraison = 'livré';Cette requête `UPDATE` va identifier les clients 2 et 5 comme ayant une commande livrée et mettra à jour leur statut dans la table `clients`.
Mettre à jour un nombre limité de lignes avec TOP
Parfois, on ne veut modifier qu’un nombre fixe de lignes ou un pourcentage des lignes qui correspondent à une condition. La clause `TOP` de T-SQL est faite pour ça.
La syntaxe `TOP (expression)` permet de spécifier un nombre de lignes. Par exemple, pour mettre à jour le statut des 2 premiers clients de Lyon (par ordre d’ID) :
UPDATE TOP (2) clients
SET statut_compte = 'vérifié'
WHERE ville = 'Lyon';La syntaxe `TOP (expression) PERCENT` fonctionne de la même manière, mais avec un pourcentage. Pour mettre à jour 50% des clients actifs :
UPDATE TOP (50) PERCENT clients
SET statut_compte = 'archive'
WHERE statut_compte = 'actif';Attention au tri : Sans une clause `ORDER BY` (utilisée avec une sous-requête ou une CTE), les lignes affectées par `TOP` ne sont pas prévisibles. Le système choisit les premières lignes qu’il trouve, ce qui peut varier.
Utiliser des expressions de table communes (CTE) avec WITH
Une CTE (Common Table Expression), introduite par le mot-clé `WITH`, permet de créer un résultat temporaire et nommé que l’on peut ensuite utiliser dans une requête `UPDATE`. C’est très pratique pour simplifier des requêtes complexes.
Par exemple, si on veut mettre à jour les clients de Lyon qui ont un nom de famille de plus de 5 lettres. Une CTE peut d’abord sélectionner ces clients, puis la commande `UPDATE` peut agir sur ce résultat.
WITH ClientsAModifier AS (
SELECT id, nom, ville
FROM clients
WHERE ville = 'Lyon' AND LEN(nom) > 5
)
UPDATE clients
SET statut_compte = 'long_nom'
WHERE id IN (SELECT id FROM ClientsAModifier);L’utilisation d’une CTE rend la requête plus lisible et plus facile à maintenir qu’une sous-requête imbriquée complexe.
Retourner les données modifiées avec la clause OUTPUT
Une des fonctionnalités les plus utiles de T-SQL est la clause `OUTPUT`. Elle permet de retourner les données qui viennent d’être modifiées, directement dans la même opération. C’est parfait pour l’archivage, la journalisation ou simplement pour confirmer ce qui a été changé.
La clause `OUTPUT` donne accès à deux « tables » virtuelles :
- `deleted` : contient les valeurs des lignes avant la mise à jour.
- `inserted` : contient les valeurs des lignes après la mise à jour.
Exemple : on met à jour la ville de tous les clients français pour la mettre en majuscules, et on veut voir l’ancienne et la nouvelle valeur.
UPDATE clients
SET ville = UPPER(ville)
OUTPUT
deleted.id,
deleted.ville AS ancienne_ville,
inserted.ville AS nouvelle_ville
WHERE pays = 'France';Cette requête ne se contente pas de faire la mise à jour. Elle affiche un tableau de résultats montrant, pour chaque ligne modifiée, l’ID, l’ancienne ville et la nouvelle ville. C’est un moyen efficace de contrôler l’impact de vos requêtes.
Bonnes Pratiques et Points d’Attention
Utiliser `UPDATE` est simple en apparence, mais quelques bonnes pratiques permettent d’éviter les erreurs et d’optimiser les performances, surtout sur de grosses bases de données.
Le risque des mises à jour non déterministes
Ce problème complexe survient lors de l’utilisation de la clause `FROM` avec une jointure. Si, pour une ligne de la table que vous mettez à jour, plusieurs lignes de la table jointe correspondent, le moteur SQL ne sait pas quelle valeur choisir. Il en prendra une au hasard, et le résultat sera « non déterministe » : il pourrait changer à chaque exécution de la requête.
La règle d’or est de s’assurer que votre `JOIN` garantit une correspondance unique entre la table à modifier et la table source d’information.
Vérifier le nombre de lignes affectées avec @@ROWCOUNT
Après avoir exécuté une requête `UPDATE`, comment être sûr qu’elle a bien modifié le nombre de lignes attendu ? T-SQL propose une variable globale très simple : `@@ROWCOUNT`.
Juste après votre `UPDATE`, vous pouvez exécuter `SELECT @@ROWCOUNT;`. Cette commande retournera le nombre exact de lignes qui ont été affectées par la dernière instruction.
UPDATE clients
SET statut_compte = 'premium'
WHERE ville = 'Lyon';
SELECT @@ROWCOUNT AS LignesModifiees;Le résultat de ce `SELECT` sera `2` (pour nos clients Thomas et Lucas). C’est un excellent réflexe à avoir pour valider le comportement de vos scripts.
Gérer les types de données LOB (TEXT, NTEXT, VARCHAR(MAX))
Les colonnes contenant de gros volumes de données (texte long, images), appelées LOB (Large Object), demandent une attention particulière.
- Types de données obsolètes : Les types `text`, `ntext` et `image` sont considérés comme dépassés. Il est fortement recommandé d’utiliser leurs équivalents modernes : `varchar(max)`, `nvarchar(max)` et `varbinary(max)`.
- Mises à jour partielles : Pour modifier une partie d’un très grand texte sans réécrire toute la valeur, T-SQL propose la clause `.WRITE`. Elle permet de remplacer un segment de la donnée à une position (`Offset`) et sur une certaine longueur (`Length`).
La syntaxe est la suivante :
UPDATE ma_table
SET ma_colonne_lob.WRITE('nouveau_texte', @Offset, @Length)
WHERE id = 123;Cette approche est beaucoup plus performante pour les mises à jour sur des données volumineuses.
Les opérateurs d’assignation composés
Pour des opérations mathématiques simples, comme incrémenter une valeur, il n’est pas nécessaire d’écrire `SET colonne = colonne + valeur`. T-SQL supporte des opérateurs d’assignation composés qui rendent le code plus court et plus clair.
Voici les principaux opérateurs :
- `+=` (Additionner et assigner)
- `-=` (Soustraire et assigner)
- `*=` (Multiplier et assigner)
- `/=` (Diviser et assigner)
- `%=` (Modulo et assigner)
Par exemple, pour ajouter 10 au stock d’un produit, la syntaxe est très concise.
Au lieu d’écrire :
UPDATE produits
SET stock = stock + 10
WHERE id = 123;Vous pouvez simplement écrire :
UPDATE produits
SET stock += 10
WHERE id = 123;Le résultat est identique, mais la requête est plus directe et facile à lire.
