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);
$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']."
";
}
sqlite_close($sq);
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']."
";
}
sqlite_close($sq);
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']."
";
}
sqlite_close($sq);
{
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']."
";
}
sqlite_close($sq);
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.
0 commenti:
Posta un commento
Proponi un'idea, segnalaci un problema.
Entra a far parte di CS3, pubblica i tuoi articoli.
Scrivi un commento!