Redéfinir les exceptions de requête erronée

Version imprimable

05/12/2008, 21h52
gtraxx

Redéfinir les exceptions de requête erronée
Bonsoir à tous , je me demandais comment redefinir les exceptions, faut dire que le gros message :

Citation:

Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE[42S02] ....

est assez embêtant et j'aimerai le remplacer par quelque chose de plus court du genre " erreur en bsd " sans plus :lol:
Comment procéder, j'ai une multitude de class et il me faut quelque chose de clair .
Je procéde de cette façon pour mes requêtes (en gros)
Code:

1 2 $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $stmt = $dbh->prepare("SELECT * FROM dbmachin WHERE machin = :machin");
une idée ?
05/12/2008, 22h02
kaymak

Salut,

tu l'intitialises comment $dbh ?
Utilises tu un modèle MVC avec un point d'entrée unique ?
As tu penser à set_exception_handler ?

a plus

c'est une fonction en faites :
Code:

1 2 3 4 5 6 7 8 9 10 11 function loaddata(){ $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $stmt = $dbh->prepare("SELECT * FROM dbmachin WHERE machin = :machin"); $stmt->bindParam(':machin',$this->machin, PDO::PARAM_STR); $stmt->setFetchMode(PDO::FETCH_ASSOC); $stmt->execute(); $result = $stmt->fetchAll(); $stmt->closeCursor(); $stmt = null; return $result; }
set_exception_handler j'y ai penser mais je voulais avoir un exemple simple pour redefinir les exception PDO et classique

Citation:

Utilises tu un modèle MVC avec un point d'entrée unique ?

je n'ai pas compris la question, j'utilise un style de modele MVC simple pour l'instant je me forme avec le zendframework :mouarf:

06/12/2008, 15h39
kaymak

Salut,

Concernant $dbh, je m'attendais plutôt a une ligne du style $dbh = new PDO.

pour les deux autres solutions, c'est dans le pire des cas, set_exception_handler doit pouvoir permettre de modifier l'exception juste avant de la mettre en stack.
Un point d'entrée unique te permettrait, de l'entourer d'un try catch, et ainsi de modifier ces exceptions à leur émission, et juste avant qu'elle ne soit affichée.

Mais la première solution, qui consiste a attraper ces exceptions dans une classe héritant de PDO, est plus adaptée si tu peux la mettre en place.

voici la ligne lol :

Code:

$dbh = new PDO($host, $u, $p);

Pour ce qui est de l'exception c'est vrai que j'aurai du l'entourer d'un block try
comme ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
function loaddata(){
           global $host, $u, $p;
                        $dbh = new PDO($host, $u, $p);
			$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
try{
$stmt = $dbh->prepare("SELECT * FROM dbmachin WHERE machin = :machin");
}catch (Exception $e) {
            $e->getMessage();
}
			$stmt->bindParam(':machin',$this->machin, PDO::PARAM_STR);
			$stmt->setFetchMode(PDO::FETCH_ASSOC);
			$stmt->execute();
			$result = $stmt->fetchAll();
			$stmt->closeCursor();
			$stmt = null;
		return $result;
	}

Pour ce qui est d'une class héritant de pdo j'ai penser à un truc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class ExtendsException extends Exception
{
    public function __construct($msg=null, $code=0)
    {
        parent::__construct($msg, $code);
    }
 
    public function MysqlConnexion()
    {
        if ( ! $dbh = new PDO($host, $u, $p) )
        {
            throw new ExtendsException('Impossible de se connecter à MySQL');
        }
    }
    public function MysqlTable($sql)
    {
    	$dbh = new PDO($host, $u, $p);
    	if (!$stmt = $dbh->prepare($sql))
    	{
    		 throw new ExtendsException('Impossible de se connecter à MySQL');
    	}
    }
}
function exception_handler($ExtendsException)
{
    $ExtendsException->MysqlTable();
}
 
set_exception_handler('exception_handler');

Probléme je ne vois pas comment la mettre en place, je serai obliger de l'introduire dans chacune de mes class hors le coté pratique n'y est pas
Une idée ?

06/12/2008, 19h36
kaymak

Ce que tu peux c'est créer une classe qui hérite de PDO, et redéfinir les méthodes qui provoque des exception, pour y ajouter un bloc try/catch, et dans le catch tu attrapes l'exception.
A cote tu crées une classe d'exception qui étend de exception ou pdoexception.
Cette class prend en param l'exception attrapée plus haut, et crée un nouveau message d'erreur lisible en fonction du code de l'exception.
Dans le catch, ald de renvoyer une pdoexception, tu la transformes avec ta nouvelle classe d'exception. et c'est celle ci que tu laisses filer.

Je pense avoir compris ce que vous me suggérer mais je n'arrive pas à définir une class etendue fonctionelle:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class ExtendPdo extends PDOException { public function __construct($msg=null, $code=0) { parent::__construct($msg, $code); } function ExceptionGet(){ $msg("Erreur mysql"); parent::getMessage($msg); } } $exception = new ExtendPdo($msg); set_exception_handler($exception);
Vous n'auriez pas un exemple simple que je puisse retravailler ?

Regardes, avec un exemple tirer de la doc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
<?php
/**
 * PHP Document Object plus
 * 
 * PHP Document Object plus is library with functionality of PDO, entirely written
 * in PHP, so that developer can easily extend it's classes with specific functionality,
 * such as providing database usage statistics implemented in v1.0b
 * 
 * @author Peter Pokojny
 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
 */
    class PDOp {
        protected $PDO;
        public $numExecutes;
        public $numStatements;
        public function __construct($dsn, $user=NULL, $pass=NULL, $driver_options=NULL) {
            $this->PDO = new PDO($dsn, $user, $pass, $driver_options);
            $this->numExecutes = 0;
            $this->numStatements = 0;
        }
        public function __call($func, $args) {
            return call_user_func_array(array(&$this->PDO, $func), $args);
        }
        public function prepare() {
            $this->numStatements++;
 
            $args = func_get_args();
            $PDOS = call_user_func_array(array(&$this->PDO, 'prepare'), $args);
 
            return new PDOpStatement($this, $PDOS);
        }
        public function query() {
            $this->numExecutes++;
            $this->numStatements++;
 
            $args = func_get_args();
            $PDOS = call_user_func_array(array(&$this->PDO, 'query'), $args);
 
            return new PDOpStatement($this, $PDOS);
        }
        public function exec() {
            $this->numExecutes++;
 
            $args = func_get_args();
            return call_user_func_array(array(&$this->PDO, 'exec'), $args);
        }
    }
    class PDOpStatement implements IteratorAggregate {
        protected $PDOS;
        protected $PDOp;
        public function __construct($PDOp, $PDOS) {
            $this->PDOp = $PDOp;
            $this->PDOS = $PDOS;
        }
        public function __call($func, $args) {
            return call_user_func_array(array(&$this->PDOS, $func), $args);
        }
        public function bindColumn($column, &$param, $type=NULL) {
            if ($type === NULL)
                $this->PDOS->bindColumn($column, $param);
            else
                $this->PDOS->bindColumn($column, $param, $type);
        }
        public function bindParam($column, &$param, $type=NULL) {
            if ($type === NULL)
                $this->PDOS->bindParam($column, $param);
            else
                $this->PDOS->bindParam($column, $param, $type);
        }
        public function execute() {
            $this->PDOp->numExecutes++;
            $args = func_get_args();
            return call_user_func_array(array(&$this->PDOS, 'execute'), $args);
        }
        public function __get($property) {
            return $this->PDOS->$property;
        }
        public function getIterator() {
            return $this->PDOS;
        }
   }
?>

Dans ce bout de code, je vais modifier exec pour te montrer ou je veux en venir.

Code:

1
2
3
4
5
6
7
8
9
10
 
        public function exec() {
            $this->numExecutes++;
            try{
                $args = func_get_args();
                return call_user_func_array(array(&$this->PDO, 'exec'), $args);
            }catch(PDOException $Ex ){
                throw new ExtendsException ( $Ex->code, $Ex->message );
            }
        }

Dans extendsException, l'idéal serait de re définir Exception::msg, en fonction de $code, juste après avoir appelé parent::__construct();
Aussi, il peut être utile de sauvegarder le message d'erreur précédent, ou même toute l'exception dans un nouveau membre qui pourrait être originalMessage / originalException ou bien encore innerException.

Ceci devrait pouvoir te permettre de faire ce que tu souhaites.
Et plus encore, puisque tu as toutes les pièces (requetes sql, variables binder ect) à disposition pour afficher un jolie message d'erreur bien français, et usefull.

En espérant que ce soit plus clair.

a plus

intéressant j'avais commencé à écrire une extension moins complète faut dire mais bon je vais la décortiquer pour mieux la comprendre et ainsi intégrer certain élément de cet exemple :
Voici la mienne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
class DataOjects extends PDO 
{	
	private $con;					// 
	private $select; 				// requette de séléction
	private $execute; 				// requette d'execution
	private $email='monmail@serveur.com';					// email de l'admin du site
	//private $dns;
 
    public function __construct () 
    {
    	$dbInfo = new CallDbData();
        try 
        {
			$this->con = parent::__construct($dbInfo->getconnStr(),$dbInfo->getuser(),$dbInfo->getpass());
		    // pour mysql on active le cache de requête
		    if($this->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql')
		    	$this->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
		    return $this->con;
        }
        catch(PDOException $e) {
        	echo $e->getMessage();
			//On indique par email qu'on n'a plus de connection disponible
			/*error_log(date('D/m/y').' à '.date("H:i:s").' : '.$e->getMessage(), 1, $this->email);
			$message= new Message();
			$message->outPut('Erreur 500', 'Serveur de BDD indisponible, nous nous excusons de la gêne occasionnée');*/
		}
    }
    public function selectTransaction($reqSelect){
 
		try
		{
			$this->con = parent::beginTransaction();
			//$result= parent::query($reqSelect);
			$result = parent::prepare($reqSelect);
			$result->setFetchMode(PDO::FETCH_ASSOC);
			$result->execute();
			$this->con = parent::commit();
			// ou
			// $this->con = parent::rollBack();
	  		return $result;
		}
		catch (PDOException $e) 
		{
			echo $e->getMessage();
			//On indique par email que la requête n'a pas fonctionné.
			/*error_log(date('D/m/y').' à '.date("H:i:s").' : '.$e->getMessage(), 1, $this->email);
			$this->con =parent::rollBack();
			$message= new Message();
			$message->outPut('Erreur dans la requêtte', 'Votre requête a été abandonné');*/
		}
	}
	public function selectAllSimple($reqSelect){
 
		try{
 
			$result = parent::prepare($reqSelect);
			$result->setFetchMode(PDO::FETCH_ASSOC);
			$result->execute();
			$resultat = $result->fetchAll();
			$result->closeCursor();
			$result = null;
			return $resultat;
 
		}catch (PDOException $e){
 
			echo $e->getMessage();
		}
 
	}
	static function WhileFetch($row){
		while($row = self::selectOneSimple($reqSelect)->fetch()){
				$row;
			}
			//$resultat = $result->fetch();
			$result->closeCursor();
			$result = null;
			return $row;
	}
	public function selectOneSimple($reqSelect){
 
		try {
 
			$result = parent::prepare($reqSelect);
			$result->setFetchMode(PDO::FETCH_ASSOC);
			$result->execute();
			return $result;
 
		}catch (PDOException $e){
 
			echo $e->getMessage();
		}
 
	}
}

Bon elle n'est pas super mais je doit corriger les bugs et intégrer les exception PDO.
Cependant j'ai remarquer que mes erreurs sont intercepter par un block exception classique contenu ailleurs.
Donc exception PDO n'ai jamais envoyé , je l'ai remarquer en testant avec un try sur la fonction de requette et en modifiant la requette sql avec une erreur intentionnelle.