Per molti anni PHP è stato affiancato al database MySQL. Possiamo quasi dire che la loro crescita è stata parallela ed ha portato grossi miglioramenti nel campo delle applicazioni web opensource. Per molto tempo quindi con PHP è stato fornito nativamente il supporto alle librerie per l'accesso a MySQL. Purtroppo il cambio di licenza di quest'ultimo ha obbligato gli sviluppatori a rimuovere il supporto nativo per MySQL (anche se la libreria è sempre in evoluzione e distribuita).
Al fine di aiutare comunque coloro che necessitano di un database ma hanno solamente accesso alla configurazione minima di PHP, gli sviluppatori hanno deciso di implementare nativamente il supporto ad un altro sistema di database: SQLite. Questo sistema, cui abbiamo dedicato un ampio approfondimento, si differenzia molto da MySQL dato che non si basa su un'architettura client server ed è stato sviluppato appositamente per permettere l'accesso molto veloce ai dati. I database creati sono contenuti in un unico file binario (possono anche essere creati database temporanei salvati in memoria) che può essere acceduto tramite le funzioni fornite dalla libreria per eseguirvi query SQL.
La libreria SQLite fornisce un'interfaccia sia ad oggetti sia procedurale. Dato che il compito di questa guida introduttiva non comprende la trattazione delle programmazione ad oggetti, ci occuperemo dell'interfaccia a funzioni. Per chi fosse interessato a MySQL rimandiamo alla guida
Per operare su un database è necessario recuperare una risorsa (un po' come abbiamo visto precedentemente per i file) e lavorare su questa con delle funzioni apposite. La risorsa connessa ad un database può essere recuperata utilizzando sqlite_open:
$sq = sqlite_open("miodb.db", 0666, $sqlite_error);
Il primo parametro è il nome del file che conterrà i nostri dati (se non esiste verrà creato), il secondo indica i permessi da associare al database (attualmente il parametro viene ignorato da SQLite anche se l'impostazione consigliata è 0666) mentre il terzo conterrà eventualmente una stringa con il messaggio di errore eventualmente riscontrato durante l'apertura della fonte di dati. In caso sia andato tutto per il verso giusto, $sq conterrà la risorsa che ci permetterà di accedere al database miodb.db, altrimenti assumerà un valore nullo. Per questo motivo è sempre buona prassi controllare il valore restituito da sqlite_open prima di proseguire.
Per effettuare una query sul database possiamo utilizzare la funzione sqlite_query, ed analizzare il risultato eventualmente ottenuto (per esempio in caso di operazioni di selezione) attraverso sqlite_fetch_array. Un semplice esempio:
$sq = sqlite_open("miodb.db", 0666, $sqlite_error);
if(!$sq)
{
die("Errore Sqlite: ".$sqlite_error);
}
sqlite_query($sq, "CREATE TABLE prova_tbl (campo varchar(10))");
for($i = 0; $i < 10; ++$i)
{
sqlite_query($sq, "INSERT INTO prova_tbl VALUES ('Prova ".$i."')");
}
$result = sqlite_query($sq, "SELECT * FROM prova_tbl");
while($data = sqlite_fetch_array($result))
{
echo $data['campo']."<br />";
}
sqlite_close($sq);
Nel codice precedente ci siamo connessi al database, abbiamo controllato che non ci fossero errori ed abbiamo eseguito delle query sulla risorsa recuperata. La prima query ha creato una tabella di nome prova_tbl con un campo di nome "campo"; la seconda, eseguita all'interno di un ciclo, si è occupata di inserire dieci valori nella tabella mentre la terza ha recuperato tutti questi valori. All'interno del ciclo while abbiamo recuperato una dopo l'altra le singole righe selezionate ed abbiamo stampato i valori del campo "campo". Come possiamo notare la funzione sqlite_fetch_array restituisce la prossima riga selezionata oppure FALSE nel caso in cui quella precedente fosse l'ultima.
Come è stato possibile notare da questa breve introduzione, SQLite si comporta in modo molto simile ad un database relazionale, con la differenza che non opera in un'architettura client / server e permette l'esecuzione di query molto semplici e compatte.
Una funzionalità molto interessante della libreria, che mi sento di dover trattare prima di chiudere, è quella che permette di registrare delle funzioni PHP da richiamare all'interno delle proprie query SQL. Vediamo un semplice esempio:
function trim_upper($string)
{
return strtoupper(trim($string));
}
$sq = sqlite_open("miodb.db", 0666, $sqlite_error);
if(!$sq)
{
die("Errore Sqlite: ".$sqlite_error);
}
sqlite_create_function($sq, "trimup", "trim_upper", 1);
$result = sqlite_query($sq, "SELECT trimup(campo) AS campo FROM prova_tbl");
while($data = sqlite_fetch_array($result))
{
echo $data['campo']."<br />";
}
sqlite_close($sq);
Il codice accede al database che abbiamo creato precedentemente e recupera tutte le righe applicando direttamente da SQL la funzione trim_upper (che elimina gli spazi all'inizio ed alla fine e rende la stringa maiuscola) al campo selezionato. La funzione viene registrata attraverso sqlite_create_function che accetta come parametri la risorsa rappresentante il database, il nome da utilizzare all'interno dell'SQL per richiamare la funzione passata come terzo argomento ed infine il numero di parametri accettati. Grazie a questa interessante funzionalità si può estendere il linguaggio SQL utilizzato da SQLite con un insieme di funzioni adatte a compiere le operazioni più ripetitive sui dati, al fine di rendere il codice più ordinato e pulito.