Classe d'accès aux données

**syldevise** · 09/01/2009, 17h12

Bonjour à tous,

Dans le cadre d'une future application web que je souhaite développer, j'ai créer une classe d'accès à la base de données par l'intermédiaire de PDO.

J'aimerais avoir votre avis sur cette classe, sur sa pertinence, son utilité, si vous êtes arrivé à l'utiliser facilement, ... N'hésitez surtout pas à critiquer !

Merci d'avance à tous pour vos réponses !

Pour info voici ma config : PHP 5.2.4 avec le driver pdo_mysql 5.0.18 et MySQL 5.0.27.

Classe Connexion :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
<?php
	class Connexion {
 
		private static $host = "localhost"; // votre serveur web
		private static $bdd = "bdd"; // le nom de la BDD
		private static $user = "user"; // l'utilisateur de la BDD
		private static $password = "password"; // le mot de passe de l'utilisateur de la BDD
 
		private $unPDO; // instance de l'objet PDO
		private $stmt; // instance de l'objet PDOStatement
		private $sql; // stocke le SQL
		private $procedure; // nom de la prodédure stockée
		private $param = array(); // paramètres de la procédure stockée
		private $transactionEnCours; // permet de gérer les transactions SQL
 
		// Création d'un nouvel objet Connexion
		public function __construct(){
	    	try{
				$this->unPDO = new PDO("mysql:host=".self::$host.";dbname=".self::$bdd, self::$user, self::$password, PDO::getAvailableDrivers());
			} catch (Exception $erreur) {
				throw new Exception($erreur->getMessage());
			}
	    }
 
		// Requête SQL sur la BDD
	    public function requeteSQL($sql){
	    	try{
	    		$this->sql = $sql;
	    	} catch (Exception $erreur) {
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
 
		// Procédure stockée sur la BDD
	    public function requeteProcedure($procedure){
	    	try{
	    		$this->sql = "";
	    		$this->procedure = $procedure;
	    	} catch (Exception $erreur) {
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
 
		// Ajouter des paramètres à une procédure stockée
		// Soit Array soit chaine de caractère
	    public function parametreAjouter($param){
	    	try{
	    		if(is_array($param)){
	    			$this->param = $param;
	    		} else {
	    			$this->param[] = $param;
	    		}
	    	} catch (Exception $erreur) {
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
 
		// Exécuter le SQL avec retour : requête ou procédure stockée
		// paramètre $retourTableauAssociatif : permet de forcer le retour de fonction en tableau associatif
	    public function executer($retourTableauAssociatif = false){
	    	try{
	    		if($this->sql == ""){
	    			$this->sql = "call ".$this->procedure;
 
		    		$this->sql .= "(";
		    		$indexParam = 0;
		    		foreach ($this->param as $key=>$value){
		    			if($indexParam != 0){
		    				$this->sql .= ",";
		    			}
		    			$this->sql .= ":".$key;
		    			$indexParam++;
		    		}
		    		$this->sql .= ")";
		    		$this->stmt = $this->unPDO->prepare($this->sql, $this->unPDO->getAvailableDrivers());
 
		    		foreach($this->param as $key=>$valeur){
						$type = $this->retournerType($valeur);
						$this->stmt->bindValue(":".$key, $valeur, $type);
					}
 
		    		$this->stmt->execute();
 
	    		} else {
	    			$this->stmt = $this->unPDO->prepare($this->sql);
		    		$this->stmt->execute();
	    		}
 
	    		$error = $this->stmt->errorInfo();
 
				if(isset($error[2])){
					$error = $this->stmt->errorInfo();
					throw new Exception($error[2]);
				}
 
	    		$i = 0;
				$lignes = array();
				while ($row = $this->stmt->fetch(PDO::FETCH_NAMED)) {
					$lignes[$i] = $row;
					$i++;
			    }
 
			    if($retourTableauAssociatif){
			    	return $lignes[0];
			    } else {
			    	return $lignes;
			    }
 
	    	} catch (Exception $erreur) {
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
	    // Exécuter le SQL sans retour : requête ou procédure stockée
	    public function executerSansRetour(){
	    	try{
	    		if($this->sql == ""){
	    			$this->sql = "call ".$this->procedure;
 
		    		$this->sql .= "(";
		    		$indexParam = 0;
		    		foreach ($this->param as $key=>$value){
		    			if($indexParam != 0){
		    				$this->sql .= ",";
		    			}
		    			$this->sql .= ":".$key;
		    			$indexParam++;
		    		}
		    		$this->sql .= ")";
		    		$this->stmt = $this->unPDO->prepare($this->sql, $this->unPDO->getAvailableDrivers());
 
		    		foreach($this->param as $key=>$valeur){
						$type = $this->retournerType($valeur);
						$this->stmt->bindValue(":".$key, $valeur, $type);
					}
 
		    		$this->stmt->execute();
 
	    		} else {
	    			$this->stmt = $this->unPDO->prepare($this->sql);
		    		$this->stmt->execute();
	    		}
 
	    		$error = $this->stmt->errorInfo();
 
				if(isset($error[2])){
					$error = $this->stmt->errorInfo();
					throw new Exception($error[2]);
				}
 
	    	} catch (Exception $erreur) {
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
 
		// Compte le nombre de ligne affectée par un requête SELECT, INSERT, UPDATE, DELETE
	    public function nombreLigne(){
	    	try{
	    		if($this->stmt instanceof PDOStatement){
	    			return $this->stmt->rowCount();
	    		} else {
	    			throw new Exception("L'objet PDOStatement n'a pas été instancié.");
	    		}
	    	} catch (Exception $erreur){
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
 
		// Compte le nombre de colonne
	    public function nombreColonne(){
	    	try{
	    		return $this->stmt->columnCount();
	    	} catch (Exception $erreur){
	    		throw new Exception($erreur->getMessage());
	    	}
	    }
 
		// Retrourne le dernier ID insérer sur la BDD : pour fonctionner le moteur de stockage la table doit être en InnoDB
	    public function dernierID(){
	    	$lastID = $this->unPDO->lastInsertId();
	    	if($lastID == 0){
	    		throw new Exception("Dernier ID insérer à 0");
	    	} else {
	    		return $lastID;
	    	}
	    }
 
		// Dans le cas d'une requête avec plusieurs SELECT, permet de se positionner le SELECT suivant
	    // NON FONCTIONNEL AVEC MYSQL : PDOStatement::nextRowset() => ne fonctionne pas avec MySQL
	    public function selectSuivant(){
	    	$this->stmt->nextRowset();
	    	$i = 0;
			$lignes = array();
			while ($row = $this->stmt->fetch(PDO::FETCH_NAMED)) {
				$lignes[$i] = $row;
				$i++;
		    }
 
    		return $lignes;
	    }
 
		// Permet de démarrer une transaction : pour fonctionner le moteur de stockage la table doit être en InnoDB
	    public function transactionDemarrer(){
	    	$this->transactionEnCours = true;
	    	$this->unPDO->beginTransaction();
	    }
 
		// Permet de confirmer une transaction : pour fonctionner le moteur de stockage la table doit être en InnoDB
	    public function transactionConfirmer(){
	    	$this->transactionEnCours = false;
	    	$this->unPDO->commit();
	    }
 
		// Permet d'annuler une transaction : pour fonctionner le moteur de stockage la table doit être en InnoDB
	    public function transactionAnnuler(){
	    	if($this->transactionEnCours){
	    		$this->unPDO->rollBack();
	    	}
	    	$this->transactionEnCours = false;
	    }
 
		// Clotûre la connexion avec la BDD
	    public function deconnexion(){
	    	$this->unPDO = null;
	    }
 
		// Retourne le SQL éxécuter dans la BDD
	    public function debug(){
	    	throw new Exception($this);
	    }
 
		// Est exécuté lorsque l'instance de l'objet Connexion() est détruit
	    public function __destruct(){
	    	if($this->transactionEnCours) $this->unPDO->transactionAnnuler();
	    	if($this->unPDO != null) $this->unPDO = null;
	    }
 
		// Est exécuté lorsque l'instance de l'objet Connexion() est converti en String
		public function __toString() {
			return $this->sql;
		}
 
		// Retourne le type du paramétre pour une prodédure stockée
		private function retournerType($variable){
	    	switch ($variable) {
	    		case is_int($variable) :
	    			return PDO::PARAM_INT;
	    		break;
 
	    		case is_string($variable) :
	    			return PDO::PARAM_STR;
	    		break;
 
	    		case is_bool($variable) :
	    			return PDO::PARAM_BOOL;
	    		break;
 
	    		case is_null($variable) :
	    			return PDO::PARAM_NULL;
	    		break;
 
	    		default:
	    			throw new Exception("Ce type de données n'est pas géré !");
	    		break;
	    	}
	    }
	}
?>

Utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
<?php
	// Exemple 1 : requête SQL
	$uneConnexion = new Connexion();
	$uneConnexion->requeteSQL("SELECT * FROM ma_table");
 
	$desResultat = $uneConnexion->executer();
	// La variable $desResultat contient l'ensemble des données de la table 'ma_table'
 
	$uneConnexion->deconnexion();
 
	// Exemple 2 : procédures stockées avec transaction
	try{
		$uneConnexion = new Connexion();
		$uneConnexion->transactionDemarrer();
 
		$uneConnexion->requeteProcedure("update_table1");
		$uneConnexion->parametreAjouter("param1");
		$uneConnexion->parametreAjouter("param2");
		$uneConnexion->executerSansRetour();
 
		$uneConnexion->requeteProcedure("update_table2");
		$desParam = array("param1", "param2", "param3");
		$uneConnexion->parametreAjouter($desParam);
		$uneConnexion->executerSansRetour();
 
		// Traitement
		// Si une erreur intervient dans le traitement, transaction est annulée dans le catch
		// Si aucune erreur n'est soulevé, la transaction est confirmée
		$uneConnexion->transactionConfirmer();
		$uneConnexion->deconnexion();
	} catch(Exception $erreur){
		$uneConnexion->transactionAnnuler();
		$uneConnexion->deconnexion();
		echo($erreur->getMessage());
	}
?>

**zevince** · 09/01/2009, 17h38

je vais etre un peu hors sujet dans ma reponse.. mais pourquoi re-ecrire ce qui l'a deja ete, et de facon excellente, avec Propel, par exemple ?

http://propel.phpdb.org/trac/

**syldevise** · 09/01/2009, 19h54

Envoyé par zevince

je vais etre un peu hors sujet dans ma reponse.. mais pourquoi re-ecrire ce qui l'a deja ete, et de facon excellente, avec Propel, par exemple ?

http://propel.phpdb.org/trac/

Non c'est pas hors sujet, mais la mise en oeuvre est quand même beaucoup plus lourde.

Classe d'accès aux données

PHP & Base de données

Vue hybride

Discussions similaires

Partager

Partager