Comment Lire une Base de Données SQLite sur Node.js

Pour lire une base de données SQLite dans un environnement Node.js, vous pouvez utiliser des bibliothèques spécifiques qui permettent d’interagir avec les fichiers SQLite. Une des bibliothèques les plus populaires pour cela est sqlite3. Voici un guide étape par étape pour configurer votre environnement et lire une base de données SQLite dans une application Node.js.

Étape 1 : Installer Node.js

Assurez-vous que Node.js est installé sur votre système. Vous pouvez vérifier cela en exécutant la commande suivante dans votre terminal :

node -v

Si Node.js n’est pas installé, vous pouvez le télécharger et l’installer à partir de nodejs.org.

Étape 2 : Créer un projet Node.js

Créez un nouveau répertoire pour votre projet et accédez-y depuis le terminal :
Fenêtre de terminal
```
mkdir my-sqlite-project
cd my-sqlite-project
```
Initialisez un projet Node.js avec npm init :
Fenêtre de terminal
```
npm init -y
```
Cela créera un fichier package.json avec les paramètres par défaut.

Étape 3 : Installer la bibliothèque `sqlite3`

Ensuite, vous devez installer la bibliothèque sqlite3, qui vous permettra de manipuler des bases de données SQLite dans Node.js.

npm install sqlite3

Étape 4 : Lire une base de données SQLite dans Node.js

Créez un fichier JavaScript, par exemple index.js, dans votre projet :
Fenêtre de terminal
```
touch index.js
```

Ouvrez ce fichier index.js dans votre éditeur de texte préféré, puis ajoutez le code suivant pour lire les données d’une base de données SQLite :

const sqlite3 = require('sqlite3').verbose();

// Ouvrir une base de données SQLite
let db = new sqlite3.Database('./my-database.db', sqlite3.OPEN_READWRITE, (err) => {
    if (err) {
        console.error(err.message);
    } else {
        console.log('Connecté à la base de données SQLite.');
    }
});

// Exécuter une requête SELECT
db.serialize(() => {
    db.each(`SELECT id, name, email FROM users`, (err, row) => {
        if (err) {
            console.error(err.message);
        }
        console.log(`${row.id}: ${row.name} - ${row.email}`);
    });
});

// Fermer la base de données
db.close((err) => {
    if (err) {
        console.error(err.message);
    } else {
        console.log('Fermeture de la base de données.');
    }
});

Explication du code :

Connexion à la base de données : let db = new sqlite3.Database('./my-database.db', sqlite3.OPEN_READWRITE, ...);
- Ce code ouvre la base de données my-database.db. Si elle n’existe pas, vous devez spécifier le bon chemin vers une base de données existante.
- Le mode sqlite3.OPEN_READWRITE ouvre la base de données en lecture et en écriture. Vous pouvez également utiliser sqlite3.OPEN_READONLY si vous ne voulez que lire les données.
Exécution d’une requête SELECT : db.serialize(() => { ... });
- La méthode serialize() s’assure que les requêtes sont exécutées de manière séquentielle.
- db.each() exécute une requête SELECT et traite chaque ligne de résultat individuellement. Dans cet exemple, les données sont récupérées de la table users et affichées dans la console.
Fermeture de la base de données : db.close(...);
- Une fois les opérations terminées, il est recommandé de fermer la connexion à la base de données pour libérer les ressources.

Étape 5 : Exécuter le script

Une fois votre code écrit, vous pouvez exécuter le script à partir du terminal :

node index.js

Si tout est correctement configuré, vous verrez les résultats de votre requête SELECT s’afficher dans la console.

Étape 6 : Manipuler les résultats

Vous pouvez adapter ce modèle de base pour manipuler les résultats selon vos besoins, par exemple en les stockant dans des structures de données, en les transformant, ou en les renvoyant dans le cadre d’une API REST.

Utilisation de SQLite nativement dans Node.js

Depuis Node.js v21.0.0, un support préliminaire et expérimental de SQLite a été introduit directement dans le runtime Node.js. Cette fonctionnalité est toujours en développement mais offre une alternative intéressante aux modules tiers.

Activer l’API SQLite native

Pour utiliser l’API SQLite native, vous devez démarrer Node.js avec le flag --experimental-sqlite :

node --experimental-sqlite votre-script.js

Utilisation basique

// Importer le module SQLite expérimental
import { sqlite3 } from 'node:sqlite3';

// Ouvrir ou créer une base de données
const db = sqlite3.open(':memory:'); // Base de données en mémoire

// Exécuter des requêtes SQL
db.exec('CREATE TABLE utilisateurs (id INTEGER PRIMARY KEY, nom TEXT, email TEXT)');
db.exec('INSERT INTO utilisateurs (nom, email) VALUES ("Alice", "[email protected]")');

// Exécuter une requête avec des paramètres
const stmt = db.prepare('SELECT * FROM utilisateurs WHERE nom = ?');
const result = stmt.all('Alice');
console.log(result); // [{ id: 1, nom: 'Alice', email: '[email protected]' }]

// Nettoyer les ressources
stmt.finalize();
db.close();

Méthodes principales

L’API SQLite native de Node.js propose plusieurs méthodes importantes :

Ouverture d’une base de données

// Syntaxe
sqlite3.open(filename, [flags, vfs]);

// Exemples
const memoryDb = sqlite3.open(':memory:'); // Base de données en mémoire
const fileDb = sqlite3.open('ma-base.db'); // Fichier sur disque

Les flags optionnels peuvent être une combinaison de :

SQLITE_OPEN_READONLY: Ouvre en lecture seule
SQLITE_OPEN_READWRITE: Ouvre en lecture/écriture
SQLITE_OPEN_CREATE: Crée la base de données si elle n’existe pas

Exécution de requêtes

// Pour les requêtes sans retour
db.exec('CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, nom TEXT)');

// Préparation d'une requête paramétrée
const insertStmt = db.prepare('INSERT INTO items (nom) VALUES (?)');
insertStmt.run('Objet 1');

// Récupération de résultats
const selectStmt = db.prepare('SELECT * FROM items');
const allItems = selectStmt.all(); // Toutes les lignes
const firstItem = selectStmt.get(); // Première ligne seulement

// Itération sur les résultats
for (const row of selectStmt.iterate()) {
  console.log(row);
}

Avantages de l’API native

L’API SQLite native de Node.js présente plusieurs avantages potentiels :

Performance : En tant que partie intégrante du runtime, elle peut offrir de meilleures performances que les modules tiers.
Simplicité : Pas besoin d’installer des dépendances externes.
Cohérence : Interface standardisée qui ne changera pas entre les projets.

Limitations actuelles

Étant donné que cette fonctionnalité est expérimentale, elle présente certaines limitations :

API incomplète : Certaines fonctionnalités avancées de SQLite peuvent ne pas être encore disponibles.
Stabilité : L’API peut changer entre les versions de Node.js.
Documentation : La documentation est encore en développement.

Pour les projets de production, il est actuellement recommandé de continuer à utiliser des bibliothèques éprouvées comme sqlite3 ou better-sqlite3 jusqu’à ce que l’API native atteigne un état stable.