Quando si scrive un'applicazione Web è quasi impossibile non far uso di un database.
Che si tratti di un sito di commercio elettronico, di un'applicazione di content management, di un guest book amatoriale o di una chat, in generale, l'applicazione Web è sempre uno strato applicativo che ruota intorno a uno o più database.
Il linguaggio PHP, volendosi collocare come linguaggio di spessore, dotato di tutte le funzioni e le caratteristiche che lo possano rendere una valida alternativa a linguaggi più blasonati, non può non supportare la gestione completa di un accesso a database.
Il motore PHP, essendo un prodotto completamente open source, ha sempre avuto storicamente un legame particolare con un altro prodotto open: MySQL.
Da un po' di tempo a questa parte però, e in particolare dalla versione 2.0 del Zend Engine che è il vero motore di PHP5, lo strato di accesso al database si è evoluto fino a supportare, in maniera indipendente, una lunghissima serie di database alternativi: DBM, DBX, LDAP, MySQL, ODBC, Oracle, Postgres, Sybase, SQL Server.
Per ognuno di questi database esistono moduli aggiuntivi di PHP che lo rendono in grado di accedere ai vari database. In questo capitolo ci concentreremo su MySQL per il fatto che si tratta di un database open source e piuttosto semplice da utilizzare.
Le stesse considerazioni, tuttavia, si possono applicare a qualsiasi altro motore di database per il quale esista un modulo di integrazione con il motore PHP.
15_1.Accesso a un database MySQL
L'accesso a un database MySQL può essere fatto utilizzando semplici funzioni che, fino alla versione 4 di PHP, erano intergrate direttamente nel linguaggio. Dalla versione 5 in poi è necessario installare a parte MySQL per poterle utilizzare. Vediamo uno script che ne fa uso per accedere a un database MySQL.
<html>
<head>
<title>Accesso a database</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$query = "select * from rubrica";
$dbResult = mysql_query($query, $db);
$AffectedRows = mysql_affected_rows($db);
print("<h3>Accesso al database $database sul server $host</h3>");
print("<h3>Username = $user</h3>");
print("<h3>Password = $password</h3>");
print("<h3>Query = $query</h3>");
print("<h3>Numero di record trovati: $AffectedRows</h3>");
mysql_close($db);
?>
</body>
</html>
Guardando il codice sorgente dello script si può vedere che per effettuare il collegamento con un host su cui gira un'istanza di MySQL si utilizza la funzione:
$db = mysql_connect($host, $user, $password)
che riceve come parametri il nome dell'host, l'utente e la password.
Questa funzione restituisce un oggetto che rappresenta integralmente il nostro host e con il quale è possibile utilizzare la funzione
mysql_select_db($database, $db)
per selezionare l'istanza corretta del database. Questo è essenziale in quanto l'istanza del database server può contenere più di un database.
Dopo aver selezionato il database, possiamo effettuare una query su una qualsiasi delle tabelle che contiene attraverso la funzione:
$dbResult = mysql_query($query, $db);
A questo punto abbiamo l'oggetto $dbResult che contiene il risultato della nostra query.
Nel caso del nostro esempio viene utilizzata la funzione mysql_affected_rows($db) che restituisce il numero dei record che sono stati interessati dalla precedente esecuzione della query.
Al termine dell'esecuzione di operazioni sul database è essenziale utilizzare la funzione mysql_close($db) per rilasciare la connessione al database e permettere eventualmente a un altro client di utilizzarla.
15_2.Query di estrazione
Una delle operazioni che si possono compiere su un database è l'estrazione dei dati da una tabella. Vediamo il seguente esempio:
<html>
<head>
<title>Query su database</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$query = "select * from rubrica";
$dbResult = mysql_query($query, $db);
print "<table border=\"1\">\n";
while ($line = mysql_fetch_array($dbResult, MYSQL_NUM)) {
print "\t<tr>\n";
foreach ($line as $col_value) {
print "\t\t<td>$col_value</td>\n";
}
print "\t</tr>\n";
}
print "</table>\n";
mysql_free_result($dbResult);
mysql_close($db);
?>
</body>
</html>
Il nostro obiettivo è l'estrazione di tutti i record contenuti nella tabella rubrica e la stampa di tutti i valori all'interno di una tabella HTML.
Dal punto di vista delle problematiche di accesso all'host, della selezione del database e dell'esecuzione della query, ci ritroviamo nelle stesse condizioni dell'esempio precedente.
La situazione però cambia radicalmente quando si tratta di utilizzare i dati estratti dalla query.
In questo esempio viene utilizzata la funzione:
mysql_fetch_array($dbResult, tipo_array)
che restituisce l'i-esimo record del result-set e sposta in avanti il cursore di indicizzazione.
Il risultato dell'esecuzione di questa funzione è un array costituito da tutti gli elementi che sono stati estratti dalla query in quel record e questo array può avere chiavi diverse in funzione del valore della costante tipo_array.
In particolare abbiamo la seguente situazione:
MYSQL_ASSOC: la chiave dell'array è il nome delle colonne della tabella;MYSQL_NUM: la chiave dell'array è un numero intero;MYSQL_BOTH: l'array ha come chiave sia un numero intero che il nome della colonna della tabella.
Nel nostro caso, quindi, siamo in grado di utilizzare un ciclo while per scandire tutto il result-set e a ogni iterazione la funzione mysql_fetch_array ci restituirà un array dotato di chiavi numeriche che indicizzano tutti i valori del singolo record della tabella.
È sufficiente organizzare questi elementi attraverso i tag HTML per ottenere l'output voluta
15_3.Inserimento di un record
L'inserimento di un record in una tabella attraverso un'interfaccia Web prevede l'utilizzo di un form HTML che passi i valori da inserire a uno script in grado di inserirli fisicamente all'interno del database.
Nel caso del nostro database rubrica, il form HTML potrebbe essere come quello della Figura 8.3 , il cui codice HTML è di questo tipo:
<html>
<head>
<title>Inserimento di un record nel DB</title>
</head>
<body>
<table>
<form method="post" action="8-4.php">
<tr><td>Cognome</td>
<td><input type="text" name="cognome" size="20" maxlength="20"></td></tr>
<tr><td>Nome</td>
<td><input type="text" name="gnome" size="20" maxlength="20"></td></tr>
<tr><td>Azienda</td>
<td><input type="text" name="azienda" size="20" maxlength="20"></td></tr>
<tr><td>Ruolo</td>
<td><input type="text" name="ruolo" size="20" maxlength="20"></td></tr>
<tr><td>Email</td>
<td><input type="text" name="email" size="20" maxlength="20"></td></tr>
<tr><td>Telefono</td>
<td><input type="text" name="telefono" size="20" maxlength="20"></td></tr>
<tr><td>Cellulare</td>
<td><input type="text" name="cellulare" size="20" maxlength="20"></td></tr>
<tr><td colspan=\"2\"><input type="submit" value="Inserisci"></td></tr>
</form>
</table>
</body>
</html>
In questo caso, poiché sappiamo in anticipo la struttura del database, possiamo utilizzare un form HTML statico componendolo in modo da avere i nomi dei campi di input coincidenti con i nomi dei campi della tabella del database che andremo a popolare.
A questo punto dobbiamo solo creare lo script che riceva i valori di questi parametri e li utilizzi per popolare la tabella sul database. Vediamone il codice:
<html>
<head>
<title>Inserimento nel database</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$query = "insert into rubrica " .
"(cognome, nome, azienda, ruolo, email, telefono, cellulare) " .
"VALUES('" .
$_REQUEST['cognome'] . "','" . $_REQUEST['nome'] . "','" .
$_REQUEST['azienda'] . "','" . $_REQUEST['ruolo'] . "','" .
$_REQUEST['email'] . "','" . $_REQUEST['telefono'] . "','" .
$_REQUEST['cellulare'] . "')";
if (!mysql_query($query, $db))
{
print("Attenzione, impossibile inserire il record");
}
else
{
print("Il record è stato inserito");
}
mysql_close($db);
?>
</body>
</html>
Anche in questo caso abbiamo le classiche funzioni di collegamento con l'host e di selezione del database, ma questa volta la query che viene eseguita non è una query di selezione, ma è di tipo INSERT.
La composizione, infatti, della query utilizzando la sintassi SQL standard:
insert into tabella (elenco campi) VALUES (elenco valori)
consente di inserire il record all'interno della tabella senza dover usare funzioni particolari, ma utilizzando la semplice esecuzione di una query sul database.
L'esecuzione avviene, anche questa volta, utilizzando la funzione:
mysql_query($query, $db)
che restituisce un valore TRUE se il record è stato inserito e un valore FALSE in caso di errore.
Nel nostro caso, il record è stato inserito correttamente.
15_4.Indici autoincrementali
Quando in una tabella MySQL esistono campi auto-incrementali, campi cioè il cui valore non può essere selezionato dall'utente in quanto è il motore database stesso che si occupa di valorizzarli in maniera incrementale rispetto ai valori inseriti in precedenza, può essere importante conoscere, immediatamente dopo l'inserimento, il valore che il database ha assegnato autonomamente a questo campo, soprattutto se questo deve essere utilizzato come collegamento con altre tabelle.
Si pensi per esempio all'inserimento, in un'applicazione di commercio elettronico, di un ordine effettuato da un cliente e di tutti i prodotti che costituiscono l'ordine stesso.
Quello che deve essere fatto è l'inserimento dell'ordine e poi, subito dopo l'inserimento e prima di effettuare l'operazione di commit, deve essere fatto l'inserimento di tutti i prodotti nell'apposita tabella, utilizzando come chiave di collegamento tra i prodotti e l'ordine un ipotetico ID dell'ordine appena inserito.
In casi come questi è utile poter disporre di un meccanismo di auto-incremento degli ID, ma deve anche essere possibile recuperare il valore dell'informazione prima che venga realizzata l'operazione di commit, soprattutto perché in caso di errori sarà possibile tornare indietro ed eventualmente eliminare anche l'inserimento del record dell'ordine.
Vediamo com'è possibile recuperare il valore di un campo auto-incrementale subito dopo l'inserimento del record:
<html>
<head>
<title>Inserimento con lettura del id</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$cognome="Pitagorico";
$nome="Archimede";
$azienda="Paperopoli SAS";
$ruolo="Inventore";
$email="archimede@paperopoli.com";
$telefono="0987654321";
$cellulare="12345678";
$query = "insert into rubrica " .
"(cognome, nome, azienda, ruolo, email, telefono, cellulare) " .
"VALUES('$cognome','$nome','$azienda',
'$ruolo','$email','$telefono','$cellulare')";
if (!mysql_query($query, $db))
{
print("Attenzione, impossibile inserire il record");
}
else
{
print("Il record è stato inserito:<br>");
print("ID: " . mysql_insert_id($db) . "<br>");
print("Cognome: $cognome<br>");
print("Nome: $nome<br>");
print("Azienda: $azienda<br>");
print("Ruolo: $ruolo<br>");
print("Email: $email<br>");
print("Telefono: $telefono<br>");
print("Cellulare: $cellulare<br>");
}
mysql_close($db);
?>
</body>
</html>
Come si può vedere il record viene correttamente inserito e viene stampato anche il valore che il motore del database ha assegnato al campo autoincrementale presente nella tabella.
Questo risultato è garantito dall'utilizzo della funzione mysql_insert_id($db) che, eseguita immediatamente dopo una query di inserimento sul database, restituisce il valore dell'unico campo autoincrementale della tabella.
Con questo strumento possiamo gestire problematiche anche complesse di inserimenti multipli di record su tabelle diverse e che utilizzano i valori di alcuni id autoincrementali come chiavi relazionali.
15_5.Navigazione tra i record
Utilizzando le potenti funzioni che il motore di PHP mette a disposizione per la gestione del database è possibile creare script sufficientemente semplici che permettano la navigazione all'interno dei record del database.
Vediamone un esempio:
<html>
<head>
<title>Navigare tra i record</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$startindex=$_REQUEST['seek'];
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$query = "select * from rubrica";
$dbResult = mysql_query($query, $db);
$AffectedRows = mysql_affected_rows($db);
mysql_data_seek($dbResult,$startindex);
$row=mysql_fetch_row($dbResult);
foreach ($row as $k => $v)
{
$myfield = mysql_fetch_field($dbResult,$k);
print ($myfield->name . " : $v<br>");
}
mysql_free_result($dbResult);
mysql_close($db);
print("<br>Seleziona il record<br>");
for($index=0;$index<$AffectedRows;$index++)
{
print("<a href=\"{$_SERVER['PHP_SELF']}?seek=$index\" >". ($index+1) . "</a> ");
}
?>
</body>
</html>
Questo script, genera una piccola applicazione Web in grado di navigare tra i record presenti nella tabella rubrica. Cerchiamo di capire come questo sia possibile.
L'obiettivo di questo script è l'esecuzione di una query di selezione su una tabella e la stampa del primo record tra quelli trovati.
Successivamente, nella parte bassa della pagina, l'applicazione dovrà stampare una serie di link che puntino direttamente ai singoli record presenti sulla tabella, in modo che l'utente possa utilizzarli per saltare direttamente sul record specificato.
Innanzitutto lo script, come nei casi precedenti, si collega al database ed effettua una query sulla tabella rubrica.
Un'altra delle operazioni che vengono svolte all'inizio dello script è la lettura del parametro seek dalla request per verificare se è stato passato un puntamento a un particolare record; in caso contrario il record visualizzato sarà il primo.
Uno strumento come quello che stiamo costruendo è in sostanza un'applicazione di paginazione tra i record presenti sulla tabella del database. Per costruire una qualsiasi paginazione, in generale, servono due cose: il numero degli elementi che si devono paginare e uno strumento per saltare direttamente all'elemento selezionato. Vediamo quali strumenti abbiamo a disposizione per risolvere il nostro problema.
Come detto in precedenza, siamo in grado risalire al numero di record interessati dalla query, cioè, in caso di query di selezione, al numero totale di record estratti dalla query. Questo viene svolto attraverso la funzione mysql_affected_rows($db).
Il valore restituito da questa funzione sarà utilizzato per realizzare un ciclo for che si occuperà di stampare tutti i link alla pagina corrente. Ogni link passerà allo script corrente un parametro, il seek visto in precedenza, che ci consentirà di saltare al record desiderato.
Ecco l'ultimo punto che ci interessa: dato un result set, come è possibile saltare a uno specifico record?
La soluzione si presenta sotto forma di una funzione:
mysql_data_seek($dbResult,$startindex);
Quello che si ottiene utilizzando questa funzione è lo spostamento del cursore che il motore PHP mantiene aperto su quel particolare oggetto $dbResult. Lo spostamento avverrà esattamente all'i-esimo record dove l'indice è il valore del parametro $startindex che è stato recuperato in precedenza dalla request. Si noti che la funzione mysql_data_seek numera i record a partire dal valore zero; pertanto, per andare alla posizione i-esima sarà necessario passare (i-1) come valore del parametro.
Adesso abbiamo tutti gli elementi: il numero totale dei record su cui effettuare la paginazione e uno strumento che ci consente di saltare a uno specifico record. Non resta altro che utilizzarli all'interno di un ciclo for per costruire il nostro pacchetto di link che, naturalmente, saranno diretti sempre allo script stesso: questo si ottiene attraverso l'utilizzo della variabile $_SERVER['PHP_SELF'].
A questo punto, per fare le cose bene, vogliamo che ogni singola pagina della nostra applicazione sia in grado di ricavare autonomamente alcune informazioni dal database, in particolare il nome dei campi della tabella che andranno ad arricchire la nostra pagina di dettaglio del singolo record.
Per ottenere questo risultato viene utilizzata questa porzione di codice:
$row=mysql_fetch_row($dbResult);
foreach ($row as $k => $v)
{
$myfield = mysql_fetch_field($dbResult,$k);
print ($myfield->name . " : $v<br>");
}
La funzione mysql_fetch_row($dbResult) popola un oggetto $row che è in sostanza un array contenente tutti i valori di tutti i campi di quel particolare record del database.
L'array è dotato di una chiave numerica che parte dal valore zero e che consente di accedere alle informazioni di dettaglio sul singolo valore di un certo campo.
Questa chiave numerica, che corrisponde uno a uno a un singolo campo della tabella, viene utilizzata per ricavare, a partire dal result set, un oggetto di alto livello che contiene tutte le informazioni su un singolo campo del database.
Per ottenere questo risultato si utilizza la funzione mysql_fetch_ field($dbResult,$k) alla quale viene passato il result set e il numero corrispondente al campo che ci interessa, anche qui iniziando dal valore zero.
Quello che si ottiene è l'oggetto $myfield che consente di accedere a tutta una serie di informazioni sul campo, in particolare:
$myfield->blob: restituisceTRUEse il campo è di tipo blob;$myfield->max_lenght: restituisce la lunghezza massima del campo;$myfield->multiple_key: restituisceTRUEse il campo è una chiave non univoca;$myfield->name: restituisce il nome del campo;$myfield->not_null: restituisceTRUEse il campo non può contenere il valorenull;$myfield->numeric: restituisceTRUEse il campo è di tipo numerico;$myfield->primary_key: restituisceTRUEse il campo è una chiave primaria;$myfield->table: restituisce il nome della tabella o dell'alias che viene utilizzato;$myfield->type: restituisce il tipo della colonna;$myfield->unique_key: restituisceTRUEse il campo è una chiave univoca;$myfield->unsigned: restituisceTRUEse il campo è di tipo unsigned;$myfield->zerofill: restituisceTRUEse il campo è riempito da zeri.
A questo punto abbiamo realizzato l'applicazione Web che consente di navigare su un singolo record di una certa tabella avendo anche tutte le informazioni che ci servono sui campi e possiamo anche saltare direttamente al record desiderato.
15_6.Un'interfaccia più evoluta
A questo punto possiamo provare a realizzare una piccola applicazione Web in grado di mostrarci una lista di tutti i record presenti nella tabella e che ci consenta agevolmente di cancellare un record o di modificarlo.
Vediamo il codice sorgente di questa applicazione, il cui output è mostrato nella Figura 8.7.
<html>
<head>
<title>Interfaccia verso il database</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$query = "select * from rubrica";
$dbResult = mysql_query($query, $db);
$AffectedRows = mysql_affected_rows($db);
print "<table border=\"1\">\n";
for ($index=0 ; $index<$AffectedRows ; $index++)
{
$row=mysql_fetch_row($dbResult);
if($index==0)
{
print "<tr>\n";
foreach ($row as $k => $v)
{
$myfield = mysql_fetch_field($dbResult,$k);
print ("<td><b>" . $myfield->name . "</b></td>");
}
print "</tr>\n";
}
foreach ($row as $k => $v)
{
print ("<td>$v ");
if ($k==0)
{
print "<br>";
print "<a href=\"8-8.php?id=$v\">Cancella</a>";
print "<br>";
print "<a href=\"8-9.php?id=$v\">Modifica</a>";
}
print ("</td>");
}
print "</tr>\n";
}
print "</table>\n";
mysql_free_result($dbResult);
mysql_close($db);
?>
</body>
</html>
Guardando l'output dello script (Figura 8.7) che abbiamo sviluppato possiamo notare immediatamente qualche cambiamento rispetto agli esempi precedenti.
Innanzitutto viene mostrata una lista di tutti i record presenti nella tabella organizzandoli ordinatamente in una tabella HTML.
La creazione della tabella avviene grazie a un ciclo for che consente di creare una riga della tabella HTML per ogni record del database: naturalmente il limite superiore del ciclo for, la condizione di terminazione, coincide con il valore generato dalla funzione mysql_affected_rows.
Dal database abbiamo poi estratto le informazioni relative ai nomi dei singoli campi della tabella attraverso la costruzione di un oggetto $myfield generato dalla funzione mysql_fetch_field e queste sono state utilizzate per la costruzione della prima riga della tabella HTML, in modo che possano essere utilizzate come intestazione e facilitare la lettura.
Infine nella prima colonna, quella normalmente utilizzata per contenere la chiave primaria della tabella, spesso indicata attraverso un indice auto-incrementale, sono stati inseriti due link che portano rispettivamente alla funzione di cancellazione e alla funzione di modifica per quello specifico record.
Scriveremo più avanti gli script che vengono utilizzati, ma a questo punto appare già chiara l'interfaccia.
Lo script di cancellazione dovrà essere il file 8-8.php e dovrà gestire un parametro in ingresso id che contiene la chiave dell'elemento da cancellare. Lo scriveremo in modo che chieda all'utente una conferma, visto che si tratta di una cancellazione irreversibile.
Lo script di modifica dovrà essere il file 8-9.php e dovrà gestire, come lo script di cancellazione, lo stesso parametro id che contiene la chiave del record da modificare.
15_7.Eliminazione di un record
Lo script di eliminazione fisica di un record dal database è un componente dell'applicazione che stiamo costruendo.
L'obiettivo è costruire uno script completamente integrato con la gestione della lista che abbiamo costruito, si tratta di un sistema di cancellazione che deve chiedere conferma all'utente prima di eliminare realmente il record e dopo l'eventuale cancellazione deve riportare alla lista dei record presenti nella tabella.
Vediamo questo script:
<html>
<head>
<title>Eliminazione di un record</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$confirm=$_REQUEST['confirm'];
$id=$_REQUEST['id'];
if ($confirm)
{
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
$query = "delete from rubrica where id=$id";
$dbResult = mysql_query($query, $db);
$AffectedRows = mysql_affected_rows($db);
if ($AffectedRows==0)
{
print("<h3>Non esistono record con i criteri selezionati</h3>");
}
else
{
print("<h3>Il record è stato eliminato
</h3>");
print("<h3><a href=\"8-7.php\">Torna alla lista</a></h3>");
}
mysql_close($db);
}
else
{
print("<h3>Eliminare il record?</h3>");
print("<h3><a href=\"{$_SERVER['PHP_
SELF']}?id=$id&confirm=1\">Conferma</a></h3>");
print("<h3><a href=\"8-7.php\">Annulla</a>
</h3>");
}
?>
</body>
</html>
Partendo dalla lista, possiamo fare un clic su uno qualsiasi dei link "cancella" presenti vicino agli id dei singoli record
Se si utilizza il link "Annulla" si ritorna alla lista, se invece si utilizza il link "Conferma" lo script richiama se stesso aggiungendo all'id del record da cancellare anche il parametro confirm che sottintende un'avvenuta conferma da parte dell'utente.
Questo comportamento viene gestito, all'interno dello script di cancellazione, attraverso un'istruzione condizionale di questo genere:
$confirm=$_REQUEST['confirm'];
if ($confirm)
{
// codice da eseguire in caso di conferma
}
else
{
// codice di eseguire per richiedere la conferma
}
È chiaro che nella richiesta di conferma dovrà essere mostrato un link composto in modo tale da contenere anche il parametro 'confirm' valorizzato a 1, in modo che al secondo passaggio l'eliminazione venga in effetti selezionata.
Dal punto di vista del database, in ogni caso, quello che più conta è la composizione della query che viene eseguita: si tratta infatti di una query esplicita di cancellazione del tipo:
$query = "delete from rubrica where id=$id";
dove il parametro $id è naturalmente quello che viene passato allo script dalla tabella precedente, quella della Figura 8.7.
15_8.Modifica di un record
La modifica di un record di un database di per sé non costituisce un vero problema: anche in questo caso, infatti, è sufficiente scrivere la query di aggiornamento in SQL e inviarla all'istanza del database.
Nel nostro contesto, però, poiché stiamo tentando la realizzazione di un'interfaccia utente un po' più evoluta, costruiamo uno script in grado di creare dinamicamente un form di modifica dei dati con già i valori reimpostati e alla conferma dell'utente andiamo a memorizzarli nel database.
Questo comportamento si può ottenere con lo script seguente:
<html>
<head>
<title>Modifica di un record</title>
</head>
<body>
<?php
$host = 'localhost';
$user = 'admin';
$password = 'admin';
$database = 'rubrica';
$confirm=$_REQUEST['confirm'];
$id=$_REQUEST['id'];
$db = mysql_connect($host, $user, $password)
or die ("Impossibile connettersi al server $host");
mysql_select_db($database, $db)
or die ("Impossibile connettersi al database $database");
if (!$confirm)
{
$query = "select * from rubrica where id=$id";
$dbResult = mysql_query($query, $db);
$AffectedRows = mysql_affected_rows($db);
if ($AffectedRows==0)
{
print("<h3>Non esistono record con i criteri selezionati</h3>");
}
else
{
mysql_data_seek($dbResult,0);
$row=mysql_fetch_row($dbResult);
print("<table>");
print("<form method=\"post\" action=\"{$_SERVER['PHP_SELF']}\">");
foreach ($row as $k => $v)
{
$myfield = mysql_fetch_field($dbResult,$k);
print("<tr><td>$myfield->name</td>");
print("<td><input type=\"text\" value=\"" . $v . "\" name=\"" . $myfield->name . "\" size=\"100\"maxlength=\"100\"></td></tr>");
}
print("<tr><td colspan=\"2\"><input type=\"
submit\" value=\"Conferma modifiche\"></td></tr> ");
print("<input type=\"hidden\" name=\"confirm\
" value=\"1\">");
print("</form>");
print("</table>");
mysql_free_result($dbResult);
mysql_close($db);
}
}
else
{
$cognome=$_REQUEST['Cognome'];
$nome=$_REQUEST['Nome'];
$azienda=$_REQUEST['Azienda'];
$ruolo=$_REQUEST['Ruolo'];
$email=$_REQUEST['Email'];
$telefono=$_REQUEST['Telefono'];
$cellulare=$_REQUEST['Cellulare'];
$query = "update rubrica set cognome=\"$cognome\","
. " nome=\"$nome\","
. " azienda=\"$azienda\","
. " ruolo=\"$ruolo\","
. " email=\"$email\","
. " telefono=\"$telefono\","
. " cellulare=\"$cellulare\""
. " where id=$id";
$dbResult = mysql_query($query, $db);
$AffectedRows = mysql_affected_rows($db);
if ($AffectedRows!=0)
{
print("<h3>Il record è stato aggiornato
</h3>");
print("<h3><a href=\"8-7.php\">Torna alla lista</a></h3>");
}
mysql_close($db);
}
?>
</body>
</html>
Si tratta, di una pagina di modifica dei dati di un record in un database.
Se viene passato un valore corretto per l'id del record, allora viene creato dinamicamente il form di modifica dei dati, ogni campo di testo è già preimpostato con il valore di quel campo in quel record.
L'utente può quindi modificare le informazioni di dettaglio dei singoli campi e alla pressione del campo conferma tutti questi dati vengono spediti alla stesso script, questa volta dotato anche del parametro confirm che garantisce che si sta operando sotto la responsabilità dell'utente.
A questo punto, quindi, lo script effettua la modifica del record nel database e restituisce all'utente un messaggio di conferma e la possibilità di tornare alla pagina della lista.