PDO: connessione e gestione degli errori

PDO, acronimo di PHP Data Objects, è un'estensione introdotta con php 5 che costituisce un'interfaccia coerente ed uniforme per l'accesso e l'interazione ai vari tipi di database. Essa ci consentirà di scrivere codice PHP cross-database che renderà semplice il passaggio tra le diverse tipologie di database (ad esempio MySql, SQLite, MsSQL, etc etc).

Infatti, se sviluppiano applicativi in php utilizzando MySql e le funzioni ad esso dedicato (mysql_connect, mysql_select_db, mysql_query, etc. etc.) saremo vincolati ad usare necessariamente MySql; il passaggio ad un'alta tipologia di database, ad esempio SQLite, richiederà la modifica dell'intero codice per sostituire le funzioni con quelle opportune (sqlite_open, sqlite_exec, etc etc).

Al contrario, utilizzando PDO tale operazione sarà indolore: infatti, indipendentemente dal database con cui andremo ad interagire le funzioni impiegate per eseguire le query saranno sempre le stesse.

I database con i quali possiamo interagire

La tipologia di database con i quali potremo interagire dipende dai driver disponibili nella versione di PHP che stiamo utilizzando. Per conoscerli faremo:

print_r(PDO::getAvailableDrivers());

Connessioni al database

La connessione al database avviene attraverso l'istanza del PDO: definiremo il tipo, il nome e le credenziali di accesso del database che andremo ad interrogare. 

Il primo parametro di tale istanza è il DSN e definirà, così, il tipo e il nome del database che intendiamo utilizzare. Questo è diverso a seconda del tipo di database; ecco di seguito alcuni esempi:

<?php
// MySQL
$mysql_dsn = "mysql:host=localhost;dbname=test";

// SQLite
$sqlite_dsn = "sqlite:path/database.db";

// PostgreSQL
$postgresql_dsn = "pgsql:dbname=pg1;host=localhost";
?>

Il secondo è il terzo parametro sono rispettivamente username e password di accesso al nostro database.

Il corretto utilizzo del PDO richiede il costrutto try/catch (fra poco capiremo il perchè) e, pertanto, la maniera corretta per connettersi al database sarà: 

<?php
try 
	{
	$dsn = "mysql:host=localhost;dbname=test";
	$username = "root";
	$pass = "";

	$PDO = New PDO($dsn, $username, $pass);
	} 
catch (PDOException $e) {
	die('Connessione fallita: ' . $e->getMessage());
	}
?>

Try/catch dovrà essere necessariamente utilizzato in fase di connessione per poter tracciare il fallimento di questa (altrimenti in caso di fallimento si avrà un "rozzo" FATAL ERROR).

In tutti gli altri casi, come vedremo, gli errori potranno essere diversamente gestiti.

Gli attributi

Il costruttore ammette un quarto parametro opzionale, costituito da un array (con struttura "nome attributo" => "valore attributo") che ci servirà per definire gli attibuti: questi definiscono alcuni dei "comportamenti" che assumerà la classe PDO durante tutto il suo utilizzo.

Inoltre, questi possono settati e letti ricorrendo ai metodi setAttribute e getAttribute.

Nel corso della trattazione esamineremo alcuni di questi attributi.

Gestire gli errori

Fra gli attributi che possiamo settare vi è il gestore degli errori:

$PDO->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

Nel codice mostrato settiamo l'attributo PDO::ATTR_ERRMODE con il valore PDO::ERRMODE_EXCETPION attraverso il metodo setAttribute. Questo definisce il comportamento che assumerà il gestore degli errori. 

Per comprendere, guardiamo questo "classico" utilizzo delle funzioni per interrogare i database a cui tutti siamo stati abituati:

<?php
$res = @mysql_query("SELECT * FROM inesistente");
if (!$res) {
    die('Query fallita: ' . mysql_error());
}
?>

In questo esempio proposto la funzione mysql_query in caso di errore SQL darà come return FALSE, genera un WARNING che "azzittiamo" con l'operatore silence @ e interrompiamo l'esecuzione con die facendoci mostrare la tipologia di errore riscontrato. 

Se si utilizza il PDO per gestire gli errori avremo tre possibilità:

1. PDO::ERRMODE_SILENT: non produce alcun errore; questo è il valore di default.
2. PDO::ERRMODE_WARNING: in questo caso sarà sollevato un WARNING;
3. PDO::ERRMODE_EXCEPTION: viene sollevata una eccezione.

Quest'ultima modalità è sicuramente quella più rigorosa dal punto di vista della OOP.

Occorre evidenziare che per intercettare le eccezioni si dovrà ricorrere al costrutto try/catch. 

Pertanto, se interagendo con la nostra base dati dovesse verificarsi qualche errore SQL verranno sollevate le cosiddette exceptions che per essere intercettate richiedono il costrutto try catch. 

Le eccezioni non è argomento che attiene direttamente il PDO ma colgo l'occasione per segnalare un ottimo articolo introduttivo che ne parla specificatamente.

A titolo puramente esemplicativo, utilizzando PDO avremo che:

<?php
// settiamo il gestore degli errori
$PDO->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

try{ 
	// commettiamo un errore SQL
	$PDO->query("SELECT * FROM inesistente");
	}
catch(PDOException $e){
	// otteniamo l'errore
	echo 'Error: ' . $e->getMessage(); 
	echo 'Line: ' . $e->getLine(); 
	echo 'File: ' . $e->getFile(); 
	}

Se invece non intendiamo servirci delle eccezioni possiamo adottare un approccio "tradizionale" come quello che segue:

$PDO->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT ); 
$resultset = $PDO->query("SELECT * FROM inesistente");
if(!$resultset){
	print_r($PDO->errorInfo());
	die();
	}

Conclusioni

Abbiamo esaminato come effettuare la connessione al database e le diverse modalità per gestire degli errori.

Cosa ci rimane da fare è semplice da capire: rivolgere le query dal nostro database. Negli esempi proposti abbiamo utilizzato il metodo PDO->query() ma questo non è il solo a disposizione.

Ebbene nel prossimo articolo vi parlerò dei metodi a nostra disposizione per eseguire le query.