Figura 300.7. Il messaggio può essere personalizzato nella dichiarazione della classe. Notare che i messaggi di errori dell'interprete non compaiono.
|
|
[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico] [volume] [parte]
Una caratteristica del PHP è la capacità di gestire direttamente i principali serventi di base di dati tramite connessioni dirette senza l'utilizzo di strati intermedi quali ODBC (anche se gestiti perfettamente) o JDBC; una volta installato l'interprete in modo corretto, si è in grado di connettersi a qualunque base di dati(1). Si va da ORACLE a MSSQLServer a DB2 per arrivare ai più diffusi e leggeri MySQL e PostgreSQL.
La scelta di MySQL per gli esempi della guida non è casuale bensì obbligata visto il successo avuto negli ultimi anni da questo DBMS(2) che vanta una leggerezza e grandi prestazioni anche se non dispone di tutte le caratteristiche e funzionalità dei concorrenti di fascia superiore. Inoltre è distribuito liberamente in Internet ed è facile da installare e configurare.
Per lo sviluppo di progetti di medie dimensioni, dunque, MySQL risulta un'ottima scelta; per questo motivo i siti Internet che lo utilizzano aumentano a vista d'occhio incoraggiandone lo sviluppo.
Tutto ciò che verrà trattato di seguito con applicazioni pratiche riguarderà MySQL.
Il PHP è in grado di gestire le base di dati mediante un linguaggio d'interrogazione strutturato chiamato SQL(3) che tramite una sintassi standard permette di effettuare tutte le operazioni necessarie sui dati contenuti in archivio, inserimenti, modifiche, cancellazioni, selezione e quanto altro. Verrà data per scontata una conoscenza di base dell'SQL e si procederà con la trattazione di problematiche legate al suo utilizzo tramite il PHP.
Le base di dati sono strutture progettate e realizzate con lo scopo di immagazzinare e gestire grandi moli di dati. Mediante particolari algoritmi di ricerca vengono forniti i dati richiesti in breve tempo senza doversi preoccupare di come essi vengono scritti e letti sul disco, in altre parole si può pensare alla base di dati come ad un magazzino al quale ci si rivolge per depositare e ritirare del materiale senza doversi preoccupare di dove e come esso viene archiviato. Nel momento del bisogno basterà solo richiedere il materiale al "magazziniere" che saprà dove e come prendere i dati e come fornirceli in maniera leggibile.
Una volta creata la base di dati e attivate le politiche di accesso ciò di cui si necessita per operare sui dati è:
Indirizzo IP. L'indirizzo IP dell'elaboratore che ospita il DBMS MySQL;
Nome della base di dati. Ogni base di dati viene identificata mediante un nome;
Username. Il nome dell'utente abilitato alla manipolazione dei dati contenuti nella base di dati;
Appare chiaro che questi dati sono importanti e vanno tenuti segreti ma è altrettanto chiaro che potrebbero cambiare per motivi di sicurezza o per necessità di manutenzione; tale aspetto non va sottovalutato durante la progettazione e la scrittura del codice. Un consiglio è quello di concentrare in un unico file tutti i parametri necessari alla connessione alla base di dati, tale file verrà poi incluso all'inizio di ogni pagina dalla quale si voglia effettuare una connessione al database.
In una situazione estrema potrebbe cambiare addirittura il tipo di DBMS utilizzato, in questo caso se si rispettano gli standard e si disegna il codice in modo intelligente con poche modifiche si può continuare ad utilizzare la stessa applicazione PHP pur cambiando il tipo di base di dati in gioco. Questo tuttavia è un esempio estremo e se non si hanno necessità particolari(4) di progettazione conviene disegnare l'applicazione intorno alla base di dati in modo da sfruttare al massimo le prestazioni del DBMS.
Un buon metodo di procedere è quello di inserire uno strato tra le funzioni del PHP e la nostra programmazione, ad esempio una classe che gestisce l'interazione con la base di dati, in questo modo il codice è meno rigido e permette di apportare modifiche in modo meno laborioso.
Un esempio pratico. Le fasi principali di una interrogazione ad una base di dati sono le seguenti:
|
Osserviamo nel dettaglio la gestione della connessione ad una base dati nel caso di MySQL:
|
Mentre nel caso di PostgreSQL:
|
Le differenze sono lampanti, PostgreSQL richiede molti parametri in più, inoltre effettua una connessione direttamente ad una particolare base di dati mentre in MySQL il nome del database va specificato al momento dell'esecuzione della query SQL.
Si pensi ad un sito moderno con molti contenuti, ad esempio un portale che in ogni pagina esegue almeno una connessione per estrarre i dati da visualizzare dalla base di dati; è impensabile scrivere codice come quello visto sopra in ogni pagina del sito, se solo cambiasse la password si dovrebbero modificare tutte le pagine interessate.
A questo punto dovrebbe essere chiaro che l'ideale è la realizzazione di una classe da includere all'inizio di ogni pagina PHP che necessita di una connessione alla base di dati, in cui implementare tutte le funzionalità necessarie.
I problemi precedentemente posti sono risolti. Se dovessero cambiare i parametri basterebbe modificare un solo file, quello contenente la dichiarazione della classe, impostando i nuovi valori. Se dovesse cambiare il DBMS basterebbe riscrivere il codice della classe mantenendo invariati gli standard di definizione e funzionamento dei metodi, in questo modo tutti gli oggetti continuerebbero a funzionare. Non sempre questo passaggio è possibile, tutto dipende da come viene scritto il codice.
Nelle pagine seguenti verrà implementata una classe utile per la gestione di base di dati MySQL dando per scontata la procedura di creazione della base di dati utilizzata negli esempi che seguiranno la parte teorica.
Per gli esempi pratici della guida verrà utilizzata una piccola e semplice base di dati dal nome brdp_esempio_1 il cui script di creazione è reperibile al seguente indirizzo in formato.tgz: <http://www.urcanet.it/brdp/php_manual/esempi/cap_8/sql_1.tgz> o se si preferisce il formato .zip: <http://www.urcanet.it/brdp/php_manual/esempi/cap_8/sql_1.zip>
In questa sezione verrà trattata la classe database, distribuita sotto licenza GNU/GPL, che gestisce la connessione e l'interazione con le base di dati, in questo caso di tipo MySQL ma un utile esercizio potrebbe essere la riscrittura della classe per un altro DBMS, ad esempio PostgreSQL.
La versione completa della classe può essere scaricata nei formati .tgz e .zip dai seguenti indirizzi: <http://www.urcanet.it/brdp/php_manual/esempi/cap_8/brdp_db_php.tgz> e <http://www.urcanet.it/brdp/php_manual/esempi/cap_8/brdp_db.zip>
Ecco un estratto del codice della classe.
|
Si inizi con l'analizzare la struttura della classe. Il costruttore ammette quattro parametri, ovvero i parametri necessari alla connessione con la base di dati; essi possono essere scritti in modo diretto nella classe o impostati in altri file di configurazione da includere prima di essa. Nei nostri esempi inseriremo i parametri nella classe e la includeremo come libreria al principio di ogni script che necessita di interfacciarsi con una base di dati.
Dal modo in cui vengono passati i parametri al costruttore si capisce che la classe gestirà una base di dati di default ma sarà in grado di interrogarne anche altre tramite oggetti dichiarati con parametri diversi. Per comprendere meglio il concetto ecco un esempio:
|
I due oggetti creati lavoreranno in modo analogo con gli stessi metodi ma su due base di dati diverse, tuttavia conviene dichiarare sempre i parametri in modo centralizzato, magari in un array prima della classe, in questo modo sarà sempre semplice modificare i valori necessari alla connessione.
Una volta creato l'oggetto bisogna connettersi al DBMS; va sottolineato che l'accesso alla base di dati è di tipo concorrenziale e che c'è un limite alle connessioni che possono essere mantenute aperte contemporaneamente dal servente, quindi è bene chiudere sempre la connessione e prima possibile.
|
Come è facile intuire, con il metodo connetti() viene aperta la connessione che può essere chiusa tramite il metodo disconnetti(). Se il DBMS è in ascolto e i parametri per la connessione, nonchè la base di dati, sono corretti l'esempio dovrebbe mostrare una schermata bianca, in caso contrario una pagina simile a quella in figura 300.7.
|
Figura 300.7. Il messaggio può essere personalizzato nella dichiarazione della classe. Notare che i messaggi di errori dell'interprete non compaiono.
|
Dunque una volta connessi è possibile interrogare la base di dati mediante la sintassi SQL e il metodo esegui($query_sql) che ritorna un valore falso se ci sono problemi durante l'esecuzione della query.
In particolare il PHP restituisce il risultato di operazioni di tipo SELECT in array associativi a due dimensioni strutturati con il nome del campo e il numero di righe partendo da 0. In pratica, una query di questo genere: SELECT nome, cognome FROM BRDP_TB_UTENTI LIMIT 0, 3 eseguita sulla base di dati di prova brdp_esempio_1 restituisce questo risultato:
+----------+---------+ | nome | cognome | +----------+---------+ | Gianluca | Giusti | | Mirko | Simeoni | | Fabio | Ferri | +----------+---------+ |
Viene estratto sotto forma di array associativo di dimensione 2x3 i cui valori possono essere "letti" tramite il metodo leggi($numero_riga,$nome_campo). Per conoscere il numero di righe restituite dalla query basta utilizzare il metodo righe(). Ricapitolando la procedura è la seguente:
|
Il risultato è simile a:
0) Nome: Gianluca 1) Nome: Mirko 2) Nome: Fabio |
Va notato che lo script non mostra il cognome, è compito del lettore completare l'esempio.
Una volta creato l'oggetto e stabilita la connessione viene impostata la query da eseguire sulla base di dati, tramite un controllo if ne viene verificata l'esecuzione, se non è falsa allora cicla i valori estratti tramite un ciclo for. Per la precisione andrebbe inserito un else alla riga 17 per segnalare eventuali errori nell'esecuzione, anche questo ultimo ritocco è lasciato come esercizio al lettore.
Va sottolineato che le righe dell'array partono con indice 0.
Per concludere, la classe comprende altri due metodi query2select e getlast_id che verranno trattati in seguito tramite degli esempi. Il primo esegue una query e formatta il risultato nel contenuto di una SELECT HTML mentre il secondo restituisce il valore dell'ID generato (in modalità "auto_increment") nell'ultimo inserimento effettuato tramite la connessione in uso dall'oggetto.
Per gli esempi di utilizzo della classe verrà utilizzata la base di dati chiamata brdp_esempio_1 che è possibile riprodurre fedelmente tramite lo script reperibile all'indirizzo riportato nella sezione 300.1.
La base di dati è molto semplice ed è composta da due tabelle strutturate come di seguito:
|
La prima BRDP_TB_UTENTI contiene i dati relativi a degli utenti fittizi che potrebbero avere a disposizione la possibilità di gestire una loro rubrica, mentre BRDP_TB_AGENDA contiene i contatti degli utenti relazionati tramite il valore BRDP_TB_AGENDA.id_utente all'utenza BRDP_TB_UTENTI.id_utente. La struttura è molto semplice e serve solo come appoggio per gli script di esempio inquanto la complessità delle query in gioco non cambia il concetto.
Come primo passo nel file index.php raggiungibile a questo indirizzo: <http://www.urcanet.it/brdp/php_manual/esempi/cap_8/index.php> viene eseguita una semplice query che restituisce tutti gli utenti con campo attivo = 1. Spesso si preferisce non rimuovere fisicamente, dati non sensibili, dalla base di dati ma eliminarli logicamente ovvero tramite un campo convenzionalmente impostato a zero. In questo caso il campo che discrimina l'esistenza o meno dell'utente è il campo "attivo", se contiene valore pari a 0 l'utente non è attivo, se è 1 allora va visualizzato in elenco.
di seguito il codice del primo esempio:
|
Come prima cosa alla riga 3 viene inclusa la classe di gestione della base di dati, da tale riga in poi sarà possibile istanziare oggetti di tipo database ed usarne tutti i metodi.
Alla riga 5 viene creata l'istanza $db alla classe database. Di seguito alla riga 6 il primo utilizzo del nuovo oggetto con l'apertura della connessione alla base di dati predefinita. Come visto precedentemente questo è il passo che permette in caso di necessità di specificare parametri di connessione diversi da quelli predefiniti e impostati nella classe di connessione nel file brdp_db.php.
Nella riga 7 viene assegnata alla variabile $sql la query come una semplice stringa, questa variabile sarà poi fornita al metodo di esecuzione.
Segue del semplice codice HTML mentre alla riga 31 viene mostrata la query che verrà eseguita in fase di interrogazione.
Prima di approfondire la parte più interessante dell'esempio è bene ricordare l'importanza della gestione degli errori. In questo caso la query è statica dunque una volta testatone il funzionamente non si dovrebbero avere problemi inquanto non cambierà nel tempo, spesso però tali stringhe vengono composte usando parametri ricevuti da altre pagine e questo aumenta le probabilità di errore dovuti a eccezioni non gestite. La classe in ogni caso nasconde ogni tipo di errore dell'interprete PHP ma per realizzare un codice professionale non basta, bisogna anche informare il visitatore di cosa sta succedendo o comunque informarlo della generazione di un errore.
L'esecuzione della query avviene alla riga 40 ed avviene all'interno di un'istruzione if, questo perchè il metodo torna un valore falso in caso di errore e di conseguenza mostra al visitatore il messaggio della riga 55.
Se la query viene eseguita senza errori l'interprete continua con l'esecuzione della riga 41. Nell'esempio in oggetto viene eseguita una SELECT dunque il risultato sarà un array associativo con 5 colonne ed n righe. A priori non si conosce il numero di voci restituite dalla query per questo, alla riga 41, prima di visualizzare le voci viene controllata la quantità di righe tramite il metodo righe(), se è zero viene informato il visitatore che non sono state trovate voci in archivio altrimenti viene mostrato il risultato.
Dalla riga 42 alla 50 viene visualizzato il risultato della SELECT mediante un ciclo for. È importante notare come si parta dal valore 0 e si incrementi $db->righe() volte.
I valori vengono visualizzati mediante il metodo leggi() che accetta il numero di riga da leggere e il nome della colonna (campo della tabella) da estrarre. Il funzionamento è semplice e intuitivo, e si può trattare il metodo come una semplice variabile ad esempio leggendo l'i-esimo nome come di seguito:
|
Mentre si visualizza il risultato vengono costruiti dinamicamente i collegamenti alle pagine di dettaglio e agenda relative all'utente in oggetto. Il risultato dello script è riportato in figura 300.14.
|
Figura 300.14. L'elenco utenti e i collegamenti vengono creati dinamicamente in seguito all'interrogazione della base di dati.
|
Nella programmazione di tutti i giorni si ripetono molte operazioni: una, ad esempio, è la realizzazione di una lista partendo dai dati contenuti in una o più tabelle di una base di dati. Il metodo query2select permette di formattare i dati ottenuti tramite una SELECT SQL in una SELECT HTML. Il risultato è mostrato in figura 300.16.
Il codice per ottenere tale risultato è il seguente:
|
Il codice è molto simile all'esempio precedente, quindi non necessita di particolari spiegazioni. La parte da analizzare è la riga 40 dove viene utilizzato il metodo in analisi; i parametri da passare sono cinque: la stringa contenente la SELECT SQL, il campo da mostrare nella SELECT HTML (in questo caso nome), il campo da impostare come valore dell'attributo value della scelta HTML. Il metodo inoltre accetta un eventuale valore da impostare come selezionato se trovato tra i valori estratti dalla base di dati (se falso allora nessun valore sarà selezionato). Infine si trova il metodo di risposta, ovvero il modo in cui il risultato deve essere restituito; se il parametro è vero mostra a video i dati estratti e formattati, altrimenti se è falso li ritorna come valore.
|
Figura 300.16. Il metodo query2select esegue la query e restituisce direttamente valori in una SELECT HTML.
|
Analizzando il sorgente della pagina visualizzata sul navigatore si capisce meglio il funzionamento e l'utilizzo dei parametri passati al metodo. Questo è ciò che viene generato dal metodo:
|
Se la riga 40 fosse stata questa:
|
il risultato ottenuto sarebbe stato:
|
Ovvero l'utente "Rossi" sarebbe stato impostato come selezionato, questo risulta comodo nelle maschere di modifica dove esiste già un valore da visualizzare come predefinito.
Come anticipato nei capitoli precedenti le query possono essere composte dinamicamente utilizzando il PHP.
I collegamenti realizzati nel precedente esempio forniscono tramite il metodo get uno o più parametri alle pagine di destinazione. Si prenda in considerazione lo script dettagli.php che riceve il parametro utente. Tale pagina effettuerà una SELECT nella tabella BRDP_TB_UTENTI della base di dati estraendo i dati relativi all'utente con id_utente uguale al valore ricevuto in get da index.php. Con il codice seguente si otterrà il risultato mostrato in figura 300.21.
|
Oltre a cambiare il modo di formattazione del risultato, varia la costruzione della query; questa volta, infatti, viene assemblata usando un parametro ricevuto da un'altra pagina. Nell'esempio non vengono effettuati controlli sul valore di tale variabile, ma in circostanze più serie è buona norma verificare almeno il tipo di dato e se la variabile è nulla. Ad esempio, in questo caso ci si aspetta un valore intero (il codice utente). Il controllo viene lasciato come esercizio al lettore.
Nell'esempio la query è molto semplice ma spesso ci si trova ad operare con strutture più complesse e con vari parametri da filtrare per ogni interrogazione; in queste situazioni è importante gestire tutte le possibili eccezioni in modo da eliminare eventuali errori.
|
Figura 300.21. Con la condizione where viene selezionato un solo utente. La query viene generata dinamicamente.
|
In questo caso il risultato considerato corretto deve fornire una sola, riga dunque il controllo è quello della riga 41 oltre al solito sull'esecuzione alla riga 40.
Inoltre, essendo una sola riga non si ha bisogno di ciclare l'array; di conseguenza al metodo leggi() viene passato direttamente il valore 0 pari alla prima riga.
Come più volte sottolineato, questa non vuole essere una guida sull'SQL; tuttavia non esiste il solo comando SELECT ma è possibile inserire, aggiornare e rimuovere dei valori dalla base di dati, oltre a svariate altre operazioni che esulano dall'obiettivo di questa guida e che quindi non verranno trattate.
Di seguito verrà osservato il comportamento del PHP nel gestire istruzioni che non restituiscono dei valori, come nel caso del comando SELECT, ma che restituiscono un valore falso se qualcosa è andato storto.
Prima di analizzare il codice è bene ricordare che è di fondamentale importanza la gestione di eventuali errori e dei messaggi restituiti dal DBMS.
Si supponga di aver ricevuto dei dati da un modulo HTML e di voler inserire tali informazioni nella tabella dei contatti BRDP_TB_AGENDA. I dati da gestire sono: nome, cognome, email, telefono, fax e utente. Va ricordato che la tabella in oggetto è relazionata alla tabella BRDP_TB_UTENTI dunque la nuova riga che si andrà ad inserire dovrà in qualche modo riferirsi ad un utente contenuto nella tabella degli utenti. Il dato che permette di mantenere tale relazione è passato dal modulo con la variabile utente, che dunque deve essere un intero.
Questa è la porzione di codice che gestisce l'inserimento:
|
Va notato come i valori di tipo non numerico vadano racchiusi tra il singolo apice, mentre, i numerici possono essere passati direttamente.
L'indentazione della query non è obbligatoria, ma in casi di interrogazioni complesse aiuta ad individuare eventuali errori in fase di correzione: dunque è consigliata.
Il funzionamento del comando UPDATE è simile all'inserimento e permette di modificare uno o più campi di una tabella tramite le condizioni della clausula WHERE.
Di seguito un esempio di una porzione di codice SQL che gestisce un aggiornamento.
|
Come è facile notare, la gestione della query dal punto di vista dell'interprete PHP è del tutto identica alla INSERT ed alla DELETE che viene riportata di seguito.
|
Nelle operazioni di cancellazione e modifica è importante ponderare le condizioni altrimenti tutti i campi verranno interessati. Ad esempio, una query come: delete from BRDP_TB_AGENDA svuota la tabella BRDP_TB_AGENDA di tutto il suo contenuto.
A seguito di un'interrogazione è possibile ottenere informazioni più dettagliate, come il numero di righe interessate dall'operazione, o ancora gestire i singoli tipi di errori del DBMS. Per quanto interessante, questo aspetto esula dallo scopo della guida ma rimane un ottimo esercizio per quanti vogliano approfondire l'argomento.
Come esempio nei capitoli precedenti si è trattata la gestione di una semplice agenda multiutente; di seguito essa verrà completata in modo da aumentare la dimestichezza con gli argomenti fin qui trattati.
Nella directory contenente gli esempi - raggiungibile qui: <http://www.urcanet.it/brdp/php_manual/esempi/> - alla sezione riservata al capitolo 8, si trovano due file index.php e menu.php; tramite il primo si accede agli esempi visti fino ad ora, mentre scegliendo il secondo si tratteranno gli script di seguito implementati mediante i quali sarà possibile aggiungere, modificare e rimuovere i contatti dell'utente selezionato. Il codice visto fino ad ora e quello che segue non cura la parte estetica per non appesantire il codice con porzioni di HTML che renderebbero soltanto più faticosa la lettura del listato.
Partendo dal file menu.php, quello che si ottiene è una pagina di selezione simile a quella riportata in figura 300.25.
|
Figura 300.25. La pagina di selezione permette di scegliere l'operazione da effettuare sui contatti dell'utente associato.
|
Tramite questa pagina iniziale sarà possibile inserire, modificare e cancellare i contatti degli utenti attivi in archivio. Il codice dello script trattato è il seguente:
|
In linea di principio è molto simile alle precedenti, esegue, infatti, un'interrogazione alla base di dati e cicla tramite una struttura while i valori attenuti. Nel ciclo vengono anche creati i collegamenti alle pagine di gestione passando, in modo dinamico, l'identificativo dell'utente proprietario dei contatti. In particolare ci si riferisce alle righe 44, 45 e 46.
Di seguito si analizzerà l'inserimento di un nuovo contatto, effettuato tramite una maschera di inserimento dati che viene inviata ad una seconda pagina la quale effettua il salvataggio dei dati nella tabella BRDP_TB_AGENDA.
Il file inserisci_edita.php permette di editare i campi di testo che verranno spediti al file inserisci_salva.php, il quale salverà i dati in archivio senza effettuare controlli di alcun genere: dunque anche i campi vuoti saranno inseriti.
In un sito curato e sicuro vengono effettuati controlli Javascript al momento dell'inoltro del modulo, questo aspetto esula dallo scopo della guida ma è bene tenerlo presente al momento della scrittura di un codice efficiente e professionale.
Di seguito il listato della pagina contenente la maschera di inserimento:
|
Non ci sono particolari complicazioni, il codice è puro HTML che formatta il modulo. Va notato però che alla riga 24 viene passato in modo nascosto il valore dell'identificativo dell'utente proprietario del nuovo contatto, esso viene preso dall'array $HTTP_GET_VARS dei valori ricevuti tramite il metodo get e inviato alla pagina successiva.
Come è facile immaginare il risultato del listato appena visto è il seguente:
|
Figura 300.28. Da questa pagina è possibile inserire il nuovo contatto per l'utente precedentemente selezionato.
|
Il file inserisci_salva.php riceve i valori e li formatta nella sintassi SQL che effettua una INSERT nella tabella. Ecco il codice nel dettaglio:
|
Oltre alle normali operazioni di connessione, viene impostato come intero l'identificativo utente alla riga 8, poi dalla 10 alla 26 viene formattata la query per l'inserimento. Si noti ancora come i valori di tipo stringa vengono contenuti tra singoli apici, mentre i valori interi non hanno bisogno di limitatori; la stringa, inoltre, è generata dinamicamente in base ai valori ricevuti.
Alla riga 56 e 57 vengono effettuati due controlli che permettono di evitare comportamenti ambigui, anche quando il visitatore arriva per errore nella pagina senza aver seguito il percorso corretto, ad esempio in seguito all'apertura della stessa dall'elenco delle preferite. Questo per quanto riguarda il primo controllo; il secondo, invece, verifica la corretta esecuzione della query come più volte trattato.
Più interessante invece è la riga 60 nella quale viene estratto l'identificativo del contatto appena creato tramite il metodo getlast_id della classe database. Tale metodo è utilizzabile in caso di tabelle aventi come chiave primaria un intero autoincrementante ed è il caso della tabella in esempio; l'identificativo del nuovo contatto, infatti, non è stato specificato perchè sarà il DBMS ad assegnarlo in modo progressivo ad ogni nuova voce inserita. Ovviamente il valore è l'ultimo inserito dalla connessione attiva e non l'ultimo in assoluto dal momento che più visitatori in modo concorrente possono inserire valori nella tabella.
La pagina di salvataggio restituisce la seguente risposta:
|
Figura 300.30. La pagina informa l'utente dell'esito dell'operazione e in caso positivo mostra l'ID assegnato al nuovo contatto.
|
Oltre all'inserimento, è possibile eliminare e modificare voci già esistenti; di seguito verrà trattata la procedura di cancellazione. Come prima cosa va identificata univocamente la voce da rimuovere dall'archivio; tramite il menu iniziale cliccando sulla voce "cancella" associata ad uno degli utenti proprietari di una rubrica si passa il parametro utente alla pagina cancella_scegli.php. Tale file mostrerà tutti i contatti associati all'utente mediante il metodo query2select mostrando una scelta di questo tipo:
|
Figura 300.31. Tramite questa pagina è possibile scegliere il contatto da rimuovere.
|
Il codice, ormai familiare, per ottenere tale risultato è:
|
Il metodo trattato è stato ampliamente spiegato, da notare, ancora, la costruzione dinamica della query nella riga 8, al lettore il compito di implementare i controlli del caso.
Il modulo HTML trasmette il codice utente ottenuto in questa pagina insieme al codice del contatto scelto per essere rimosso. Di seguito il codice della pagina che effettua la rimozione.
|
Come al solito la query viene costruita utilizzando i parametri ricevuti dalla pagina precedente. Prima di procedere è bene far notare che un parametro ricevuto non viene utilizzato; questa non è una distrazione di chi scrive, è semplicemente compito del lettore inserirlo in modo corretto nella query. Ovviamente il funzionamento è garantito anche in questa versione del codice grazie all'univocità della chiave di identificazione del contatto.
Alla riga 40 viene controllato che sia stato specificato il codice della voce da rimuovere, senza controllare che si tratti di un intero. Si provi a modificare la barra dell'indirizzo assegnando una stringa al parametro rappresentante il codice del contatto per verificare la gestione dell'errore. Con l'aggiunta di un controllo si può gestire più in dettaglio l'anomalia, l'esercizio è lasciato al lettore.
Alla riga 41 viene controllata l'esecuzione dell'istruzione, il risultato di questo programma è il seguente:
|
Figura 300.34. Il risultato dell'operazione di rimozione.
|
Per rendere funzionante il prototipo di questa rudimentale rubrica non manca che implementare la parte di modifica dei contatti presenti in archivio. Partendo dal file principale menu.php, scegliendo la voce "modifica" si accede alla pagina modifica_scegli.php che permette di scegliere il contatto da editare; questa pagina è un clone di cancella_scegli.php, con l'unica differenza sulla pagina di destinazione a cui punta, dunque risulta inutile riproporne il codice. Ecco come si presenta:
|
Figura 300.35. Del tutto simile a cancella_scegli.php; a cambiare è la pagina di destinazione modifica_modifica.php.
|
La modifica avverrà tramite una maschera simile a quella di inserimento, con la differenza che i campi saranno valorizzati con i dati presenti nella base di dati, in modo che il visitatore possa modificare uno o più campi e salvare i nuovi valori. Il codice per ottenere tale risultato è il seguente:
|
L'interazione del PHP con l'HTML in questo esempio è più evidente. Una volta selezionati i dati dall'archivio vengono mostrati nei campi del modulo tramite le righe dalla 39 alla 43, mentre alle righe 36 e 37 vengono valorizzati i campi nascosti contenenti il valore del codice utente e del codice contatto.
Il controllo alla riga 34 è ormai chiaro, esso verifica che la query venga eseguita correttamente e che restituisca una sola riga. Se le due condizioni non si verificano contemporaneamente viene visualizzato un messaggio di errore. Questo è il risultato del codice appena visto:
|
Figura 300.37. Tramite il modulo è possibile modificare uno o più campi salvando i nuovi valori nella base di dati.
|
A questo punto il visitatore può modificare i campi che preferisce ed inviare il tutto alla pagina successiva che provvederà al salvataggio nella base di dati dei nuovi valori. Lo script che si occupa di questa ultima operazione è modifica_salva.php di cui viene riportato il codice di seguito:
|
Dalla riga 10 alla 20 viene costruita la query, la quale non è complessa ma richiede attenzione particolare come nel caso della cancellazione; infatti, se non viene specificata la condizione di WHERE corretta si rischia di apportare la stessa modifica a più righe. Nel caso peggiore si potrebbero modificare le righe della tabella rendendole tutte uguali se si omettesse la clausola di riga 18 e 19.
Il risultato è simile ai precedenti e viene riportato di seguito:
|
Figura 300.39. Viene visualizzata la query e mostrato l'esito della sua esecuzione.
|
Con la gestione delle modifiche si può considerare completa l'applicazione di esempio; essa ovviamente va presa come un ripetitivo utilizzo dei metodi della classe database ed ha come scopo unico quello di acquisire dimestichezza con la gestione delle base di dati tramite il PHP.
Come prima cosa non è stato minimamente tenuto conto dell'aspetto grafico e della impaginazione dei dati: non è una mancanza ma una scelta. In questo modo il codice è velocemente leggibile e si è evitato di perdere di vista l'obiettivo degli esempi. Ognuno poi nelle proprie applicazioni potrà integrare il codice nella veste grafica del proprio sito come meglio crede.
Per lo stesso motivo non sono stati implementati controlli Javascript per non divagare in argomenti non strettamente inerenti questa guida. Inutile dire che non si può fare a meno di tali controlli in un sito di qualità, l'invito quindi è a documentarsi anche su questo linguaggio se si vuole implementare un prodotto di qualità.
Tutti i controlli sui dati ricevuti dalle pagine di inserimento, cancellazione e modifica sono stati trascurati per lo stesso motivo sopra citato. Un esempio per tutti: un indirizzo email non può non contenere il carattere '@', come deve contenere per forza almeno un carattere '.' oltre alla lunghezza che non può essere inferiore a sette caratteri (a@bc.de ovviamente è un limite plausibile). Prima di inserire dati in un archivio è bene tenere conto di queste problematiche; si pensi, ad esempio, ad una anagrafica utenti di un negozio virtuale in cui la metà degli indirizzi email dei clienti registrati è falso o vuoto: non sarà possibile contattare in alcun modo gli utenti iscritti per campagne pubblicitarie sui nuovi prodotti.
Infine prima di iniziare a lavorare sulla base di dati tramite codice è bene assicurarsi di avere i permessi necessari per effettuare le operazioni eseguite nel codice. Se ad esempio l'utente con cui ci si collega (impostato nella classe) non ha i permessi di cancellazione, allora una query che effettua una DELETE non verrà mai eseguita, non a causa di problemi nel codice ma per mancanza di permessi nella configurazione del DBMS. Dunque, come prima cosa è bene testare il funzionamento dei vari comandi SQL da linea di comando prima di passare all'esecuzione degli stessi dal PHP.
Programmare in PHP --- Copyright © 2001-2003, 2005 Gianluca Giusti -- <brdp (ad) urcanet·it>
1) L'elenco delle base di dati gestite dal PHP è riportato nella sezione 293.2.
2) Acronimo di DataBase Management System ovvero il sistema di gestione delle base di dati.
3) Acronimo di Structured Query Lenguage.
4) È il caso di applicazioni Web generiche che devono essere personalizzabili secondo le necessità dettate da strutture già esistenti. Ad esempio un gestore di banner pubblicitari deve appoggiarsi su strutture già esistenti come quelle di un portale e spesso viene integrato nella base di dati a disposizione. In questo caso il prodotto deve gestire i diversi DBMS altrimenti resterebbe tagliato fuori da una o più fette di mercato.
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome il_php_e_le_base_di_dati.htm
[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [translators] [docinfo] [indice analitico]
