Subversion Repositories Applications.framework

Rev

Rev 430 | Rev 461 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5 aurelien 1
<?php
105 aurelien 2
// declare(encoding='UTF-8');
5 aurelien 3
/**
238 jpm 4
 * Classe Bdd, d'accés au base de données.
401 jpm 5
 * Elle fait office d'abstraction légère de base de données en utilisant diverses possibilités d'accès aux
238 jpm 6
 * bases de données (PDO, mysql, mysqli, SQLite3).
7
 * Les valeurs pour le paramètre 'bdd_abstraction' du fichier config.ini sont : pdo, mysql, mysqli, sqlite3
8
 * Vous pouvez aussi utiliser : "php:Bdd::ABSTRACTION_PDO","php:Bdd::ABSTRACTION_MYSQL", "php:Bdd::ABSTRACTION_MYSQLI",
9
 * "php:Bdd::ABSTRACTION_SQLITE3".
10
 * Elle peut être étendue, pour ajouter le support d'autres bases de données où prendre en compte des méthodes spécifique à
11
 * un type d'abstraction.
12
 *
13
 * @category	php 5.2
14
 * @package	Framework
15
 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>
16
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
241 jpm 17
 * @copyright	Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
238 jpm 18
 * @license	http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
19
 * @license	http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
20
 * @version	$Id: Bdd.php 433 2013-09-04 14:28:25Z jpm $
21
 * @link		/doc/framework/
22
 */
23
class Bdd {
219 jpm 24
	/** Constante stockant le squelette du message en cas d'erreur de requête sql. */
25
	const ERREUR_REQUETE_TPL = 'Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s';
401 jpm 26
 
219 jpm 27
	/** Constante stockant le squelette du message en cas d'erreur de connexion à la base de données. */
28
	const ERREUR_CONNEXION_TPL = 'Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration.\nMessage : %S.';
401 jpm 29
 
219 jpm 30
	/** Constante stockant le squelette du message en cas d'erreur de sélection de la base de données. */
231 delphine 31
	const ERREUR_SELECTION_BDD_TPL = 'Erreur de sélection de la base de données, vérifiez les paramètres du fichier de configuration.\nMessage : %S.';
401 jpm 32
 
219 jpm 33
	/** Constante stockant le code pour l'abstraction de PDO. */
34
	const ABSTRACTION_PDO = 'pdo';
401 jpm 35
 
219 jpm 36
	/** Constante stockant le code pour l'abstraction de mysql. */
37
	const ABSTRACTION_MYSQL = 'mysql';
401 jpm 38
 
219 jpm 39
	/** Constante stockant le code pour l'abstraction de mysqli. */
40
	const ABSTRACTION_MYSQLI = 'mysqli';
401 jpm 41
 
219 jpm 42
	/** Constante stockant le code pour l'abstraction de SQLite3. */
43
	const ABSTRACTION_SQLITE3 = 'sqlite3';
401 jpm 44
 
219 jpm 45
	/** Constante stockant le code pour le mode tableau associatif des résultats des requêtes. */
46
	const MODE_ASSOC = 'ASSOC';
401 jpm 47
 
219 jpm 48
	/** Constante stockant le code pour le mode objet des résultats des requêtes. */
49
	const MODE_OBJET = 'OBJECT';
401 jpm 50
 
219 jpm 51
	/** Mode de fetch associatif */
238 jpm 52
	protected $ASSOC = '';
401 jpm 53
 
219 jpm 54
	/** Mode de fetch objet */
238 jpm 55
	protected $OBJECT = '';
133 aurelien 56
 
219 jpm 57
	/** abstraction de base de données utilisée */
238 jpm 58
	protected $abstraction;
401 jpm 59
 
219 jpm 60
	/** DSN pour accéder à la base de données */
238 jpm 61
	protected $dsn;
401 jpm 62
 
219 jpm 63
	/** Type de base de données (mysql, mysqli, etc ...) */
238 jpm 64
	protected $type;
401 jpm 65
 
219 jpm 66
	/** Hote herbergeant la base de données */
238 jpm 67
	protected $hote;
401 jpm 68
 
219 jpm 69
	/** Nom de la base de données à laquelle le modèle doit se connecter */
238 jpm 70
	protected $bdd_nom;
401 jpm 71
 
219 jpm 72
	/** Nom d'utilisateur */
238 jpm 73
	protected $utilisateur;
401 jpm 74
 
219 jpm 75
	/** Mot de passe */
238 jpm 76
	protected $pass;
120 aurelien 77
 
219 jpm 78
	/** Encodage de la base de données */
238 jpm 79
	protected $encodage = null;
401 jpm 80
 
219 jpm 81
	/** Connexion à la base de données */
238 jpm 82
	protected $connexion = null;
5 aurelien 83
 
238 jpm 84
	/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
401 jpm 85
	protected $parametres_obligatoires = array('bdd_abstraction', 'bdd_protocole', 'bdd_serveur', 'bdd_nom',
247 jpm 86
		'bdd_utilisateur', 'bdd_mot_de_passe', 'bdd_encodage');
401 jpm 87
 
238 jpm 88
	/** Constructeur par défaut, appelé à l'initialisation. */
145 jpm 89
	public function __construct() {
241 jpm 90
		Config::verifierPresenceParametres($this->parametres_obligatoires);
133 aurelien 91
		$this->abstraction = strtolower(Config::get('bdd_abstraction'));
120 aurelien 92
		$this->type = Config::get('bdd_protocole');
93
		$this->hote = Config::get('bdd_serveur');
94
		$this->bdd_nom = Config::get('bdd_nom');
95
		$this->utilisateur = Config::get('bdd_utilisateur');
96
		$this->pass = Config::get('bdd_mot_de_passe');
420 gduche 97
 
120 aurelien 98
		$this->encodage = Config::get('bdd_encodage');
99
 
430 raphael 100
		if ($this->type == 'sqlite' || $this->type == 'sqlite2') {
101
			$this->dsn = $this->type.':'.$this->hote;
102
		} else {
103
			$this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
401 jpm 104
		}
133 aurelien 105
		$this->initialiserProtocole();
120 aurelien 106
	}
107
 
238 jpm 108
	/** Initialise les constantes de classe à leur bonne valeur et déclenche une erreur si le protocole n'est pas bien défini. */
109
	protected function initialiserProtocole() {
133 aurelien 110
		switch ($this->abstraction) {
219 jpm 111
			case self::ABSTRACTION_PDO :
238 jpm 112
				$this->ASSOC = PDO::FETCH_ASSOC;
429 raphael 113
				$this->OBJECT = PDO::FETCH_OBJ;
219 jpm 114
				break;
115
			case self::ABSTRACTION_MYSQL :
238 jpm 116
				$this->ASSOC = 'mysql_fetch_assoc';
117
				$this->OBJECT = 'mysql_fetch_object';
219 jpm 118
				break;
119
			case self::ABSTRACTION_MYSQLI :
238 jpm 120
				$this->ASSOC = 'fetch_assoc';
121
				$this->OBJECT = 'fetch_object';
219 jpm 122
				break;
123
			case self::ABSTRACTION_SQLITE3 :
238 jpm 124
				$this->ASSOC = 'SQLITE3_ASSOC';
125
				$this->OBJECT = 'SQLITE3_OBJECT';
219 jpm 126
				break;
133 aurelien 127
			default:
238 jpm 128
				$m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
129
				trigger_error($m, E_USER_WARNING);
133 aurelien 130
		}
238 jpm 131
	}
401 jpm 132
 
238 jpm 133
	/**
134
	 * Connection à la base de données en utilisant les informations fournies par
135
	 * le fichier de configuration.
136
	 * Cette méthode est private et final car elle n'a pas vocation a être appelée par l'utilisateur.
433 jpm 137
	 * TODO : il est peut être nécessaire pour MYSQL, MYSQLi et SQLITE3 afin d'éviter les boucles infinis
138
	 * d'erreur quand la bdd n'est pas configuré d'utiliser : $this->connexion->query (comme pour PDO)
238 jpm 139
	 */
140
	protected function connecter() {
141
		if ($this->connexion == null) {
142
			switch ($this->abstraction) {
143
				case self::ABSTRACTION_PDO :
144
					try {
145
						$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
354 jpm 146
						$this->connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
238 jpm 147
					} catch (PDOException $e) {
148
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
149
						trigger_error($e, E_USER_WARNING);
150
					}
401 jpm 151
					if ($this->encodage != null && $this->type == 'mysql') {
427 raphael 152
						$this->connexion->query("SET names '".$this->encodage."'");
401 jpm 153
					} else if ($this->type == 'sqlite') {
427 raphael 154
						$this->connexion->query("PRAGMA case_sensitive_like = false");
401 jpm 155
					}
238 jpm 156
					break;
157
				case self::ABSTRACTION_MYSQL :
158
					$this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
159
					if ($this->connexion !== false) {
160
						$selection = mysql_select_db($this->bdd_nom, $this->connexion);
161
						if ($selection === false) {
162
							$e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
163
							trigger_error($e, E_USER_WARNING);
164
						}
165
					} else {
166
						$e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
167
						trigger_error($e, E_USER_WARNING);
168
					}
401 jpm 169
					if ($this->encodage != null) {
170
						$this->requeter("SET names '".$this->encodage."'");
171
					}
238 jpm 172
					break;
173
				case self::ABSTRACTION_MYSQLI :
174
					$this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
175
					if ($this->connexion->connect_errno) {
176
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
177
						trigger_error($e, E_USER_WARNING);
178
					}
401 jpm 179
					if ($this->encodage != null) {
180
						$this->requeter("SET names '".$this->encodage."'");
181
					}
238 jpm 182
					break;
183
				case self::ABSTRACTION_SQLITE3 :
184
					// cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
185
					$this->connexion = new SQLite3($this->bdd_nom);
186
					if (!$this->connexion) {
187
						$e = sprintf(self::ERREUR_CONNEXION_TPL, '');
188
						trigger_error($e, E_USER_WARNING);
189
					}
401 jpm 190
					$this->requeter("PRAGMA case_sensitive_like = false");
238 jpm 191
					break;
192
				default:
193
					$this->connexion = null;
194
			}
401 jpm 195
 
238 jpm 196
			if ($this->encodage != null) {
197
				$this->requete("SET names '".$this->encodage."'");
198
			}
133 aurelien 199
		}
200
	}
401 jpm 201
 
133 aurelien 202
	/**
239 jpm 203
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see requeter
204
	 */
205
	final protected function requete($requete) {
329 delphine 206
		return $this->requeter($requete);
239 jpm 207
	}
401 jpm 208
 
239 jpm 209
	/**
238 jpm 210
	 * Execute une requête et retourne le résultat tel que renvoyé par l'abstraction courante.
120 aurelien 211
	 *
238 jpm 212
	 * @param string la requête à effectuer
213
	 * @return mixed un objet contenant le résultat de la requête
120 aurelien 214
	 */
239 jpm 215
	public function requeter($requete) {
238 jpm 216
		$this->connecter();
217
 
133 aurelien 218
		$retour = null;
219
		switch ($this->abstraction) {
219 jpm 220
			case self::ABSTRACTION_PDO :
221
				try {
222
					$retour = $this->connexion->query($requete);
223
				} catch (PDOException $e) {
224
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
225
					trigger_error($m, E_USER_WARNING);
226
				}
140 jpm 227
				break;
219 jpm 228
			case self::ABSTRACTION_MYSQL :
229
				$retour = mysql_query($requete, $this->connexion);
140 jpm 230
				break;
219 jpm 231
			case self::ABSTRACTION_MYSQLI :
133 aurelien 232
				$retour = $this->connexion->query($requete);
140 jpm 233
				break;
219 jpm 234
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 235
				$retour = $this->connexion->exec($requete);
140 jpm 236
				break;
133 aurelien 237
		}
238
		return $retour;
120 aurelien 239
	}
401 jpm 240
 
238 jpm 241
	/**
239 jpm 242
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recuperer
243
	 */
244
	final protected function requeteUn($requete, $mode = self::MODE_ASSOC) {
245
		return $this->recuperer($requete, $mode);
246
	}
401 jpm 247
 
239 jpm 248
	/**
238 jpm 249
	 * Execute une requête et retourne le premier résultat sous forme de tableau (par défaut) ou d'objet.
250
	 * Les noms des champs de la base de données correspondent aux noms des clés du tableau ou aux noms des attributs de l'objet.
251
	 *
252
	 * @param string la requête à effectuer
253
	 * @param string le mode de retour ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
254
	 * @return mixed un objet ou un tableau contenant le résultat de la requête
255
	 */
239 jpm 256
	public function recuperer($requete, $mode = self::MODE_ASSOC) {
238 jpm 257
		$this->connecter();
133 aurelien 258
 
259
		$retour = null;
260
		switch ($this->abstraction) {
219 jpm 261
			case self::ABSTRACTION_PDO :
173 aurelien 262
				try {
238 jpm 263
					$resultat = $this->connexion->query($requete);
355 jpm 264
					$retour = ($resultat !== false) ? $resultat->fetch($this->$mode) : $resultat;
173 aurelien 265
				} catch (PDOException $e) {
219 jpm 266
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
267
					trigger_error($m, E_USER_WARNING);
173 aurelien 268
				}
140 jpm 269
				break;
219 jpm 270
			case self::ABSTRACTION_MYSQL :
238 jpm 271
				$res = mysql_query($requete, $this->connexion);
133 aurelien 272
				$fonction_fetch = $this->$mode;
273
				$retour = $fonction_fetch($res);
140 jpm 274
				break;
219 jpm 275
			case self::ABSTRACTION_MYSQLI :
133 aurelien 276
				$res = $this->connexion->query($requete);
277
				$fonction_fetch = $this->$mode;
278
				$retour = $res->$fonction_fetch();
140 jpm 279
				break;
219 jpm 280
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 281
				$retour = $this->connexion->querySingle($requete);
140 jpm 282
				break;
133 aurelien 283
		}
284
		return $retour;
120 aurelien 285
	}
401 jpm 286
 
238 jpm 287
	/**
239 jpm 288
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recupererTous
289
	 */
290
	final protected function requeteTous($requete, $mode = self::MODE_ASSOC) {
291
		return $this->recupererTous($requete, $mode);
292
	}
401 jpm 293
 
239 jpm 294
	/**
401 jpm 295
	 * Execute une requête et retourne un tableau de résultats. Un résultat peut être présentés sous forme
238 jpm 296
	 * de tableau (par défaut) ou d'objet.
401 jpm 297
	 * Les noms des champs de la base de données correspondent aux noms des clés du tableau résultat ou
238 jpm 298
	 * aux noms des attributs de l'objet résultat.
299
	 *
300
	 * @param string la requête à effectuer
301
	 * @param string le mode de retour des résultats : ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
302
	 * @return array un tableau contenant les résultats sous forme d'objets ou de tableau (par défaut).
303
	 */
239 jpm 304
	public function recupererTous($requete, $mode = self::MODE_ASSOC) {
238 jpm 305
		$this->connecter();
401 jpm 306
 
133 aurelien 307
		$retour = null;
308
		switch ($this->abstraction) {
219 jpm 309
			case self::ABSTRACTION_PDO :
143 jpm 310
				try {
238 jpm 311
					$resultat = $this->connexion->query($requete);
355 jpm 312
					$retour = ($resultat !== false) ? $resultat->fetchAll($this->$mode) : $resultat;
143 jpm 313
				} catch (PDOException $e) {
219 jpm 314
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
315
					trigger_error($m, E_USER_WARNING);
140 jpm 316
				}
317
				break;
219 jpm 318
			case self::ABSTRACTION_MYSQL :
238 jpm 319
				$resultat = mysql_query($requete, $this->connexion);
133 aurelien 320
				$fonction_fetch = $this->$mode;
238 jpm 321
				while ($ligne = $fonction_fetch($resultat)) {
133 aurelien 322
					$retour[] = $ligne;
323
				}
140 jpm 324
				break;
219 jpm 325
			case self::ABSTRACTION_MYSQLI :
238 jpm 326
				$resultat = $this->connexion->query($requete);
133 aurelien 327
				$function_fetch = $this->$mode;
238 jpm 328
				while ($ligne = $resultat->$function_fetch()) {
133 aurelien 329
					$retour[] = $ligne;
330
				}
140 jpm 331
				break;
219 jpm 332
			case self::ABSTRACTION_SQLITE3 :
238 jpm 333
				$resultat = $this->connexion->query($requete);
334
				while ($ligne = $resultat->fetch_array($this->ASSOC)) {
219 jpm 335
					if ($mode == self::MODE_OBJET) {
336
						// Cas particulier de sqllite qui n'a pas de fonction fetch_object
133 aurelien 337
						$ligneObjet = new stdClass();
140 jpm 338
						foreach ($ligne as $colonne => $valeur) {
133 aurelien 339
							$ligneObjet->$colonne = $valeur;
340
						}
219 jpm 341
						$ligne = $ligneObjet;
133 aurelien 342
					}
219 jpm 343
					$retour[] = $ligne;
133 aurelien 344
				}
140 jpm 345
				break;
133 aurelien 346
		}
347
		return $retour;
348
	}
349
 
120 aurelien 350
	/**
238 jpm 351
	 * Protège une chaine de caractères avant l'insertion dans la base de données (ajout de quotes ou guillemets).
352
	 * @param string la chaine à protéger
353
	 * @return string la chaine protégée
120 aurelien 354
	 */
238 jpm 355
	public function proteger($chaine) {
356
		$this->connecter();
133 aurelien 357
 
358
		$retour = $chaine;
359
		switch ($this->abstraction) {
219 jpm 360
			case self::ABSTRACTION_PDO :
133 aurelien 361
				$retour = $this->connexion->quote($chaine);
140 jpm 362
				break;
219 jpm 363
			case self::ABSTRACTION_MYSQL :
133 aurelien 364
				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
140 jpm 365
				break;
219 jpm 366
			case self::ABSTRACTION_MYSQLI :
133 aurelien 367
				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';
140 jpm 368
				break;
219 jpm 369
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 370
				$retour = $this->connexion->escapeString($chaine);
140 jpm 371
				break;
133 aurelien 372
		}
373
		return $retour;
120 aurelien 374
	}
406 gduche 375
 
376
	/**
377
	* Protège les chaines d'un tableau de caractères avant l'insertion dans la base de données (ajout de quotes ou guillemets).
378
	* @param array le tableau de chaines à protéger
379
	* @return array le tableau avec les chaines protégées
380
	*/
408 gduche 381
	public function protegerTableau($tableau) {
406 gduche 382
		$champsProteges = array();
383
		foreach($tableau as $champ => $valeur) {
384
			$champsProteges[$champ] = $this->proteger($valeur);
385
		}
386
		return $champsProteges;
387
	}
120 aurelien 388
 
389
	/**
239 jpm 390
	 * Retourne l'identifiant de la dernière ligne insérée, ou la dernière valeur d'une séquence d'objets, dépendamment, dans
391
	 * le cas de PDO, du driver utilisé. Les méthodes utilisées pour retourner l'identifiant peuvent avoir des comportements
392
	 * différent. Consulter la documentation PHP correspondant à l'abstraction choisie avant de l'utiliser :
393
	 * @link(http://fr.php.net/manual/fr/pdo.lastinsertid.php, PDO::lastInsertId([ string $name = NULL ]))
401 jpm 394
	 * @link(http://php.net/manual/en/mysqli.insert-id.php, mysqli->insert_id())
239 jpm 395
	 * @link(http://fr.php.net/manual/fr/function.mysql-insert-id.php, mysql_insert_id())
401 jpm 396
	 * @link(http://fr.php.net/manual/fr/sqlite3.lastinsertrowid.php, SQLite3::lastInsertRowID())
239 jpm 397
	 * @param mixed un paramètre éventuel à transmettre (en fonction de l'abstraction de BDD utilisée).
398
	 * @return mixed le dernier identifiant de clé primaire ajouté dans la base de données (string ou int).
399
	 */
400
	public function recupererIdDernierAjout($parametres = null) {
401
		$this->connecter();
402
 
420 gduche 403
		$retour = null;
239 jpm 404
		switch ($this->abstraction) {
405
			case self::ABSTRACTION_PDO :
406
				$retour = $this->connexion->lastInsertId($parametres);
407
				break;
408
			case self::ABSTRACTION_MYSQL :
409
				$retour = mysql_insert_id($this->connexion);
410
				break;
411
			case self::ABSTRACTION_MYSQLI :
412
				$retour = $this->connexion->insert_id();
413
				break;
414
			case self::ABSTRACTION_SQLITE3 :
415
				$retour = $this->connexion->lastInsertRowID();
416
				break;
417
		}
418
		return $retour;
419
	}
401 jpm 420
 
239 jpm 421
	/**
219 jpm 422
	 * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
120 aurelien 423
	 */
247 jpm 424
	public function __destruct() {
340 jpm 425
		if (isset($this->connexion)) {
426
			switch ($this->abstraction) {
427
				case self::ABSTRACTION_PDO :
428
					$this->connexion = null;
429
					break;
430
				case self::ABSTRACTION_MYSQL :
431
					if (isset($this->connexion)) {
432
						return mysql_close($this->connexion);
401 jpm 433
					}
340 jpm 434
					break;
435
				case self::ABSTRACTION_MYSQLI :
436
					$this->connexion->close();
437
					break;
438
				case self::ABSTRACTION_SQLITE3 :
439
					$this->connexion->close();
440
					break;
441
			}
120 aurelien 442
		}
443
	}
5 aurelien 444
}
445
?>