Php e Mysql

Introduzione
In questo capitolo affronteremo le dinamiche relative all’interazione tra pagine scritte con PHP
e il database MySQL. PHP può connettersi a svariati tipi di database server come: MS Access,
Postgres, Oracle, Microsoft Sql, Sybase, SQL Server e tanti altri. In ogni caso, la soluzione
MySQL è sicuramente la più utilizzata in assoluto tra i programmatori, infatti, MySQL è un
potentissimo software Open Source (scaricabile gratuitamente dal sito www.mysql.com), che
come PHP garantisce prestazioni in linea con le più note soluzioni a pagamento.
13.1 Introduzione a MySQL
MySQL è un software per la gestione di database (un DBMS: DataBase Management System o
“sistema per la gestione di database”), appartenete alla famiglia dei database SQL server
(Structured Query Language). Le sue caratteristiche più note sono quelle di essere: “multi processo”, “multi - utente”, “veloce” e “robusto”.
Con il termine “database” si intende un archivio utilizzato per la gestione di dati; questi dati
vengono organizzati tramite tabelle e ciascuna tabella è suddivisa per righe e per colonne. I
dati (documenti, immagini ed altro) saranno contenuti, letti, scritti, aggiornati ed eliminati
nelle righe di ogni tabella.
Per SQL, viene indicato un linguaggio standard preposto all’archiviazione e alla modifica dei
dati inseriti in un database.
MySQL è “multi - processo” in quanto può soddisfare contemporaneamente le interrogazioni
(query) di più utenti; per lo stesso motivo è un software “multi - utente” dato che prevede di
poter essere utilizzato da più utenti alla volta.
Grazie a MySQL abbiamo la possibilità di gestire velocemente enormi quantità di informazioni
sfruttando al minimo l’hardware disponibile anche in situazioni particolarmente critiche.
13.2 Connessione a MySQL da una pagina PHP
Avvertenza: gli script di questo capitolo non sono stati creati da “root” (utente
amministratore), ma da uno “user” MySQL creato appositamente per simulare al meglio il
lavoro su uno spazio web (”hosting”) professionale.
Se state lavorando con EasyPHP su Windows, copiate in “www” la cartella “phpmyadmin” che
trovate nella directory principale di EasyPHP. A questo punto, digitando
http://localhost/phpmyadmin/ aprirete la schermata principale di Phpmyadmin. Cliccate su
“Utenti” o su “Privilegi” a seconda della versione e aggiungete un nuovo utente” cliccando
sull’apposito link. I dati utilizzati per questo capitolo sono i seguenti: host = “localhost”; user =
“webmaster”; password = “parolachiave”.
Se state lavorando su Linux e avete installato phpmyadmin, copiate la cartella “phpmyadmin”
da “/var/www/” a “/var/www/html” e seguite lo stesso procedimento.
La connessione di PHP a MySQL richiede una sintassi molto semplice e sfrutta una funzione
predefinita chiamata mysql_connect(). Questa funzione richiede il passaggio di tre
parametri:
il nome di “host“, cioè il nome dell’elaboratore su cui gira il server MySQL (ad esempio
“localhost”);
uno username, cioè il nome dell’utente che intende accedere alle informazioni conservate nel
database;
la password dell’utente.
Quindi, un esempio di sintassi corretta per la connessione a MySQL potrebbe essere questo:
mysql_connect(server, utente, password)
Alla normale sintassi di “mysql_connect()”, è utile accompagnare un messaggio di errore che
verrà visualizzato nel caso si verificassero problemi durante la connessione, per far questo
utilizzeremo l’istruzione die (Rif. capitolo 5):
mysql_connect(server, utente, password) or die (messaggio di errore)
Facciamo un’esempio:
$connessione = mysql_connect(’localhost’, ‘root, ‘root) or die (”Impossibile connettersi al
server host.”);
Naturalmente, i tre parametri da passare a “mysql_connect()” possono essere espressi anche
sotto forma di variabili:
// assegnamo i valori alle variabili
$host = ‘localhost’;
$user_name = ‘root’;
$password = ‘root’;
// stabiliamo la connessione
$connessione = mysql_connect($host, $user, $password) or die (”Impossibile connettersi al
server host.”);
Una volta eseguite le nostre operazioni sul database, dovremo chiudere la connessione. Per far
questo, utilizzeremo la funzione mysql_close() alla fine dei nostri script con questa sintassi:
mysql_close($connessione)
13.3 Creazione di un database
Una volta operata la connessione tra PHP e MySQL, possiamo scegliere tra lavorare con dei
database creati in precedenza o realizzarne di nuovi. Per ordinare a PHP la creazione ex novo
di un database si pò utilizzare la funzione mysql_create_db(), che accetta come parametro il
nome della base di dati che vogliamo realizzare; ecco quindi la sua sintassi:
mysql_create_db (”nome_database”)
Per mostrare un esempio chiarificatore della funzione svolta da “mysql_create_db()”
basteranno poche righe di codice:
<?PHP
/* creazione di un database con “mysql_create_db()” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “user”, “parolachiave”)
or die(”Impossibile connettersi al server host.”);
// creiamo il database e introducoamo il costrutto
// di controllo “if” per ottenere un messaggio di conferma
if (mysql_create_db (”secrets”))
{
print (”Database creato con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un errore nella creazione del database.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
Avremmo ottenuto lo stesso risultato passando alla funzione “mysql_connect()” delle variabili
come parametri; dato che non possono coesistere due database con lo stesso nome, per fare
un esempio creeremo una nuova base di dati chiamata “secrets2″:
<?PHP
/* creazione di un database con “mysql_create_db()” */
// assegnamo i valori alle variabili
$host=’localhost’;
$user=’webmaster’;
$password=’parolachiave’;
// stabiliamo la connessione con MySQL
// passando le variabili come parametri a mysql_connect()
$connessione = mysql_connect($host, $user, $password)
or die(”Impossibile connettersi al server host.”);
// creiamo il database e introduciamo il costrutto
// di controllo “if” per ottenere un messaggio di conferma
if (mysql_create_db (”secrets2″))
{
print (”Database creato con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un errore nella creazione del database.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
Come avrete potuto notare “stabilire una connessione con MySQL” non significa stabilire una
connessione con un database, ma col DBMS che lo gestisce; infatti è possibile connettersi
anche in assenza di database e crearne uno nuovo; per “connessione di PHP a MySQL” si
intende invece instaurare il “dialogo” tra i due software.
Come vedremo tra poco, con l’avvento delle nuove versioni di PHP l’uso di “mysql_create_db()”
per la creazione di database è stato sconsigliato, ma è rimasto perfettamente funzionante per
questioni di compatibilità verso il basso, cioè per le versioni precedenti di PHP. Spiegheremo
tra qualche paragrafo un’alternativa più “attuale” con la quale raggiungere lo stesso risultato.
13.4 Selezione di un database
Stabilita la connessione tra PHP e MySQL grazie a “mysql_connect()”, dovremo selezionare un
database con il quale operare; utilizzeremo quindi un’altra funzione nativa di PHP chiamata
mysql_select_db() che necessita di questo tipo di sintassi:
mysql_select_db(nome_database, connessione)
Come avrete potuto notare, “mysql_select_db()” richiede il passaggio di due parametri:
il database name, cioè la base di dati che ci interessa selezionare;
la connessione creata attraverso “mysql_connect()” (”$connessione”).
Per esempio, potremmo selezionare un database chiamato “secrets” in questo modo
mysql_select_db(’secrets’, $connessione) or die (”Impossibile connettersi al database
secrets”);
Anche nel caso di “mysql_select_db()”, la funzione accetta variabili passate come parametri:
// assegnamo i valori alle variabili
$host = ‘localhost’;
$user_name = ‘webmaster’;
$password = ‘parolachiave’;
$database = ’secrets’;
// stabilamo la connessione
$connessione = mysql_connect($host, $user, $password) or die (”Impossibile connettersi al
server host.”);
// selezioniamo il database
mysql_select_db($database, $connessione) or die (”Impossibile connettersi al database
$database”);
13.5 Lettura dei dati
Un vota stabilita la connessione tra una pagina PHP e MySQL e selezionato la base di dati che
ci interessa, vediamo come bisogna operare per recuperare le informazioni inserite nella nostra
database.
La lettura e il recupero dei dati da una database si ottiene formulando ed eseguendo una
query, cioè un’ “interrogazione” (o una “richiesta”) rivolta al database. Per formulare una
query di lettura su un database si utilizza il costrutto “select * from nome_database” dove “*”
è un’indicazione generica del tipo di dato contenuto; nel caso del nostro database “secrets”
potremmo formulare una query del genere:
$query = “select * from secrets”;
Dopo aver formulato la query, è necessario eseguirla utilizzando la funzione mysql_query() con
la seguente sintassi:
mysql_query(query, connessione)
Avrete notato come questa funzione rchieda due specifici parametri:
il risultato della formulazione della query;
il risultato della connessione ottenuto tramite “mysql_connect()”.
Quindi, un esempio completo di formulazione ed esecuzione di una query ad un database
potrebbe essere questo:
// formulazione di una query
$query = “SELECT * FROM secrets”;
// esecuzione di una query
$risultato = mysql_query($query, $connessione) or die(”Impossibile eseguire la query”);
La variabile $risultato, ottenuta attraverso il passaggio dei parametri alla funzione
“mysql_query()”, sarà appunto il dato derivante dalla richiesta operata al database.
13.6 CREATE DATABASE come alternativa a mysql_create_db()
Abbiamo già anticipato che l’uso di “mysql_create_db()” per la creazione di database viene
sconsigliato, anche se funziona ancora correttamente per questioni di compatibilità con le
versioni di PHP meno recenti. Ora che conosciamo il significato di una query e sappiamo
utilizzare la funzione “mysql_query()”, possiamo introdurre un metodo alternativo per
realizzare i nostri database attraverso PHP. A questo scopo sfrutteremo il comando SQL
CREATE DATABASE dotato di una sintassi molto semplice:
$query = “CREATE DATABASE nome_database”;
Alla formulazione della query, faremo seguire la sua esecuzione attraverso la funzione
“mysql_query()” alla quale verranno passati come parametri il risultato della query e quello
della connessione ottenuto tramite “mysql_connect()”.
Per fare un esempio, creeremo una database chiamato “secrets3″ utilizzando “CREATE
DATABASE”:
<?PHP
/* creazione di un database con “CREATE DATABASE” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// formuliamo la query
$query = “CREATE DATABASE secrets3″;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Database creato con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un errore nella creazione del database.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
13.7 Creazione di un tabella
I database creati negli esempi precedenti, sono per ora “vuoti”, infatti non contengono ancora
dati o informazioni; non è possibile lavorare su dei database vuoti, quindi dovremo creare
almeno una semplice tabella in cui inserire alcuni dati.
Per fare un esempio, fingiamo di dover inserire nel nostro database “secrets3″ una tabella
(”pass”) destinata a contenere gli utenti di un nostro sito internet e le loro password; per fare
questo useremo l’istruzione SQL CREATE TABLE introdotta dalla funzione “mysql_query()”.
I campi creati, “utente” e “password”, avranno rispettivamente una lunghezza massima di 40 e
80 caratteri (”CHAR”)
Ecco il codice dello script:
<?PHP
/* creazione di una tabella in un database con “CREATE TABLE” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// selezioniamo il database
mysql_select_db(secrets3, $connessione) or die (”Impossibile selezionare il database.”);
// formuliamo la query
$query = “CREATE TABLE pass (utente CHAR(40), password CHAR(80))”;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Tabella creata con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un errore nella creazione della tabella.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
Nell’ultimo script proposto, grazie al comando “SQL CREATE TABLE”, abbiamo inserito nel
nostro database una tabella chiamata “pass” che ha il compito di contenere i campi “utente” e
“password”. La funzione “mysql_query()” ci ha quindi restituito un recordset, cioè una
struttura di dati che contiene il risultato di una query.
13.8 Inserimento ed estrazione dei dati
Ora che abbiamo creato la nostra tabella “pass” non ci resta che vedere in che modo sia
possibile scrivere (o meglio “inserire”) dati al suo interno attraverso PHP; anche in questo
caso, formuleremo una richiesta al database (”query”), grazie al comando SQL INSERT.
La sintassi da rispettare per rendere efficace il comando “INSERT” è questa:
$query = “INSERT INTO tabella (campo1, campo2) VALUES(’valore1′, ‘valore2′)”;
Dopo la formulazione della richiesta, bisogna passare il nome del database, il parametro
ottenuto dalla query e il risultato di “mysql_connect()” come parametri alla funzione
“mysql_query()”:
mysql_query($query, $connessione)
Vediamo un esempio di scrittura su database; inseriremo nella nostra tabella “pass” i nomi di
due utenti con le loro relative password utilizzando il comando “INSERT”:
<?PHP
/* scrivere su un database con “INSERT” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// selezioniamo il database
mysql_select_db(secrets3, $connessione) or die (”Impossibile selezionare il database.”);
// formuliamo una prima query
$query = “INSERT INTO pass (utente, password) VALUES (’magellano’, ‘12f456b’)”;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Dati inseriti con successo.” . “<br>”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un un errore nell’inserimento dei dati.” . “<br>”);
}
// formuliamo una seconda query
$query = “INSERT INTO pass (utente, password) VALUES(’wonder’, ‘7t8t9r0′)”;
// passiamo il risultato della seconda query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Dati inseriti con successo.” . “<br>”);
// poniamo un’alternativa ad “if” con “else2
}
else
{
print (”Si è verificato un errore nell’inserimento dei dati.” . “<br>”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
Nello script appena proposto, abbiamo inserito i nomi dei due utenti (”magellano” e “wonder”)
e le loro rispettive password (”12f456b” per il primo e “7t8t9r0″ per il secondo), utilizzando i
campi “utente” e “password” della tabella “pass” creata nell’esempio del paragrafo precedente
utilizzando il comando SQL “CREATE TABLE”.
Ora, se vogliamo estrarre questi dati e visualizzarli a video, ci basterà richiedere la loro lettura
a PHP attraverso il comando “SELECT”; facciamo un esempio:
<?PHP
/* leggere ed estrarre dati con “SELECT” */
// stabiliamo la connessione
$connessione = mysql_connect (”localhost” , “webmaster” , “parolachiave”)
or die(”Connessione non riuscita”);
{
print “Connessione effettuata.”;
}
// selezioniamo il database
mysql_select_db (”secrets3″) or die (”Selezione del database fallita”);
// formuliamo la query utilizzando “SELECT”
// con la sintassi “SELECT *FROM nome_tabella”
$query = “SELECT * FROM pass”;
// passiamo il risultato della query come
// parametro a “mysql_query()”
$risultato = mysql_query ($query, $connessione) or die(”Impossibile eseguire la query”);
// stampiamo i risultati in una tabella con HTML
// “mysql_fetch_array()” restituisce un array che corrisponde alla riga caricata
// “MYSQL_ASSOC” è un valore che contiene il nome delle colonne
print “<table>\n” ;
while ($riga = mysql_fetch_array ($risultato, MYSQL_ASSOC))
{
print “\t<tr>\n” ;
foreach ($riga as $valore)
{
print “\t\t <td>$valore</td> \n”;
}
print “\t</tr>\n”;
}
print “</table>\n”;
// liberiamo la memoria occupata dal risultato
// con la funzione “mysql_free_result()”
mysql_free_result ($risultato);
// Chiudiamo la connessione
mysql_close ($connessione);
?>
13.9 Aggiornamento dei dati
Per aggiornare i dati presenti nel nostro database, useremo il comando SQL UPDATE; la
sintassi di questo comando varia a seconda dei valori che vogliamo modificare, ma segue
sempre la stessa logica. Nel prossimo esempio la query sarà espressa in questo modo:
$query = “UPDATE tabella SET campo2 = ‘nuovo_valore’ WHERE campo1 = ‘valore1′
LIMIT n”;
Una volta formulata la query, entra in gioco la funzione “mysql_query()” alla quale andranno
passati i soliti parametri.
Ecco un esempio di aggiornamento dei dati in un database; modificheremo la password
dell’utente “magellano”
<?PHP
/* aggiornare i dati di un database con “UPDATE” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// selezioniamo il database
mysql_select_db (”secrets3″) or die (”Selezione del database fallita”);
// formuliamo la query
$query = “UPDATE pass SET password = ‘aaaaaab’ WHERE utente = ‘magellano’ LIMIT 1″;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Dati aggiornati con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un un errore nell’aggiornamento dei dati.”);
}
// chiudiamoo la connessione
mysql_close($connessione);
?>
13.10 Cancellazione dei dati
Per cancellare dei dati dal database useremo il comando SQL DELETE dotato di questa sintassi:
$query = “DELETE FROM tabella WHERE campo1 = ‘valore1′ AND campo2 = ‘valore1′ LIMIT
n”;
Ecco un esempio in cui elimineremo il nome dell’utente “Magellano” e la sua password dalla
tabella “pass” del nostro database “secrets3″:
<?PHP
/* cancellare dati da un database con DELETE */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// selezioniamo il database
mysql_select_db (”secrets3″) or die (”Selezione del database fallita”);
// formuliamo la query
$query = “DELETE FROM pass WHERE utente = ‘magellano’ AND password = ‘12f456b’ LIMIT
1″;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Dati eliminati con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un un errore nell’eliminazione dei dati.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
13.11 Eliminare un database
Per eliminare un database si utilizza il comando SQL DROP DATABASE dotato di una sintassi
simile a quella di “CREATE DATABASE”:
$query = “DROP DATABASE nome_database”;
In pratica, uno script generato per eliminare un database si differenzia dallo script realizzato
allo scopo di crearlo unicamente per il comando SQL che entra in gioco.
Col prossimo esempio elimineremo definitivamente il database “secrets3″:
<?PHP
/* eliminare un database con “DROP DATABASE” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// selezioniamo il database
mysql_select_db (”secrets3″) or die (”Selezione del database fallita”);
// formuliamo la query
$query = “DROP DATABASE secrets3″;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Database eliminato con successo.”);
// poniamo un’alternativa ad if con else
}
else
{
print (”Si è verificato un errore durante l’eliminazione del database.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
13.12 Gestione degli errori
In questo paragrafo tratteremo brevemente della gestione degli errori nell’interazione tra PHP
e MySQL. Dato che come avrete certamente notato, in questo tipo di operazioni ci si può
trovare a scrivere dei lunghi listati di codice, può essere utile impiegare una funzione in grado
di restituirci a video gli errori causati da omissioni o sbagli in sede di scrittura e realizzazione
degli script. Tra l’altro, gli errori che ritornano dal database MySQL alcune volte non
visualizzano messaggi di avvertimento, ci si può quindi trovare nella condizione di dover
lavorare alla cieca per identificare il frammento di codice contenente l’errore o la dimenticanza.
Anche in questo caso PHP ci fornisce alcune funzioni di controllo predefinite:
mysql_error(): restituisce il testo di un errore accorso dopo l’ultima funzione MySQL utilizzata,
diversamente, non restituisce nulla se il codice è corretto;
mysql_errno(): che restituisce il numero di errore accorso dopo l’ultima funzione MySQL
utilizzata, diversamente, restituisce zero se il codice è corretto.
Facciamo un esempio, cerchiamo di connetterci ad un database inesistente e di selezionare
una tabella al suo interno:
<?PHP
/* Gestione degli errori MySQL con PHP */
// stabiliamo la connessione a MySQL
mysql_connect(”localhost”, “webmaster”, “parolachiave”) or die (”Impossibile stabilire la
connessione.”);
// selezioniamo il database
mysql_select_db (”db_error”);
echo mysql_errno() . ” = ” . mysql_error(). “<br>”;
// selezioniamo la tabella
mysql_select_db(”tb_error”);
mysql_query (”SELECT * FROM tabella_inesistente”);
echo mysql_errno() . ” = ” . mysql_error() . “<br>”;
// chiudiamo la connessione
mysql_close($connessione);
?>
Un volta testato questo script, riceveremo a video un avvertimento contenente la segnalazione
di due errori:
l’errore “1049″, che si manifesta nel caso in cui si cerchi di selezionare un database
inesistente;
l’errore “1046″, che si manifesta nel caso in cui si cerchi di selezionare una tabella inesistente.
13.13 Tutorial: visualizzare il numero di utenti connessi ad un sito
In questo tutorial, utilizzeremo congiuntamente PHP e MySQL per creare uno script in grado di
contare e visualizzare in tempo reale il numero di utenti collegati contemporaneamente al
nostro sito internet (users on-line).
Innanzitutto dovremo creare un database da utilizzare per contenere i dati che ci interessano;
chiameremo questa base di dati “utenti_connessi” e per crearla utilizzeremo il comando SQL
“CREATE DATABASE”:
<?PHP
/* creiamo il database con “utenti_connessi” */
// stabiliamo la connessione con MySQL
$connessione = mysql_connect(”localhost”, “webmaster”, “parolachiave”)
or die(”Impossibile connettersi al server host”);
// formuliamo la query
$query = “CREATE DATABASE utenti_connessi”;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connessione))
{
print (”Database creato con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un errore nella creazione del database.”);
}
// chiudiamo la connessione
mysql_close($connessione);
?>
Ora creiamo un file “riutilizzabile” in grado di connettersi al database “utenti_connessi” e di
selezionarlo, questo script verrà richiamato grazie all’istruzione “include” ogni volta che ne
avremo bisogno; chiameremo il file “connetti.php“:
<?PHP
/* creiamo il file di connessione */
// stabiliamo la connessione con MySQL
$connetti = mysql_connect(”localhost”, “webmaster”, “parolachiave”) or die (”Impossibile
connettersi al server host.”);
// selezioniamo il database
mysql_select_db(”utenti_connessi”) or die (”Impossibile selezionare il database.”);
?>
E’ quindi arrivato il momento di realizzare una tabella destinata all’archiviazione dei dati
all’interno del nostro database, quest’ultima comprenderà due campi: “utenti”, destinato a
fungere da contatore (PRIMARY KEY), e “ip”, che archivierà l’IP fornito dai client dei visitatori.
<?PHP
/* creiamo la tabella “visite” nel database “utenti_connessi” */
// stabiliamo la connessione a Mysql
include(”connetti.php”);
// formuliamo la query per richiedere
// la creazione di 3 campi “NOT NULL”
// che cioè non dovranno mai essere vuoti
$query = “CREATE TABLE visite (
utenti int(20) NOT NULL,
ip char(20) NOT NULL,
PRIMARY KEY (utenti))”;
// passiamo il risultato della query alla funzione
// e richiediamo un messaggio di conferma
if (mysql_query($query, $connetti))
{
print (”Tabella creata con successo.”);
// poniamo un’alternativa ad “if” con “else”
}
else
{
print (”Si è verificato un errore nella creazione della tabella.”);
}
// chiudiamo la connessione
mysql_close($connetti);
?>
Passiamo ora alla parte operativa del nostro programmino, creeremo due files: il primo,
“utenti.php”, destinato al conteggio dei visitatori in linea e alla conseguente archiviazione dei
dati nella tabella; il secondo, “mostra_utenti.php”, avrà la funzione di mostrare i risultati
rilevati attraverso il primo.
Il primo file, “utenti.php“, è di semplice realizzazione:
<?PHP
/* contiamo gli utenti on-line e inseriamo i loro dati nel database */
// stabiliamo la connessione a Mysql
include (”connetti.php”);
// assegnamo i valori alle variabili
$utenti = time();
$ip = $_SERVER["REMOTE_ADDR"];
// inseriamo i dati nei rispettivi campi
$insert = mysql_query(”INSERT INTO visite VALUES (’$utenti’,'$ip’)”,$connetti);
mysql_close($connetti);
?>
Per la creazione del file di conteggio e archiviazione abbiamo innanzitutto incluso il file di
connessione.
In secondo luogo abbiamo assegnato alle variabili $utenti e $ip i loro rispettivi valori: alla
prima abbiamo assegnato la funzione “time()” in modo da recuperare il “timestamp” preciso di
ogni visita al nostro sito; alla seconda, invece, abbiamo attribuito il metodo $_SERVER a cui
verrà passata la costante predefinita REMOTE_ADDR, in questo modo sarà possibile registrare
un diverso IP per i client di ogni visitatore.
Infine, attraverso un semplice comando SQL “INSERT” abbiamo predisposto una query in
grado di registrare i dati delle diverse visite al nostro sito nella tabella “visite”.
Ora, non dovremo far altro che includere il file appena creato in tutte le pagine del nostro sito
in PHP ad esclusione di quella in cui intendiamo visualizzare il numero degli utenti connessi:
include (”PERCORSO/utenti.php”);
Passiamo quindi alla creazione del file di visualizzazione “mostra_utenti.php”; iniziamo subito
con l’analisi del codice commentato:
<?PHP
/* visualizziamo i visitatori on-line */
// stabiliamo la connessione a Mysql
include (”connetti.php”);
// stabiliamo il tempo di visualizzazione per ogni visitatore
// on-line, per esempio: 10 minuti
$durata = “10″;
// assegnamo il timestamp come valore alla variabile $utenti
$utenti = time();
// calcoliamo la scadenza di ogni visiatatore in secondi
$scadenza = $utenti-($durata*60);
// ricaviamo l’IP dei visitatori tramite il metodo $_SERVER
$ip = $_SERVER["REMOTE_ADDR"];
// inseriamo i dati nel database
$on_line = mysql_query(”INSERT INTO visite VALUES (’$utenti’,'$ip’)”,$connetti);
// stabiliamo la cancellazione dei dati dopo il tempo di scadenza prestabilito
$on_line = mysql_query(”DELETE FROM visite WHERE utenti<’$scadenza’”,$connetti);
// distinguiamo i diversi visitatori sulla base dei diversi IP
$on_line = mysql_query(”SELECT DISTINCT ip FROM visite”,$connetti);
// sommiamo i visitatori on-line
$visitatori = mysql_numrows($on_line);
// visualizziamo il risultato
echo “Visitatori on-line: $visitatori”;
// chiudiamo la connessione
mysql_close();
?>
Come avrete potuto notare, anche “mostra_utenti.php” si basa su un codice semplice e di
facile comprensione: in pratica, non abbiamo fatto altro che estrarre i dati contenuti nel nostro
database, distinguerli per IP di ogni client e visualizzarli. Per evitare che le informazioni su i
visitatori disconnessi si sommino a quelle degli utenti on-line è stato sufficiente stabilire un
tempo di cancellazione calcolato a partire dal timestamp indicato nel campo “utenti” della
nostra tabella.
Utilizziamo l’istruzione “include” per inserire questo file nella pagina PHP in cui vogliamo che i
risultati vengano visualizzati, naturalmente, testando questo script in locale l’unico client
visualizzato sarà quello sul quale stiamo lavorando.