Subversion Repositories Applications.framework

Rev

Rev 460 | 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 
 */
21 
class Bdd {
219 jpm 22 
	/** Constante stockant le squelette du message en cas d'erreur de requête sql. */
23 
	const ERREUR_REQUETE_TPL = 'Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s';
401 jpm 24 
 
219 jpm 25 
	/** Constante stockant le squelette du message en cas d'erreur de connexion à la base de données. */
26 
	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 27 
 
219 jpm 28 
	/** Constante stockant le squelette du message en cas d'erreur de sélection de la base de données. */
231 delphine 29 
	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 30 
 
219 jpm 31 
	/** Constante stockant le code pour l'abstraction de PDO. */
32 
	const ABSTRACTION_PDO = 'pdo';
401 jpm 33 
 
219 jpm 34 
	/** Constante stockant le code pour l'abstraction de mysql. */
35 
	const ABSTRACTION_MYSQL = 'mysql';
401 jpm 36 
 
219 jpm 37 
	/** Constante stockant le code pour l'abstraction de mysqli. */
38 
	const ABSTRACTION_MYSQLI = 'mysqli';
401 jpm 39 
 
219 jpm 40 
	/** Constante stockant le code pour l'abstraction de SQLite3. */
41 
	const ABSTRACTION_SQLITE3 = 'sqlite3';
401 jpm 42 
 
219 jpm 43 
	/** Constante stockant le code pour le mode tableau associatif des résultats des requêtes. */
44 
	const MODE_ASSOC = 'ASSOC';
401 jpm 45 
 
219 jpm 46 
	/** Constante stockant le code pour le mode objet des résultats des requêtes. */
47 
	const MODE_OBJET = 'OBJECT';
401 jpm 48 
 
219 jpm 49 
	/** Mode de fetch associatif */
238 jpm 50 
	protected $ASSOC = '';
401 jpm 51 
 
219 jpm 52 
	/** Mode de fetch objet */
238 jpm 53 
	protected $OBJECT = '';
133 aurelien 54 
 
219 jpm 55 
	/** abstraction de base de données utilisée */
238 jpm 56 
	protected $abstraction;
401 jpm 57 
 
219 jpm 58 
	/** DSN pour accéder à la base de données */
238 jpm 59 
	protected $dsn;
401 jpm 60 
 
219 jpm 61 
	/** Type de base de données (mysql, mysqli, etc ...) */
238 jpm 62 
	protected $type;
401 jpm 63 
 
219 jpm 64 
	/** Hote herbergeant la base de données */
238 jpm 65 
	protected $hote;
401 jpm 66 
 
219 jpm 67 
	/** Nom de la base de données à laquelle le modèle doit se connecter */
238 jpm 68 
	protected $bdd_nom;
401 jpm 69 
 
219 jpm 70 
	/** Nom d'utilisateur */
238 jpm 71 
	protected $utilisateur;
401 jpm 72 
 
219 jpm 73 
	/** Mot de passe */
238 jpm 74 
	protected $pass;
120 aurelien 75 
 
219 jpm 76 
	/** Encodage de la base de données */
238 jpm 77 
	protected $encodage = null;
401 jpm 78 
 
219 jpm 79 
	/** Connexion à la base de données */
238 jpm 80 
	protected $connexion = null;
5 aurelien 81 
 
238 jpm 82 
	/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
401 jpm 83 
	protected $parametres_obligatoires = array('bdd_abstraction', 'bdd_protocole', 'bdd_serveur', 'bdd_nom',
247 jpm 84 
		'bdd_utilisateur', 'bdd_mot_de_passe', 'bdd_encodage');
401 jpm 85 
 
238 jpm 86 
	/** Constructeur par défaut, appelé à l'initialisation. */
145 jpm 87 
	public function __construct() {
241 jpm 88 
		Config::verifierPresenceParametres($this->parametres_obligatoires);
133 aurelien 89 
		$this->abstraction = strtolower(Config::get('bdd_abstraction'));
120 aurelien 90 
		$this->type = Config::get('bdd_protocole');
91 
		$this->hote = Config::get('bdd_serveur');
92 
		$this->bdd_nom = Config::get('bdd_nom');
93 
		$this->utilisateur = Config::get('bdd_utilisateur');
94 
		$this->pass = Config::get('bdd_mot_de_passe');
95 
		$this->encodage = Config::get('bdd_encodage');
96 
 
401 jpm 97 
		if ($this->type == 'sqlite' || $this->type == 'sqlite2') {
98 
			$this->dsn = $this->type.':'.$this->hote;
99 
		} else {
100 
			$this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
101 
		}
133 aurelien 102 
		$this->initialiserProtocole();
120 aurelien 103 
	}
104 
 
238 jpm 105 
	/** Initialise les constantes de classe à leur bonne valeur et déclenche une erreur si le protocole n'est pas bien défini. */
106 
	protected function initialiserProtocole() {
133 aurelien 107 
		switch ($this->abstraction) {
219 jpm 108 
			case self::ABSTRACTION_PDO :
238 jpm 109 
				$this->ASSOC = PDO::FETCH_ASSOC;
435 jpm 110 
				$this->OBJECT = PDO::FETCH_OBJ;
219 jpm 111 
				break;
112 
			case self::ABSTRACTION_MYSQL :
238 jpm 113 
				$this->ASSOC = 'mysql_fetch_assoc';
114 
				$this->OBJECT = 'mysql_fetch_object';
219 jpm 115 
				break;
116 
			case self::ABSTRACTION_MYSQLI :
238 jpm 117 
				$this->ASSOC = 'fetch_assoc';
118 
				$this->OBJECT = 'fetch_object';
219 jpm 119 
				break;
120 
			case self::ABSTRACTION_SQLITE3 :
238 jpm 121 
				$this->ASSOC = 'SQLITE3_ASSOC';
122 
				$this->OBJECT = 'SQLITE3_OBJECT';
219 jpm 123 
				break;
133 aurelien 124 
			default:
238 jpm 125 
				$m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
126 
				trigger_error($m, E_USER_WARNING);
133 aurelien 127 
		}
238 jpm 128 
	}
401 jpm 129 
 
238 jpm 130 
	/**
131 
	 * Connection à la base de données en utilisant les informations fournies par
132 
	 * le fichier de configuration.
133 
	 * Cette méthode est private et final car elle n'a pas vocation a être appelée par l'utilisateur.
435 jpm 134 
	 * TODO : il est peut être nécessaire pour MYSQL, MYSQLi et SQLITE3 afin d'éviter les boucles infinis
135 
	 * d'erreur quand la bdd n'est pas configuré d'utiliser : $this->connexion->query (comme pour PDO)
238 jpm 136 
	 */
137 
	protected function connecter() {
138 
		if ($this->connexion == null) {
139 
			switch ($this->abstraction) {
140 
				case self::ABSTRACTION_PDO :
141 
					try {
142 
						$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
354 jpm 143 
						$this->connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
238 jpm 144 
					} catch (PDOException $e) {
145 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
146 
						trigger_error($e, E_USER_WARNING);
147 
					}
401 jpm 148 
					if ($this->encodage != null && $this->type == 'mysql') {
435 jpm 149 
						$this->connexion->query("SET names '".$this->encodage."'");
401 jpm 150 
					} else if ($this->type == 'sqlite') {
435 jpm 151 
						$this->connexion->query("PRAGMA case_sensitive_like = false");
401 jpm 152 
					}
238 jpm 153 
					break;
154 
				case self::ABSTRACTION_MYSQL :
155 
					$this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
156 
					if ($this->connexion !== false) {
157 
						$selection = mysql_select_db($this->bdd_nom, $this->connexion);
158 
						if ($selection === false) {
159 
							$e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
160 
							trigger_error($e, E_USER_WARNING);
161 
						}
162 
					} else {
163 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
164 
						trigger_error($e, E_USER_WARNING);
165 
					}
401 jpm 166 
					if ($this->encodage != null) {
167 
						$this->requeter("SET names '".$this->encodage."'");
168 
					}
238 jpm 169 
					break;
170 
				case self::ABSTRACTION_MYSQLI :
171 
					$this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
172 
					if ($this->connexion->connect_errno) {
173 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
174 
						trigger_error($e, E_USER_WARNING);
175 
					}
401 jpm 176 
					if ($this->encodage != null) {
177 
						$this->requeter("SET names '".$this->encodage."'");
178 
					}
238 jpm 179 
					break;
180 
				case self::ABSTRACTION_SQLITE3 :
181 
					// cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
182 
					$this->connexion = new SQLite3($this->bdd_nom);
183 
					if (!$this->connexion) {
184 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, '');
185 
						trigger_error($e, E_USER_WARNING);
186 
					}
401 jpm 187 
					$this->requeter("PRAGMA case_sensitive_like = false");
238 jpm 188 
					break;
189 
				default:
190 
					$this->connexion = null;
191 
			}
133 aurelien 192 
		}
193 
	}
460 jpm 194 
 
424 aurelien 195 
	/**
460 jpm 196 
	 * Permet de tester, puis de reconnecter une connection au cas ou celle aurait été
424 aurelien 197 
	 * perdue (utile dans le cas d'une connection ouverte depuis trop longtemps)
198 
	 * @return boolean
199 
	 */
200 
	public function ping() {
201 
		try {
202 
			// requête très simple qui ne teste que l'activité de la connection
203 
			$requete = 'SELECT 1';
204 
			switch ($this->abstraction) {
205 
				case self::ABSTRACTION_PDO :
206 
						$retour = $this->connexion->query($requete);
207 
					break;
208 
				case self::ABSTRACTION_MYSQL :
209 
					$retour = mysql_query($requete, $this->connexion);
210 
					break;
211 
				case self::ABSTRACTION_MYSQLI :
212 
					$retour = $this->connexion->query($requete);
213 
					break;
214 
				case self::ABSTRACTION_SQLITE3 :
215 
					$retour = $this->connexion->exec($requete);
216 
					break;
217 
			}
218 
		} catch (PDOException $e) {
219 
			$this->connecter();
220 
		}
221 
		return true;
222 
	}
401 jpm 223 
 
133 aurelien 224 
	/**
239 jpm 225 
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see requeter
226 
	 */
227 
	final protected function requete($requete) {
329 delphine 228 
		return $this->requeter($requete);
239 jpm 229 
	}
401 jpm 230 
 
239 jpm 231 
	/**
481 jpm 232 
	 * Effectue une requête et retourne le résultat tel que renvoyé par l'abstraction courante.
120 aurelien 233 
	 *
238 jpm 234 
	 * @param string la requête à effectuer
235 
	 * @return mixed un objet contenant le résultat de la requête
120 aurelien 236 
	 */
239 jpm 237 
	public function requeter($requete) {
238 jpm 238 
		$this->connecter();
239 
 
133 aurelien 240 
		$retour = null;
241 
		switch ($this->abstraction) {
219 jpm 242 
			case self::ABSTRACTION_PDO :
243 
				try {
244 
					$retour = $this->connexion->query($requete);
245 
				} catch (PDOException $e) {
246 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
247 
					trigger_error($m, E_USER_WARNING);
248 
				}
140 jpm 249 
				break;
219 jpm 250 
			case self::ABSTRACTION_MYSQL :
251 
				$retour = mysql_query($requete, $this->connexion);
140 jpm 252 
				break;
219 jpm 253 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 254 
				$retour = $this->connexion->query($requete);
140 jpm 255 
				break;
219 jpm 256 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 257 
				$retour = $this->connexion->exec($requete);
140 jpm 258 
				break;
133 aurelien 259 
		}
260 
		return $retour;
120 aurelien 261 
	}
401 jpm 262 
 
238 jpm 263 
	/**
481 jpm 264 
	 * Execute une requête (Utile pour UPDATE, INSERT, DELETE) et retourne le résultat tel que renvoyé par l'abstraction courante.
265 
	 *
266 
	 * @param string la requête à effectuer
267 
	 * @return mixed le nombre de résultat affecté par la  requête
268 
	 */
269 
	public function executer($requete) {
270 
		$this->connecter();
271 
 
272 
		$retour = null;
273 
		switch ($this->abstraction) {
274 
			case self::ABSTRACTION_PDO :
275 
				try {
276 
					$retour = $this->connexion->exec($requete);
277 
				} catch (PDOException $e) {
278 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
279 
					trigger_error($m, E_USER_WARNING);
280 
				}
281 
				break;
282 
			default:
283 
				$m = "Cette méthode n'est pas disponible pour l'abstraction de base de données actuellement utilisée.";
284 
				trigger_error($m, E_USER_ERROR);
285 
		}
286 
		return $retour;
287 
	}
288 
 
289 
	/**
239 jpm 290 
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recuperer
291 
	 */
292 
	final protected function requeteUn($requete, $mode = self::MODE_ASSOC) {
293 
		return $this->recuperer($requete, $mode);
294 
	}
401 jpm 295 
 
239 jpm 296 
	/**
238 jpm 297 
	 * Execute une requête et retourne le premier résultat sous forme de tableau (par défaut) ou d'objet.
298 
	 * 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.
299 
	 *
300 
	 * @param string la requête à effectuer
301 
	 * @param string le mode de retour ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
302 
	 * @return mixed un objet ou un tableau contenant le résultat de la requête
303 
	 */
239 jpm 304 
	public function recuperer($requete, $mode = self::MODE_ASSOC) {
238 jpm 305 
		$this->connecter();
133 aurelien 306 
 
307 
		$retour = null;
308 
		switch ($this->abstraction) {
219 jpm 309 
			case self::ABSTRACTION_PDO :
173 aurelien 310 
				try {
238 jpm 311 
					$resultat = $this->connexion->query($requete);
355 jpm 312 
					$retour = ($resultat !== false) ? $resultat->fetch($this->$mode) : $resultat;
173 aurelien 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);
173 aurelien 316 
				}
140 jpm 317 
				break;
219 jpm 318 
			case self::ABSTRACTION_MYSQL :
238 jpm 319 
				$res = mysql_query($requete, $this->connexion);
133 aurelien 320 
				$fonction_fetch = $this->$mode;
321 
				$retour = $fonction_fetch($res);
140 jpm 322 
				break;
219 jpm 323 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 324 
				$res = $this->connexion->query($requete);
325 
				$fonction_fetch = $this->$mode;
326 
				$retour = $res->$fonction_fetch();
140 jpm 327 
				break;
219 jpm 328 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 329 
				$retour = $this->connexion->querySingle($requete);
140 jpm 330 
				break;
133 aurelien 331 
		}
332 
		return $retour;
120 aurelien 333 
	}
401 jpm 334 
 
238 jpm 335 
	/**
239 jpm 336 
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recupererTous
337 
	 */
338 
	final protected function requeteTous($requete, $mode = self::MODE_ASSOC) {
339 
		return $this->recupererTous($requete, $mode);
340 
	}
401 jpm 341 
 
239 jpm 342 
	/**
401 jpm 343 
	 * Execute une requête et retourne un tableau de résultats. Un résultat peut être présentés sous forme
238 jpm 344 
	 * de tableau (par défaut) ou d'objet.
401 jpm 345 
	 * Les noms des champs de la base de données correspondent aux noms des clés du tableau résultat ou
238 jpm 346 
	 * aux noms des attributs de l'objet résultat.
347 
	 *
348 
	 * @param string la requête à effectuer
349 
	 * @param string le mode de retour des résultats : ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
350 
	 * @return array un tableau contenant les résultats sous forme d'objets ou de tableau (par défaut).
351 
	 */
239 jpm 352 
	public function recupererTous($requete, $mode = self::MODE_ASSOC) {
238 jpm 353 
		$this->connecter();
401 jpm 354 
 
133 aurelien 355 
		$retour = null;
356 
		switch ($this->abstraction) {
219 jpm 357 
			case self::ABSTRACTION_PDO :
143 jpm 358 
				try {
238 jpm 359 
					$resultat = $this->connexion->query($requete);
355 jpm 360 
					$retour = ($resultat !== false) ? $resultat->fetchAll($this->$mode) : $resultat;
143 jpm 361 
				} catch (PDOException $e) {
219 jpm 362 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
363 
					trigger_error($m, E_USER_WARNING);
140 jpm 364 
				}
365 
				break;
219 jpm 366 
			case self::ABSTRACTION_MYSQL :
238 jpm 367 
				$resultat = mysql_query($requete, $this->connexion);
133 aurelien 368 
				$fonction_fetch = $this->$mode;
238 jpm 369 
				while ($ligne = $fonction_fetch($resultat)) {
133 aurelien 370 
					$retour[] = $ligne;
371 
				}
140 jpm 372 
				break;
219 jpm 373 
			case self::ABSTRACTION_MYSQLI :
238 jpm 374 
				$resultat = $this->connexion->query($requete);
133 aurelien 375 
				$function_fetch = $this->$mode;
238 jpm 376 
				while ($ligne = $resultat->$function_fetch()) {
133 aurelien 377 
					$retour[] = $ligne;
378 
				}
140 jpm 379 
				break;
219 jpm 380 
			case self::ABSTRACTION_SQLITE3 :
238 jpm 381 
				$resultat = $this->connexion->query($requete);
382 
				while ($ligne = $resultat->fetch_array($this->ASSOC)) {
219 jpm 383 
					if ($mode == self::MODE_OBJET) {
384 
						// Cas particulier de sqllite qui n'a pas de fonction fetch_object
133 aurelien 385 
						$ligneObjet = new stdClass();
140 jpm 386 
						foreach ($ligne as $colonne => $valeur) {
133 aurelien 387 
							$ligneObjet->$colonne = $valeur;
388 
						}
219 jpm 389 
						$ligne = $ligneObjet;
133 aurelien 390 
					}
219 jpm 391 
					$retour[] = $ligne;
133 aurelien 392 
				}
140 jpm 393 
				break;
133 aurelien 394 
		}
395 
		return $retour;
396 
	}
397 
 
120 aurelien 398 
	/**
460 jpm 399 
	 * Protège une chaine de caractères ou le contenu d'un tablea avant l'insertion dans la base de données
400 
	 * (ajout de quotes ou guillemets).
401 
	 * @param Mixed une chaine ou un tableau à protéger
402 
	 * @return mixed la chaine ou le tableau à protégé
403 
	 */
404 
	public function proteger($donnees) {
405 
		$this->connecter();
406 
		if (is_array($donnees)) {
407 
			$retour = $this->protegerTableau($donnees);
408 
		} else {
409 
			$retour = $this->protegerChaine($donnees);
410 
		}
411 
		return $retour;
412 
	}
413 
 
414 
	/**
238 jpm 415 
	 * Protège une chaine de caractères avant l'insertion dans la base de données (ajout de quotes ou guillemets).
416 
	 * @param string la chaine à protéger
417 
	 * @return string la chaine protégée
120 aurelien 418 
	 */
460 jpm 419 
	private function protegerChaine($chaine) {
133 aurelien 420 
		$retour = $chaine;
421 
		switch ($this->abstraction) {
219 jpm 422 
			case self::ABSTRACTION_PDO :
133 aurelien 423 
				$retour = $this->connexion->quote($chaine);
140 jpm 424 
				break;
219 jpm 425 
			case self::ABSTRACTION_MYSQL :
133 aurelien 426 
				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
140 jpm 427 
				break;
219 jpm 428 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 429 
				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';
140 jpm 430 
				break;
219 jpm 431 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 432 
				$retour = $this->connexion->escapeString($chaine);
140 jpm 433 
				break;
133 aurelien 434 
		}
435 
		return $retour;
120 aurelien 436 
	}
435 jpm 437 
 
403 gduche 438 
	/**
460 jpm 439 
	 * @deprecated changement de nom. Deviendra "private" dans la version 0.5. Utiliser à la place : @see proteger
440 
	 */
441 
	public function protegerTableau(Array $tableau) {
442 
		foreach ($tableau as $id => $val) {
443 
			if (is_array($val)) {
444 
				$tableau[$id] = $this->protegerTableau($val);
445 
			} else {
446 
				$tableau[$id] = $this->protegerChaine($val);
447 
			}
403 gduche 448 
		}
460 jpm 449 
		return $tableau;
403 gduche 450 
	}
120 aurelien 451 
 
452 
	/**
239 jpm 453 
	 * 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
454 
	 * le cas de PDO, du driver utilisé. Les méthodes utilisées pour retourner l'identifiant peuvent avoir des comportements
455 
	 * différent. Consulter la documentation PHP correspondant à l'abstraction choisie avant de l'utiliser :
456 
	 * @link(http://fr.php.net/manual/fr/pdo.lastinsertid.php, PDO::lastInsertId([ string $name = NULL ]))
401 jpm 457 
	 * @link(http://php.net/manual/en/mysqli.insert-id.php, mysqli->insert_id())
239 jpm 458 
	 * @link(http://fr.php.net/manual/fr/function.mysql-insert-id.php, mysql_insert_id())
401 jpm 459 
	 * @link(http://fr.php.net/manual/fr/sqlite3.lastinsertrowid.php, SQLite3::lastInsertRowID())
239 jpm 460 
	 * @param mixed un paramètre éventuel à transmettre (en fonction de l'abstraction de BDD utilisée).
461 
	 * @return mixed le dernier identifiant de clé primaire ajouté dans la base de données (string ou int).
462 
	 */
463 
	public function recupererIdDernierAjout($parametres = null) {
464 
		$this->connecter();
465 
 
411 aurelien 466 
		$retour = null;
239 jpm 467 
		switch ($this->abstraction) {
468 
			case self::ABSTRACTION_PDO :
469 
				$retour = $this->connexion->lastInsertId($parametres);
470 
				break;
471 
			case self::ABSTRACTION_MYSQL :
472 
				$retour = mysql_insert_id($this->connexion);
473 
				break;
474 
			case self::ABSTRACTION_MYSQLI :
475 
				$retour = $this->connexion->insert_id();
476 
				break;
477 
			case self::ABSTRACTION_SQLITE3 :
478 
				$retour = $this->connexion->lastInsertRowID();
479 
				break;
480 
		}
481 
		return $retour;
482 
	}
401 jpm 483 
 
239 jpm 484 
	/**
219 jpm 485 
	 * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
120 aurelien 486 
	 */
247 jpm 487 
	public function __destruct() {
340 jpm 488 
		if (isset($this->connexion)) {
489 
			switch ($this->abstraction) {
490 
				case self::ABSTRACTION_PDO :
491 
					$this->connexion = null;
492 
					break;
493 
				case self::ABSTRACTION_MYSQL :
494 
					if (isset($this->connexion)) {
495 
						return mysql_close($this->connexion);
401 jpm 496 
					}
340 jpm 497 
					break;
498 
				case self::ABSTRACTION_MYSQLI :
499 
					$this->connexion->close();
500 
					break;
501 
				case self::ABSTRACTION_SQLITE3 :
502 
					$this->connexion->close();
503 
					break;
504 
			}
120 aurelien 505 
		}
506 
	}
5 aurelien 507 
}
460 jpm 508 
?>