Développer en PHP avec le module SQLite intégré à ServBay

ServBay est un environnement de développement Web local puissant, conçu pour les développeurs et compatible avec de nombreuses piles technologiques. Il intègre le module SQLite, ce qui rend la gestion et le stockage des données via SQLite dans des applications PHP particulièrement simples et efficaces. Ce guide vous explique en détail comment profiter de cette fonctionnalité dans ServBay.

Présentation du module SQLite

SQLite est un système de gestion de base de données relationnelle embarqué et léger. Contrairement aux bases de données client/serveur classiques comme MySQL ou PostgreSQL, SQLite ne nécessite aucun serveur indépendant, étant directement intégré sous forme de bibliothèque à l’application. Toute la base de données est stockée dans un seul fichier, ce qui simplifie grandement le déploiement et la gestion.

SQLite est largement adopté pour ses qualités suivantes, en particulier dans les applications de petite à moyenne taille, le cache local, les applications mobiles, ainsi que pour le développement et les tests :

Caractéristiques principales

1. Léger : Une bibliothèque de petite taille à faible consommation de ressources.
2. Zéro configuration : Aucun serveur à installer ou à configurer, pas de gestion d’utilisateurs — prêt à l’emploi.
3. Haute performance : Excellente rapidité sur la majorité des lectures et pour des écritures modérées.
4. Stockage dans un seul fichier : Toute la base de données tient dans un fichier .sqlite, facile à sauvegarder, migrer et gérer.
5. Prise en charge des transactions ACID : Garantit la fiabilité, la cohérence et l’intégrité des données.
6. Multiplateforme : Compatible avec de nombreux systèmes d’exploitation et langages de programmation.

Support de SQLite par ServBay

ServBay intègre plusieurs versions de PHP, et pour chacune d’elles, les extensions SQLite requises (sqlite3 et pdo_sqlite) sont déjà installées et activées par défaut. Ainsi, il n’est pas nécessaire d’installer, de compiler ou de configurer manuellement aucune extension PHP pour profiter de SQLite dans vos projets PHP.

Prérequis

• ServBay est installé et fonctionne sous macOS.
• La version de PHP que vous souhaitez utiliser est activée et lancée dans ServBay.
• Vous disposez d’un dossier pour héberger vos fichiers de site Web, idéalement le répertoire racine par défaut de ServBay /Applications/ServBay/www ou un de ses sous-répertoires.

Comment utiliser SQLite dans ServBay

Comme le module SQLite est activé par défaut dans ServBay, aucune étape d’activation spécifique n’est requise. Votre environnement PHP est prêt à utiliser les classes et fonctions SQLite directement.

Vérifier si l’extension SQLite est activée :

Vous pouvez vérifier le chargement de l’extension SQLite dans ServBay via la fonction phpinfo() :

1. Créez un fichier PHP contenant <?php phpinfo(); ?> (par exemple info.php).
2. Placez ce fichier dans le répertoire racine de votre site ServBay, par exemple /Applications/ServBay/www/servbay.demo/info.php.
3. Accédez-y via votre navigateur (exemple : http://servbay.demo/info.php).
4. Recherchez "sqlite" ou "pdo_sqlite" sur la page affichée. Si vous repérez ces sections de configuration, l’extension est bien activée.

Utiliser SQLite dans un code PHP

Une fois l’extension SQLite activée, vous pouvez accéder nativement aux API PHP pour toutes les opérations sur une base SQLite. PHP propose différentes approches pour interagir avec SQLite, principalement via la classe orientée objet SQLite3 et PDO (PHP Data Objects).

Voici deux exemples : l’un utilisant SQLite3, l’autre PDO. Il est conseillé de placer vos scripts PHP, ainsi que les fichiers de base de données .sqlite générés, à l’intérieur du répertoire de votre projet Web, par exemple /Applications/ServBay/www/nom-de-votre-projet/.

Exemple de code (utilisation standard de SQLite3)

Cette méthode utilise la classe native SQLite3 de PHP pour une interface orientée objet avec SQLite.

<?php
// Chemin du fichier de base de données
// Il est recommandé de placer la base dans un sous-dossier "data/" du projet
$db_file = __DIR__ . '/data/servbay_demo.sqlite'; // __DIR__ est le répertoire du script courant

// Vérifier si le dossier "data" existe, sinon le créer
if (!is_dir(__DIR__ . '/data')) {
    mkdir(__DIR__ . '/data', 0777, true);
}

// Connexion à la base de données SQLite
// Si le fichier n’existe pas il sera automatiquement créé par SQLite
try {
    $db = new SQLite3($db_file);
    echo "Connexion à la base de données réussie : " . $db_file . "\n";
} catch (Exception $e) {
    die("Échec de la connexion à la base de données : " . $e->getMessage());
}


// Création de la table
// Utilisation de IF NOT EXISTS pour éviter toute erreur en cas de création multiple
$create_table_sql = "CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    age INTEGER
)";
if ($db->exec($create_table_sql)) {
    echo "Table 'users' créée ou déjà existante\n";
} else {
    echo "Erreur lors de la création de la table : " . $db->lastErrorMsg() . "\n";
}


// Insertion des données
$name = 'ServBay Demo User';
$email = '[email protected]';
$age = 30;

// Utilisation d’une requête préparée pour éviter l’injection SQL
$stmt = $db->prepare("INSERT INTO users (name, email, age) VALUES (:name, :email, :age)");
$stmt->bindValue(':name', $name, SQLITE3_TEXT);
$stmt->bindValue(':email', $email, SQLITE3_TEXT);
$stmt->bindValue(':age', $age, SQLITE3_INTEGER);

// Exécuter l’insertion et vérifier la réussite (email est UNIQUE, une insertion dupliquée échouera)
if ($stmt->execute()) {
    echo "Insertion réussie : Nom=" . $name . ", Email=" . $email . "\n";
} else {
    // Vérifier l’erreur d’unicité
    if (strpos($db->lastErrorMsg(), 'UNIQUE constraint failed') !== false) {
         echo "Échec de l’insertion : Email '" . $email . "' existe déjà\n";
    } else {
        echo "Échec de l’insertion : " . $db->lastErrorMsg() . "\n";
    }
}
$stmt->close(); // Fermer la requête préparée


// Requête SELECT
$search_name = 'ServBay Demo User';
$query_sql = "SELECT id, name, email, age FROM users WHERE name = :name";
$stmt = $db->prepare($query_sql);
$stmt->bindValue(':name', $search_name, SQLITE3_TEXT);

$result = $stmt->execute();

echo "Résultat de la requête :\n";
$found = false;
while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
    print_r($row);
    $found = true;
}
if (!$found) {
    echo "Aucune donnée correspondante trouvée\n";
}

$result->finalize(); // Libérer le jeu de résultats
$stmt->close(); // Fermer la requête préparée


// Fermer la connexion à la base
$db->close();
echo "Connexion à la base fermée\n";

?>

Exemple de code (avec PDO)

PDO (PHP Data Objects) fournit une couche d’abstraction commune pour accéder à différents systèmes de base de données, ce qui facilite les changements d’un type de base à un autre. Utiliser PDO avec SQLite est recommandé pour sa flexibilité et la compatibilité avec d’autres types de bases.

<?php
// Chemin du fichier de base de données
// Il est recommandé de placer la base dans un sous-dossier "data/" du projet
$db_file = __DIR__ . '/data/servbay_demo_pdo.sqlite'; // __DIR__ est le répertoire du script courant

// Vérifier si le dossier "data" existe, sinon le créer
if (!is_dir(__DIR__ . '/data')) {
    mkdir(__DIR__ . '/data', 0777, true);
}

try {
    // Création de l’instance PDO
    // Le DSN (Data Source Name) doit être 'sqlite:chemin_de_la_base'
    $dsn = 'sqlite:' . $db_file;
    $pdo = new PDO($dsn);

    // Définir le mode de gestion des erreurs sur Exception (pratique pour le debug)
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    // Définir le mode de récupération par défaut (par exemple tableau associatif)
    $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);

    echo "Connexion à la base de données réussie : " . $db_file . "\n";

    // Création de la table
    $create_table_sql = "CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        email TEXT UNIQUE NOT NULL,
        age INTEGER
    )";
    $pdo->exec($create_table_sql);
    echo "Table 'users' créée ou déjà existante\n";


    // Insertion des données
    $name = 'ServBay PDO User';
    $email = '[email protected]';
    $age = 35;

    // Utilisation d’une requête préparée
    $stmt = $pdo->prepare("INSERT INTO users (name, email, age) VALUES (:name, :email, :age)");

    // Exécuter l’insertion et vérifier la réussite (email est UNIQUE, une insertion dupliquée échouera)
    try {
        $stmt->execute([
            ':name' => $name,
            ':email' => $email,
            ':age' => $age
        ]);
        echo "Insertion réussie : Nom=" . $name . ", Email=" . $email . "\n";
    } catch (PDOException $e) {
         // Vérifier l’erreur d’unicité (erreur SQLite 19)
         if ($e->getCode() == '23000' || strpos($e->getMessage(), 'UNIQUE constraint failed') !== false) {
             echo "Échec de l’insertion : Email '" . $email . "' existe déjà\n";
         } else {
             throw $e; // Relancer tout autre type d’erreur
         }
    }
    $stmt->closeCursor(); // Libérer la ressource de la requête


    // Requête SELECT
    $search_name = 'ServBay PDO User';
    $stmt = $pdo->prepare("SELECT id, name, email, age FROM users WHERE name = :name");
    $stmt->execute([':name' => $search_name]);

    $data = $stmt->fetchAll(); // Récupérer tous les résultats

    echo "Résultat de la requête :\n";
    if ($data) {
        print_r($data);
    } else {
        echo "Aucune donnée correspondante trouvée\n";
    }

    $stmt->closeCursor(); // Libérer la ressource de la requête

} catch (PDOException $e) {
    // Gestion des exceptions PDO
    echo "Erreur sur l’opération base de données : " . $e->getMessage();
    // Le code erreur SQLSTATE est accessible via $e->getCode()
}

// Avec PDO, la connexion se ferme automatiquement en fin de script

?>

Emplacement du fichier de base de données :

Dans les exemples ci-dessus, les fichiers de base de données (servbay_demo.sqlite et servbay_demo_pdo.sqlite) sont créés dans le sous-répertoire data/ du dossier contenant le script PHP en cours d’exécution. Par exemple, si votre script est /Applications/ServBay/www/my-servbay-project/index.php, la base sera créée dans /Applications/ServBay/www/my-servbay-project/data/.

Stocker votre base de données dans un sous-répertoire de projet facilite la gestion, l’organisation et la sauvegarde. Assurez-vous que l’utilisateur exécutant ServBay dispose des droits en écriture sur ce dossier (ce qui est généralement le cas avec la configuration par défaut de ServBay sous macOS).

Points d’attention

• Les fichiers de bases de données SQLite contiennent des informations sensibles ; il est impératif d’éviter qu’ils soient accessibles publiquement. Si possible, stockez-les hors des répertoires accessibles par le Web, ou configurez votre serveur (Caddy, Nginx, etc.) pour bloquer l’accès direct aux fichiers .sqlite. L’utilisation du dossier data/ dans l’exemple est pour des raisons pratiques — en production, optez pour une sécurité renforcée.
• SQLite est idéal pour des scénarios où les écritures concurrentes sont peu fréquentes. Dans le cas d’écritures intensives et simultanées, des problèmes de blocage ou de performance peuvent apparaître. Pour des besoins d’écritures concurrentes élevées, privilégiez MySQL ou PostgreSQL.
• Même si ServBay active SQLite par défaut, si vous ne voyez aucune trace de SQLite dans la sortie de phpinfo(), vérifiez la configuration PHP de ServBay ou essayez de redémarrer le service ServBay.

Questions fréquentes (FAQ)

Q : Dois-je installer SQLite séparément ?

R : Non. L’extension SQLite est intégrée et pré-activée dans les bundles PHP fournis par ServBay. Elle est prête à être utilisée dans vos scripts PHP.

Q : Où dois-je placer mon fichier de base de données .sqlite ?

R : Il est recommandé de le placer dans un sous-dossier qui n’est pas directement accessible par le Web (par exemple data/ ou database/) dans votre dossier de projet pour plus de sécurité. Dans l’exemple, __DIR__ . '/data/' est utilisé pour définir un chemin relatif.

Q : Mon script PHP n’arrive pas à se connecter à la base SQLite ou à créer le fichier, que faire ?

R : Vérifiez les points suivants :

• Assurez-vous que ServBay fonctionne et que vous passez bien par ServBay pour accéder à votre script PHP.
• Consultez la sortie de phpinfo() pour vérifier que les extensions sqlite3 et pdo_sqlite sont actives.
• Vérifiez que le dossier de la base existe et que l’utilisateur qui exécute ServBay a les droits d’écriture nécessaires.

Conclusion

ServBay offre un support natif et pratique pour SQLite avec PHP. Grâce au module SQLite intégré et activé par défaut, vous pouvez développer et tester facilement en local vos applications PHP utilisant SQLite, sans aucune étape de configuration complexe. Avec la légèreté et la simplicité d’utilisation de SQLite, ServBay s’impose comme un environnement local de développement efficace et accessible.