PHP-ontwikkeling met de ingebouwde SQLite-databasemodule in ServBay

ServBay is een krachtige lokale webontwikkelomgeving, speciaal ontworpen voor ontwikkelaars en ondersteunt diverse technologieën. Het heeft een ingebouwde SQLite-databasemodule, waardoor het gebruik van SQLite voor dataopslag en -beheer binnen PHP-applicaties uiterst eenvoudig wordt. In dit artikel lees je hoe je optimaal van deze functionaliteit in ServBay profiteert.

Overzicht van de SQLite-module

SQLite is een lichtgewicht, embedded relationeel databasemanagementsysteem. In tegenstelling tot traditionele client/server-databases zoals MySQL of PostgreSQL, vereist SQLite geen afzonderlijk serverproces. De database wordt direct geïntegreerd in de applicatie als een bibliotheek. Alle data wordt opgeslagen in één enkel bestand, wat implementatie en beheer vereenvoudigt.

SQLite is populair vanwege deze eigenschappen en is met name geschikt voor kleine en middelgrote applicaties, lokale caching, mobiele applicaties, en ontwikkel- of testomgevingen:

Belangrijkste eigenschappen

1. Lichtgewicht: De kernbibliotheek is compact en verbruikt weinig middelen.
2. Zonder configuratie: Geen installatie of serverconfiguratie nodig; direct te gebruiken.
3. Hoge prestaties: Voor de meeste leesbewerkingen en matig schrijfverkeer biedt SQLite uitstekende prestaties.
4. Opslag in één bestand: De volledige database wordt opgeslagen in een .sqlite-bestand: makkelijk te back-uppen, migreren en beheren.
5. ACID-transactieondersteuning: Betrouwbare verwerking met waarborging van dataconsistentie en -integriteit.
6. Cross-platform: Ondersteunt diverse besturingssystemen en programmeertalen.

Ondersteuning van SQLite in ServBay

ServBay integreert meerdere PHP-versies en voor elk daarvan zijn de relevante SQLite-extensies (zoals sqlite3 en pdo_sqlite) al vooraf geïnstalleerd en standaard ingeschakeld. Je hoeft dus geen extensies meer te downloaden, compileren of configureren – gebruik SQLite direct in elk PHP-project.

Vereisten

• ServBay is geïnstalleerd en draait op macOS.
• Je hebt de gewenste PHP-versie ingeschakeld en draaiend binnen ServBay.
• Je beschikt over een map voor de websitebestanden. Het is aan te raden de standaard webroot van ServBay te gebruiken: /Applications/ServBay/www of een submap daarvan.

SQLite gebruiken in ServBay

Omdat de SQLite-module standaard is ingeschakeld in ServBay, hoeft er geen aparte activatiestap plaats te vinden. De PHP-omgeving staat klaar en je kunt direct de relevante functies en klassen van SQLite aanroepen.

Controleren of de SQLite-extensie is ingeschakeld:

Wil je zeker weten dat de SQLite-extensie correct is geladen? Controleer dit dan via de uitvoer van phpinfo():

1. Maak een PHP-bestand met de inhoud <?php phpinfo(); ?> (bijvoorbeeld info.php).
2. Plaats dit bestand binnen een websitemap in de ServBay-webroot, bijvoorbeeld /Applications/ServBay/www/servbay.demo/info.php.
3. Open dit bestand in je browser (bijvoorbeeld http://servbay.demo/info.php).
4. Zoek op de resultaatpagina naar "sqlite" of "pdo_sqlite". Zie je de overeenkomstige configuratiesecties, dan is de extensie succesvol geladen.

SQLite gebruiken in PHP-code

Zodra de extensie beschikbaar is, kun je de bijbehorende SQLite-API’s direct in je PHP-applicatie gebruiken. PHP biedt meerdere manieren om met SQLite te communiceren, waarvan de meest gebruikte de objectgeoriënteerde SQLite3-klasse en PDO (PHP Data Objects) zijn.

Hieronder vind je eenvoudige voorbeelden hoe je in ServBay met beide methoden verbind, tabellen aanmaakt, data invoegt en opvraagt. Plaats deze scripts en de bijbehorende .sqlite-databasebestanden idealiter in je projectmap, bijvoorbeeld /Applications/ServBay/www/your-project-name/.

Voorbeeldcode (standaard SQLite3-methode)

Met deze aanpak gebruik je de ingebouwde PHP-klasse SQLite3, die een objectgeoriënteerde interface biedt voor SQLite-databases.

<?php
// Pad naar het databasebestand
// Het is aan te raden het databasebestand in een submap, zoals data/, van de projectmap op te slaan
$db_file = __DIR__ . '/data/servbay_demo.sqlite'; // __DIR__ verwijst naar de map van het huidige script

// Zorg dat de datamap bestaat
if (!is_dir(__DIR__ . '/data')) {
    mkdir(__DIR__ . '/data', 0777, true);
}

// Verbinding maken met de SQLite-database
// Als het bestand niet bestaat, maakt SQLite het automatisch aan
try {
    $db = new SQLite3($db_file);
    echo "Succesvol verbonden met database: " . $db_file . "\n";
} catch (Exception $e) {
    die("Verbinding met de database mislukt: " . $e->getMessage());
}


// Tabel aanmaken
// Gebruik IF NOT EXISTS om fout bij dubbele aanmaak te voorkomen
$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 "Tabel 'users' aangemaakt of bestaat al\n";
} else {
    echo "Tabel aanmaken mislukt: " . $db->lastErrorMsg() . "\n";
}


// Data invoegen
$name = 'ServBay Demo User';
$email = '[email protected]';
$age = 30;

// Gebruik prepared statements om SQL-injecties te voorkomen
$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);

// Voer de invoeging uit en controleer succes (email is UNIQUE, dubbele invoer faalt)
if ($stmt->execute()) {
    echo "Data succesvol ingevoegd: Naam=" . $name . ", Email=" . $email . "\n";
} else {
    // Controleer of het een unieke beperking betreft
    if (strpos($db->lastErrorMsg(), 'UNIQUE constraint failed') !== false) {
         echo "Invoegen mislukt: Email '" . $email . "' bestaat al\n";
    } else {
        echo "Invoegen mislukt: " . $db->lastErrorMsg() . "\n";
    }
}
$stmt->close(); // Sluit de prepared statement af


// Data opvragen
$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 "Zoekresultaten:\n";
$found = false;
while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
    print_r($row);
    $found = true;
}
if (!$found) {
    echo "Geen overeenkomende data gevonden\n";
}

$result->finalize(); // Vrijgeven van het resultaat
$stmt->close(); // Sluit de statement af


// Databaseverbinding sluiten
$db->close();
echo "Databaseverbinding gesloten\n";

?>

Voorbeeldcode (PDO-methode)

PDO (PHP Data Objects) biedt een uniforme abstractielaag voor databaseverbindingen. Met PDO kun je via dezelfde functies verschillende databases aanspreken. Het gebruik van PDO voor SQLite wordt aanbevolen: het is flexibel en ondersteunt meerdere databasesystemen.

<?php
// Pad naar het databasebestand
// Het is aan te raden het databasebestand in een submap, bijvoorbeeld data/, op te slaan
$db_file = __DIR__ . '/data/servbay_demo_pdo.sqlite'; // __DIR__ verwijst naar de map van het huidige script

// Zorg dat de datamap bestaat
if (!is_dir(__DIR__ . '/data')) {
    mkdir(__DIR__ . '/data', 0777, true);
}

try {
    // Maak een nieuw PDO-instantie aan
    // DSN (Data Source Name) formaat: 'sqlite:pad_naar_databasebestand'
    $dsn = 'sqlite:' . $db_file;
    $pdo = new PDO($dsn);

    // Zet foutmodus op exceptie voor makkelijke debugging
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    // Zet standaard fetch-mode bijvoorbeeld op associatieve array
    $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);

    echo "Succesvol verbonden met database: " . $db_file . "\n";

    // Tabel aanmaken
    $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 "Tabel 'users' aangemaakt of bestaat al\n";


    // Data invoegen
    $name = 'ServBay PDO User';
    $email = '[email protected]';
    $age = 35;

    // Gebruik prepared statements
    $stmt = $pdo->prepare("INSERT INTO users (name, email, age) VALUES (:name, :email, :age)");

    // Voer de invoeging uit en controleer succes (email is UNIQUE, dubbele invoer faalt)
    try {
        $stmt->execute([
            ':name' => $name,
            ':email' => $email,
            ':age' => $age
        ]);
        echo "Data succesvol ingevoegd: Naam=" . $name . ", Email=" . $email . "\n";
    } catch (PDOException $e) {
         // Controleer op unieke beperking (SQLite foutcode 19)
         if ($e->getCode() == '23000' || strpos($e->getMessage(), 'UNIQUE constraint failed') !== false) {
             echo "Invoegen mislukt: Email '" . $email . "' bestaat al\n";
         } else {
             throw $e; // Gooi andere fouten opnieuw
         }
    }
    $stmt->closeCursor(); // Vrijgeven van statement resources


    // Data opvragen
    $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(); // Haal alle resultaten op

    echo "Zoekresultaten:\n";
    if ($data) {
        print_r($data);
    } else {
        echo "Geen overeenkomende data gevonden\n";
    }

    $stmt->closeCursor(); // Vrijgeven van statement resources

} catch (PDOException $e) {
    // PDO-exceptie afvangen
    echo "Databasebewerking mislukt: " . $e->getMessage();
    // Je kunt ook $e->getCode() gebruiken om de SQLSTATE-code te achterhalen
}

// PDO sluit de verbinding automatisch af aan het einde van het script

?>

Over de locatie van het databasebestand:

In bovenstaande voorbeelden worden de databasebestanden (servbay_demo.sqlite en servbay_demo_pdo.sqlite) aangemaakt in de data/-submap van de map waar het PHP-script zich bevindt. Staat jouw PHP-bestand bijvoorbeeld op /Applications/ServBay/www/my-servbay-project/index.php, dan wordt de database aangemaakt in /Applications/ServBay/www/my-servbay-project/data/.

Het bewaren van het databasebestand in een submap van je project is goede praktijk en maakt beheer en back-up makkelijker. Let erop dat de gebruiker waarmee ServBay draait, schrijfrechten heeft op deze map (in de standaard ServBay-configuratie op macOS is dit meestal geen probleem).

Belangrijke aandachtspunten

• SQLite-databasebestanden bevatten gevoelige data, zorg dat deze niet publiekelijk toegankelijk zijn. Plaats het bestand buiten de direct toegankelijke webmappen, of configureer de webserver (zoals Caddy of Nginx) om directe toegang tot .sqlite-bestanden te blokkeren. In deze voorbeelden plaatsen we het bestand in een data/-subdirectory voor demonstratiedoeleinden; in een productieomgeving zijn strengere maatregelen noodzakelijk.
• SQLite is geschikt voor scenario’s waar gelijktijdig schrijven weinig voorkomt. Bij intensief gelijktijdig schrijven kunnen prestatieproblemen en lockfouten ontstaan. Overweeg bij applicaties met veel gelijktijdige schrijfbewerkingen een client/server-database als MySQL of PostgreSQL.
• Hoewel ServBay standaard de SQLite-extensies inschakelt, controleer bij afwezigheid van gerelateerde info in phpinfo() de PHP-configuratie binnen ServBay, of probeer de ServBay-dienst opnieuw op te starten.

Veelgestelde vragen (FAQ)

Vraag: Moet ik SQLite apart installeren?

Antwoord: Dat hoeft niet. De PHP-pakketten van ServBay bevatten de SQLite-extensies standaard, zodat je deze direct vanuit PHP kunt gebruiken.

Vraag: Waar moet ik mijn .sqlite-databasebestand plaatsen?

Antwoord: Het verdient de voorkeur het bestand in een niet direct via het web toegankelijke submap van je project te plaatsen, zoals data/ of database/. In de codevoorbeelden wordt __DIR__ . '/data/' gebruikt om een relatief pad op te geven.

Vraag: Waarom kan mijn PHP-script geen verbinding maken met SQLite of geen bestand aanmaken?

Antwoord: Controleer het volgende:

• Zorg dat ServBay draait en je het PHP-bestand via ServBay benadert.
• Controleer in de uitvoer van phpinfo() of de sqlite3- en pdo_sqlite-extensies actief zijn.
• Controleer of de map waarin het databasebestand moet komen bestaat en de ServBay-gebruiker schrijfrechten heeft.

Samenvatting

ServBay biedt PHP-ontwikkelaars eenvoudige en krachtige ondersteuning voor SQLite-databases. Dankzij de geïntegreerde en standaard ingeschakelde SQLite-module ontwikkel en test je lokaal eenvoudig op basis van SQLite, zonder complexe configuratie. Met het lichtgewicht en direct inzetbare karakter van SQLite is ServBay een uiterst efficiënt en gebruiksvriendelijk hulpmiddel voor lokale webontwikkeling.