Mise à jour MySQL avec Node.js : Tutoriel complet et pratique

1. Introduction : Modifier des données MySQL avec Node.js

La mise à jour de données dans une base MySQL via Node.js est une opération fondamentale du développement back-end. Ce tutoriel vous guide à travers les différentes techniques pour exécuter des requêtes SQL UPDATE avec le module mysql de Node.js, en couvrant les cas d'usage les plus courants : mise à jour simple, requête préparée pour éviter les injections SQL, jointure JOIN multi-tables et mise à jour par lot. En 2026, le package mysql2 avec support natif des Promises et d'async/await est recommandé pour les nouveaux projets, mais les exemples ci-dessous restent valides avec le package mysql classique.

2. Syntaxe générale de la requête UPDATE en MySQL

Avant d'explorer les exemples Node.js, maîtrisons la syntaxe SQL de base. La requête UPDATE MySQL suit cette structure :

UPDATE nom_table
SET colonne1 = valeur1, colonne2 = valeur2, ...
WHERE condition;

Explication détaillée de chaque clause

1. UPDATE : Mot-clé qui indique une opération de modification sur des enregistrements existants. Contrairement à INSERT qui crée de nouveaux enregistrements, UPDATE modifie des données déjà présentes.
2. nom_table : Nom exact de la table cible. Exemple : UPDATE employee pour modifier la table des employés.
3. SET : Définit les nouvelles valeurs colonne par colonne. Séparez plusieurs affectations par des virgules. Les valeurs peuvent être des constantes (6000), des chaînes ('HR') ou des expressions calculées comme salary + 1000.
4. WHERE condition : Filtre les lignes à modifier. Sans cette clause, TOUTES les lignes sont mises à jour, ce qui peut causer des dommages irréversibles. Toujours spécifier une condition précise comme WHERE id = 1.

Exemple de syntaxe UPDATE pratique

UPDATE employee
SET salary = 6000, department = 'HR'
WHERE id = 1;

Cette requête met à jour uniquement l'employé avec l'ID 1 : son salaire passe à 6000 et son département change en "HR". Les autres lignes ne sont pas touchées.

Résultats attendus

Données avant la mise à jour :

Après exécution :

Danger : UPDATE sans clause WHERE

La clause WHERE est critique pour la sécurité de vos données. Sans elle, la requête suivante réinitialise le salaire de TOUS les employés à zéro :

UPDATE employee SET salary = 0; -- DANGER : affecte toutes les lignes !

Adoptez la bonne pratique de toujours tester vos requêtes UPDATE avec un SELECT préalable utilisant la même clause WHERE avant d'exécuter la modification.

3. Mise à jour simple avec Node.js et mysql.query()

Cet exemple illustre comment connecter Node.js à MySQL et exécuter une requête UPDATE pour augmenter le salaire de tous les employés. C'est le cas d'usage le plus basique, utile pour comprendre le flux de la connexion et l'exécution de requêtes.

const mysql = require('mysql'); // Import du module mysql (npm install mysql)
// Création de l'objet de connexion avec les paramètres de la base de données
const connection = mysql.createConnection({
    host: 'localhost',     // Serveur MySQL (IP ou nom de domaine)
    user: 'root',          // Nom d'utilisateur MySQL
    password: 'password',  // Mot de passe (utiliser une variable d'environnement en production !)
    database: 'madb'       // Nom de la base de données cible
});
// Établissement de la connexion à MySQL
connection.connect((err) => {
    if (err) throw err; // Arrête l'exécution si la connexion échoue
    console.log('Connecté à la base de données MySQL.');
    // Requête UPDATE sans WHERE : met à jour TOUS les salaires
    // salary = salary + 1000 : utilise une expression arithmétique, pas une valeur fixe
    const sql = "UPDATE employee SET salary = salary + 1000";
    connection.query(sql, (err, result) => {
        if (err) throw err;
        // result.affectedRows indique combien de lignes ont été modifiées
        console.log("Nombre d'enregistrements mis à jour : " + result.affectedRows);
    });
    connection.end(); // Ferme proprement la connexion après la requête
});

Explication pédagogique

Ce script établit une connexion MySQL via createConnection(), puis exécute la requête avec connection.query(). La propriété result.affectedRows retournée dans le callback indique le nombre de lignes effectivement modifiées — très utile pour valider que la mise à jour a bien fonctionné. Notez que l'absence de clause WHERE ici est intentionnelle : on souhaite augmenter le salaire de tous les employés.

Résultats attendus

4. Mise à jour sécurisée avec une déclaration préparée Node.js MySQL

Les requêtes préparées (prepared statements) sont la méthode recommandée pour toute mise à jour incluant des données utilisateur. En remplaçant les valeurs dynamiques par des marqueurs ?, vous protégez votre application contre les injections SQL, l'une des vulnérabilités les plus exploitées selon l'OWASP Top 10.

// Valeurs dynamiques à injecter dans la requête de manière sécurisée
const employeeId = 1;    // ID de l'employé à modifier
const newSalary = 6000;  // Nouveau salaire à appliquer
// Les marqueurs ? seront remplacés dans l'ordre par les valeurs du tableau
// Le driver mysql échappe automatiquement les valeurs pour prévenir les injections SQL
const sql = "UPDATE employee SET salary = ? WHERE id = ?";
// Passage des valeurs dans un tableau : [valeur_pour_1er_?, valeur_pour_2e_?]
connection.query(sql, [newSalary, employeeId], (err, result) => {
    if (err) throw err;
    // Si affectedRows vaut 0, aucun enregistrement ne correspond à l'ID fourni
    console.log("Nombre d'enregistrements mis à jour : " + result.affectedRows);
});

Pourquoi utiliser des déclarations préparées ?

Sans requête préparée, un attaquant pourrait passer la valeur 1 OR 1=1 comme employeeId pour contourner la clause WHERE et modifier tous les enregistrements. Avec les paramètres liés ?, le driver MySQL échappe automatiquement les caractères spéciaux, rendant l'injection impossible. C'est une bonne pratique de sécurité Node.js MySQL indispensable en production.

Résultats attendus

5. Mise à jour avec JOIN : combiner deux tables MySQL dans un UPDATE

La clause JOIN dans une requête UPDATE MySQL permet de mettre à jour une table en utilisant des données provenant d'une autre table liée. C'est particulièrement utile pour appliquer des bonus, des remises ou toute valeur stockée dans une table de référence.

// Requête UPDATE avec INNER JOIN pour combiner les tables employee et merits
// INNER JOIN : seuls les employés ayant un enregistrement dans merits sont affectés
const sql = `
    UPDATE employee
    INNER JOIN merits ON employee.id = merits.employee_id
    SET employee.salary = employee.salary + merits.bonus`;
// La colonne merits.bonus contient le montant du bonus propre à chaque employé
// La jointure garantit que chaque employé reçoit son bonus individuel
connection.query(sql, (err, result) => {
    if (err) throw err;
    console.log("Nombre d'enregistrements mis à jour : " + result.affectedRows);
});

Comment fonctionne l'UPDATE avec INNER JOIN ?

La clause INNER JOIN merits ON employee.id = merits.employee_id crée une correspondance entre les deux tables. Seuls les employés présents dans les deux tables auront leur salaire modifié. Si un employé n'a pas d'entrée dans merits, son salaire reste inchangé. Pour inclure tous les employés (même sans bonus), utilisez LEFT JOIN à la place.

Résultats attendus

Table employee :

Table merits :

Après exécution :

6. Mise à jour par lot : modifier plusieurs enregistrements en une seule requête

Quand vous devez mettre à jour plusieurs enregistrements MySQL avec des valeurs différentes en une seule opération, la technique CASE WHEN est la plus performante. Elle évite de multiplier les appels à la base de données et réduit la latence réseau.

const mysql = require('mysql');
const connection = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: 'password',
    database: 'madb'
});
// Tableau des employés à mettre à jour avec leur nouveau salaire respectif
const employees = [
    { id: 1, newSalary: 5000 },
    { id: 2, newSalary: 7000 },
    { id: 3, newSalary: 8000 }
];
// Construction dynamique d'une requête CASE WHEN pour mise à jour par lot
// CASE id WHEN 1 THEN 5000 WHEN 2 THEN 7000 ... : associe chaque ID à son salaire
const caseStatements = employees
    .map(emp => `WHEN ${emp.id} THEN ${emp.newSalary}`)
    .join(' ');
// ELSE salary : les lignes hors du tableau gardent leur salaire actuel
// WHERE id IN (...) : restreint la mise à jour aux seuls IDs du tableau
const ids = employees.map(emp => emp.id).join(', ');
const sql = `UPDATE employee SET salary = CASE id ${caseStatements} ELSE salary END WHERE id IN (${ids})`;
connection.connect((err) => {
    if (err) throw err;
    console.log('Connecté à la base de données MySQL.');
    // Une seule requête pour mettre à jour les 3 employés simultanément
    connection.query(sql, (err, result) => {
        if (err) throw err;
        console.log("Nombre d'enregistrements mis à jour : " + result.affectedRows);
    });
    connection.end();
});

Avantages de la mise à jour par lot avec CASE WHEN

Performance : une seule requête remplace N requêtes individuelles, ce qui réduit drastiquement les allers-retours réseau vers le serveur MySQL. Atomicité : toutes les mises à jour s'effectuent dans une même transaction implicite. Scalabilité : cette approche reste efficace même avec des dizaines d'enregistrements à modifier simultanément.

Résultats attendus

7. Migration vers mysql2 avec async/await (recommandé en 2026)

En 2026, le package mysql2 avec Promises et async/await est la norme pour les projets Node.js modernes. Il offre de meilleures performances, le support des requêtes préparées natives et une syntaxe plus lisible.

const mysql = require('mysql2/promise'); // mysql2 avec support des Promises
async function updateEmployeeSalary(employeeId, newSalary) {
    // Création d'une connexion avec async/await (plus lisible que les callbacks)
    const connection = await mysql.createConnection({
        host: 'localhost',
        user: 'root',
        password: process.env.DB_PASSWORD, // Bonne pratique : variable d'environnement
        database: 'madb'
    });
    try {
        // execute() utilise les vraies requêtes préparées côté serveur MySQL
        // Plus sécurisé que query() pour les données utilisateur
        const [result] = await connection.execute(
            'UPDATE employee SET salary = ? WHERE id = ?',
            [newSalary, employeeId]
        );
        console.log(`${result.affectedRows} enregistrement(s) mis à jour.`);
        return result.affectedRows;
    } finally {
        await connection.end(); // Toujours fermer la connexion, même en cas d'erreur
    }
}
// Appel de la fonction avec gestion d'erreur moderne
updateEmployeeSalary(1, 6500).catch(console.error);

8. Conclusion

Ce tutoriel vous a fourni une maîtrise complète des techniques de mise à jour MySQL avec Node.js : depuis la requête UPDATE basique jusqu'aux mises à jour par lot avec CASE WHEN, en passant par les requêtes préparées anti-injection SQL et les jointures JOIN multi-tables. Pour vos nouveaux projets en 2026, privilégiez mysql2 avec async/await pour un code plus maintenable et sécurisé. La maîtrise de ces patterns vous permettra de concevoir des applications back-end Node.js robustes et performantes.

Par carabde | Mis à jour le 18 février 2026