Architettura a tre livelli (1) - Università degli studi di Bergamo

Elaborazione Automatica dei Dati
Php e MySQL
Enrico Cavalli
Anno Accademico 2012 - 2013
Architettura a tre livelli (1)
•
Le applicazioni sono sviluppate secondo una architettura a tre livelli,
affermatasi con Internet. In questo contesto:
– il client dell’applicazione ( livello 1 ) è un semplice browser che richiede
pagine a un server web
– Il server web ( livello 2 ) costituisce il server dell’applicazione e interagisce
con il server del database
– Il database server ( livello 3 ) accede al database per recuperare i dati
richiesti dal client
•
Vantaggi
–
–
–
–
Stazioni di lavoro leggere, dotate solo di un browser
Possibilità di operare da qualsiasi macchina dotata di un browser
La distribuzione dell’applicazione è semplificata
La manutenzione dell’applicazione è semplificata (ogni cambiamento nel
software applicativo avviene sul solo server)
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
2
Architettura a tre livelli (2)
•
Si vogliono sviluppare applicazioni per permettere a utenti inesperti di
accedere al database di una applicazione
– Non è pensabile che accedano al database con comandi SQL
– Vedono e modificano i dati tramite maschere
•
Oltre a sapere dialogare interattivamente con MySQL e saper sviluppare
pagine web dinamiche con Php, bisogna imparare a:
–
–
–
–
–
Ricevere le richieste dell’utente tramite parametri
Assegnare il valore dei parametri a variabili php di uno script
Sviluppare script in base alle richieste ricevute
Sviluppare script che interrogano o modificano un database
Sviluppare script per inviare all’utente le informazioni richieste
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
3
1
Architettura a tre livelli (3)
1
Server
Web
6
2
5
3
DB
Server
MySQL
Php
4
1.
Il browser richiede una pagina Web dinamica
2.
Il Web server riconosce nella richiesta un file con estensione .php e quindi attiva
l’interprete Php per eseguire gli script in esso contenuti
3.
Lo script Php contiene i comandi per collegarsi al database MySQL e inviare le
richieste tramite comandi in SQL
4.
Il Server MySQL restituisce i dati richiesti
5.
Lo script Php scrive i dati in una pagina Web e la restituisce al Web Server
6.
Il Web Server invia al browser la pagina richiesta in formato HTML
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
4
Database utilizzato
•
Il database Alimentari raccoglie gli ordini di prodotti alimentari.
Prodotto
IDProdotto {PK}
Descrizione
Reparto
Prezzo
N
Includere
Numero{PK}
Quantità
N
Ordine
IDOrdine
Data
Cliente
{PK}
Prodotti( IDProdotto, Descrizione, Categoria, Prezzo )
Ordini( IDOrdine, Data, Cliente)
RigheOrdine( Numero, Quantita, IDProdotto, IDOrdine )
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
5
Metodi Get e Post (1)
Pagina inviata dal web server
al browser. Contiene il nome
dello script di risposta
Pagina visualizzata
dal browser
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
6
2
Metodi Get e Post (2)
•
Con il metodo GET i parametri sono trasmessi al server nell’URL della
pagina richiesta e sono visibili nella pagina di risposta
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
7
Metodi Get e Post (3)
•
Quando il browser richiama lo script di risposta costruisce per ogni parametro del
modulo una coppia NomeParametro=Valore ( nome=Gianfranco, cognome=Farinoni )
che invia con la modalità GET o la modalità POST
•
GET: i parametri sono codificati come parte dell’indirizzo e sono visualizzati insieme
all’URL della pagina Web. Il nome è case sensitive
–
–
–
–
•
modalità non adatta alla trasmissione di dati riservati
modalità non adatta alla trasmissione di campi di grande dimensione
Php: salvati nell’array associativo $_GET
$_GET[“nome”]
$_GET[“cognome”]
POST: i parametri sono trasmessi in un canale riservato con una modalità che li rende
invisibili all’utente
– modalità non adatta per le pagine che si vogliono salvare nei bookmarks
– Php: salvati nell’array associativo $_POST
– $_POST[“nome”] $_POST[“cognome”]
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
8
Metodi Get e Post (4)
•
Un altro modo di passare parametri ad una pagina Php consiste nel richiamare la pagina
aggiungendo i parametri al suo indirizzo
– http://Host/Pagina.php?par1=val1&par2=val2&
...
– spazi o caratteri speciali nei nomi o nei valori
•
•
•
spazi +, caratteri speciali %hh
indirizzo=Via Monte Rosa 12/a indirizzo=Via+Monte+Rosa+12%2Fa
I parametri sono trasmessi nell’array $_GET. Se manca un parametro Php segnala un
errore al momento del recupero del valore mancante. Usare isset( ) per identificare
queste situazioni e fornire eventuali valori di default
http://.../iscrizioni.php?matr=254712&corso=6611
$matr = $_GET[“matr”];
$corso = $_GET[“corso”];
If (isset($_GET[“matr”]))
$matr = $_GET[“matr”];
else
$matr = “mancante”;
if (isset($_GET[“corso”]))
$corso = $_GET[“corso”];
else
$corso = 0001;
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
9
3
Operazioni sul database (1)
Connessione.php
<?php
$hostname = "localhost";
$username = "root";
$password = "";
//---- Apertura della connessione con il server MySQL
$conn = mysql_connect($hostname, $username, $password);
if (! $conn ) {
echo "Errore durante la connessione a MySQL.";
exit();
} else {
echo ("Connessione a MySQL effettuata con successo.");
}
// ---- Selezione di un database
$conn è un oggetto
// ---- Operazioni sul database
che identifica la
// ---- Chiusura della connessione
connessione ...
mysql_close( $conn );
?>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
10
Operazioni sul database (2)
ScegliDatabase.php
mysql_select_db()
restituisce un valore
<?php
di verità ..
$conn = mysql_connect("localhost", "root", "");
if (! $conn ) {
exit("Errore durante la connessione a MySQL.");
} else {
echo "Connessione a MySQL effettuata con successo<BR>";
}
//-----------------------------------------------------// ---- Scelta di Alimentari come database di default
//-----------------------------------------------------if ( ! mysql_select_db("Alimentari", $conn) ) {
exit("Errore nella scelta del database Alimentari");
}
echo "Selezione riuscita, Alimentari è db di default";
//-----------------------------------------------------// ---- Operazioni sul database Alimentari
//-----------------------------------------------------mysql_close( $conn );
if(!exp1){exp2} exp1 OR exp2
?>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
11
Short Circuit Evaluation
if(!exp1){exp2} exp1 OR exp2
SCE nel caso di OR
$Str = “Valore iniziale”;
$L1 = True;
$L2 = $L1 OR ($Str = 0);
echo ‘$L2 vale ‘.$L2;
echo ‘$Str vale ‘.$Str;
// $L2 = $L1 || ($Str = 0);
$Str = “Valore iniziale”;
$L1 = False;
$L2 = $L1 OR ($Str = 0);
echo ‘$L2 vale ‘.$L2;
echo ‘$Str vale ‘.$Str;
// $L2 = $L1 || ($Str = 0);
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
12
4
Short Circuit Evaluation
SCE nel caso di AND
$Str = “Valore iniziale”;
$L1 = True;
$L2 = $L1 AND ($Str = 0);
echo ‘$L2 vale ‘.$L2;
echo ‘$Str vale ‘.$Str;
// $L1 && ($Str = 0);
$Str = “Valore iniziale”;
$L1 = False;
$L2 = $L1 AND ($Str = 0);
echo ‘$L2 vale ‘.$L2;
echo ‘$Str vale ‘.$Str;
// $L1 && ($Str = 0);
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
13
Dettagli su espressioni logiche
OR versus ||
$Ris = $L1 OR $L2;
($Ris = $L1) OR $L2;
$Ris = $L1 || $L2;
$Ris = ($L1 || $L2);
/*-----------------------------------------------------* Valutare le espressioni per: $L1 = False; $L2 = True;
*------------------------------------------------------*/
AND versus &&
$Ris = $L1 AND $L2;
($Ris = $L1) AND $L2;
$Ris = $L1 && $L2;
$Ris = ($L1 && $L2);
/*-----------------------------------------------------* Valutare le espressioni per: $L1 = True; $L2 = False;
*------------------------------------------------------*/
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
14
Operazioni sul database (3)
•
Le operazioni sul database si eseguono con la funzione mysql_query( )
mysql_query( StringaQuery, Connessione )
– StringaQuery contiene il testo del comando SQL che si vuole eseguire
(bisogna omettere il ; finale)
– Connessione specifica il database tramite un identificatore di connessione,
per default si considera l’ultima connessione stabilita
– mysql_query() restituisce false in caso di errore, mentre restituisce true, o un
puntatore alla risposta all’interrogazione, in assenza di errori
– Esempi basati sulla tabella Clienti:
CREATE TABLE Clienti (
IDCliente
VARCHAR(10) PRIMARY KEY,
Nome
VARCHAR(30),
Cognome
VARCHAR(30)
);
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
15
5
Operazioni sul database (4)
CreaClienti.php
<?php
$conn = mysql_connect("localhost", "root", "");
if (! $conn ) exit("Errore durante la connessione a MySQL.");
echo "Connessione a MySQL effettuata con successo. <BR><HR>";
mysql_select_db("Alimentari") or exit("Errore db Alimentari");
echo "Alimentari è db di default. <BR><HR>";
$conn mancante in:
// ---- Costruzione del comando SQL
mysql_select_db( )
$sqlcmd = "CREATE TABLE Clienti("
mysql_query( )
. "IDCliente Varchar(10) PRIMARY KEY,"
. "Nome
Varchar(30),"
. "Cognome
Varchar(30) )";
// ---- Esecuzione del comando SQL e fine connessione
mysql_query( $sqlcmd ) or exit("Errore in creazione Clienti");
echo "Tabella Clienti creata con successo. <BR><HR>";
mysql_close($conn);
?>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
16
Operazioni sul database (5)
/****************************************************************
* Approcci alternativi in caso di errore
*
*
mysql_errno() restituisce il codice di errore oppure 0
*
mysql_error() restituisce un messaggio di errore o
*
la stringa vuota
****************************************************************/
// ---- Esecuzione del comando SQL
mysql_query( $sqlcmd );
Visualizzare il
comando
eseguito
è una buona
prassi
if ( mysql_errno() == 0 ){
echo "Comando eseguito con successo.";
} else {
echo "Errore nel comando: <BR> $sqlcmd <BR>";
echo mysql_error();
}
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
17
Operazioni sul database (6)
InserisciCliente.php
<?php
// ---- apertura della connessione con MySQL su Alimentari
$idcliente = "farigian";
$nome = "Gianfranco";
$cognome = "Farinoni";
// ---- Costruzione del comando INSERT
$sqlcmd = "INSERT INTO Clienti VALUES ";
$sqlcmd .= "('$idcliente','$nome','$cognome')";
echo "Comando: $sqlcmd <BR>";
mysql_query( $sqlcmd );
if ( mysql_errno()== 0 ) {
echo "Comando eseguito con successo.";
} else {
echo "Errore nel comando: ", mysql_error();
}
// ---- chiusura della connessione
?>
Comando: INSERT INTO Clienti VALUES(‘farigian’,’Gianfranco’,’Farinoni’)
Comando eseguito con successo
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
18
6
Operazioni sul database (7)
ModificaCliente.php
$idcliente = "farigian"; $nome = "Gian Franco";
// ---- Costruzione del comando UPDATE
$sqlcmd = "UPDATE Clienti ";
$sqlcmd .= "SET Nome='$nome' ";
$sqlcmd .= "WHERE IDCliente='$idcliente'";
echo "Comando: $sqlcmd <BR>";
mysql_affected_rows( )
// ---- Esecuzione del comando e messaggi informativi
mysql_query( $sqlcmd );
if ( mysql_errno()== 0 ){
echo "Comando eseguito con successo.<BR>";
echo "Numero di righe modificate = ", mysql_affected_rows();
} else {
echo "Errore nel comando: <BR> $sqlcmd <BR>";
echo mysql_error();
}
Comando: UPDATE Clienti SET Nome='Gian Franco' WHERE IDCliente='farigian'
Comando eseguito con successo.
Numero di righe modificate = 1
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
19
Operazioni sul database (8)
CancellaCliente.php
<?php
// ---- apertura della connessione con MySQL su Alimentari
$idcliente = "farigian";
// ---- Costruzione del comando DELETE
$sqlcmd = "DELETE FROM Clienti ";
$sqlcmd .= "WHERE IDCliente = '$idcliente'";
echo "Comando in esecuzione: $sqlcmd <BR>";
// ---- Esecuzione del comando
mysql_query($sqlcmd) or exit("Errore nel comando DELETE");
echo "Comando eseguito con successo.<BR>";
// ---- chiusura della connessione
?>
Comando: DELETE FROM Clienti WHERE IDCliente='farigian'
Comando eseguito con successo.
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
20
Operazioni sul database (9)
InserisciOrdine.php
$data
= "2006-10-05";
$cliente = "farigian";
mysql_insert_id( )
// ---- Costruzione del comando INSERT
$sqlcmd = "INSERT INTO Ordini VALUES ";
$sqlcmd .= "( null, '$data', '$cliente' )";
echo "Comando: $sqlcmd <BR>";
// ---- Esecuzione del comando e messaggi
mysql_query( $sqlcmd );
if ( mysql_errno()== 0 ){
$id = mysql_insert_id();
echo "Ordine inserito con successo.<BR>";
echo "IDOrdine = $id";
} else {
echo "Errore nel comando: <BR> $sqlcmd <BR>";
echo mysql_error();
}
Comando: INSERT INTO Ordini VALUES ( null, '2006-10-05', 'farigian' )
Ordine inserito con successo.
IDOrdine = 1
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
21
7
Interrogazioni sul database (1)
$risultato = mysql_query(“SELECT * FROM Ordini”)
$risultato: false oppure un oggetto dal quale si estraggono le righe
della risposta con
mysql_fetch_array( $risultato )
mysql_fetch_array( )
restituisce false oppure la
prossima riga in
un array associativo
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
22
Interrogazioni sul database (2)
E’ utile pensare a $risultato come alla tabella restituita da SELECT: gli indici
dell’array associativo $risultato sono i nomi delle colonne della tabella.
<?php
// ---- attenzione alle colonne quando sono rinominate
$sqlcmd = “SELECT IDOrdine AS Numero, Data, “
. “Cliente AS CodiceCliente FROM Ordini”;
$risultato = mysql_query( $sqlcmd);
if (! $risultato) exit( "Errore nel comando SELECT" );
$riga = mysql_fetch_array($risultato);
$id
= $riga["Numero"];
$data
= $riga["Data"];
$cliente = $riga["CodiceCliente"];
..
?>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
23
Interrogazioni sul database (3)
/**************************************************************
due modi per estrarre tutte le righe dal risultato
**************************************************************/
// ----- recupera la prima riga
$riga = mysql_fetch_array($risultato);
while ($riga)
{
// ----- Operazioni sulla riga
// ----- Estrazione della prossima riga
$riga = mysql_fetch_array($risultato);
}
mysql_num_rows( $risultato )
// ----- sapendo quante sono le righe ...
for ($volte = 0; $volte<mysql_num_rows($risultato); $volte++)
{
$riga = mysql_fetch_array($risultato);
// ----- Operazioni sulla riga
}
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
24
8
Interrogazioni sul database (4)
<?php
// ---- connessione al database Alimentari
$reparto = "alimsur";
Prodotti del reparto
“alimsur”
// ---- Costruzione del comando SELECT
$sqlcmd = "SELECT IDProdotto, Descrizione, Prezzo ";
$sqlcmd .= "FROM Prodotti ";
$sqlcmd .= "WHERE Reparto = '$reparto' ";
echo "Comando SELECT: $sqlcmd <HR Size=4>";
// ---- Interrogazione e gestione dell'errore
$risultato = mysql_query( $sqlcmd );
if (! $risultato)
exit("Errore nell'interrogazione: <BR> $sqlcmd ");
// ---- Estrazione della prima riga e iterazione
$riga = mysql_fetch_array( $risultato );
if (!$riga) exit("Non ci sono prodotti in $reparto ");
//-------------------------------------------------------------//------ $riga OR exit("Non ci sono prodotti in $reparto ");
//-------------------------------------------------------------. . .
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
25
Interrogazioni sul database (5)
. . .
while ( $riga ) {
Prodotti del reparto
// ---- Visualizzaione della riga
“alimsur”
$idprodotto = $riga["IDProdotto"];
$descrizione = $riga["Descrizione"];
$prezzo
= $riga["Prezzo"];
echo "Codice = $idprodotto, Descrizione = $descrizione,
Prezzo = $prezzo <HR>";
// ---- Estrazione della prossima riga
$riga = mysql_fetch_array( $risultato );
}
echo "Numero prodotti = ", mysql_num_rows($risultato);
// ---- Chiusura della connessione
?>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
26
Interazione con Form HTML (1)
Per mostrare queste funzionalità consideriamo il caso di un utente che
vuole effettuare acquisti presso un’azienda che commercializza prodotti
alimentari on line e, tramite un form, richiede l’elenco dei prodotti del
reparto desiderato.
Lo script di risposta visualizza i prodotti del reparto scelto, con codice,
descrizione e prezzo. L’utente a questo punto effettua un ordine
comunicando codice e quantità di un prodotto desiderato e i propri dati.
Vedi le pagine HTML e Php nei seguenti file:
•
•
•
RichiestaElencoProdotti.html
ProdottiReparto.php
RegistraOrdine.php
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
27
9
Interazione con Form HTML (2)
RichiestaElencoProdotti.html
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
28
Interazione con Form HTML (3)
ProdottiReparto.php
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
29
Interazione con Form HTML (4)
. . .
ProdottiReparto.php
<?php
. . .
// ---- Costruzione del comando SELECT
$sqlcmd = "SELECT IDProdotto, Descrizione, Prezzo ";
$sqlcmd .= "FROM Prodotti ";
$sqlcmd .= "WHERE Reparto = '$reparto' ";
// ---- Interrogazione e gestione dell'errore
$risultato = mysql_query( $sqlcmd );
$risultato OR exit("Errore nell'interrogazione: <BR> $sqlcmd ");
if ( mysql_num_rows($risultato)==0 )
exit("Non ci sono prodotti nel reparto $desrep");
?>
<TABLE BORDER=1 CELLPADDING=4>
<TR>
<TH>Codice</TH>
<TH>Descrizione</TH>
<TH>Prezzo</TH>
</TR>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
30
10
Interazione con Form HTML (5)
ProdottiReparto.php
<?php
while ( $riga=mysql_fetch_array($risultato) )
{
$idprodotto = $riga["IDProdotto"];
$descrizione = $riga["Descrizione"];
$prezzo
= $riga["Prezzo"];
echo "<TR>";
echo "<TD>$idprodotto</TD>";
echo "<TD>$descrizione</TD>";
echo "<TD>$prezzo</TD>";
echo "</TR>";
}
echo "</TABLE><BR>";
echo "Numero prodotti = ", mysql_num_rows($risultato);
echo "<BR><HR>";
// --------------- Chiusura della connessione
mysql_close($conn);
?>
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
31
Interazione con Form HTML (6)
ProdottiReparto.php
<STRONG>
Per ordinare un prodotto compili il modulo e faccia clic su:
Invia Ordine
</STRONG>
<FORM ACTION="http://127.0.0.1/RegistraOrdine.php" METHOD="POST" >
<INPUT Type="text" NAME="idprodotto" SIZE=10> Codice Prodotto<BR>
<INPUT Type="text" NAME="quantita" VALUE="1" SIZE=4> Quantità<BR>
<INPUT Type="text" NAME="cliente" SIZE=4> Codice Cliente<BR>
<INPUT Type="text" NAME="nome" SIZE=20> Nome
<INPUT Type="text" NAME=cognome SIZE=20> Cognome
<HR> <BR>
<INPUT TYPE="submit" VALUE="Invia Ordine">
<INPUT TYPE="reset" VALUE="Annulla">
</FORM>
. . .
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
32
Interazione con Form HTML (7)
RegistraOrdine.php
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
33
11
Validazione dei dati (1)
I dati inviati dagli utenti devono essere controllati sia per ragioni di sicurezza, sia
per prevenire malfunzionamenti dovuti a valori inattesi o irragionevoli dei dati
trasmessi erroneamente o maliziosamente dagli utenti
• Controlli lato client (eseguiti dal browser) richiedono Javascript
• Controlli lato server Web eseguiti da script PHP
• Controlli lato server database sono i vincoli d’integrità ecc.
Se RegistraOrdine.php riceve come parametri: un codice prodotto corretto, il
carattere “d” come quantità e il valore nullo per cliente, lo script invia il seguente
messaggio:
Prodotto ordinato: Zuppa di pesce
Prezzo unitario: 6.30
Quantità ordinata: d
Importo ordine: 0
Registra un ordine
senza cliente e con
quantità uguale a 0
------------------------------------------------------------------Ordine registrato alle 05:58:06 del giorno: 09-02-2006
Cliente:
Identificativo ordine: 13/8
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
34
Validazione dei dati (2)
Per controllare l’esatta natura dei valori trasmessi usiamo il codice:
$idprodotto = $_POST["idprodotto"];
$quantita
= $_POST["quantita"];
$cliente
= $_POST["cliente"];
echo "prodotto = "; var_dump($idprodotto); echo "<BR>";
echo "quantita = "; var_dump($quantita); echo "<BR>";
echo "cliente = "; var_dump($cliente); echo "<BR>";
if ($quantita > 0 )
echo "maggiore <BR>";
else
Controlli su:
echo "minore uguale <BR>";
stringhe nulle,
echo "quantita = ", $quantita*1, "<BR>"; e valori opportuni in base al
“contesto” nel quale si opera
•
•
•
•
I dati arrivano sempre allo script come stringhe di caratteri
I dati omessi arrivano come stringhe vuote: “”
Se un parametro inizia con caratteri di tipo numerico viene gestito come valore numerico
Se un parametro inizia con caratteri non numerici oppure è la stringa nulla diventa 0 nel
calcolo di espressioni numeriche
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
35
Validazione dei dati (3)
Validazione dei caratteri inseriti. Per esempio: sono validi solo caratteri alfanumerici.
$user = $_POST["utente"];
$pwd
= $_POST["password"];
$ammessi = "abcdefghijklmnopqrstuvwxyz"
. "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
$userok = true;
for( $pos=0; $pos<strlen($user) && $userok; $pos++ ) {
$car = substr($user, $pos, 1);
if ( strpos($ammessi, $car) === false ) $userok = false; }
$pwdok = true;
for( $pos=0; $pos<strlen($pwd) && $pwdok; $pos++ ) {
$car = substr($pwd, $pos, 1);
if ( strpos($ammessi, $car) === false ) $pwdok = false; }
if ($userok && $pwdok )
{ accesso ai dati }
else
echo "Inserimento dati non corretto”;
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
===
!==
Confronto per
valore e tipo
36
12
Validazione dei dati (4)
Validazione dei caratteri inseriti. Per esempio: certi termini non sono ammessi
$user
= $_POST["utente"];
$vietate = array ("select", "insert", "update", "delete",
"drop",
"alter", "--",
"'");
$userok = true;
for( $k=0; $k <= 7 && $userok; $k++ )
{
if ( strpos($vietate[$k], $user) !== false ) $userok = false;
}
. . .
$CMD = “Select * From Utenti Where”
if ($userok && $pwdok )
. “User = ‘$user’ and Psw = ‘$pwd’”
{ accesso ai dati }
else
Cosa succede se l’utente come user o
echo "Inserimento dati non corretto”;
password inserisce:
1’ OR ‘1’ = ‘1
Per impedire l’SQL injection si usano appunto il controllo dei caratteri o delle parole immesse
oltre alla applicazione della funzione: mysql_real_escape_string( .... ) che sostituisce ai
caratteri speciali le rispettive sequenze di escape.
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
37
Esercizi
1.
Scrivere uno script per inserire righe nella tabella Clienti di un database. La tabella ha il seguente schema:
Clienti(IDCliente, Nome, Cognome) e tutti i campi sono di tipo Varchar.
2.
3.
4.
Scrivere uno script per modificare i dati inseriti nella tabella Clienti del precedente esercizio.
Scrivere uno script per cancellare una riga inserita nella tabella Clienti dell’esercizio 1.
Scrivere uno script per modificare o cancellare un record della tabella Clienti dell’esercizio 1. Lo script deve
visualizzare il comando eseguito e in caso di errore nel comando deve inviare un messaggio con la descrizione e il
numero dell’errore. Provatelo cercando di cancellare o modificare un record inesistente.
5.
Scrivere uno script per inserire righe nella tabella Prodotti di schema: Prodotti(IDProdotto, Descrizione,
Categoria, Prezzo) con la chiave auto_increment. Visualizzare il comando eseguito e il valore assunto dalla
chiave.
6.
La tabella Atleti di un database contiene le informazioni sui concorrenti a una gara sportiva internazionale. Costruire
la pagina Web per visualizzare l’elenco alfabetico con cognome e nome degli atleti di una nazione prefissata.
7.
Data una tabella Anagrafica di un database, costruire la pagina Web che visualizza, ordinata alfabeticamente, il
cognome e nome delle persone che abitano in una data provincia fornita dall’utente tramite un form HTML.
8.
Creare una pagina PHP per inserire un nuovo studente nel database della segreteria fornendo i dati tramite il form di
una pagina HTML.
9.
Data la tabella Clienti di schema: ( Codice, Cognome, Nome, Indirizzo, CAP, Email ), si costruisca uno script che
riceve, tramite un form HTML il codice di un cliente e ne controlla l’esistenza in Clienti.
Se il cliente è in archivio lo script ne visualizza i dati in un form con il quale è possibile aggiornare i dati del cliente.
.
Se il cliente non è in archivio lo comunica con un messaggio
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
38
// ---------------------------------------------------------------------------------//----- Esercizi sulla tabella TCambi che generalizza CalcolaValuta.php
// ---- Apertura della connessione etc. omessa
// ---------------------------------------------------------------------------------$sqlcmd
= “SELECT Divisa, Valore ";
. “FROM TCambi”;
echo "Comando: $sqlcmd <BR>";
//----------------------------------------------------$TCambi = mysql_query( $sqlcmd );
if (! $TCambi) exit( "Errore nel comando SELECT" );
//-----------------------------------------------------$riga = mysql_fetch_array($TCambi);
while ($riga) {
$divisa = $riga[“Divisa”];
$valore = $riga[“Valore”];
/*--------------------------------* elemento di array $valute
*---------------------------------*/
$valute[$divisa] = $valore;
$riga = mysql_fetch_array($TCambi);
}
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
39
13
// ---- Esecuzione dell’interrogazione ….
echo "<HR>";
echo “<h2>Valute in archivio</h2><br />”
echo "<table border>";
echo "<tr> <th>Divisa</th> <th>Valore</th> </tr>";
$riga = mysql_fetch_array($TCambi);
while ($riga) {
$divisa = $riga[“Divisa”];
$valore = $riga[“Valore”];
echo "<tr> <td>$divisa</td> <td>$valore</td> </tr>";
$riga = mysql_fetch_array($TCambi);
}
echo "</table>";
echo "<HR>";
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
40
// --------------------------------------// cancellazione di una riga di TCambi
// --------------------------------------$divisa = $_GET(divisa);
$divisa = Maiuscolo( trim($divisa) );
if ($divisa = “EURO”) exit(“Operazione non ammessa per Euro”);
// ----
Apertura conessione e scelta del DB omessi
$sqlcmd
= "DELETE FROM TCambi";
. "WHERE Divisa = '$divisa'";
echo "Comando in esecuzione: $sqlcmd <BR>";
mysql_query($sqlcmd) or exit("Errore nel comando DELETE");
echo "Comando eseguito con successo.<BR>";
// ---- chiusura della connessione omessa
Elaborazione automatica dei dati - Enrico Cavalli - Università di Bergamo
41
14