4 Pubblicare i dati MySQL sul Web - Gruppo di Logica e Geometria

4
Pubblicare i dati MySQL
sul Web
Eccoci: questo è ciò che probabilmente vi interessava di più! In questo capitolo imparerete le
procedure per prendere delle informazioni contenute in un database per poi mostrarle su una
pagina Web in modo che tutti possano vederle. Fino a qui avete installato e imparato i principi di base di MySQL, un database relazionale e PHP, un linguaggio di scripting lato-server.
Ora vedrete come utilizzare questi due strumenti insieme per creare un sito Web!
Una ripassata ai principi di base
Prima di andare avanti vale la pena dare una breve occhiata indietro per ricordarci il nostro
scopo ultimo. Abbiamo due strumenti molto potenti a nostra disposizione: il linguaggio di
scripting e un database MySQL. È importante capire come questi possano operare insieme.
L’idea è quella di un sito Web il cui contenuto risiede in un database che viene richiamato
dinamicamente per creare delle pagine Web visibili con un normale browser. In questo modo
da una parte avrete un visitatore del vostro sito che usa un browser Web per richiedere una
pagina e che si aspetta di ricevere un documento HTML standard. Dall’altro lato avrete il contenuto del vostro sito che sta in più tabelle di in un database MySQL che, a sua volta, sa solo
rispondere a delle query (comandi) SQL.
Come è mostrato nella figura 4.1, il linguaggio di scripting PHP è il tramite che unisce i due
linguaggi. Processa la pagina richiesta, va a cercare i dati dal database MySQL e li consegna
come una pagina HTML ben formattata. Con PHP potete scrivere gli aspetti di presentazione del vostro sito (tutte le grafiche e i layout di pagina) come i “template” del normale HTML.
Dove ci dovrebbe essere il contenuto, in questi template, utilizzerete del codice PHP per connettervi al database MySQL in modo che, utilizzando le query SQL già usate per creare una
tabella di barzellette nel Capitolo 2, Primi passi con MySQL, il contenuto venga recuperato e
visualizzato.
Solo perché sia chiaro nella vostra testa, questo è quello che succederà quando qualcuno visiterà una pagina sul vostro sito Web costruito su un database:
Creare siti Web con PHP e MySQL
Figura 4.1. PHP recupera i dati da MySQL per produrre pagine Web.
1. Il browser del visitatore richiede la pagina con un URL normale.
2. Il software del server Web (Apache, IIS, o qualsiasi altro) riconosce che il file richiesto è
uno script PHP e allora, sul server, interpreta il file usando il suo plug-in PHP, prima di
rispondere alla richiesta della pagina.
3. Alcuni comandi PHP (che dovete ancora imparare) si connetteranno al database MySQL
e richiederanno il contenuto della pagina Web.
4. Il database MySQL risponderà mandando il contenuto richiesto allo script PHP.
5. Lo script PHP immagazzinerà il contenuto in una o più variabili PHP e quindi utilizzerà
una dichiarazione echo per proporlo come output e parte della pagina Web.
6. Il plug-in PHP termina, con una copia dell’HTML per il server Web.
7. Il server Web manda l’HTML al browser come se fosse un file HTML normale, con la sola
eccezione che, anziché venire direttamente da un file HTML, la pagina è un output fornito dal plug in PHP.
Connettersi a MySQL con PHP
Prima che possiate ricavare dei contenuti dal vostro database MySQL, da includere poi in una
pagina Web, dovete sapere come stabilire una connessione a MySQL con uno script PHP. In
precedenza, nel Capitolo 2, Primi passi con MySQL, avete usato un programma chiamato
mysql che vi ha permesso di creare tale connessione dal prompt dei comandi. PHP non ha
bisogno di nessun programma speciale, comunque; la possibilità di connettersi a MySQL è
insita nello stesso linguaggio. La funzione integrata mysql_connect stabilisce la connessione:
mysql_connect(address, username, password)
In questo caso address è l’indirizzo IP o il nome host del computer sul quale il server MySQL
è in esecuzione (‘localhost’ se è in esecuzione nello stesso computer del software del Web
Server) e username e password sono gli stessi nome utente e password di MySQL che avete
usato per connettervi al server MySQL, nel Capitolo 2, Primi passi con MySQL.
60
Capitolo 4: Pubblicare i dati MySQL sul Web
Dovreste ricordarvi che le funzioni in PHP fanno risultare un valore (output) solo quando
vengono richiamate. Non preoccupatevi se questo non vi fa risuonare alcun campanello – è
un dettaglio su cui abbiamo glissato quando abbiamo parlato inizialmente delle funzioni, nel
Capitolo 3, Primi passi con PHP. Oltre a fare qualcosa di utile quando sono richiamate, la maggior parte delle funzioni ha come output un valore; questo valore potrebbe essere immagazzinato in una variabile per un uso successivo. La funzione mysql_connect mostrata in precedenza, per esempio, ha come risultato un numero che identifica la connessione che è stata stabilita. Poiché abbiamo intenzione di usare questa connessione dovremo tener presente questo
valore. Ecco un esempio di come potremmo connetterci al nostro server MySQL.
$dbcnx = mysql_connect(‘localhost’, ‘root’, ‘mypasswd’);
Come descritto prima, i valori dei tre parametri di funzione potrebbero variare in base al
vostro server MySQL. Quello che è importante da vedere è che il valore risultato di mysql_connect (che è chiamato identificatore di connessione) è salvato un una variabile chiamata $dbcnx.
Poiché il server MySQL è un software completamente a sé stante, dobbiamo considerare la
possibilità che il server possa essere indisponibile o inaccessibile, a causa di un blackout del
network o perché la combinazione nome utente/password che avete fornito non viene accettata. In questi casi, la funzione mysql_connect non ha come risultato un identificatore di connessione, non essendo stabilita alcuna connessione; al contrario ha un risultato di “falso”.
Questo ci permette di reagire a questo fallimento usando una dichiarazione if:
$dbcnx = @mysql_connect(‘localhost’, ‘root’, ‘mypasswd’);
if (!$dbcnx) {
echo ‘<p>Unable to connect to the ‘ .
‘database server at this time.</p>’ );
exit();
}
Ci sono tre trucchi nuovi in questa porzione di codice. In primo luogo abbiamo posizionato
un simbolo @ davanti alla funzione mysql_connect. Molte funzioni, compresa mysql_connect,
mostrano automaticamente terribili messaggi d’errore quando non funzionano. Mettere un
simbolo @ (conosciuto anche come operatore di soppressione errori) di fronte al nome della
funzione dice alla funzione, eventualmente, di funzionare silenziosamente e ci permette di
mostrare un nostro messaggio di errore, più amichevole.
Successivamente abbiamo messo un punto esclamativo (!) davanti alla variabile $dbcnx , nella
condizione della dichiarazione if. Il punto esclamativo è l’operatore di negazione di PHP che
tramuta un valore falso in uno vero o viceversa. Quindi, se la connessione fallisce e mysql_connect ha un risultato di falso, !$dbcnx sarà vero e porterà in esecuzione il corpo della nostra
dichiarazione if. Alternativamente, se viene creata una connessione, l’identificatore di connessione immagazzinato in $dbcnx sarà vero (qualsiasi numero maggiore di zero è considerato “true” da PHP), in questo modo sarà valutato falso !$dbcnx e la dichiarazione nella dichiarazione if non sarà eseguita.
61
Creare siti Web con PHP e MySQL
L’ultimo trucco è nella funzione exit, che è il primo esempio di funzione che abbiamo incontrato e che può essere richiamata senza parametri. Se viene richiamata in questo modo, tutto
quello che fa è obbligare PHP a smettere di leggere la pagina in quel punto. Questa è una
buona risposta a una connessione a un database non riuscita, perché nella maggior parte dei
casi la pagina non sarà in grado di mostrare alcuna informazione utile senza quella connessione.
Come anche visto nel Capitolo 2, Primi passi con MySQL, una volta stabilita la connessione, il
passo successivo è quello di selezionare un database con il quale lavorare. Diciamo di lavorare con il database di barzellette che abbiamo creato nel Capitolo 2, Primi passi con MySQL. Il
database che abbiamo creato si chiamava ijdb. Selezionare quel database in PHP è solo questione di usare un’altra funzione:
mysql_select_db(‘ijdb’, $dbcnx);
Da notare che usiamo la variabile $dbcnx, che contiene la connessione all’identificatore di connessione per dire alla funzione quale connessione di database utilizzare. Questo parametro è
effettivamente opzionale. Quando è omesso la funzione userà automaticamente il link dell’identificatore dell’ultima connessione aperta. Questa funzione ha un risultato vero quando ha
successo e falso quando c’è un errore. Ancora una volta è prudente usare una dichiarazione if
per gestire gli errori:
if (!@mysql_select_db(‘ijdb’)) {
exit(‘<p>Unable to locate the joke ‘ .
‘database at this time.</p>’);
}
Questa volta bisogna notare che, anziché assegnare il risultato della funzione a una variabile
e dopo aver controllato se la variabile è vera o falsa, abbiamo semplicemente usato la funzione come condizione. Potrebbe sembrare un po’ strano, ma è usato molto comunemente come
shortcut. Per verificare se la condizione è vera o falsa, PHP esegue la funzione e quindi controlla il suo valore di risposta – esattamente ciò che avevamo bisogno accadesse.
Un altro shortcut che abbiamo utilizzato è richiamare exit con un parametro di stringa.
Quando viene richiamato con un parametro, exit funziona come una dichiarazione echo,
eccetto per il fatto che lo script comincia a esistere dopo che la stringa è eseguita. Far riferimento a exit, in questo modo, è uguale a far riferimento a una dichiarazione echo seguita da
exit senza alcun parametro, che è quella che abbiamo usato sopra mysql_connect.
Con una connessione stabilita e un database selezionato siamo pronti a utilizzare i dati immagazzinati nel database.
Inviare le query SQL con PHP
Nel Capitolo 2, Primi passi con MySQL, ci siamo connessi al server database MySQL usando
un programma chiamato mysql, che ci permetteva di digitare le query (comandi) di SQL e di
62
Capitolo 4: Pubblicare i dati MySQL sul Web
vedere immediatamente i risultati di quelle query. In PHP esiste un meccanismo simile: la
funzione mysql_query
mysql_query(query[, connection_id])
In questo caso query è la stringa che contiene i comandi SQL che vogliamo eseguire. Come
anche con mysql_select_db, il parametro dell’identificatore di connessione è opzionale.
Il risultato di questa funzione dipenderà dal tipo di query eseguita. Per la maggior parte dei
comandi SQL mysql_query ha come risultato o vero o falso (true o false), per indicare rispettivamente il successo o l’insuccesso. Considerate i seguenti esempi che mirano a creare la
tabella di barzellette che abbiamo già creato nel Capitolo 2, Primi passi con MySQL:
$sql = ‘CREATE TABLE joke (
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
joketext TEXT,
jokedate DATE NOT NULL
)’;
if (@mysql_query($sql)) {
echo ‘<p>joke table successfully created!</p>’;
} else {
exit(‘<p>Error creating joke table: ‘ .
mysql_error() . ‘</p>’);
}
Usiamo di nuovo il trucco @ per evitare ogni messaggio di errore prodotto da mysql_query e
lo sostituiamo con un messaggio di errore più amichevole. La funzione mysql_error qui ha
avuto come responso una stringa di testo che descrive l’ultimo messaggio di errore che è stato
inviato dal server MySQL.
Per le query DELETE, INSERT e UPDATE (che sono utilizzate per modificare i dati immagazzinati), MySQL conserva una traccia del numero delle righe di tabelle (record) che sono state interessate dalle query. Considerate il comando SQL, che abbiamo usato nel Capitolo 2, Primi
passi con MySQL per modificare la data di tutte le barzellette che contenevano la parola
“chicken”:
$sql = “UPDATE joke SET jokedate=’1994-04-01’
WHERE joketext LIKE ‘%chicken%’”;
Quando eseguiamo questa query, possiamo usare la funzione mysql_affected_rows per vedere il numero di righe che sono interessate da questo aggiornamento:
if (@mysql_query($sql)) {
echo ‘<p>Update affected ‘ . mysql_affected_rows() .
‘ rows.</p>’;
} else {
exit(‘<p>Error performing update: ‘ . mysql_error() .
‘</p>’);
}
63
Creare siti Web con PHP e MySQL
Le query con SELECT devono essere trattate in un modo leggermente differente, perché possono interessare una grande quantità di dati e PHP deve fornire dei modi per gestire queste
informazioni.
Gestire i set di risultati del comando SELECT
Per la maggior parte delle query di SQL, la funzione mysql_query ha come risultato o true
(successo) o false (insuccesso). Per le query SELECT questo non è sufficiente. Vi ricorderete che
le query SELECT sono utilizzate per visionare i dati immagazzinati nel database. PHP, oltre a
indicare se la query ha avuto successo o meno, deve anche ricevere i risultati della query.
Quindi, quando processa la query SELECT, mysql_query ha come risultato un numero che identifica una serie di risultati e che contiene l’elenco delle righe (record) che si sono avute come
risultati della query. Il risultato false viene dato se la query fallisce per qualche ragione.
$result = @mysql_query(‘SELECT JokeText FROM Jokes’);
if (!$result) {
exit(‘<p>Error performing query: ‘ . mysql_error() .
‘</p>’);
}
Dopo essersi assicurato che non è stato incontrato alcun errore nel processare la query, il codice posizionerà un numero all’interno della variabile $result. Questo numero corrisponde al
set dei risultati che contiene il testo di tutte le barzellette nella tabella degli scherzi. Non essendoci nessun limite pratico al numero di scherzi nel database, il risultato può essere considerevolmente grande.
Abbiamo detto prima che il ciclo while è un’utile struttura di controllo per gestire grandi
quantità di dati. Quello che segue è un possibile abbozzo di codice che processerà le righe di
un set di risultati una alla volta:
while ($row = mysql_fetch_array($result)) {
// process the row...
}
La condizione per il ciclo while probabilmente non assomiglia alle condizione a cui siete abituati, quindi lasciateci spiegare come funziona. Considerate la condizione come una dichiarazione separata:
$row = mysql_fetch_array($result);
La funzione mysql_fetch_array accetta il numero del set di risultati come un parametro
(immagazzinato nella variabile $result in questo caso) e mostra come risultato la riga successiva nel set di risultati come in un array (ritornate al Capitolo 3, Primi passi con PHP per
una discussione sugli array). Quando non ci sono più righe nella serie di risultati,
mysql_fetch_array dà come risultato false.
64
Capitolo 4: Pubblicare i dati MySQL sul Web
La dichiarazione assegna un valore alla variabile $row ma, allo stesso tempo, l’intera dichiarazione prende lo stesso valore. Questo è ciò che vi permette di usare la dichiarazione come una
condizione nel ciclo while. Poiché un ciclo while continuerà a lavorare finché la sua condizione viene valutata falsa, questo ciclo avverrà tante volte quante sono le righe nella serie di
risultati, mentre $row prenderà il valore della riga successiva ogni volta che il loop verrà eseguito. Tutto quello che rimane da fare è capire come ricavare i valori dalla variabile $row ogni
volta che è eseguito il loop.
Le righe di una serie di risultati che si sono avute come risultato da mysql_fetch_array sono
rappresentate come array associativi. Gli indici prendono il nome dalla colonna della tabella
nel set di risultati. Se $row è una riga del nostro set di risultati, allora $row[‘joketext’] è il
valore nella colonna joketext di quella riga. Ed ecco come dovrebbe apparire il nostro ciclo
while se volessimo stampare il testo di tutte le barzellette nel nostro database:
while ($row = mysql_fetch_array($result)) {
echo ‘<p>’ . $row[‘joketext’] . ‘</p>’;
}
Ricapitolando: questo è il codice completo di una pagina Web PHP che si connetterà al nostro
database, andrà a trovare il testo di tutte le barzellette nel database e le mostrerà in paragrafi
HTML:
Esempio 4.1. jokelist.php
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”>
<head>
<title>Our List of Jokes</title>
<meta http-equiv=”content-type”
content=”text/html; charset=iso-8859-1” />
</head>
<body>
<?php
// Connettiti col server database
$dbcnx = @mysql_connect(‘localhost’, ‘root’, ‘mypasswd’);
if (!$dbcnx) {
exit(‘<p>Unable to connect to the ‘ .
‘database server at this time.</p>’);
}
// Seleziona il database delle barzellette
if (!@mysql_select_db(‘ijdb’)) {
exit(‘<p>Unable to locate the joke ‘ .
‘database at this time.</p>’);
}
?>
<p>Here are all the jokes in our database:</p>
65
Creare siti Web con PHP e MySQL
<blockquote>
<?php
// Richiedi il testo di tutte le barzellette
$result = @mysql_query(‘SELECT joketext FROM joke’);
if (!$result) {
exit(‘<p>Error performing query: ‘ . mysql_error() . ‘</p>’);
}
// Mostra il testo di ogni barzelletta in un paragrafo
while ($row = mysql_fetch_array($result)) {
echo ‘<p>’ . $row[‘joketext’] . ‘</p>’;
}
?>
</blockquote>
</body>
</html>
La figura 4.2 mostra come appare questa pagina una volta che avete aggiunto una paio di barzellette al database.
Figura 4.2. Tutto il mio repertorio – in una sola pagina!
Inserire i dati nel database
In questa sezione vedremo come utilizzare gli strumenti a nostra disposizione per permettere ai visitatori del sito di aggiungere le loro barzellette al database. Se vi piacciono le sfide
potreste cercare di pensare un modo da soli, prima di andare avanti a leggere. Ci sono un paio
di cose nuove in questa sezione, ma per la maggior parte è solo un’applicazione di esempio
che comprende tutto quello che abbiamo imparato fino a qui.
Se volete che i visitatori del vostro sito inseriscano nuove barzellette avrete ovviamente bisogno di un form. Ecco un codice per un form che fa al caso nostro:
66
Capitolo 4: Pubblicare i dati MySQL sul Web
Esempio 4.2. jokes.php (esercitazione)
<form action=”<?php echo $_SERVER[‘PHP_SELF’]; ?>” method=”post”>
<label>Type your joke here:<br />
<textarea name=”joketext” rows=”10” cols=”40”>
</textarea></label><br />
<input type=”submit” value=”SUBMIT” />
</form>
La figura 4.3 mostra come appare questo form in un browser.
Figura 4.3. Un’altra perla di comicità è aggiunta al database.
Come abbiamo visto prima, una volta inviato, questo form caricherà la stessa pagina (poiché
abbiamo la variabile $_SERVER[‘PHP_SELF’] per l’attributo di azione del form) con una differenza: una variabile sarà compresa nella richiesta. La variabile joketext conterrà il testo della
barzelletta come è stato digitato nell’area di testo e apparirà negli array $_POST e $_REQUEST
creati da PHP.
Per inserire la barzelletta inviata al database usiamo mysql_query per eseguire una query
INSERT, utilizzando il valore immagazzinato in $_POST[‘joketext’] per completare la colonna
joketext nella query:
Esempio 4.3. jokes.php (esercitazione)
if (isset($_POST[‘joketext’])) {
$joketext = $_POST[‘joketext’];
$sql = “INSERT INTO joke SET
joketext=’$joketext’,
67
Creare siti Web con PHP e MySQL
jokedate=CURDATE()”;
if (@mysql_query($sql)) {
echo ‘<p>Your joke has been added.</p>’;
} else {
echo ‘<p>Error adding submitted joke: ‘ .
mysql_error() . ‘</p>’;
}
}
Il nuovo trucco in questo esempio è mostrato in grassetto. La funzione MySQL CURDATE() è
utilizzata qui per assegnare la data corrente come valore della colonna jokedate. MySQL effettivamente ha dozzine di queste funzioni, ma le mostreremo solo se sarà necessario. Per i riferimenti completi alle funzioni MySQL fate riferimento all’Appendice B, Funzioni MySQL.
Abbiamo il codice che permetterà di digitare una barzelletta e aggiungerla al nostro database.
Tutto quello che rimane da fare è inserirla nella nostra pagina esistente in un modo efficace.
Poiché la maggior parte degli utenti vorrà visualizzare le barzellette, non vogliamo rovinare la
nostra pagina con grossi e brutti caratteri, a meno che l’utente non esprima interesse nell’aggiungere nuove barzellette. Per questa ragione la nostra applicazione è ben progettata per
implementare pagine multiuso. Ecco il codice completo:
Esempio 4.4. jokes.php
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”>
<head>
<title>The Internet Joke Database</title>
<meta http-equiv=”content-type”
content=”text/html; charset=iso-8859-1” />
</head>
<body>
<?php if (isset($_GET[‘addjoke’])): // L’utente vuole aggiungere una barzelletta
?>
<form action=”<?php echo $_SERVER[‘PHP_SELF’]; ?>” method=”post”>
<label>Type your joke here:<br />
<textarea name=”joketext” rows=”10” cols=”40”>
</textarea></label><br />
<input type=”submit” value=”SUBMIT” />
</form>
<?php else: // Default page display
// Connettiti al server database
$dbcnx = @mysql_connect(‘localhost’, ‘root’, ‘mypasswd’);
if (!$dbcnx) {
exit(‘<p>Unable to connect to the ‘ .
‘database server at this time.</p>’);
}
68
Capitolo 4: Pubblicare i dati MySQL sul Web
// Seleziona il database delle barzellette
if (!@mysql_select_db(‘ijdb’)) {
exit(‘<p>Unable to locate the joke ‘ .
‘database at this time.</p>’);
}
// Se una barzelletta viene inviata
// aggiungila al database
if (isset($_POST[‘joketext’])) {
$joketext = $_POST[‘joketext’];
$sql = “INSERT INTO joke SET
joketext=’$joketext’,
jokedate=CURDATE()”;
if (@mysql_query($sql)) {
echo ‘<p>Your joke has been added.</p>’;
} else {
echo ‘<p>Error adding submitted joke: ‘ .
mysql_error() . ‘</p>’;
}
}
echo ‘<p>Here are all the jokes in our database:</p>’;
// Richiedi il testo di tutte le barzellette
$result = @mysql_query(‘SELECT joketext FROM joke’);
if (!$result) {
exit(‘<p>Error performing query: ‘ .
mysql_error() . ‘</p>’);
}
// Mostra il testo di ogni barzelletta in un paragrafo
while ($row = mysql_fetch_array($result)) {
echo ‘<p>’ . $row[‘joketext’] . ‘</p>’;
}
// Questo link caricherà la pagina
// con il form di invio della barzelletta
echo ‘<p><a href=”’ . $_SERVER[‘PHP_SELF’] .
‘?addjoke=1”>Add a Joke!</a></p>’;
endif;
?>
</body>
</html>
Caricatela e aggiungete al database una barzelletta o due utilizzando il vostro browser. La pagina risultante dovrebbe essere come mostrato nella figura 4.4.
Perfetto! Con un singolo file che contiene un po’ di codice PHP siamo in grado di vedere le
barzellette esistenti e aggiungerne di nuove.
69
Creare siti Web con PHP e MySQL
Figura 4.4. Guarda, Ma’! Niente SQL!
Una sfida
Come “compitino” provate a immaginare come posizionare sulla pagina, a fianco di ogni barzelletta, un link con un pulsante “Delete this joke” (Elimina questa barzelletta) che, quanto
viene attivato, rimuove quella barzelletta dal database e mostra un elenco di barzellette aggiornato. Ecco un paio di suggerimenti per iniziare:
•
•
•
Sarete in grado di farlo sempre in una pagina multiuso.
Dovrete usare il comando SQL DELETE che abbiamo visto per la prima volta nel Capitolo
2, Primi passi con MySQL.
Questo è il suggerimento più importante: per cancellare una barzelletta in modo specifico, dovrete essere in grado di identificarla univocamente. La colonna id nella tabella delle
barzellette è stata progettata per questo motivo. Dovrete far passare l’id della barzelletta
da cancellare assieme alla richiesta di cancellazione della barzelletta. La stringa della query
del pulsante “Delete this joke” è un posto perfetto in cui posizionare questo valore.
Se pensate di avere la risposta, o se vi piacerebbe vedere la soluzione voltate pagina. Buona fortuna!
Riepilogo
In questo capitolo avete imparato le funzioni PHP in grado di interfacciarvi con il server database MySQL. Usando queste funzioni avete costruito il vostro primo sito Web basato su un
database che mostra on-line il database ijdb e che permette ai visitatori di aggiungere le barzellette.
70
Capitolo 4: Pubblicare i dati MySQL sul Web
Nel Capitolo 5, Progettazione di database relazionali, torneremo indietro alle righe di comando MySQL. Impareremo a usare i principi dei database relazionali e le query avanzate per rappresentare tipi più complessi di informazione e per dare ai nostri visitatori il merito delle barzellette che inseriscono.
Soluzione della sfida
Ecco la soluzione al “compitino” dato prima. Bisognava fare questi cambiamenti per inserire
un pulsante “Delete this joke” a fianco di ogni barzelletta:
•
•
•
•
In precedenza abbiamo fatto passare una variabile addjoke con il pulsante “Add a Joke!”
alla fine di ogni pagina, per segnalare che il nostro script avrebbe dovuto mostrare il form
di immissione della barzelletta, invece del solito elenco di barzellette. Allo stesso modo
dobbiamo far passare una variabile deletejoke con il nostro pulsante “Delete this joke”
per indicare il nostro desiderio di cancellare una barzelletta.
Per ogni barzelletta rintracciamo la colonna id dal database insieme alla colonna joketext,
in modo da sapere quale id è associato con ogni barzelletta nel database.
Dobbiamo far coincidere il valore della variabile $_GET[‘deletejoke’] all’id della barzelletta che stiamo cancellando. Per fare ciò inseriamo il valore dell’id trovato nel database
all’interno del codice HTML apposta per il pulsante “Delete this joke” di ogni barzelletta.
Usando una dichiarazione if verifichiamo se $_GET[‘deletejoke’] è configurata su un
valore specifico (attraverso la funzione isset), quando la pagina si carica. Se è così, utilizziamo il valore sulla quale è configurata (l’id della barzelletta da cancellare) con una
dichiarazione DELETE di SQL, che cancella la barzelletta in questione.
Questo è il codice completo. Se avete qualche domanda non esitate a sottoporla al sito di
SitePoint!
Esempio 4.5. challenge.php
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN”
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”>
<head>
<title>The Internet Joke Database</title>
<meta http-equiv=”content-type”
content=”text/html; charset=iso-8859-1” />
</head>
<body>
<?php if (isset($_GET[‘addjoke’])): // L’utente vuole aggiungere una barzelletta
?>
<form action=”<?php echo $_SERVER[‘PHP_SELF’]; ?>” method=”post”>
<label>Type your joke here:<br />
<textarea name=”joketext” rows=”10” cols=”40”>
</textarea></label><br />
71
Creare siti Web con PHP e MySQL
<input type=”submit” value=”SUBMIT” />
</form>
<?php else: // Mostra la pagina di default
// Connettiti al server database
$dbcnx = @mysql_connect(‘localhost’, ‘root’, ‘mypasswd’);
if (!$dbcnx) {
exit(‘<p>Unable to connect to the ‘ .
‘database server at this time.</p>’);
}
// Seleziona il database delle barzellette
if (!@mysql_select_db(‘ijdb’)) {
exit(‘<p>Unable to locate the joke ‘ .
‘database at this time.</p>’);
}
// Se una barzelletta è stata inviata,
// aggiungila al database.
if (isset($_POST[‘joketext’])) {
$joketext = $_POST[‘joketext’];
$sql = “INSERT INTO joke SET
joketext=’$joketext’,
jokedate=CURDATE()”;
if (@mysql_query($sql)) {
echo ‘<p>Your joke has been added.</p>’;
} else {
echo ‘<p>Error adding submitted joke: ‘ .
mysql_error() . ‘</p>’;
}
}
// Se una barzelletta è stata cancellata
// rimuovila dal database.
if (isset($_GET[‘deletejoke’])) {
$jokeid = $_GET[‘deletejoke’];
$sql = “DELETE FROM joke
WHERE id=$jokeid”;
if (@mysql_query($sql)) {
echo ‘<p>The joke has been deleted.</p>’;
} else {
echo ‘<p>Error deleting joke: ‘ .
mysql_error() . ‘</p>’;
}
}
echo ‘<p> Here are all the jokes in our database: </p>’;
// Richiedi l’ID e il testo di tutte le barzellette
$result = @mysql_query(‘SELECT id, joketext FROM joke’);
if (!$result) {
exit(‘<p>Error performing query: ‘ .
mysql_error() . ‘</p>’);
}
72
Capitolo 4: Pubblicare i dati MySQL sul Web
// Mostra il testo di ogni barzelletta in un paragrafo
// con un pulsante “Delete this joke” a fianco di ognuna.
while ($row = mysql_fetch_array($result)) {
$jokeid = $row[‘id’];
$joketext = $row[‘joketext’];
echo ‘<p>’ . $joketext .
‘ <a href=”’ . $_SERVER[‘PHP_SELF’] .
‘?deletejoke=’ . $jokeid . ‘“>’ .
‘Delete this joke</a></p>’;
}
// Quando viene premuto, il link caricherà questa pagina
// con mostrato il form di immissione della barzelletta.
echo ‘<p><a href=”’ . $_SERVER[‘PHP_SELF’] .
‘?addjoke=1”>Add a Joke!</a></p>’;
endif;
?>
</body>
</html>
73