Mise à jour des données avec UPDATE

Aujourd'hui, on va attaquer un autre bloc super important de ta nouvelle base de connaissances — la mise à jour des données. On va voir comment modifier des infos existantes dans PostgreSQL avec la commande UPDATE. Pourquoi c'est important ? Bah, parce que dans la vraie vie, les données ne restent jamais figées. Imagine que ton pote change de numéro de téléphone, ou qu'un étudiant passe dans un autre groupe — évidemment, tu voudras mettre à jour ces infos dans ta base.

Quand ton crush du lycée, Svetka Sokolova, devient soudainement Svetka Khachatourian (bah ouais, c'est la vie), ça demande des modifs dans ta base de données. Les scénarios où tu dois mettre à jour des données, ça arrive tout le temps :

• Corriger des erreurs dans un enregistrement.
• Mettre à jour des infos (déménagement, changement de statut).
• Modification massive des données, genre augmenter les salaires des employés.

Mettre à jour des données, c'est changer la valeur d'une ou plusieurs colonnes pour une ou plusieurs lignes d'une table, sans ajouter de nouveaux enregistrements.

Syntaxe de la commande UPDATE

La commande UPDATE dans PostgreSQL a une syntaxe plutôt claire. Mate la structure :

UPDATE table
SET column1 = value1,
    column2 = value2
WHERE condition;

Explications :

• table : le nom de la table où tu veux modifier des trucs.
• SET column = value : le paramètre qui dit quelle colonne tu veux changer et avec quelle valeur.
• WHERE condition : la condition qui précise quelles lignes tu veux mettre à jour (super important pour pas tout modifier n'importe comment).

Détail crucial : si tu oublies de mettre WHERE (ou si tu le fais mal), tes modifs vont toucher toutes les lignes de la table. Et là, c'est la cata assurée.

Exemple : changer le nom d'un étudiant

Imaginons qu'on a une table students avec les colonnes id, name, email. On veut changer le nom de l'étudiant avec id = 1 en "Maria Chi".

UPDATE students
SET name = 'Maria Chi'
WHERE id = 1;

Cette commande va trouver la ligne avec id = 1 et mettre à jour la colonne name avec la nouvelle valeur. Easy, non ?

Mettre à jour plusieurs colonnes

Souvent, tu dois changer plusieurs valeurs d'un coup dans un enregistrement. Par exemple, imagine qu'un étudiant a changé non seulement de nom, mais aussi d'adresse mail. Voilà comment faire :

UPDATE students
SET name = 'Otto Lin',
    email = 'otto.lin@example.com'
WHERE id = 2;

Là, on met à jour à la fois name et email pour l'étudiant avec id = 2. PostgreSQL te permet de mettre plusieurs paires colonne=valeur séparées par des virgules dans la partie SET.

Mettre à jour plusieurs lignes

Et si tu dois modifier les données pour plusieurs lignes d'un coup ? Genre, tu veux transférer un groupe d'étudiants dans une nouvelle promo. Pour ça, tu peux mettre à jour les lignes qui correspondent à un critère précis. Disons qu'on a le champ group_number, et on veut passer tous les étudiants du groupe 101 au groupe 202 :

UPDATE students
SET group_number = 202
WHERE group_number = 101;

Cette commande va mettre à jour toutes les lignes où group_number vaut 101, et le remplacer par 202.

5. La condition WHERE : fais gaffe !

Comme on l'a déjà dit, WHERE — c'est ton gilet de sauvetage. Sans lui, la requête va toucher toutes les lignes de la table. Par exemple, la commande suivante va changer le GROUPE de tous les étudiants, pas seulement ceux du groupe 101. Et ça, tu veux clairement pas :

UPDATE students
SET group_number = 202;

S'il te plaît, mets toujours WHERE si tu veux pas flinguer tes données par accident. Mieux vaut être trop prudent.

Pense à la commande UPDATE comme une commande qui modifie les colonnes de la table, pas les lignes. Son but, c'est d'attribuer une certaine valeur à toutes les cellules d'une colonne. Et c'est seulement la présence de WHERE qui fait que ça ne touche pas toutes les lignes.

Mettre à jour à partir des données d'une autre table

Parfois, on veut pas juste "écrire" une valeur à la main, mais mettre à jour les valeurs de la table A en utilisant les données de la table B. Ça arrive souvent — surtout quand les données sont stockées séparément : genre, les calculs dans une table, les profils utilisateurs dans une autre.

Imaginons qu'on a une table students, et qu'on doit mettre à jour la colonne debt en utilisant la table payments, où est stocké le montant actuel de la dette (due_amount). Chaque enregistrement de students correspond à un enregistrement dans payments via le champ student_id.

La syntaxe ressemblera à ça :

UPDATE students
SET debt = payments.due_amount
FROM payments
WHERE students.id = payments.student_id;

Ce qui se passe :

• PostgreSQL utilise FROM payments comme source de données.
• La condition WHERE fait le lien entre les lignes des deux tables.
• Il ne met à jour que les lignes de students qui ont une correspondance dans payments.

À retenir : dans ce UPDATE ... FROM, il y a en fait un JOIN caché, même si on n'utilise pas le mot-clé JOIN.

En vrai, sous le capot, c'est un JOIN. Ça ressemble à peu près à ça :

UPDATE students
SET debt = p.due_amount
FROM payments p
    JOIN students s ON s.id = p.student_id
WHERE students.id = p.student_id;

Comment voir ce qui va être mis à jour

Avant de lancer un UPDATE, c'est super malin de vérifier ce qui va vraiment changer. Tu peux faire ça avec un SELECT construit sur le même principe :

SELECT
    students.id, 
    students.name, 
    students.debt AS ancienne_dette, 
    payments.due_amount AS nouvelle_dette
FROM students
    JOIN payments ON students.id = payments.student_id;

Le résultat va te montrer :

• l'ancienne valeur de la dette (ancienne_dette);
• la nouvelle valeur qui vient de la table payments (nouvelle_dette).

Cette méthode aide à vérifier la logique avant d'écraser tes données pour de bon.

Pièges potentiels

• Si payments contient plusieurs enregistrements pour un même étudiant, UPDATE va planter avec l'erreur : more than one row returned. Il faut soit utiliser une agrégation (MAX, SUM, LIMIT 1), soit s'assurer que student_id dans payments est unique.
• N'oublie pas que UPDATE ... FROM — c'est une particularité de PostgreSQL et ça marche pas pareil dans d'autres SGBD (genre MySQL).

Exemples pratiques

Exemple 1 : Changer le statut des étudiants

Imaginons que les étudiants qui ont fini le cours reçoivent le statut "diplômé". On a une colonne status. Pour mettre à jour le statut des étudiants avec completed_course = true :

UPDATE students
SET status = 'diplômé'
WHERE completed_course = true;

Exemple 2 : Augmenter les salaires des employés

Si tu as une table employees et que tu veux augmenter de 10% le salaire de tous ceux qui bossent au département des ventes :

UPDATE employees
SET salary = salary * 1.10
WHERE department = 'Sales';

Là, on utilise une opération mathématique direct dans la partie SET. Pratique pour les modifs en masse.

Exemple 3 : Mise à jour conditionnelle

Parfois, tu dois mettre à jour les données selon une condition. Par exemple, si le salaire d'un employé est inférieur à 50 000, il doit augmenter de 20%, sinon de 10% :

UPDATE employees
SET salary = CASE
                WHEN salary < 50000 THEN salary * 1.20
                ELSE salary * 1.10
             END;

Cette commande utilise la structure CASE pour appliquer des règles différentes selon la valeur de salary.

Erreurs classiques avec UPDATE

Tu t'en doutes sûrement, c'est quoi l'erreur la plus fréquente ? Ouais, c'est oublier le WHERE. Imagine la scène : t'as une base avec 10 000 employés, et tu augmentes par erreur le salaire de tout le monde. Même si ça fait plaisir à tes collègues, pour ta carrière, c'est… pas ouf.

Autre erreur courante — mettre à jour la mauvaise colonne. Vérifie toujours ce que tu modifies et où tu l'écris. Un simple SELECT avant le UPDATE peut te sauver la vie (et du temps).