logo oujood
🔍

Node.js - MySQL Insert Into: Un guide pas à pas avec exemples concrets


OUJOOD.COM

Introduction

Node.js est un environnement de serveur puissant qui permet de construire des applications web scalables. Lorsqu'il est combiné avec MySQL, il devient un outil idéal pour gérer des bases de données relationnelles. Dans cet article, nous allons explorer comment utiliser l'instruction INSERT INTO dans Node.js avec MySQL, tout en abordant des sujets essentiels comme la gestion des erreurs, la sécurité, et l'utilisation des transactions.

Insérer avec Node.js

Voici un exemple simple d'insertion de données dans une base MySQL :

📋 Copier le code

const mysql = require('mysql');

const connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'testdb'
});

connection.connect((err) => {
  if (err) throw err;
  console.log('Connecté à MySQL!');
  
  const sql = "INSERT INTO users (name, email, age) VALUES ('Alice', 'alice@example.com', 30)";
  connection.query(sql, (err, result) => {
    if (err) throw err;
    console.log('1 enregistrement inséré, ID:', result.insertId);
  });
});

Explications :

  • Nous utilisons le module mysql pour gérer les connexions à la base de données.
  • La méthode createConnection permet de se connecter à la base de données testdb.
  • L'instruction SQL INSERT INTO ajoute un enregistrement avec les valeurs spécifiées.
  • result.insertId retourne l'ID de l'enregistrement nouvellement créé.

INSERT avec déclaration préparée

Utiliser des requêtes préparées est une pratique essentielle pour éviter les injections SQL :

📋 Copier le code

const sql = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
const values = ['Bob', 'bob@example.com', 45];

connection.query(sql, values, (err, result) => {
  if (err) throw err;
  console.log('Données insérées, ID:', result.insertId);
});

Explications :

  • Les points d'interrogation (?) servent de paramètres dans la requête SQL.
  • Les valeurs à insérer sont passées dans un tableau séparé, appelé values.
  • Cette méthode protège contre les attaques par injection SQL, car les paramètres sont échappés automatiquement.

Insérer plusieurs enregistrements

Voici comment insérer plusieurs lignes en une seule requête :

📋 Copier le code

const sql = "INSERT INTO users (name, email, age) VALUES ?";
const values = [
  ['Charlie', 'charlie@example.com', 28],
  ['Diana', 'diana@example.com', 35],
  ['Edward', 'edward@example.com', 40]
];

connection.query(sql, [values], (err, result) => {
  if (err) throw err;
  console.log('Nombre d\'enregistrements insérés:', result.affectedRows);
});

Explications :

  • Le tableau values contient plusieurs sous-tableaux, chaque sous-tableau représentant une ligne.
  • La méthode query insère toutes les lignes en une seule requête, ce qui est plus rapide que plusieurs requêtes séparées.
  • Le nombre total d'enregistrements insérés est accessible via result.affectedRows.

Gestion des erreurs avec INSERT INTO

Voici un exemple de gestion d'erreurs dans une requête MySQL avec Node.js :

📋 Copier le code

const sql = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
const values = ['Alice', 'alice@example.com', 30];

connection.query(sql, values, (err, result) => {
  if (err) {
    if (err.code === 'ER_DUP_ENTRY') {
      console.error('Erreur : Email déjà existant.');
    } else {
      console.error('Erreur SQL :', err.message);
    }
    return;
  }
  console.log('Enregistrement inséré, ID:', result.insertId);
});

Explications :

  • Vérification spécifique pour détecter l'erreur ER_DUP_ENTRY en cas de duplication d'un enregistrement.
  • Ajout d'une structure de gestion générale pour d'autres erreurs potentielles.

Utiliser des transactions pour des insertions multiples

Les transactions permettent d'exécuter plusieurs requêtes tout en garantissant que toutes réussissent ou échouent ensemble :

📋 Copier le code

connection.beginTransaction((err) => {
  if (err) throw err;

  const sql1 = "INSERT INTO accounts (name, balance) VALUES ('Alice', 100)";
  connection.query(sql1, (err, result) => {
    if (err) {
      return connection.rollback(() => {
        throw err;
      });
    }

    const sql2 = "INSERT INTO logs (action, status) VALUES ('account created', 'success')";
    connection.query(sql2, (err, result) => {
      if (err) {
        return connection.rollback(() => {
          throw err;
        });
      }

      connection.commit((err) => {
        if (err) {
          return connection.rollback(() => {
            throw err;
          });
        }
        console.log('Transaction réussie!');
      });
    });
  });
});

Explications :

  • Utilisez beginTransaction, rollback, et commit pour gérer la cohérence des données dans des opérations complexes
  • Chaque requête est vérifiée avant de confirmer les changements.

Node.js avec MySQL : INSERT INTO et Bonnes Pratiques

1. Gestion des erreurs

La gestion des erreurs est cruciale pour assurer la stabilité de votre application. Voici un exemple de code pour insérer des données dans une table MySQL tout en gérant les erreurs potentielles :

📋 Copier le code

const mysql = require('mysql');
const connection = mysql.createConnection({
host: 'localhost',
user: 'root',
password: '',
database: 'testdb'
});

connection.connect();

const query = 'INSERT INTO users (name, email) VALUES (?, ?)';
const values = ['John Doe', 'john.doe@example.com'];

connection.query(query, values, (error, results, fields) => {
if (error) {
console.error('Erreur lors de l\'insertion des données:', error);
return;
}
console.log('Données insérées avec succès:', results);
});

connection.end();

Dans cet exemple, si une erreur survient lors de l'exécution de la requête, elle sera capturée et affichée dans la console.

2. Sécurité : Prévention des injections SQL

Les injections SQL sont une vulnérabilité courante qui peut permettre à un attaquant d'exécuter des requêtes SQL malveillantes. Pour les prévenir, il est essentiel d'utiliser des requêtes paramétrées. Voici comment vous pouvez le faire :

📋 Copier le code

const query = 'INSERT INTO users (name, email) VALUES (?, ?)';
const values = ['John Doe', 'john.doe@example.com'];

connection.query(query, values, (error, results, fields) => {
if (error) {
console.error('Erreur lors de l\'insertion des données:', error);
return;
}
console.log('Données insérées avec succès:', results);
});

En utilisant des marqueurs de position (?), vous évitez que les entrées utilisateur ne soient interprétées comme du code SQL.

3. Utilisation des transactions

Les transactions sont utiles lorsque vous devez exécuter plusieurs requêtes SQL qui doivent toutes réussir ou échouer ensemble. Voici un exemple d'utilisation des transactions avec Node.js et MySQL :

📋 Copier le code

connection.beginTransaction((err) => {
if (err) {
console.error('Erreur lors du début de la transaction:', err);
return;
}

const query1 = 'INSERT INTO users (name, email) VALUES (?, ?)';
const values1 = ['John Doe', 'john.doe@example.com'];

connection.query(query1, values1, (error, results, fields) => {
if (error) {
	return connection.rollback(() => {
		console.error('Erreur lors de l\'insertion, annulation de la transaction:', error);
	});
}

const query2 = 'UPDATE accounts SET balance = balance - ? WHERE user_id = ?';
const values2 = [100, results.insertId];

connection.query(query2, values2, (error, results, fields) => {
	if (error) {
		return connection.rollback(() => {
			console.error('Erreur lors de la mise à jour, annulation de la transaction:', error);
		});
	}

	connection.commit((err) => {
		if (err) {
			return connection.rollback(() => {
				console.error('Erreur lors de la validation de la transaction:', err);
			});
		}
		console.log('Transaction réussie!');
	});
});
});
});

Dans cet exemple, si une des requêtes échoue, la transaction est annulée, garantissant ainsi l'intégrité des données.

Node.js avec MySQL : Intégration d'INSERT INTO dans une application complète

4. Intégration d'INSERT INTO dans une application complète

Dans cette section, nous allons créer une application simple avec un front-end (HTML/CSS) et un back-end (Node.js/MySQL) qui permet à l'utilisateur de soumettre un formulaire pour ajouter des données dans une base de données MySQL.

Étape 1 : Créer le front-end (HTML)

Voici un exemple de formulaire HTML permettant à l'utilisateur d'entrer son nom et son adresse e-mail :

📋 Copier le code

<form action="/submit" method="POST">
<label for="name">Nom :</label>
<input type="text" id="name" name="name" required>

<label for="email">Email :</label>
<input type="email" id="email" name="email" required>

<input type="submit" value="Soumettre">
</form>

Étape 2 : Configurer le back-end (Node.js)

Voici comment configurer le back-end pour traiter les données du formulaire et les insérer dans la base de données MySQL :

📋 Copier le code

const express = require('express');
const mysql = require('mysql');
const bodyParser = require('body-parser');

const app = express();
const port = 3000;

// Configuration de la connexion à MySQL
const connection = mysql.createConnection({
host: 'localhost',
user: 'root',
password: '',
database: 'testdb'
});

connection.connect();

// Middleware pour parser les données du formulaire
app.use(bodyParser.urlencoded({ extended: true }));

// Route pour afficher le formulaire
app.get('/', (req, res) => {
res.sendFile(__dirname + '/index.html');
});

// Route pour traiter la soumission du formulaire
app.post('/submit', (req, res) => {
const { name, email } = req.body;

const query = 'INSERT INTO users (name, email) VALUES (?, ?)';
const values = [name, email];

connection.query(query, values, (error, results) => {
if (error) {
	console.error('Erreur lors de l\'insertion des données:', error);
	res.status(500).send('Erreur lors de l\'insertion des données');
	return;
}
res.send('Données insérées avec succès !');
});
});

// Démarrer le serveur
app.listen(port, () => {
console.log(`Serveur démarré sur http://localhost:${port}`);
});

Étape 3 : Tester l'application

1. Créez un fichier index.html avec le formulaire HTML fourni ci-dessus.

2. Créez un fichier server.js avec le code Node.js ci-dessus.

3. Assurez-vous que MySQL est installé et que la base de données testdb et la table users existent.

4. Exécutez le serveur Node.js avec la commande node server.js.

5. Ouvrez votre navigateur et accédez à http://localhost:3000 pour voir le formulaire.

6. Soumettez le formulaire et vérifiez que les données sont bien insérées dans la base de données.

5. Cas pratique : Node.js et MySQL

Pour illustrer davantage, voici un cas pratique complet où nous utilisons Node.js et MySQL pour créer une application de gestion d'utilisateurs. Cette application permet :

  • D'afficher un formulaire pour ajouter un utilisateur.
  • De stocker les données dans une base de données MySQL.
  • De gérer les erreurs et d'afficher des messages de succès ou d'échec.

Vous pouvez étendre cette application en ajoutant des fonctionnalités supplémentaires, comme la mise à jour ou la suppression d'utilisateurs.

Nous espérons que cet article vous a aidé à comprendre comment intégrer INSERT INTO dans une application Node.js avec MySQL. En combinant ces techniques avec une bonne gestion des erreurs, une sécurité renforcée et l'utilisation de transactions, vous pouvez créer des applications robustes et sécurisées.


Cours precedent    Sommaire     Cours suivant