Siamo arrivati all’ultima puntata di questa guida base al linguaggio PHP, e per concludere affrontiamo oggi un argomento di sicuro non semplice ma che cercheremo di trattare in modo tale da fornire alcuni strumenti utili per la sua comprensione: stiamo parlando delle espressioni regolari. In una sola puntata non riusciremo a trattare l’argomento in modo completo al 100% ma con le nozioni che avremo alla fine potremo eseguire diverse operazioni.

Le espressioni regolari

Per iniziare possiamo dire che cosa sono e a che cosa servono le espressioni regolari. Si tratta di particolari costrutti che si usano per verificare se all’interno di una stringa (e quando in PHP si parla di stringa si intende anche un testo lungo e complesso) è presente una certa sottostringa. Potreste pensare che in realtà non ci sono novità perché abbiamo già visto, nella puntata dedicata alle funzioni sulle stringhe, come cercare e sostituire sottostringhe. In realtà le espressioni regolari sono uno strumento molto più potente perché non definiscono semplici sottostringhe ma, data la loro natura versatile, con un solo pattern (una sequenza di caratteri) possiamo cercare una grande varietà di sottostringhe.

Le espressioni regolari possono essere utili per moltissime situazioni: per esempio, nella puntata in cui parlavamo dei form abbiamo fatto un cenno alle espressioni regolari perché abbiamo detto che servono per controllare se l’utente inserisce un indirizzo email corretto. Questo infatti potrebbe essere un utilizzo, ma potremmo usare le espressioni regolari per altre operazioni, per esempio controllare se un dominio è stato scritto correttamente, evidenziare una certa occorrenza o un insieme di occorrenze in un testo, cercare tutte le etichette HTML presenti in un testo, sostituire doppi apici con virgolette, controllare la complessità di una password e via dicendo.

I metacaratteri

Entriamo subito nell’argomento e iniziamo a parlare di “metacaratteri”, ovvero di caratteri speciali inseriti all’interno di una espressione regolare e che sono dotati di un significato ben preciso. Per esempio la sequenza [a-z] indica “qualsiasi lettera minuscola compresa tra la a e la z”. Se volessimo invece trovare tutte le lettere non solo minuscole ma anche maiuscole dovremmo scrivere un’espressione come questa: [a-zA-Z]. Avrete quindi intuito che le parentesi quadre racchiudono un insieme di caratteri. Vediamo quali sono i metacaratteri:

I quantificatori

Esistono poi i quantificatori, che indicano quante volte bisogna cercare un’occorrenza all’interno della nostra stringa principale:

Alcuni esempi…

Facciamo alcuni esempi per comprendere meglio:

… e altri esempi, più pratici

E così via. A questo punto abbiamo quindi gli strumenti per creare dei pattern utili… partiamo dall’esempio più semplice, ovvero un pattern per validare una partita IVA che come tutti sappiamo è composta da undici numeri:

^[0-9]{11}$

Non facciamo altro che creare una sequenza [0-9] che indica un qualsiasi numero, e la facciamo seguire subito dalla sequenza {11} che indica che il numero deve obbligatoriamente occorrere undici volte. L’accento circonflesso e il dollaro indicano ovviamente l’inizio e la fine della stringa. Se omettessimo uno dei due, avremmo vanificato il controllo in quanto potremmo inserire un qualsiasi numero prima o dopo la nostra partita IVA e il pattern verrebbe comunque validato perché il nostro script non saprebbe da dove inizia o dove finisce la stringa.

Possiamo poi creare un pattern che controlli che un dato file sia un’immagine:

^.+\.(jpeg|jpg|png|gif)$

Abbiamo qui il punto che indica una qualsiasi sequenza di caratteri, seguito da un “vero” punto (per essere considerato tale, deve essere preceduto dal carattere di escape) e quindi dalle estensioni tipiche delle immagini “da web” (jpeg, jpg, png, gif) tra parentesi tonde e separate tra di loro per mezzo dell’operatore disgiuntivo.

Prendiamo poi, per esempio, un controllo per validare una data:

^[0-9]{1,2}\.[0-9]{1,2}\.[0-9]{4}$

In questo caso non facciamo altro che creare tre sequenze [0-9] rispettivamente per i giorni, i mesi e gli anni: nei primi due casi il numero può comparire da un minimo di una a un massimo di due volte e deve essere seguito da un punto (con cui separiamo i numeri della data… gusti personali) a sua volta preceduto da un backslash. Per quanto riguarda l’anno invece il numero deve essere obbligatoriamente presente quattro volte.

Più complesso invece è il pattern per validare un indirizzo email:

^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9_\.\-]+\.[a-z]{2,6}$

Nella prima sequenza tra parentesi quadre inseriamo tutti i caratteri alfanumerici insieme all’underscore, al punto e al trattino e indichiamo che possono ricorrere una o più volte attraverso l’uso del segno +, a fui facciamo seguire la chiocciola. Questa prima sequenza rappresenta il nome utente dell’indirizzo. Dopo la chiocciola inseriamo un’altra sequenza tra parentesi quadre simile alla prima e poi inseriamo il punto preceduto dal carattere di escape. Abbiamo quindi il nome del dominio, a cui facciamo seguire l’espressione [a-z] che può ricorrere da un minimo di 2 fino a un massimo di 6 volte: è nient’altro che l’estensione del dominio.

Le classi di caratteri

Per alcune delle espressioni che abbiamo utilizzato esistono poi le cosiddette “classi di caratteri”, ovvero caratteri che corrispondono a precise sequenze e che possono accorciare molto il nostro lavoro. Vediamone alcune:

Negli ultimi cinque casi, le parentesi quadre sono parte integrante della sequenza, quindi se vogliamo cercare i i segni di interpunzione nella nostra stringa il pattern dovrà essere strutturato in questo modo:

[[:punct:]]

Con le classi di caratteri, le stringhe per la validazione di partite IVA e indirizzi email, tanto per prendere due degli esempi che abbiamo fatto in precedenza, potrebbero diventare una cosa di questo tipo:

^\d{11}$

^\S+@[\w.-]+\.[a-z]{2,6}$

Espressioni regolari e PHP: preg_match e preg_replace

Ma come fare per eseguire il controllo nel nostro script PHP? Abbiamo bisogno di una funzione, preg_match, che riceve come parametri il pattern e la stringa da controllare e nel caso in cui nel testo ci sia almeno una coincidenza con il pattern, la funzione restituirà come risultato 1 (true), e in caso contrario il risultato sarà 0 (false).

Per esempio, poniamo il caso di uno script che controlla se un utente, attraverso un form, ha caricato un’immagine con estensione corretta (il nome dell’immagine sarà stato precedentemente memorizzato in una variabile $immagine).

if (preg_match('/^.+\.(jpeg|jpg|png|gif)$/', $immagine)) {
echo "Grazie per aver caricato l'immagine!";
}
else {
echo "L'immagine ha un'estensione non valida";
}

I due slash inseriti dopo gli apici del primo parametro della funzione sono i delimitatori: se non inseriti, lo script restituirà un errore. Il meccanismo della funzione è molto semplice: il blocco if controlla che il risultato sia true e in caso affermativo stampa la scritta “Grazie per aver caricato l’immagine!”, mentre in caso contrario la scritta mostrata all’utente sarà “L’immagine ha un’estensione non valida”.

La funzione può essere usata anche, ovviamente, nel modo inverso, al negativo, facendo precedere la funzione dal punto esclamativo che indica negazione:

if (!preg_match('/^[a-zA-Z0-9_\.\-]+@[a-zA-Z0-9_\.\-]+\.[a-z]{2,6}$/', $indirizzoemail)) {
echo "Indirizzo email non valido";
}
else {
echo "Indirizzo email valido!";
}

In questo caso abbiamo controllato un indirizzo email. La documentazione ufficiale della funzione preg_match si può trovare all’indirizzo http://php.net/manual/en/function.preg-match.php.

Abbiamo detto poi che attraverso le espressioni regolari possiamo poi anche fare sostituzioni all’interno di un testo. Questa operazione si può eseguire attraverso l’utilizzo della funzione preg_replace che riceve tre parametri: l’espressione regolare che definisce le sequenze da sostituire, la sottostringa sostituta e la stringa all’interno della quale compiere la sostituzione. Con un esempio banale:

$testo = "Cane, gatto, topo, cavallo, pecora, mucca";
echo preg_replace ("/[aeiou]/", "*", $testo);

Attraverso l’utilizzo della funzione preg_replace (il cui risultato sarà direttamente stampato attraverso echo) cerchiamo nella stringa $testo tutte le volte in cui occorre una vocale tramite la sequenza [aeiou], e sostituiamo ogni vocale con un asterisco. Questa funzione si presta a diversi utilizzi… per esempio, stiamo costruendo un blog e vogliamo censurare le parolacce dei nostri commentatori (farò un esempio… senza parolacce ma che funziona allo stesso modo).

$testo = "Il gatto mangia il topo";
echo preg_replace ("/(gatto|topo)/", "***", $testo);

In questo caso la parola “gatto” e la parola “topo” vengono sostituite dalla sequenza ***. Possiamo poi adoperare la funzione anche per sostituire etichette HTML:

$testo = "<strong>Ciao</strong>!!!!!";
$testo = preg_replace("/(<strong>)/", "<em>", $testo);
echo preg_replace("/(<\/strong>)/", "</em>", $testo);

In questo caso sostituiamo tutte le parole marcate in grassetto con parole marcate in corsivo. Questi non sono che alcuni esempi, e la versatilità delle espressioni regolari dà modo a ognuno di sfruttarle al meglio per le proprie esigenze. Per chiunque fosse interessato all’argomento, consiglio di approfondire facendo una ricerca sul web: si trovano davvero molti siti che sapranno spiegare meglio di me e in modo più completo l’utilizzo di questo affascinante strumento.

Ciao a tutti!!!

Benissimo, con la puntata di oggi termina anche la nostra guida di base al linguaggio PHP!

Mi auguro che la guida sia stata di vostro gradimento, che possa essere stata utile per imparare qualcosa di nuovo o per ripassare e che possa in generale dare un piccolo aiuto a chiunque voglia cimentarsi con PHP. Ringrazio Laura per avermi fornito questo spazio e ovviamente un grazie a tutti quelli che mi hanno seguito fino a questo punto, a quelli che hanno seguito anche poche puntate, a chi si è collegato una volta sola e a tutti coloro che hanno commentato e hanno tentato di risolvere gli esercizi

Un grande saluto!!!!!!!

Terminiamo oggi la breve panoramica sui più comuni problemi di sicurezza con una puntata sul session hijacking, che consiste nel “furto dell’identità” di un utente che si collega a un sito web.

Session hijacking: che cos’è

Che cosa fa il malintenzionato che sottopone l’utente di un sito a session hijacking? Non fa altro che rubare l’identificativo di sessione dell’utente (ogni sessione ha un proprio id) per poi loggarsi al sito spacciandosi per l’utente a cui ha rubato le credenziali. Uno dei metodi più comuni per rubare le credenziali è sfruttare il cross-site scripting: abbiamo però già parlato nell’episodio precedente di come difenderci da questo tipo di attacchi, quindi vedremo oggi come coprirci anche da un furto ottenuto tramite “session fixation”: con la session fixation, i dati verranno rubati tramite una sessione creata ad hoc dal malintenzionato.

Certo, affinché si verifichi una session fixation devono essere soddisfatte due condizioni: codice vulnerabile e utente sprovveduto. Nella puntata sulle sessioni non abbiamo parlato del modo in cui l’id di sessione viene propagato: ciò può avvenire tramite un cookie che viene appositamente creato per contenere l’id (cookie che si estinguerà alla chiusura del browser) oppure, nel caso in cui i cookie siano stati disabilitati, tramite metodi get e post. Il ladro di sessioni può convincere l’utente del nostro sito (magari tramite una mail o con un post su un blog) a collegarsi a un indirizzo simile a questo: www.nostrosito.it/login.php?PHPSESSID=12345 dove, attraverso la query string e ipotizzando che l’id di sessione venga propagato tramite get, decide il numero di sessione.

Simuliamo un attacco

Per comprendere meglio il meccanismo di un attacco session fixation proviamo a simularne uno (ma, come detto nella scorsa puntata, solo affinché vi possiate difendere). Per prima cosa assicuriamoci che nelle impostazioni del nostro PHP sia abilitata la trasmissione dei dati di sessione attraverso url: clicchiamo quindi sull’icona di Wamp, andiamo sotto la voce PHP e quindi apriamo il file php.ini. Cerchiamo adesso la direttiva session.use_trans_sid, che è quella che consente la tramissione degli id di sessione via url (a proposito: i commenti sopra di essa vi diranno che abilitarla sottopone a rischi di sicurezza). Se è a 1 lasciamola com’è, altrimenti se è impostata a 0 dobbiamo settarla a 1. Cerchiamo poi la direttiva session.use_only_cookies (permette la trasmissione degli id di sessione solo tramite cookie) e impostiamola a 0.

A questo punto creiamo un semplice codice PHP che al nostro collegamento dà inizio a una sessione che memorizza il numero di volte in cui visualizziamo la pagina con il nostro browser:

<?php
session_start();
if (!isset($_SESSION['conto'])) {
$_SESSION['conto'] = 0;
} else {
$_SESSION['conto']++;
}
echo "Numero:" . $_SESSION['conto']."";
?>

Tutto molto semplice. Con la solita funzione isset controlliamo che la variabile $_SESSION['conto'] non sia stata inizializzata: se non esiste, la creiamo e la impostiamo a 0, se invece esiste già la incrementiamo. Terminato il blocco if stampiamo la nostra variabile.

Salvate il file chiamandolo, per esempio, “fixation.php” e inseritelo in una cartella “prova” all’interno della cartella “www” di Wamp. A questo punto aprite il vostro browser preferito (per esempio Firefox), eliminate tutti i cookie di localhost e collegatevi a questo indirizzo: http://localhost/prova/fixation.php?PHPSESSID=12345. Aggiornate la pagina un qualsiasi numero di volte, arriviamo per esempio a 9.

A questo punto chiudete pure il browser. Riaprite un altro browser (esempio, Chrome), magari anche su un altro computer se fate la prova su un server remoto, e provate a collegarvi allo stesso indirizzo: come potrete notare il conto non ripartirà da 0 ma partirà da dove siete rimasti prima (nel nostro caso vedremo “10”). Cosa significa questo? Abbiamo simulato un ipotetico utente A che utilizza Firefox, apre la pagina con il link che gli è stato suggerito dal malintenzionato utente B e dà inizio a una sessione. L’utente B aprirà poi il suo Chrome con l’id di sessione da lui stesso creato e potrà accedere ai dati dell’utente A. In questo caso si tratta semplicemente del numero di volte che ha aggiornato la pagina, ma questo tipo di attacco funziona tranquillamente anche su script molto più complessi (per esempio un login a un sito web: il malintenzionato B potrà accedere indisturbato a tutti i dati personali dell’utente A) che però hanno seri problemi di sicurezza.

Come difendersi: session_regenerate_id

Come difendersi da questo attacco? Il metodo più semplice è rigenerare spesso l’id di sessione, in modo da rendere inefficaci gli attacchi: questo si può fare agevolmente tramite l’apposita funzione session_regenerate_id, che si applica in modo molto semplice:

session_regenerate_id();

E in genere va fatto dopo aver dato il via alla sessione con session_start. La documentazione ufficiale di questa funzione si trova all’indirizzo http://php.net/manual/en/function.session-regenerate-id.php. Inoltre sarebbe bene che le direttive di cui sopra, session.use_trans_sid e session.use_only_cookies, fossero impostate rispettivamente a 0 e 1. Comunque l’utilizzo di session_regenerate_id è di per sé già sufficiente per difendersi. È quindi bene rigenerare spesso, anche prima che l’utente abbia fatto login (inserendo quindi la funzione nella pagina di login, per esempio).

Come difendersi: controllo sullo user agent

Infine potremmo eseguire un controllo aggiuntivo sullo user agent dell’utente (perché niente impedisce che uno stesso id di sessione, come abbiamo visto, possa essere utilizzato da due utenti diversi): questo consente anche di avere una difesa contro attacchi di tipo “session sidejacking”. Attraverso questo tipo di attacco, comunque difficile da mettere in atto, il malintenzionato cerca di intercettare l’id di sessione attraverso i pacchetti di rete che vengono scambiati tra il server e il browser dell’utente. Per ovviare a questa minaccia può essere utile fare in modo che l’accesso venga impedito nel caso in cui lo user agent di chi richiede l’accesso al nostro sito non corrisponda a quello dell’utente che ha effettuato il login.

Per fare questo abbiamo bisogno della variabile superglobale $_SESSION: dovremo associare a essa il valore dell’elemento HTTP_USER_AGENT della variabile superglobale $_SERVER, meglio se codificato tramite funzione md5. Il tutto nella pagina o nella funzione che consente il login:

$_SESSION['HTTP_USER_AGENT'] = md5($_SERVER['HTTP_USER_AGENT']);

In questo modo abbiamo creato un elemento della sessione chiamato HTTP_USER_AGENT a cui abbiamo associato nient’altro che il nostro user agent criptato con md5. A questo punto, per eseguire il controllo, potremmo utilizzare un codice simile a questo:

if (isset($_SESSION['HTTP_USER_AGENT'])) {
if ($_SESSION['HTTP_USER_AGENT'] != md5($_SERVER['HTTP_USER_AGENT'])) {
logout();
}
}

Con questo script non facciamo altro che controllare, sempre tramite la funzione isset, se esiste la sessione con elemento “HTTP_USER_AGENT”: in caso affermativo, se il suo valore è diverso dallo user agent, sempre criptato con md5, dell’utente che sta eseguendo lo script (in altre parole se chi si è loggato ha uno user agent diverso rispetto a quello dell’utente che sta cercando di forzare l’accesso al sito), rimandiamo l’utente a una ipotetica funzione logout che distruggerà la sessione.

Anche per oggi la puntata è arrivata alla fine: vi do appuntamento alla prossima, la trentesima nonché ultima della nostra guida!

XSS: Cross-site scripting

Partiamo dal cosiddetto “Cross-site scripting”, noto anche come XSS: si tratta di un problema, molto diffuso, che riguarda la sicurezza dei form e in particolare i form che non applicano controlli sui campi. Il malintenzionato può, tramite il form, far eseguire un codice JavaScript che magari rimanda a un suo sito dove è contenuto uno script dannoso. A proposito: ricordo a tutti quelli che leggono (visti i numerosi accessi al sito) che alcune delle cose che sto per illustrare, se messe in pratica, costituiscono un reato penalmente perseguibile. Ve ne parlo solo affinché vi possiate difendere.

Tornando al nostro XSS, prendiamo un semplicissimo form per inserire un messaggio:

<form action="xss.php" method="get">
Nome:<br />
<input type="text" name="nome" /><br />
Messaggio: <br />
<textarea rows="10" cols="20" name="messaggio"></textarea><br />
<input type="submit" name="invia" value="Invia!" /><br />
</form>

E supponiamo che il codice della pagina xss.php sia strutturato in questo modo:

<?php
echo "Nome: {$_GET['nome']}";
echo "<br /><br />Messaggio: <br /><br />";
echo stripslashes($_GET['messaggio']);
?>

Bene, questo è un codice del tutto insicuro perché non ci sono controlli di sicurezza. Nel campo “messaggio” l’hacker può facilmente inserire un codice JavaScript di questo tipo:

<script language="text/javascript">document.location.href="http://www.web-magazine.it";</script>

Dove ovviamente al posto di web-magazine.it c’è un sito malvagio. Attraverso la stampa con echo, il codice viene inserito nella pagina xss.php e quindi eseguito. E ovviamente, date le tante cose che si possono fare con JavaScript, il reindirizzamento non è che una possibilità: il malintenzionato può infatti anche installare script dannosi direttamente all’interno del sito. E questo tipo di attacco funziona sia che il nostro form abbia metodo get, sia che abbia metodo post. Tipicamente, gli script XSS vengono utilizzati per rubare cookie ai malcapitati.

Come difendersi dal cross-site scripting

Difendersi da questo tipo di attacchi è veramente molto semplice: bisogna solo tenerlo a mente! Basterà fare in modo che i caratteri riservati del linguaggio HTML vengano sostituiti con le relative entità (per esempio la parentesi uncinata aperta con <) o che le etichette HTML vengano del tutto cancellate.

Per fare questo abbiamo tre funzioni: htmlspecialchars, htmlentities e strip_tags. Funzionano tutte allo stesso modo: ricevono come parametro la stringa per la quale dobbiamo sostituire i caratteri. Ecco quindi qual è il codice corretto e sicuro da utilizzare nella pagina xss.php:

<?php
echo "<br /><br />Messaggio: <br /><br />";
echo htmlspecialchars(stripslashes($_GET['messaggio']));
?>

Oppure

echo htmlentities(stripslashes($_GET['messaggio']));

O ancora

echo strip_tags(stripslashes($_GET['messaggio']));

htmlspecialchars, htmlentities e strip_tags

Ci sono ovviamente alcune differenze tra le tre funzioni. La differenza tra htmlspecialchars e htmlentities consiste nel fatto che la prima converte in entità solo i caratteri riservati di HTML, mentre la seconda converte anche i caratteri speciali (per esempio, se dovessimo scrivere in tedesco, la o con la dieresi – ö – sarebbe convertita in ö). La funzione strip_tags invece elimina del tutto le etichette HTML. In ogni caso, il codice immesso dal malintenzionato verrebbe stampato sullo schermo e non eseguito (anzi, nel caso di strip_tags le tag verrebbero del tutto eliminate). E ricordate sempre: uno dei migliori metodi per difendersi dagli attacchi è filtrare tutto ciò che arriva in input sul nostro sito. In questo caso abbiamo visto come filtrare attraverso le tre funzioni di cui abbiamo parlato: potete trovare le documentazioni ufficiali delle funzioni a queste pagine: http://www.php.net/manual/en/function.htmlspecialchars.php (htmlspecialchars), http://php.net/manual/en/function.htmlentities.php (htmlentities), http://it.php.net/manual/en/function.strip-tags.php (strip_tags).

SQL Injection

Il secondo problema di vulnerabilità che vediamo oggi è la cosiddetta SQL Injection (iniezione di SQL). Anche in questo caso l’attacco prende di mira form scritti male per eseguire un codice SQL malevolo, e adesso vedremo nel dettaglio in cosa consiste questa pratica e perché è tanto pericolosa. Prendiamo per esempio questo semplice form per connettersi a un sito:

<form action="login.php?step=2" method="post">
Nickname:<br />
<input type="text" name="nickname" /><br />
Password: <br />
<input type="password" name="psw" /><br />
<input type="submit" name="invia" value="Invia!" /><br />
</form>

In questo caso il nostro form, invece di rimandare a una nuova pagina, rimanda alla stessa ma con l’aggiunta della query string ?step=2, in modo da scrivere tutto nella stessa pagina. L’azione del form andrà quindi scritta in un blocco if di questo tipo:

if (isset($_GET['step']) && $_GET['step'] == 2) {
// azione
}
else {
}

Ipotizziamo anche che il gestore del sito o del blog sia stato così sprovveduto da aver fatto in modo che le password vengano inserite in chiaro nel database (quindi senza criptarle attraverso il form di registrazione). Ora prendiamo il pessimo script che esegue il controllo sui dati immessi dall’utente:

$query = "SELECT * FROM autori WHERE Nickname = '{$_POST['nickname']}' AND Password = '{$_POST['psw']}'";
$risultato = mysql_query($query);
if (mysql_num_rows($risultato) == '1') {
echo "Benvenuto, utente autenticato";
// codice che mostra l'eventuale pagina personale dell'utente
}
else {
echo "Spiacente, password errata";
}

Chiariamo subito la funzione nuova, mysql_num_rows: restituisce il numero dei record trovati dalla query (nel nostro caso uno, anche perché si suppone che gli username siano univoci) e riceve come parametro il risultato della query. Qua si trova la documentazione ufficiale della funzione: http://php.net/manual/en/function.mysql-num-rows.php. Pertanto se la funzione dà come risultato 1 (e quindi trova il record), l’utente sarà loggato, in caso contrario ci sarà un messaggio che informerà l’utente di aver inserito una password errata.

Questo codice è estremamente vulnerabile, soprattutto nel caso in cui l’impostazione magic quotes gpc di PHP sia disattivata: in locale potete controllarlo su WAMP cliccando sull’icona nella barra delle applicazioni, quindi andare alla voce PHP e ancora andare su Impostazioni PHP. Se la voce “magic quotes gpc” è spuntata significa che è attiva e avete maggiori protezioni contro le SQL Injection. Ci sono però tanti provider che non attivano le magic quotes sui loro server. Ma cosa sono le magic quotes? Si tratta di un processo che aggiunge in automatico i caratteri di escape alle stringhe, ma dobbiamo sapere che a partire dalla versione 5.3.0 di PHP, magic quotes è deprecato e nella versione 6 addirittura non c’è più.

Vediamo quindi cosa può fare il malintenzionato. Nella casella nickname può inserire il nome “Federico”, e fin qui niente di strano. Ma nella casella password può tranquillamente inserire questa stringa:

' OR Nickname='Federico

Così facendo, il nostro codice eseguirebbe questa query:

$query = "SELECT * FROM autori WHERE Nickname = 'Federico' AND Password =
'' OR Nickname='Federico'";

La clausola OR inserita dal malintenzionato vanificherà il controllo sulla password: questo perché la query strutturata in tal modo dice di selezionare tutti i record della tabella autori il cui nickname sia Federico e la cui password sia vuota oppure, in alternativa a quest’ultima clausola, il cui nickname sia Federico. Dal momento che la seconda clausola è soddisfatta il malintenzionato riuscirà a entrare agevolmente al posto di Federico all’interno del sito, spacciandosi per lui e magari rubando i suoi dati… o insomma facendo tutto ciò che di cattivo si può fare entrando nel profilo di un’altra persona.

Criptiamo la password con md5

La prima operazione da fare è criptare la password attraverso la funzione md5: nel database non dovrà essere inserita in chiaro ma andrà fatta passare attraverso questa funzione (in un’ipotetica query con comando INSERT INTO metteremo tra i VALUES ‘md5($_POST['password']‘). MD5 è un algoritmo crittografico di hashing che fu realizzato nel 1991 da Ronald Linn Rivest, un crittografo statunitense: l’algoritmo trasforma una stringa in un’altra stringa a 128 bit, e non è possibile risalire alla stringa originale (se non andando… a tentativi). La funzione md5 di PHP riceve come parametro semplicemente la stringa da criptare e la documentazione ufficiale si trova qui: http://it.php.net/manual/en/function.md5.php.

Questo è solo uno dei tanti modi per criptare una password: parliamo di questo perché è il più semplice da utilizzare, ma c’è chi usa anche sistemi più sofisticati. Il nostro codice pertanto dovrà presentarsi in questa forma:

$query = "SELECT * FROM autori WHERE Nickname = '{$_POST['nickname']}' AND Password = '". md5($_POST['psw']). "'";

Dove i punti che separano md5($_POST['psw']) dal resto del codice sono un modo per concatenare valori all’interno di una variabile (le virgole non funzionano).

In questo caso ci salviamo dal malintenzionato che immette i dati di cui sopra, ma siamo ancora vulnerabili. Questo perché l’hacker potrebbe scrivere nella casella del nickname questa stringa cattivissima:

Federico' --

E magari può anche lasciare in bianco il campo della password. In tal modo la query diventerebbe questa:

$query = "SELECT * FROM autori WHERE Nickname = 'Federico' -- AND Password =
''";

I due trattini nel linguaggio SQL indicano i commenti: pertanto tutto ciò che viene dopo i due trattini sarà ignorato. Capite quindi la pericolosità della cosa malgrado il controllo tramite algoritmo md5. Sarà un giochetto per il malintenzionato riuscire a entrare nel sito e magari carpire tutta la lista degli utenti registrati o a far di peggio: pensate se potesse entrare con l’account dell’amministratore.

Come difendersi dalla SQL injection

Qual è pertanto il modo più sicuro per difendersi da questo tipo di attacco? Non dovremo far altro che aggiungere una funzione per controllare i dati immessi dall’utente (ricordate… filtrare sempre tutto), e si tratta della funzione mysql_real_escape_string, che inserisce i giusti caratteri di escape prima dei caratteri “pericolosi”. Riceve come parametro semplicemente la stringa a cui aggiungere i parametri di escape. Quindi la nostra query dovrà assumere questa forma per evitare attacchi:

$query = "SELECT * FROM autori WHERE Nickname = '". mysql_real_escape_string($_POST['nickname']) ."' AND Password = '". mysql_real_escape_string($_POST['psw']). "'";

Riusciremo così a rendere inoffensivo l’attacco del malintenzionato, perché l’ultima stringa che abbiamo visto risulterà invece in questo modo:

$query = "SELECT * FROM autori WHERE Nickname = 'Federico\' -- AND Password = ''";

Questa funzione va utilizzata solo nel caso in cui magic quotes gpc sia disattivo. Per essere però del tutto sicuri utilizziamo la funzione get_magic_quotes_gpc, che controlla la configurazione delle magic quotes (non riceve alcunché come parametro), e inseriamola in un blocco if:

if(get_magic_quotes_gpc()) {
$query = "SELECT * FROM autori WHERE Nickname = '". $_POST['nickname'] ."' AND Password = '".
$_POST['psw']. "'";
}
else {
$query = "SELECT * FROM autori WHERE Nickname = '". mysql_real_escape_string($_POST['nickname']) ."'
AND Password = '". mysql_real_escape_string($_POST['psw']). "'";
}

Controlliamo con il ciclo che il processo magic quotes gpc sia attivo, e in caso affermativo creiamo la nostra query senza la funzione mysql_real_escape_string, e in caso contrario ovviamente la aggiungiamo. Trovate la documentazione ufficiale di queste due funzioni qui http://it.php.net/manual/en/function.mysql-real-escape-string.php (mysql_real_escape_string) e qui http://php.net/manual/en/function.get-magic-quotes-gpc.php (get_magic_quotes_gpc).

Vi aspetto come sempre alla prossima puntata!

Ce ne ho messo di tempo ma alla fine ho pensato che sarebbe stato giusto dare delle spiegazioni.
Il mio problema è che non ho capacità di sintesi per cui mi sa che queste spiegazioni dureranno parecchi post.

Spiegazioni riguardo due cose principalmente.

La prima è il blog, e la carenza di aggiornamenti.

Web Magazine non si è fermato ma quasi, tempo di scrivere non ne ho più e non credo che ne avrò mai, e se non fosse per i miei preziosi Federico e Dario, rispettivamente Mr. Php e Mr. Seo, il blog sarebbe quasi defunto.

Lunga vita ai miei collaboratori!

Leggete i loro post Leggete i loro post Leggete i loro postLeggete i loro post Leggete i loro post Leggete i loro postLeggete i loro post..

i ragazzi si impegnano!

La seconda spiegazione è il perchè dopo anni in cui ho professato la cosiddetta missione freelance io sia tornata a timbrare cartellini.

Facciamo però un passo indietro, anticipando prima di tutto che questo non è un post tecnico, nè un tutorial nè una guida, è un post assolutamente personale dedicato ai miei storici seguaci e a chi proprio non sa farsi gli affari propri.

Leggendo questo post non imparerete nulla, qualcuno si farà due risate e straccerà il mio ebook… dopo averlo stampato.

Ma se pensate che le esperienze vissute possano in qualche modo arricchire allora vi racconto la mia vita negli ultimi sei mesi e cercheremo anche di dare un senso a quel titolo assurdo.

Giugno 2011 -  Dopo un breve scambio di email decido di accettare un prestigioso nonchè molto-ma-mooolto-ben-pagato incarico, rigorosamente freelance, come interface designer per un progetto della Commissione Europea, progetto che mi avrebbe portato a 900km da casa per sei mesi fino ad un massimo di tutta la vita, se lo avessi voluto.
Progetto che puoi andare a sbandierare in giro perchè oggettivamente lavorare in una ex centrale nucleare in un contesto europeo dove si parla esclusivamente in inglese è una cosa maledettamente fica, non facciamo i falsi modesti.

A quel punto se fossimo stati in una di quelle storie di Topolino con il “bivio” (si ok, leggevo topolino ma mi stava sulle palle) avrei imboccato la strada cosiddetta: Ricca e alquanto infelice. Ma qui ci arriveremo.

Aspettavo quindi  la partenza di Settembre, potevo godermi le vacanze certa del fatto che sarei poi partita per soldolandia e nel frattempo avrei fatto giusto qualche lavoretto da casa, il bello di lavorare e abitare praticamente su una spiaggia è che in estate fare pausa pranzo in costume ti ripaga da tutte le rotture di palle che ti portano i clienti.. ma invece no, niente relax pre partenza, accetto una consulenza.

In realtà era una sorta di sostituzione di un web designer, quindi sarei dovuta restare  per 6 settimane in una web agency di Napoli non potendo lavorare da casa per questo tipo di incarico, ma l’agenzia già in fase di colloquio mi aveva impressionata positivamente. Persone umili ma assolutamente competenti, idee chiare in termini di business e un ambiente allegro e giovanile che, diciamocela tutta, non potevo di certo trovare nelle 4 mura del mio studiolo casalingo.

E si, accetto, nonostante la spiaggia, il costume, e il perenne e dolcissimo suono del mare.

Prendo l’auto e torno ai rumori della città, al caos delle agenzie, e alla bellezza di poter scambiare opinioni dal vivo con un collega.

E il primo giorno in agenzia, mentre mi sentivo come una scolaretta di trent’anni che aveva tanta voglia di fare bella figura,  vengo assalita dal panico.

Mi viene assegnato il primo incarico: Disegnare un logo.

Io, che non ho problemi a dire ad un cliente che se vuole il logo lo pagherà il doppio semplicemente perchè odio fare i loghi;

io, che ho fatto le migliori litigate nella speranza di chiarire il concetto che un web designer e un grafico pubblicitario sono due figure assolutamente diverse..

io che non voglio che i loghi vengano considerati come accessori gratuiti di un sito, come il bicchiere che il supermercato ti regala se acquisti il latte, come il cioccolatino che ti offre il bar mentre ti serve il caffè, come il pareo che esce da Donna Moderna ad Agosto.

Ecco, il logo non è il pareo di Donna Moderna.

Io dovevo disegnare un logo???

Pensavo mi considerassero una discreta web designer, e mi hanno chiesto di disegnare un logo.

Il primo giorno di lavoro.

Ma ora ho tanta fame quindi il resto lo scriverò poi.

Con la puntata di oggi vedremo in che modo, con PHP, è possibile conservare informazioni durante la navigazione: si tratta di un aspetto molto utile soprattutto se è necessario costruire un sito web che debba consentire ai propri utenti di fare il login e di navigare le pagine in qualità di utenti registrati. Per fare questo abbiamo due strumenti a nostra disposizione: il primo è costituito dalle sessioni, il secondo dai cookie.

Le sessioni

Iniziamo dalle sessioni: dobbiamo immaginare le sessioni come “contenitori” in cui possiamo inserire diverse informazioni. Queste informazioni verranno memorizzate sul server e dureranno il tempo di una… “sessione”, appunto, perché quando il browser verrà chiuso tutte queste informazioni saranno cancellate.

La funzione session_start

PHP mette a disposizione di chiunque voglia creare una sessione la variabile superglobale $_SESSION, che funziona proprio come tutte le altre variabili superglobali di cui abbiamo già parlato nelle puntate scorse. Prima di tutto però c’è un’operazione preliminare da compiere, ovvero avviare la sessione. Lo si fa con una sezione apposita, session_start, che deve obbligatoriamente essere inserita prima di qualsiasi tipo di output all’interno del nostro file PHP:

<?php
session_start();
// codice...
?>

Creare sessioni

La funzione session_start (la cui documentazione ufficiale si può trovare all’indirizzo http://php.net/manual/en/function.session-start.php) non solo permette di creare una sessione, ma permette anche di recuperare dati da una sessione creata in un’altra pagina. Ma come si fa a creare una sessione? Basta semplicemente utilizzare la variabile superglobale $_SESSION e associare a essa le informazioni:

$_SESSION['nome'] = "Federico";
$_SESSION['id'] = "1";
$_SESSION['livello'] = "3";

Ovviamente queste informazioni, nel caso di un utente che si collega al nostro sito, si possono agevolmente recuperare da un database (nell’esempio ometterò, per semplicità, la query, perché parleremo nella prossima puntata di come recuperare in modo corretto e allo stesso tempo semplice i dati immessi da un utente per fare un login):

$query = // ipotetica select per verificare i dati inseriti dall'utente
$result = mysql_query($query);
$numero_record = mysql_num_rows($result);
if($numero_record == 1) {
while($row = mysql_fetch_array($result, MYSQL_ASSOC)) {
$_SESSION['id'] = $row['id'];
$_SESSION['nome'] = $row['nome'];
$_SESSION['livello'] = $row['livello'];
}
echo "Login effettuato con successo!";
}

In tutte le pagine che vorremo riservare agli utenti registrati, dovremo inserire prima di qualsiasi altra cosa la funzione session_start: se omettessimo la funzione, la pagina non potrebbe ricevere le informazioni delle sessioni. Se per esempio con un blocco if controlliamo che l’utente sia loggato (per esempio verificando, tramite isset, che sia impostato il livello dell’utente a sua volta memorizzato nella variabile superglobale $_SESSION) ma allo stesso tempo dimentichiamo di inserire la funzione session_start, la conseguenza sarà che la pagina non conoscerà le informazioni memorizzate nella sessione e la nostra applicazione si comporterà come se l’utente non si fosse mai loggato al sito. Attenzione anche a non dichiarare due volte la funzione (spesso, includendo file nella pagina, può capitare di farlo), perché session_start può essere dichiarata una volta soltanto.

Come azzerare o eliminare le sessioni

Le sessioni possono essere poi azzerate o eliminate: per fare questo è possibile utilizzare le funzioni session_unset e session_destroy. La differenza consiste nel fatto che la prima funzione elimina soltanto i dati (senza cancellare gli elementi dell’array che abbiamo dichiarato in precedenza), la seconda invece elimina dati e array. Pertanto in seguito a session_destroy sarà necessario dichiarare nuovamente session_start. Sono utili in funzioni di logout e si invocano in modo molto semplice:

session_unset();
session_destroy();

I cookie

Parliamo adesso dei cookie: molti di voi li avranno già sentiti nominare. I cookie (letteralmente “biscotti”) sono informazioni che vengono inviate dal server al client: e proprio qui sta la prima differenza rispetto alle sessioni, perché queste ultime rimangono sul server. Un’altra differenza consiste nel fatto che la sessione viene cancellata nel momento in cui il browser viene chiuso: il cookie invece persiste fino alla sua scadenza, impostata quando il cookie viene creato. Data la natura dei cookie, questi ci torneranno utili se vogliamo creare un modulo di login che si “ricordi” dell’utente una volta chiuso il browser, per evitargli magari di immettere nuovamente nome e password al collegamento successivo. Un altro esempio può essere dato da un sito multilingua: se il nostro sito accoglie l’utente in italiano, ma quest’ultimo preferisce l’inglese, potrebbe rendersi necessario un cookie che si ricordi dell’impostazione settata dall’utente (ovvero “sito in lingua inglese”) ogni volta che si collega.

La funzione setcookie e i suoi parametri

Per creare un cookie esiste un’apposita funzione, setcookie, che riceve tre parametri principali: il nome del cookie, le informazioni e la durata:

setcookie("nome", "Federico", time()+3600);

La durata si imposta utilizzando la funzione time: quest’ultima restituisce il numero di secondi trascorsi dal 1 gennaio 1970 alle ore 00:00:00. Si tratta della data di inizio del tempo calcolato sui sistemi Unix ed è, come già detto, espresso in secondi: si intuisce quindi che al valore restituito da time bisognerà aggiungere un numero di secondi equivalente al periodo di durata del nostro cookie. Nel caso dell’esempio, 3600 secondi: significa che il cookie avrà la durata di un’ora (formata da 3600 secondi). Si intuisce quindi che è possibile settare una durata qualsiasi per il nostro cookie, anche di anni!

setcookie("nome", "Federico", time()+3600*24); //un giorno

setcookie("nome", "Federico", time()+3600*24*30); // un mese

setcookie("nome", "Federico", time()+3600*24*365); // un anno

Se invece la scadenza non viene impostata, il cookie scadrà semplicemente alla fine della sessione. La documentazione ufficiale della funzione time è disponibile all’indirizzo http://php.net/manual/en/function.time.php.

Quello che abbiamo visto sopra è l’esempio più tipico, ma in realtà si possono estendere a sette i parametri che la funzione setcookie può ricevere, perché oltre a nome, valore e scadenza possiamo specificare anche percorso (ovvero la directory per cui è valido il cookie), il dominio (come per il percorso, ma si estende a tutto il dominio), la sicurezza (che se settata a true fa in modo che il cookie venga trasmesso solo attraverso protocollo sicuro https) e httponly (funziona come la sicurezza: se settato a true, fa in modo che il cookie venga trasmesso solo tramite protocollo http, e di conseguenza non sarà accessibile a linguaggi di scripting come JavaScript). Per esempio:

setcookie("nome", "Federico", time()+3600, "/prova/", "web-magazine.it", true, true);

In questo caso il cookie è valido solo per la cartella “prova” del sito “web-magazine.it” (che non va scritto con “www” anteposto), si trasmette solo in presenza di una connessione sicura ed è accessibile solo al protocollo http.

setcookie("nome", "Federico", time()+3600, "/");

In questo caso invece abbiamo creato, attraverso la formula “/”, un cookie che è valido per tutte le cartelle del sito.

Recuperare il valore dei cookie

Per recuperare il valore di un cookie che abbiamo impostato in precedenza, sarà necessario utilizzare la variabile superglobale $_COOKIE, e il nome dell’elemento dell’array non sarà altro che il primo valore che abbiamo passato come parametro alla funzione setcookie:

echo $_COOKIE['nome']; // stampa “Federico”

È ovvio che possiamo anche inizializzare variabili a cui abbinare i valori delle nostre sessioni o dei nostri cookie:

$nome = $_SESSION['nome'];
$cognome = $_COOKIE['cognome'];

Per poi utilizzarle comodamente all’interno del nostro codice, magari su blocchi condizionali. Tipicamente, ci si assicura che prima le variabili di sessione e i cookie siano settati tramite funzione isset, onde evitare di veder comparire warning sul sito nel caso in cui sessioni e cookie non siano ancora stati scritti (per esempio quando l’utente si è appena collegato al sito e non ha ancora fatto login).

Eliminare i cookie

Abbiamo visto prima come eliminare una sessione. I cookie non hanno una specifica funzione per eliminarli, ma per farlo basta semplicemente utilizzare, di nuovo, la funzione setcookie (a proposito, la pagina di documentazione ufficiale è http://php.net/manual/en/function.setcookie.php) impostando però, come scadenza, un tempo negativo:

setcookie("nome", "Federico", time()-3600);

E così facendo avremo eliminato il nostro cookie. Sempre la solita funzione si utilizza se vogliamo modificare i valori di un cookie: basterà semplicemente invocare setcookie con i nuovi parametri.

E anche per oggi la puntata arriva al termine… arrivederci al prossimo episodio!!!

Con la puntata di oggi metteremo in pratica i concetti appresi negli ultimi episodi della guida e vedremo come costruire un semplice form di ricerca PHP/MySQL per fare ricerche all’interno del nostro blog. Come sempre, in occasione di puntate “pratiche”, faremo un ripasso generale degli ultimi concetti ma introdurremo anche qualcosa di nuovo.

Costruiamo il form

Allora, iniziamo a costruire il nostro form, in maniera molto semplice, come siamo abituati:

<form name="ricerca" action="ricerca.php" method="post">
<input type="text" name="cerca" />
<input type="submit" name="vai" value="Cerca!" />
</form>

Si tratta, come vedete, di un semplicissimo form con metodo post che rimanda a una pagina “ricerca.php”. Il nostro form ha un campo, che servirà all’utente per immettere il testo da ricercare, e un bottone per inviare i dati.

Nel costruire la pagina “ricerca.php”, come prima cosa assicuriamoci di fare un controllo sul pulsante: se è stato premuto, quindi se l’utente proviene dalla pagina del form, sarà eseguito il codice, e in caso contrario (se per esempio l’utente arriva alla pagina ricerca.php semplicemente digitandola nella barra degli indirizzi) non dovrà succedere alcunché. Vediamo:

if(isset($_POST['vai'])) {
// codice
// codice
// codice
}
else {
}

Iniziamo a riempire la pagina dei risultati…

Vediamo ora come riempire il blocco if. Per prima cosa dobbiamo decidere se la ricerca riguarderà soltanto i post o i commenti. Noi vedremo tre esempi: il primo per i post, il secondo per i commenti e il terzo per entrambi.

Iniziamo dalla ricerca nei soli post. Per prima cosa stampiamo una scritta per indicare all’utente che la ricerca è stata compiuta e quindi inizializziamo una variabile, a cui assoceremo la parola cercata:

echo "Ecco i risultati della tua ricerca:<br /><br /> ";
$parolacercata = $_POST['cerca'];

Fatto questo è arrivato il momento di creare la nostra query per la ricerca all’interno della base di dati:

$query = "SELECT * FROM Post WHERE Titolo LIKE '%$parolacercata%' OR TestoHTML LIKE '%$parolacercata%'";

L’operatore LIKE e i suoi utilizzi

Bene, vedete che abbiamo due “novità”: la prima è l’operatore LIKE, e la seconda sono i due simboli di percentuale prima e dopo la variabile. Procediamo con ordine.

LIKE è un operatore di confronto, come l’uguale, il maggiore, il minore e tutti gli altri. Funziona più o meno come l’operatore di uguaglianza, ma con una differenza molto significativa: con l’uguale avremmo cercato la parola precisa, invece con LIKE eseguiamo una ricerca “non precisa”. I due caratteri di percentuale prima e dopo la variabile della parola cercata servono infatti per dare una “connotazione” all’operatore LIKE, nel senso che immettendolo prima della variabile, dichiariamo che potrebbero esserci altri caratteri prima della parola che abbiamo cercato, e invece immettendolo dopo non facciamo altro che dichiarare che potrebbero esserci altri caratteri subito dopo.

Ma vediamo un esempio concreto. Supponiamo di avere tre post, il primo che si intitola “Ciao”, il secondo che si intitola “Ciao a tutti!” e il terzo “Un ciao ai miei amici!”. E supponiamo anche di avere alcune query di ricerca (per semplicità operiamo soltanto sul titolo):

$query = "SELECT * FROM Post WHERE Titolo = '$parolacercata'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '$parolacercata'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '%$parolacercata'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '$parolacercata%'";

$query = "SELECT * FROM Post WHERE Titolo LIKE '%$parolacercata%'";

Supponiamo adesso di cercare la parola “ciao”. Vediamo i risultati per i cinque casi che abbiamo elencato sopra:

• Caso 1: viene trovato soltanto il post intitolato “Ciao”, perché abbiamo chiesto informazioni precise, ovvero i post il cui titolo è esattamente uguale alla parola cercata (maiuscole e minuscole non contano perché SQL non è case sensitive come abbiamo avuto già modo di rimarcare);
• Caso 2: è del tutto equivalente al caso 1 (quindi è praticamente inutile usare LIKE da solo);
• Caso 3: vengono trovati i post che contengono la parola cercata anche se ci sono caratteri che la precedono. Nel nostro caso troviamo soltanto “Ciao”, perché è vero che il post “Un ciao ai miei amici!” ha la parola “ciao” preceduta da altri caratteri, ma è anche seguita da un’altra sequenza (“ ai miei amici”), quindi non soddisfa i requisiti di ricerca. Se avessimo avuto un post intitolato “Un ciao”, sarebbe stato restituito come risultato;
• Caso 4: il contrario del precedente, vengono trovati “Ciao” e “Ciao a tutti!”. Abbiamo infatti cercato i record dove il campo titolo contiene la parola cercata ma può anche contenere una stringa di caratteri dopo. “Ciao” e “Ciao a tutti!” soddisfano questa condizione;
• Caso 5: vengono trovati tutti e tre i post, dal momento che abbiamo detto di estrarre i record il cui campo titolo contiene la parola cercata, che può essere o preceduta o seguita da altre sequenze di caratteri.

Possiamo poi anche fare ricerche “negative”:

$query = "SELECT * FROM Post WHERE Titolo NOT LIKE '%$parolacercata%'";

In questo caso, anteponendo quindi la parola NOT all’operatore LIKE, la nostra interrogazione fa in modo che vengano estratti i post il cui titolo non contiene la parola cercata, preceduta o seguita da altre stringhe di caratteri. E poi abbiamo anche un altro carattere speciale, l’underscore:

$query = "SELECT * FROM Post WHERE Titolo LIKE '_$parolacercata_'";

In questo caso la nostra interrogazione estrae tutti i post che contengono la parola cercata, preceduta o seguita da un solo carattere: pertanto, se il carattere di percentuale equivale a “qualsiasi numero di caratteri”, l’underscore equivale a “un solo carattere”.

La specifica ESCAPE

Potremmo però voler cercare una parola che sia effettivamente preceduta da un underscore, e quindi non volerlo considerare come carattere speciale. In questo caso dovremo scrivere questo:

$query = "SELECT * FROM post WHERE Titolo NOT LIKE '_$parolacercata' ESCAPE";

Aggiungendo la specifica ESCAPE facciamo capire che quello che precede la variabile cercata è un vero underscore e non un carattere speciale.

Bene, una volta inviata la nostra interrogazione possiamo procedere con la stampa:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo $record['Titolo']; echo "<br />";
}

Riepiloghiamo…

In questo caso stampiamo soltanto il titolo, ma possiamo decidere a piacere come far apparire all’utente il risultato della nostra ricerca. Quindi riepiloghiamo tutto il codice della pagina “ricerca.php”:

if(isset($_POST['vai'])) {
echo "Ecco i risultati della tua ricerca:<br /><br /> ";
$parolacercata = $_POST['cerca'];
$query = "SELECT * FROM post WHERE Titolo NOT LIKE '%$parolacercata%'";
$risultato = mysql_query($query);
while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo $record['Titolo']; echo "<br />";
}
}
else {
}

E anche per oggi è tutto… vi aspetto alla prossima!

Terminiamo il nostro panorama sulle operazioni che si possono fare sul database parlando oggi di funzioni aggregate e di query annidate. Iniziamo dalle prime, dette anche “funzioni di aggregazione”: si tratta di una serie di funzioni che il linguaggio SQL ci mette a disposizione per estrarre diversi tipi di informazione dal nostro database, perlopiù di tipo statistico.

La funzione COUNT

Supponiamo, per esempio, di voler creare una pagina all’interno della quale inserire una serie di statistiche relative al nostro blog. Potremmo iniziare dal numero complessivo dei post presenti nel blog (e quindi nel database). Come fare per sapere quanti sono? Utilizziamo la funzione aggregata COUNT, che invocheremo sulla tabella dando un nome al risultato che verrà estratto tramite la clausola AS. Vediamo la sintassi:

$query = "SELECT COUNT(*) AS TotalePost FROM Post";
$risultato = mysql_query($query);

Tutte le funzioni devono essere invocate dopo il comando SELECT. Nel nostro caso, invochiamo la funzione COUNT su tutti i campi (*) e quindi chiamiamo il risultato TotalePost. Possiamo poi stampare il tutto come abbiamo visto finora:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "Totale post presenti nel blog: "; echo $record['TotalePost'];
}

La funzione SUM

Supponiamo invece di voler conoscere il numero totale dei commenti ma senza operare sulla tabella Commenti: vogliamo utilizzare un campo NumCommenti della tabella Post in cui avremo inserito il numero di commenti per ogni singolo post. In questo caso ci sarà di aiuto la funzione SUM, che, come si può intuire dal nome, esegue la somma dei valori dei record. Supponiamo di avere quattro post: il primo ha dodici commenti, il secondo cinque, il terzo nove e il quarto quindici per un totale di quarantuno commenti.

La sintassi è del tutto simile a quella di COUNT. Invochiamo SUM subito dopo il comando SELECT, tra parentesi indichiamo il campo che ci interessa (ovvero il campo i cui valori saranno sommati tra di loro), diamo un nome al risultato e selezioniamo la tabella:

$query2 = "SELECT SUM(NumCommenti) AS TotaleCommenti FROM Post";
$risultato2 = mysql_query($query2);
while ($record2 = mysql_fetch_array($risultato2, MYSQL_ASSOC)) {
echo "Totale commenti presenti nel blog: "; echo $record2['TotaleCommenti'];
}

La funzione AVG

A questo punto potrebbe essere interessante sapere qual è il numero medio di commenti ai post del nostro blog (nel nostro caso è 10,25). Abbiamo anche una funzione per conoscere la media: si tratta di AVG (dall’inglese “average” che significa “media”) e il meccanismo è identico a quello di SUM. Vediamo:

$query3 = "SELECT AVG(NumCommenti) AS MediaCommenti FROM Post";
$risultato3 = mysql_query($query3);
while ($record3 = mysql_fetch_array($risultato3, MYSQL_ASSOC)) {
echo "Media commenti ai post: "; echo $record3['MediaCommenti'];
}

Le funzioni MAX e MIN

Non è cambiato niente, se non la funzione invocata subito dopo il comando SELECT. Potremmo poi voler conoscere qual è il numero dei commenti del post con il maggior numero di commenti e al contrario qual è il numero di commenti del post con il minor numero di commenti. Per compiere queste due operazioni abbiamo le funzioni MAX e MIN, e anche in questi due casi il meccanismo è simile a quello delle funzioni che abbiamo appena visto. Diamo un’occhiata a MAX:

$query4 = "SELECT MAX(NumCommenti) AS Massimo FROM Post";
$risultato4 = mysql_query($query4);
while ($record4 = mysql_fetch_array($risultato4, MYSQL_ASSOC)) {
echo "Numero commenti massimo: "; echo $record4['Massimo'];
}

E adesso MIN:

$query5 = "SELECT MIN(NumCommenti) AS Minimo FROM Post";
$risultato5 = mysql_query($query5);
while ($record5 = mysql_fetch_array($risultato5, MYSQL_ASSOC)) {
echo "Numero commenti minimo: "; echo $record5['Minimo'];
}

Le query annidate

Ma cosa dovremmo fare se volessimo sapere qual è il post con il maggior numero di commenti (e quindi non solo qual è il numero di commenti del post con il maggior numero di commenti)? Dobbiamo ricorrere a una query annidata, detta anche “subquery”: le query annidate sono interrogazioni che si trovano all’interno di altre interrogazioni. Il caso che prendiamo in esame noi è il più semplice: una interrogazione viene posta come condizione della clausola WHERE. Vediamo come funziona:

$query6 = "SELECT Titolo FROM Post WHERE NumCommenti = (SELECT MAX(NumCommenti) FROM Post)";
$risultato6 = mysql_query($query6);

Fino al WHERE quindi niente di strano: dopo l’uguale però inseriamo un nuovo comando SELECT, che dovrà estrarre il numero massimo di commenti presenti in un post. La query “più grande” estrarrà quindi il titolo il cui numero di commenti sarà uguale al massimo numero di commenti per un post presenti nel nostro database. Stampiamo poi molto semplicemente così:

while ($record6 = mysql_fetch_array($risultato6, MYSQL_ASSOC)) {
echo "Post con il maggior numero di commenti: "; echo $record6['Titolo'];
}

Ripetiamo la stessa cosa anche per conoscere il post con il minor numero di commenti. Possiamo poi creare dei comandi SELECT che estraggono informazioni dai risultati di altri comandi SELECT, come in questo caso:

$query = "SELECT * FROM (SELECT * FROM Post WHERE Id > 5) AS PrimaSelect WHERE NumCommenti > 6";
$risultato = mysql_query($query);

Che è una complicazione inutile in quanto avremmo ottenuto lo stesso risultato con un solo comando SELECT, ma è utile per capire il meccanismo delle query annidate. In questo caso selezioniamo tutti i risultati tratti a loro volta dai risultati di una prima selezione, che dovrà obbligatoriamente essere nominata (AS PrimaSelect), altrimenti la query non funzionerà e ci sarà un errore. La prima selezione, quella interna, estrae tutti i record dalla tabella Post che hanno un id maggiore di 5, e da questa selezione, il comando SELECT principale estrae i post che hanno più di sei commenti.

L’esercizio di oggi

Vi lascio come sempre con un esercizio: create una query che esegua la somma di tutti i commenti presenti nel database escludendo però il post con il maggior numero di commenti. Alla prossima!

Continuiamo la panoramica sulle operazioni che si possono fare sul database vedendo oggi due delle operazioni più importanti: la prima serve per estrarre record (e quindi informazioni) dalle tabelle, la seconda invece serve per unire due o più tabelle insieme.

Estraiamo informazioni dal database con SELECT

La prima di queste due operazioni si compie utilizzando il comando SELECT. Proviamo per esempio a selezionare il campo Titolo e il campo Link dalla tabella post:

$query = "SELECT Titolo, Link FROM Post";

La sintassi è quindi semplice: basta scrivere SELECT seguito dal nome dei campi da cui vogliamo estrarre informazioni, ognuno separato dall’altro attraverso una virgola, e quindi, dopo la parola FROM scrivere il nome della tabella. E se volessimo invece selezionare tutti i campi? Invece di scrivere i nomi di tutti quanti i campi, basta semplicemente inserire un asterisco tra SELECT e FROM:

$query = "SELECT * FROM Post";

E ovviamente, anche con SELECT, possiamo utilizzare le clausole WHERE, AND e OR:

$query = "SELECT * FROM Post WHERE Titolo = 'Ciao'";
$query2 = "SELECT * FROM Post WHERE Titolo = 'Ciao' AND IdAutore = 1";
$query3 = "SELECT * FROM Post WHERE Titolo = 'Ciao a tutti' OR Titolo = 'Ciao'";


Nel primo caso abbiamo selezionato tutti i campi della tabella Post dai record il cui titolo è “Ciao”, nella seconda query stessa cosa ma i post devono essere stati scritti dall’autore contrassegnato dall’id numero 1, e nella terza interrogazione abbiamo invece selezionato tutti i campi dei record che hanno come titolo “Ciao a tutti” oppure “Ciao”.

La clausola ORDER BY

Possiamo poi anche dare un ordine ai record che estraiamo con il comando SELECT, utilizzando la clausola ORDER BY seguita dal campo in base al quale vogliamo ordinare le informazioni. Se per esempio vogliamo ordinarli in base alla data:

$query = "SELECT * FROM Post WHERE Titolo = 'Ciao' AND IdAutore = 1 ORDER BY Data DESC";

E possiamo scegliere se ordinare in modo decrescente, come nel caso dell’esempio (DESC) oppure per ordinare in modo crescente (ASC).

Utilizziamo le informazioni estratte: mysql_fetch_array

In genere il SELECT si usa, come abbiamo detto all’inizio, per estrarre informazioni: e tali informazioni andranno poi mostrate all’utente. Bene, come si fa per mostrare queste informazioni all’utente? Abbiamo bisogno di una nuova funzione, mysql_fetch_array. Riceve come primo parametro il risultato della funzione mysql_query, e come secondo parametro il tipo di array che vogliamo utilizzare, perché il risultato della nostra query sarà trasformato in un array. Possiamo quindi scegliere un array numerico (MYSQL_NUM), un array associativo (MYSQL_ASSOC) o entrambi (MYSQL_BOTH). Il mio consiglio è quello di utilizzare un array associativo: gli indici saranno nient’altro che i nomi dei campi. Se non volete specificare il tipo di array, sarà assegnato quello di default, ovvero MYSQL_BOTH.

E dal momento che avremo bisogno di creare un array per ogni record del database, dovremo utilizzare una iterazione di tipo while, e per stampare ciò che ci interessa dovremo tener conto del fatto che staremo operando su di un array:

$query = "SELECT * FROM Post WHERE IdAutore = 1";
$risultato = mysql_query($query);
while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "{$record['Titolo']}<br />";
}

Attraverso il nostro while, nel caso dell’esempio, con una stampa scriviamo nella pagina il titolo dei post che soddisfano le condizioni poste dal comando SELECT.

Uniamo le tabelle con JOIN

Bene, facciamo ora un altro esempio. Supponiamo di voler scrivere, da qualche parte nella home page del nostro blog, i titoli dei post accompagnati dal nickname dell’autore. Nella tabella post il nickname dell’autore degli articoli non è presente: abbiamo soltanto l’id. Come facciamo quindi a compiere questa operazione? Dovremo necessariamente unire la tabella Post con la tabella Autori, per fare in modo che ai campi della tabella Post vengano anche aggiunti i campi della tabella Autori.

Per fare questo utilizziamo il comando JOIN, ma ci deve essere una condizione, ovvero la base su cui uniremo le tabelle. Cosa significa? Significa che dovrà esserci un campo che avrà gli stessi valori per entrambe le tabelle. Nel nostro caso è il campo dell’id dell’autore, ovvero IdAutore nella tabella Post e Id nella tabella Autori: affinché le due tabelle possano essere unite, ci deve essere una corrispondenza tra IdAutore di Post e Id di Autori. Questo significa che a tutti i record che hanno un certo IdAutore verranno abbinati i valori di quei record della tabella Autori il cui Id è lo stesso di IdAutore.

Nel nostro database l’autore 1 è Laura. Con il comando JOIN, a tutti i post scritti da Laura memorizzati nella tabella Post e contrassegnati, ovviamente, con l’IdAutore uguale a 1, saranno affiancati i record della tabella Autori il cui Id è uguale a 1.

Vediamo quindi la sintassi:

$query = "SELECT * FROM Post JOIN Autori ON Post.IdAutore = Autori.Id";
$risultato = mysql_query($query);

Quindi subito dopo il nome della tabella inseriamo il comando JOIN seguito dal nome della tabella da unire. Inseriamo poi la clausola ON seguita dai due campi delle tabelle che devono corrispondere tra di loro: nel nostro caso IdAutore per quanto riguarda Post e Id per quanto riguarda Autori. Deve essere scritto prima il nome della tabella, quindi, dopo un punto, il nome del campo (tabella.campo).

Per stampare i risultati il metodo è ancora quello di prima:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "{$record['Titolo']}, scritto da {$record['Nickname']}<br />";
}

Rinominiamo (provvisoriamente) campi e tabelle con la clausola AS

Supponiamo ora di voler stampare sia davanti al post che davanti all’autore il rispettivo id. Per esempio in questa forma: “Post numero 2: Ciao a tutti!!!, scritto da LauraD (autore numero 1)”. Se scrivessimo una cosa del genere:

echo "Post numero {$record['Id']}: {$record['Titolo']}, scritto da {$record['Nickname']} (autore
numero {$record['Id']})<br />";

Ovviamente non otterremmo il risultato sperato, perché ci sono due campi che hanno lo stesso nome (Id), e quando succede questo viene preso il campo Id dell’ultima tabella presa in considerazione (nel nostro caso Autori) e scartato il campo con lo stesso nome nelle tabelle precedenti. Per ovviare a questo problema possiamo rinominare, all’interno della query, il campo che crea il conflitto. Lo facciamo tramite la clausola AS, che deve essere seguita dal nuovo nome del campo che ci interessa:

$query = "SELECT Post.Titolo, Post.Id, Autori.Id AS NumeroAutore, Autori.Nickname FROM Post JOIN Autori ON Post.IdAutore = Autori.Id";
$risultato = mysql_query($query);

Abbiamo quindi rinominato il nome del campo Id della tabella Autori in NumeroAutore (ovviamente solo momentaneamente, per la query: non abbiamo alterato in alcun modo la struttura della tabella all’interno del nostro database). Stampiamo poi in questo modo:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "Post numero {$record['Id']}: {$record['Titolo']}, scritto da {$record['Nickname']} (autore
numero {$record['NumeroAutore']})<br />";
}

Si possono poi rinominare anche le tabelle, magari per questioni di praticità e rapidità, e il sistema è lo stesso che abbiamo appena visto:

$query = "SELECT * FROM Post AS p JOIN Autori AS a ON p.IdAutore = a.Id";
$risultato = mysql_query($query);

Tipi di unioni

Le unioni che abbiamo visto fino a questo momento sono unioni di tipo INNER JOIN: significa che vengono combinati tutti i record che hanno una corrispondenza e vengono invece scartati i record che non hanno corrispondenza. Avremmo potuto specificare meglio le query viste finora (prendiamo per esempio l’ultima) scrivendo così:

$query = "SELECT * FROM Post AS p INNER JOIN Autori AS a ON p.IdAutore = a.Id";
$risultato = mysql_query($query);

Ma dal momento che si tratta del tipo di unione predefinito possiamo anche non specificarlo. Questo perché esiste anche un altro tipo di unione, OUTER JOIN, che al contrario delle unioni di tipo INNER JOIN tiene conto anche dei risultati che non trovano corrispondenza tra di loro. Le unioni OUTER JOIN si suddividono a loro volta in LEFT JOIN, ovvero unioni che contengono sempre tutti i record della prima tabella (la tabella di sinistra, left) mentre per quanto riguarda i record della seconda tabella (quella di destra, right) vengono estratti solo i record che trovano una corrispondenza con quelli della tabella di sinistra, e in RIGHT JOIN, che funzionano all’inverso rispetto alle unioni LEFT JOIN.

Per esempio, supponiamo di avere tre autori e quattro post: tre scritti dall’autore 1, uno scritto dall’autore 2 e nessuno scritto dall’autore 3. Prendiamo questa query:

$query = "SELECT * FROM Autori LEFT JOIN Post ON Autori.Id = Post.IdAutore";
$risultato = mysql_query($query);

In questo caso vengono selezionati tutti i record della tabella Autori uniti ai soli record della tabella Post che trovano una corrispondenza. Con un INNER JOIN l’autore numero 3 non sarebbe stato preso in considerazione dalla query, invece con questo OUTER JOIN di tipo LEFT (avremmo potuto scrivere, nel comando, anche LEFT OUTER JOIN) l’autore numero 3 viene comunque estratto. Se poi stampassimo:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "{$record['Titolo']}, scritto da {$record['Nickname']}<br />";
}

Nel ciclo corrispondente all’autore numero 3 verrebbe stampato uno spazio bianco, perché non esisterebbe un elemento dell’array con indice Titolo abbinato all’elemento “Nickname” relativo all’autore 3.

Il RIGHT JOIN funziona allo stesso modo del LEFT JOIN ma in maniera inversa:

$query = "SELECT * FROM Post RIGHT JOIN Autori ON Autori.Id = Post.IdAutore";
$risultato = mysql_query($query);

In questo caso vengono estratti tutti i record della tabella di destra (Autori) mentre per quanto riguarda la tabella di sinistra (Post) vengono estratti solo i record che hanno una corrispondenza con Autori.

Vediamo un’altra informazione importante. Specifichiamo sempre la clausola ON altrimenti, se scrivessimo una cosa del genere:

$query = "SELECT * FROM Post JOIN Autori";
$risultato = mysql_query($query);

Otterremmo un CROSS JOIN, ovvero il prodotto cartesiano delle due tabelle, cosa che sicuramente, almeno ai fini del nostro blog, non ci interessa.

Unioni tra tre o più tabelle

Possiamo poi unire anche tre o più tabelle tra loro. Per esempio, se avessimo un’ipotetica tabella DatiAutori in cui inserire indirizzi, numeri di telefono, immagini e quant’altro, potremmo scrivere una cosa del genere:

$query = "SELECT Post.Titolo, Autori.Nickname, DatiAutori.Email FROM Post JOIN Autori ON Post.IdAutore = Autori.Id JOIN DatiAutori ON Autori.Id = DatiAutori.IdAutore";
$risultato = mysql_query($query);

E poi stampare in questo modo:

while ($record = mysql_fetch_array($risultato, MYSQL_ASSOC)) {
echo "{$record['Titolo']}, scritto da {$record['Nickname']} (email: {$record['Email']})<br /><br />";
}

Abbiamo quindi ottenuto un’unione di tre tabelle, ma non c’è limite al numero di tabelle che possiamo unire.

L’esercizio di oggi

Bene, per oggi siamo arrivati alla fine e vi lascio con un esercizio. Create uno script per stampare, nella home page, il titolo dei post, il nome dell’autore e i titoli dei commenti relativi al post, in questa forma:

Post: Ciao a tutti!
Scritto da: Federico

Commenti…
Ciao!
Benvenuto!
Bellissimo sito!

Postate come sempre le soluzioni come commenti, io vi aspetto alla prossima puntata!

Iniziamo oggi una “gita” di tre puntate all’interno delle operazioni che si possono fare sul database, cercando di fornire una panoramica abbastanza completa per poter gestire un sito PHP/MySQL di una certa complessità. Oggi vedremo tre operazioni sul database, e in particolare vedremo come inserire, aggiornare e cancellare record.

Inseriamo dati con INSERT

Partiamo dalla prima: l’operazione INSERT. No, non è una parola urlata: i comandi SQL si scrivono tutti maiuscoli (in PHP si possono comunque scrivere tutti minuscoli e non succede niente di strano: è sempre però bene scriverli tutti maiuscoli in primo luogo perché così prevede la documentazione ufficiale, in secondo luogo per non rischiare di fare confusione e in terzo luogo perché è sempre bello mantenere una forma elegante!

Prima però dobbiamo fare una piccola introduzione. L’ultima volta abbiamo detto che le interrogazioni al database si chiamano “query” (anche le operazioni di inserimento, aggiornamento e cancellazione si chiamano “query”). Per gestire le query inviate al database esiste una specifica funzione PHP, che si chiama mysql_query e che riceve come parametro proprio la query. Ma cos’è in sostanza una query parlando solo di PHP? Non è altro che una stringa di testo, ma una stringa un po’ particolare, perché contiene nient’altro che le istruzioni SQL.

Vediamo quindi come funziona il tutto. L’operazione di inserimento prevede che venga scritto prima il comando INSERT INTO, quindi il nome della tabella all’interno della quale inserire i dati, poi la clausola VALUES seguita, tra parentesi tonde, dai dati da inserire scritti nell’ordine di come appaiono i campi nella tabella. Prendiamo come punto di riferimento la tabella Post che abbiamo creato la volta scorsa: dovremo seguire, in fase di inserimento, l’ordine Id – IdAutore – Titolo – TestoHTML – Data – Link. Questo è ciò che dovremo quindi scrivere:

$query = "INSERT INTO Post VALUES ('NULL', '1', 'Ciao a tutti', 'Ciao a tutti! Questo è il mio primo post', '2011-04-03 12:00:00', '/post/primopost')";

Se invertissimo l’ordine (per esempio scambiando “1” con “Ciao a tutti”) il risultato sarebbe l’inserimento di “Ciao a tutti” nel campo IdAutore e “1” nel campo Titolo: ci sarebbe quindi un errore, perché abbiamo assegnato a IdAutore il tipo INT, e “Ciao a tutti” non è davvero un numero intero. Quindi bisogna fare grande attenzione a rispettare l’ordine dei campi in questa operazione (sbagliarsi non è difficile). Un’altra accortezza: le stringhe di testo vanno sempre messe tra apici o doppi apici. Per quanto riguarda i campi di tipo INT, si possono anche lasciare senza apici. Mi raccomando, perché se non inserite le stringhe tra apici, la query non verrà eseguita. Infine, l’ultima cosa di cui tener conto. Abbiamo inserito il valore NULL nel campo Id perché si tratta di un campo a cui abbiamo assegnato l’auto-incremento: non sarà quindi necessario specificare il numero, perché verrà automaticamente inserito il primo numero libero disponibile. Per esempio, se questo è il primissimo post del nostro blog, nel campo Id sarà inserito il numero zero.

Bene, detto questo e una volta dichiarata la variabile $query, che non è altro che una stringa di testo, come abbiamo detto, dobbiamo invocare la funzione mysql_query:

mysql_query($query);

Fatte queste operazioni, i dati verranno inseriti nel database. Mi preme specificare che la funzione mysql_query è da utilizzarsi per qualsiasi operazione eseguita sul database, quindi sarà una funzione che ci accompagnerà per un bel po’ di tempo. Potete trovare la documentazione ufficiale a questa pagina: http://php.net/manual/en/function.mysql-query.php.

Abbiamo visto come inserire dati che riempiano tutti i campi della tabella. Ma cosa dovremmo fare se volessimo riempire soltanto alcuni campi? Per esempio se volessimo lasciare in bianco il campo Link? Dovremmo specificare i singoli campi subito dopo il nome della tabella, inserendoli tra parentesi tonde, come nell’esempio seguente:

$query = "INSERT INTO Post (Id, IdAutore, Titolo, TestoHTML, Data) VALUES ('NULL', '1', 'Ciao a tutti', 'Ciao a tutti! Questo è il mio primo post', '2011-04-03 12:00:00')";
mysql_query($query);


In questo modo verranno inseriti tutti i dati che abbiamo specificato ma sarà lasciato in bianco il campo Link. Questa sintassi è più o meno simile per tutte le operazioni SQL: abbiamo un comando e abbiamo poi una o più clausole che specificano meglio ciò che viene indicato dal comando.

Aggiorniamo i dati con UPDATE

Passiamo ora al comando UPDATE, che serve per aggiornare i record e che è un pochino più complesso rispetto a INSERT. Partiamo dal caso base, quello per aggiornare un solo campo, ma in tutti i record:

$query = "UPDATE Post SET IdAutore = 1";
mysql_query($query);

La clausola WHERE

Questo è il caso più banale (e, se vogliamo, anche il più inutile): con il comando UPDATE abbiamo aggiornato la tabella Post impostando tutti i valori del campo IdAutore (quindi su tutti i record) a 1. Per aggiornare soltanto un campo nella tabella (o due o tre o comunque non tutti), dovremo essere più specifici: ci servirà la clausola WHERE, tramite la quale specificheremo un altro campo che dovrà identificare bene il record (o i record) da aggiornare. Ma vedendo il codice è più facile da intuire:

$query = "UPDATE Post SET Titolo = 'Secondo post' WHERE Id = '1'";
mysql_query($query);

In questo modo abbiamo modificato un solo record, quello che ha come Id il numero uno (ricordiamo che Id è la chiave primaria della nostra tabella quindi si tratta di un campo che non può essere doppio, non ci saranno cioè due record con lo stesso valore nel campo Id). Una piccola parentesi: noi stiamo facendo le operazioni con due passaggi ma nessuno vi vieta di fare le interrogazioni in questo modo:

mysql_query("UPDATE Post SET Titolo = 'Secondo post' WHERE Id = '1'");

È un modo più rapido per fare la stessa cosa: in questa guida facciamo però uso delle variabili per una più chiara lettura e comprensione della sintassi SQL.

Ma andiamo avanti con le nostre operazioni. Se nel nostro database avessimo due post che hanno come titolo “Ciao” e volessimo cambiarlo in “Ciao a tutti!” dovremmo comportarci come sopra:

$query = "UPDATE Post SET Titolo = 'Ciao a tutti!' WHERE Titolo = 'Ciao'";
mysql_query($query);

Le clausole OR e AND

WHERE è una delle clausole più importanti della sintassi SQL perché si abbina a moltissimi comandi. Cosa dobbiamo fare invece se vogliamo dare lo stesso titolo a due post che hanno titoli diversi, per esempio uno “Ciao” e uno “Ciao a tutti!”? Introduciamo un’altra clausola, OR:

$query = "UPDATE Post SET Titolo = 'Ciao a tutti quanti!!!' WHERE Titolo = 'Ciao' OR Titolo = 'Ciao a tutti!'";
mysql_query($query);

La clausola OR serve per “legare” tra di loro due espressioni introdotte dalla clausola WHERE, e possiamo usarla, all’interno della stessa query, tutte le volte che vogliamo (anche tre o quattro o più volte:

$query = "UPDATE Post SET Titolo = 'Ciao a tutti quanti!!!' WHERE Titolo = 'Ciao' OR Titolo = 'Ciao a tutti!' OR Titolo = 'Altro post' ";
mysql_query($query);

Cosa fare invece quando abbiamo tre post con titolo “Ciao a tutti!”, scritti da due autori diversi, e noi vogliamo cambiare il titolo solo a quelli scritti da un certo autore? Dobbiamo utilizzare la clausola AND:

$query = "UPDATE Post SET Titolo = 'Ciao a tutti quanti!!!' WHERE Titolo = 'Ciao a tutti!' AND IdAutore = 1";
mysql_query($query);

In questo modo abbiamo impostato il titolo a tutti quei post che hanno come titolo “Ciao a tutti!” e che sono stati scritti dall’autore contrassegnato dall’id 1. Quindi se ci sono altri post che hanno per titolo “Ciao a tutti!” (scritti ovviamente da autori diversi) o se ci sono altri post scritti dallo stesso autore (con titolo diverso), bene, tutti questi post non saranno aggiornati: l’operazione sarà valida solo per i post che soddisfano le clausole WHERE e AND.

Ovviamente poi, nelle espressioni delle clausole, è possibile usare, oltre all’uguale, anche altri operatori (maggiore, minore, maggiore-uguale, minore-uguale). Per esempio, volendo cambiare il titolo a tutti i post che hanno un Id maggiore di 5:

$query = "UPDATE Post SET Titolo = 'Ciao' WHERE Id > 5";
mysql_query($query);

La clausola LIMIT

Introduciamo poi un’ulteriore clausola, che ci serve se vogliamo prendere un certo numero di record contigui. Per esempio, prendiamo il caso che abbiamo visto adesso: vogliamo cambiare il titolo a tutti i post che hanno un id maggiore di 5, ma arrivando solo fino a quello che ha come id 8 (quindi valido solo per i primi tre record). Vogliamo quindi non aggiornare i post che hanno id 9, 10, 11 eccetera. Ci serve la clausola LIMIT che deve essere seguita da un numero che indica il numero di post da tenere in considerazione:

$query = "UPDATE Post SET Titolo = 'Ciao a tutti!!!' WHERE Id > 5 LIMIT 3";
mysql_query($query);

In questo modo aggiorniamo sì i post che hanno un id maggiore di 5, ma solo i tre immediatamente successivi grazie alla clausola LIMIT. Verranno aggiornati quindi solo i post 6, 7 e 8.

Cancelliamo i dati con DELETE

Vediamo infine l’ultima istruzione, DELETE, che serve per cancellare record dal nostro database. Per cancellare un singolo record dal database la sintassi è molto semplice:

$query = "DELETE FROM Post WHERE Id = '1'";
mysql_query($query);

Abbiamo semplicemente cancellato il post che ha come id il numero 1. Possiamo applicare anche a DELETE tutte le clausole che abbiamo visto per UPDATE. Vediamo per esempio con le clausole OR e AND:

$query = "DELETE FROM post WHERE Id = 5 OR Id = 6";
mysql_query($query);

$query2 = "DELETE FROM post WHERE Titolo = 'Ciao a tutti' AND IdAutore = 3";
mysql_query($query2);

Nel primo caso abbiamo cancellato i post contrassegnati dagli id 5 e 6, nel secondo caso abbiamo invece cancellato tutti i post che hanno per titolo “Ciao a tutti” e che sono stati scritti dall’autore contrassegnato dall’id numero 3.

È possibile anche cancellare tutta la tabella:

$query = "DELETE FROM post";
mysql_query($query);

Attenzione però! Una volta eseguito lo script non è più possibile arrestarlo o tornare indietro, quindi mi raccomando di usarlo con parsimonia, solo se si è sicuri del risultato e dove non fa danni.

L’esercizio di oggi

Bene, siamo arrivati alla fine e vi lascio con un esercizio: riprendiamo quindi la tradizione iniziata qualche puntata fa! Costruite una vera pagina per scrivere post in un blog, nel senso che abbiamo un form con una serie di opzioni, e una volta compilato il tutto, i dati immessi dal nostro utente vengono inviati al nostro database. Per la stampa della data potete utilizzare la funzione date che abbiamo visto nella puntata in cui abbiamo costruito il guestbook. Alla prossima!

Dopo una panoramica teorica su MySQL, è finalmente arrivato il momento di costruire il nostro database. Lo faremo direttamente tramite il programma PhpMyAdmin, senza utilizzare comandi. Per prima cosa avviamo il nostro Wamp, facciamo clic con il tasto sinistro sull’icona nella barra delle applicazioni e quindi, dal menù, selezioniamo la seconda voce: PhpMyAdmin.

Creiamo un nuovo database con PhpMyAdmin

Ci si aprirà la pagina del browser che avevamo scelto durante le fasi di installazione di Wamp. Se avete il programma in italiano, noterete che più o meno al centro della pagina c’è una sezione con scritto “MySQL localhost” e, subito sotto, la scritta “Crea un nuovo database” sotto la quale compaiono due campi. In quello vuoto, inseriamo il nome del nostro database (per esempio, “mioblog”). Il secondo è un select, che serve per selezionare la “collation”, ovvero il set di caratteri del nostro database: andrà bene un utf8_general_ci.

Possiamo quindi fare clic sul tasto crea: adesso abbiamo un database, chiamato “mioblog”, ovviamente vuoto perché dobbiamo ancora creare le tabelle. Portiamoci quindi dentro la pagina del database: vediamo un menù con una serie di voci “struttura”, “sql”, “cerca”, “query da esempio”, “esporta”, “importa”, “operazioni”, “privilegi”, “elimina”. Vedremo dopo a cosa servono queste voci: adesso è il momento di creare una tabella.

Lo facciamo tramite il form che vediamo al centro della pagina. Supponiamo quindi di voler creare la tabella “post” come abbiamo visto nell’ultima puntata. Inseriamo nel primo campo il nome della tabella, e nel secondo il numero di campi (cioè degli attributi a cui andremo ad associare i valori): nel nostro caso, i campi sono sei (uno per l’id, uno per l’id dell’autore, uno per il titolo, uno per il testo formattato in linguaggio HTML, uno per la data e uno per il link al post).

A questo punto ci comparirà un form con un numero di righe uguale al numero che abbiamo immesso poc’anzi, e per ogni riga notiamo una serie di colonne, di cui adesso comprendiamo il significato:

• Campo: è il nome del campo. Nel caso della nostra tabella, il primo sarà “Id”, il secondo “IdAutore”, il terzo “Titolo” e così via. Il consiglio che vi do è quello di utilizzare, per i campi, sempre caratteri alfanumerici o al più underscore se vogliamo inserire spazi. Sono da evitare caratteri accentati e caratteri speciali. In più, non è possibile assegnare ai nomi dei campi le parole chiave che definiscono i comandi SQL (sono un gruppo di parole come SELECT, DELETE, LIKE, LIMIT, JOIN e altre che conosceremo nelle prossime puntate);
• Tipo: è il tipo del campo. I principali sono: INT (numero intero), VARCHAR (stringa di caratteri a lunghezza variabile), DATE e DATETIME (per le date: il secondo tipo può contenere anche l’ora), TEXT, MEDIUMTEXT e LONGTEXT (testi per un massimo di, rispettivamente, 2^16, 2^24 e 2^32 caratteri), DECIMAL (per i numeri decimali). Nel nostro caso inseriremo i tipi INT per Id, IdAutore e NumCommenti, VARCHAR per Titolo e Link, DATETIME per data e TEXT per TestoHTML ;
• Lunghezza/Set: la lunghezza massima dei campi. Per i campi numerici tipicamente si inserisce 11 come lunghezza (ovvero il numero massimo che un campo di tipo INT può avere come lunghezza: se lasciamo in bianco verrà apposto automaticamente proprio 11), mentre per i nostri campi VARCHAR possiamo scegliere una lunghezza massima di 100 caratteri. Lasciamo in bianco DATETIME e TEXT;
• Predefinito, Collation, Attributi e Null: possiamo tralasciare queste colonne per cui le lasciamo in bianco (per la cronaca, servono rispettivamente: se vogliamo dare un valore predefinito al campo, se vogliamo dare al campo un set di caratteri diverso rispetto a quello dell’intero database, se vogliamo specificare attribuiti particolari -per esempio se vogliamo assegnare al campo una collation binaria- e se vogliamo associare, tra gli altri, anche il valore NULL al nostro campo).
• Indice: serve per impostare l’indice al campo. A noi interessa l’indice “PRIMARY”, che serve per identificare il campo “più importante” della tabella, il cui valore deve essere univoco (non devono cioè esserci altri record con lo stesso valore per quel campo). Solitamente è il campo Id;
• AUTO_INCREMENT: questo è molto importante. Serve per far aumentare automaticamente di una unità il campo ogni volta che verrà inserito un nuovo record. Lo spuntiamo solo per il campo Id;
• Commenti: se vogliamo aggiungere commenti per un campo.

Gestiamo le tabelle

Una volta creata la nostra prima tabella possiamo creare tutte le altre e cominciare a svolgere su di esse alcune operazioni. Prima però vediamo cosa significano quelle voci di MySQL di cui abbiamo parlato prima:

• Struttura: ci mostra la struttura del database, ovvero l’elenco delle tabelle;
• SQL: contiene un campo che ci permette di eseguire sintassi SQL (che inizieremo a vedere dalla prossima puntata);
• Cerca: per cercare una parola, un valore nel database;
• Query da esempio: se non conosciamo la sintassi SQL, questa voce ci aiuta a fare interrogazioni al database;
• Esporta: per esportare il database (possiamo scegliere tra tanti formati);
• Importa: se abbiamo un database (solitamente un file con estensione .sql) possiamo importarlo;
• Operazioni: se vogliamo inserire una nuova tabella, rinominare il database, copiarlo o cambiare la collation;
• Privilegi: se ci sono più utenti che utilizzano PhpMyAdmin, possiamo impostare da qui i loro privilegi in termini di operazioni che possono eseguire sui database.

Vediamo ora quali sono le operazioni che si possono fare sulle diverse tabelle. Clicchiamo quindi su una delle nostre tabelle (ricordo che l’elenco si può trovare nella pagina “Struttura”): vedremo un’altra serie di voci che costituiscono un menù. Vediamo a cosa servono:

• Mostra: cliccando su questa voce potremo vedere tutti i record del database, e possiamo modificarli velocemente (facendo clic sull’icona a forma di penna, attraverso la quale ci si aprirà un form simile a quello della voce “Inserisci” che vedremo tra poco) o eliminarli (facendo clic sull’icona a forma di croce: prima ci verrà chiesta la conferma dell’operazione);
• Struttura: ci mostra la struttura della tabella. I campi possono essere modificati o eliminati;
• SQL: per eseguire sintassi SQL sulla tabella;
• Cerca: per cercare un valore nella tabella;
• Inserisci: per inserire record nella tabella. Ci apparirà un form in cui dovremo inserire un valore per ogni attributo e quindi fare clic su “esegui”;
• Esporta e Importa: per esportare e importare la tabella;
• Operazioni: da qui possiamo riordinare, spostare, copiare, rinominare, commentare, analizzare la tabella;
• Svuota: per cancellare tutti i record della tabella;
• Elimina: per cancellare tutta la tabella.

Gestire i database con PhpMyAdmin, una volta appresi questi concetti, diventa, ovviamente con l’esercizio e con la pratica, molto semplice e intuitivo.

La connessione al database da PHP

Come ultimo argomento di oggi vediamo come connetterci al database attraverso il nostro sito in PHP. Dobbiamo innanzitutto creare quattro variabili, che ci servono per memorizzare l’indirizzo del server, il nome del database, il nome dell’utente e la password dell’utente del database. Tipicamente, quando si lavora in locale, il server è “localhost” e il nome dell’utente è “root”:

$host = 'localhost';
$utente = 'root';
$password = 'password';
$db = 'primoprogetto';

A questo punto dobbiamo quindi invocare la funzione mysql_connect, che serve, come avrete intuito dal nome, a far sì che il nostro sito possa connettersi al server MySQL. La funzione riceve come parametri l’indirizzo del server, il nome dell’utente e la sua password:

$connessione = mysql_connect($host,$utente,$password);

Tipicamente si usa “estendere” la funzione mysql_connect con la funzione die, che serve per fermare lo script in caso di errori e per stampare di conseguenza un messaggio all’utente. Si invoca subito dopo mysql_connect, a cui viene unita tramite la parola “or”:

$connessione = mysql_connect($host,$utente,$password) or die("Connessione non riuscita");

Se non avverrà una connessione al server MySQL per un qualsiasi errore (per esempio, se abbiamo inserito la password sbagliata), ci sarà un warning e verrà stampata la scritta “Connessione non riuscita”. Abbiamo associato il risultato di questa funzione a una variabile perché è possibile chiudere la connessione tramite la funzione mysql_close, che riceve come parametro proprio il risultato di mysql_connect:

mysql_close($connessione);

È bene specificare che la connessione si chiude comunque quando si arresta lo script che la esegue: tuttavia mysql_close può servirci se vogliamo chiudere noi la connessione in un qualche punto preciso del nostro sito.

A questo punto, dopo esserci connessi al server, dobbiamo selezionare il database che ci interessa, e lo facciamo tramite la funzione mysql_select_db, che riceve come parametro il nome del nostro database (che avevamo memorizzato nella variabile $db):

mysql_select_db($db);

Bene! Adesso siamo collegati al nostro database. Le documentazioni ufficiali delle funzioni che abbiamo visto nella puntata si trovano qui: http://php.net/manual/en/function.mysql-connect.php (mysql_connect), http://it.php.net/manual/en/function.die.php (die), http://it.php.net/manual/en/function.mysql-close.php (mysql_close), http://it.php.net/manual/en/function.mysql-select-db.php (mysql_select_db).

Quindi, ricapitolando, il codice per connetterci al database è questo:

<?php
$host = 'localhost';
$utente = 'root';
$password = 'password';
$db = 'primoprogetto';
$conn = mysql_connect($host,$utente,$password) or die("Connessione non riuscita");
mysql_select_db($db);
?>

E dovremo utilizzarlo in ogni singola pagina del sito per la quale è prevista una interazione con il database, quindi il consiglio che vi do è quello di creare un file esterno in cui inserirete questi dati, e poi lo richiamerete in ogni pagina semplicemente con un include. Ci vediamo alla prossima puntata!