Sviluppo PHP con il Modulo SQLite Integrato in ServBay

ServBay è un potente ambiente di sviluppo locale per il web, progettato specificamente per sviluppatori e compatibile con vari stack tecnologici. Include di serie il modulo database SQLite, rendendo estremamente semplice l’uso di SQLite per l’archiviazione e la gestione dei dati nelle applicazioni PHP. Questa guida fornisce una panoramica dettagliata su come sfruttare questa funzionalità all’interno di ServBay.

Panoramica sul Modulo SQLite

SQLite è un sistema di gestione database relazionale leggero e integrato. A differenza dei database client/server tradizionali (ad esempio MySQL, PostgreSQL), non richiede un server separato: viene incorporato direttamente nell’applicazione sotto forma di libreria. Tutti i dati sono memorizzati in un unico file, il che semplifica notevolmente le operazioni di distribuzione e gestione.

SQLite è ampiamente adottato, particolarmente in applicazioni di piccole e medie dimensioni, caching locale, app mobili e nei contesti di sviluppo e testing, grazie ai suoi vantaggi tra cui:

Caratteristiche principali

1. Leggerezza: La libreria core è compatta e richiede poche risorse.
2. Zero configurazione: Nessuna installazione né configurazione di server o gestione utenti: pronto all’uso.
3. Prestazioni elevate: Offre ottime performance per la maggior parte delle operazioni di lettura e per scritture moderate.
4. Archivio in un singolo file: Il database è memorizzato in un file .sqlite, facile da salvare, trasferire e gestire.
5. Transazioni ACID: Garantisce affidabilità nell’elaborazione delle transazioni e integrità dei dati.
6. Multipiattaforma: Compatibile con diversi sistemi operativi e linguaggi di programmazione.

Supporto a SQLite in ServBay

ServBay integra diverse versioni di PHP e, per ciascuna di esse, le relative estensioni SQLite (come sqlite3 e pdo_sqlite) sono già preinstallate e attivate di default. Questo significa che puoi utilizzare immediatamente SQLite nei tuoi progetti PHP senza scaricare, compilare né configurare manualmente le estensioni PHP.

Prerequisiti

• ServBay deve essere installato e attivo su macOS.
• Una versione PHP deve essere abilitata e in esecuzione tramite ServBay.
• Assicurati di avere una directory per i file del tuo sito web; si raccomanda la directory root di default di ServBay /Applications/ServBay/www oppure una sua sottocartella.

Come usare SQLite in ServBay

Poiché il modulo SQLite è già attivo di default in ServBay, non è necessario eseguire alcuna configurazione aggiuntiva. L’ambiente PHP è già predisposto e puoi quindi utilizzare immediatamente tutte le relative funzioni e classi SQLite.

Verifica del caricamento dell’estensione SQLite:

Se desideri controllare che l’estensione SQLite sia caricata correttamente, consulta la pagina di output di phpinfo().

1. Crea un file PHP contenente <?php phpinfo(); ?> (ad esempio info.php).
2. Salva questo file all’interno della directory root del sito ServBay /Applications/ServBay/www in una delle sottocartelle del tuo sito (ad esempio /Applications/ServBay/www/servbay.demo/info.php).
3. Apri il file nel browser (ad esempio visitando http://servbay.demo/info.php).
4. Cerca "sqlite" o "pdo_sqlite" nella pagina: se trovi la sezione corrispondente, significa che l’estensione è attiva.

Utilizzare SQLite nel Codice PHP

Quando l’estensione SQLite è disponibile, puoi accedere direttamente alle API SQLite dalle applicazioni PHP. PHP fornisce diversi modi per interagire con SQLite: i più comuni sono la classe orientata agli oggetti SQLite3 e l’uso di PDO (PHP Data Objects).

Di seguito trovi esempi pratici per collegarti, creare tabelle, inserire e interrogare dati tramite entrambe le modalità su ServBay. Consigliamo di salvare sia i file PHP sia il database .sqlite nella directory del tuo progetto, ad esempio /Applications/ServBay/www/your-project-name/.

Esempio (metodo standard SQLite3)

Questo approccio usa la classe incorporata PHP SQLite3, che fornisce un’interfaccia orientata agli oggetti per operare sul database SQLite.

<?php
// Percorso del database
// Si consiglia di archiviare il file database in una sottocartella del progetto web, ad esempio data/
$db_file = __DIR__ . '/data/servbay_demo.sqlite'; // __DIR__ indica la directory corrente dello script

// Assicurati che la directory dei dati esista
if (!is_dir(__DIR__ . '/data')) {
    mkdir(__DIR__ . '/data', 0777, true);
}

// Connessione al database SQLite
// Se il file non esiste, viene creato automaticamente
try {
    $db = new SQLite3($db_file);
    echo "Connessione al database riuscita: " . $db_file . "\n";
} catch (Exception $e) {
    die("Connessione al database fallita: " . $e->getMessage());
}


// Creazione della tabella
// Usa IF NOT EXISTS per evitare errori di duplicazione
$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 "Tabella 'users' creata o già esistente\n";
} else {
    echo "Creazione tabella fallita: " . $db->lastErrorMsg() . "\n";
}


// Inserimento dati
$name = 'ServBay Demo User';
$email = '[email protected]';
$age = 30;

// Usa query preparate per prevenire l’SQL injection
$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);

// Esegui l’inserimento e controlla se è riuscito (email è UNIQUE, un duplicato fallirà)
if ($stmt->execute()) {
    echo "Dati inseriti con successo: Name=" . $name . ", Email=" . $email . "\n";
} else {
    // Verifica se è un errore di vincolo UNIQUE
    if (strpos($db->lastErrorMsg(), 'UNIQUE constraint failed') !== false) {
         echo "Inserimento fallito: Email '" . $email . "' già esistente\n";
    } else {
        echo "Inserimento fallito: " . $db->lastErrorMsg() . "\n";
    }
}
$stmt->close(); // Chiudi la query preparata


// Query dei dati
$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 "Risultato query:\n";
$found = false;
while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
    print_r($row);
    $found = true;
}
if (!$found) {
    echo "Nessun dato trovato\n";
}

$result->finalize(); // Libera il set di risultati
$stmt->close(); // Chiudi la query preparata


// Chiudi la connessione al database
$db->close();
echo "Connessione database chiusa\n";

?>

Esempio (metodo PDO)

PDO (PHP Data Objects) offre un layer di astrazione per i database: permette di usare le stesse funzioni PHP per differenti sistemi di database. Si consiglia l’uso di PDO con SQLite per la sua flessibilità e compatibilità più ampia.

<?php
// Percorso del database
// Si consiglia di archiviare il file database in una sottocartella del progetto web, ad esempio data/
$db_file = __DIR__ . '/data/servbay_demo_pdo.sqlite'; // __DIR__ indica la directory corrente dello script

// Assicurati che la directory dei dati esista
if (!is_dir(__DIR__ . '/data')) {
    mkdir(__DIR__ . '/data', 0777, true);
}

try {
    // Crea una nuova istanza PDO
    // Il DSN (Data Source Name) è 'sqlite:percorso_database'
    $dsn = 'sqlite:' . $db_file;
    $pdo = new PDO($dsn);

    // Imposta la modalità errore su eccezioni, utile per il debug
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    // Imposta la modalità di fetch predefinita (ad esempio array associativi)
    $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);

    echo "Connessione al database riuscita: " . $db_file . "\n";

    // Creazione della tabella
    $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 "Tabella 'users' creata o già esistente\n";


    // Inserimento dati
    $name = 'ServBay PDO User';
    $email = '[email protected]';
    $age = 35;

    // Usa query preparate
    $stmt = $pdo->prepare("INSERT INTO users (name, email, age) VALUES (:name, :email, :age)");

    // Esegui l’inserimento e controlla se è riuscito (email è UNIQUE, un duplicato fallirà)
    try {
        $stmt->execute([
            ':name' => $name,
            ':email' => $email,
            ':age' => $age
        ]);
        echo "Dati inseriti con successo: Name=" . $name . ", Email=" . $email . "\n";
    } catch (PDOException $e) {
         // Verifica se è un errore di vincolo UNIQUE (codice errore SQLite 19)
         if ($e->getCode() == '23000' || strpos($e->getMessage(), 'UNIQUE constraint failed') !== false) {
             echo "Inserimento fallito: Email '" . $email . "' già esistente\n";
         } else {
             throw $e; // Rilancia altri tipi di errori
         }
    }
    $stmt->closeCursor(); // Libera le risorse della query


    // Query dei dati
    $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(); // Ottieni tutte le righe risultanti

    echo "Risultato query:\n";
    if ($data) {
        print_r($data);
    } else {
        echo "Nessun dato trovato\n";
    }

    $stmt->closeCursor(); // Libera le risorse della query

} catch (PDOException $e) {
    // Gestione eccezioni PDO
    echo "Errore nelle operazioni sul database: " . $e->getMessage();
    // Il codice SQLSTATE è disponibile tramite $e->getCode()
}

// La connessione PDO viene automaticamente chiusa al termine dello script, non serve chiamare close()

?>

Posizione del File Database:

Nei precedenti esempi, i file database (servbay_demo.sqlite e servbay_demo_pdo.sqlite) vengono creati nella sottocartella data/ accanto allo script PHP in esecuzione. Quindi, se il tuo file PHP si trova in /Applications/ServBay/www/my-servbay-project/index.php, il database sarà creato in /Applications/ServBay/www/my-servbay-project/data/.

Salvare il database in una sottodirectory del progetto favorisce l’organizzazione e la facilità di backup. Fai attenzione che l’utente con cui ServBay gira abbia i permessi di scrittura necessari su questa directory (sotto la configurazione ServBay di default su macOS, questo di solito è garantito).

Avvertenze

• Il file del database SQLite contiene dati sensibili: assicurati che non sia accessibile pubblicamente. Per maggiore sicurezza, archivialo fuori dalla directory pubblica del web oppure configura il server (ad esempio Caddy o Nginx) per bloccare l’accesso diretto ai file .sqlite. L’uso della sottocartella data/ nell’esempio è solo per semplicità: in produzione applica misure di sicurezza aggiuntive.
• SQLite è ideale quando non si prevedono scritture concorrenti intensive: in caso di accessi simultanei di scrittura, potresti incorrere in colli di bottiglia o lock database. Per queste esigenze, si consiglia l’uso di database client/server come MySQL o PostgreSQL.
• Anche se ServBay attiva di serie le estensioni SQLite, se non le visualizzi in phpinfo(), controlla la configurazione PHP di ServBay o riavvia il servizio.

Domande Frequenti (FAQ)

D: Devo installare SQLite separatamente?

R: No. Le estensioni SQLite sono già incluse e attivate di default nel pacchetto PHP di ServBay: puoi utilizzarle direttamente nei tuoi script PHP.

D: Dove dovrei salvare il mio file di database .sqlite?

R: Si consiglia una sottocartella protetta all’interno del progetto (ad esempio data/ oppure database/), non direttamente accessibile dal web. Gli esempi utilizzano il percorso relativo __DIR__ . '/data/'.

D: Il mio script PHP non riesce a collegarsi a SQLite o creare il file database, come mai?

R: Controlla questi aspetti:

• Accertati che ServBay sia in funzione e che tu stia eseguendo gli script PHP tramite ServBay.
• Usa phpinfo() per verificare che le estensioni sqlite3 e pdo_sqlite siano abilitate.
• Assicurati che la directory scelta per il database esista e che l’utente di ServBay abbia i permessi di scrittura.

Conclusione

ServBay offre agli sviluppatori PHP un supporto efficace per SQLite. Grazie alle estensioni preinstallate e attivate di default, puoi iniziare subito a sviluppare e testare applicazioni PHP basate su database SQLite in locale, senza configurazioni complicate. La leggerezza e la praticità di SQLite, unite alla semplicità di ServBay, rendono questo ambiente uno strumento ideale per lo sviluppo veloce su macOS.