Subversion Repositories Applications.framework

Rev

Rev 420 | Rev 429 | 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 427 2013-06-28 07:53:51Z raphael $
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');
427 raphael 97 
		$this->dsn = Config::get('bdd_dsn');
420 gduche 98 
 
120 aurelien 99 
		$this->encodage = Config::get('bdd_encodage');
100 
 
427 raphael 101 
		if (!$this->dsn) {
102 
			if ($this->type == 'sqlite' || $this->type == 'sqlite2') {
103 
				$this->dsn = $this->type.':'.$this->hote;
104 
			} else {
105 
				$this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
106 
			}
401 jpm 107 
		}
133 aurelien 108 
		$this->initialiserProtocole();
120 aurelien 109 
	}
110 
 
238 jpm 111 
	/** Initialise les constantes de classe à leur bonne valeur et déclenche une erreur si le protocole n'est pas bien défini. */
112 
	protected function initialiserProtocole() {
133 aurelien 113 
		switch ($this->abstraction) {
219 jpm 114 
			case self::ABSTRACTION_PDO :
238 jpm 115 
				$this->ASSOC = PDO::FETCH_ASSOC;
116 
				$this->OBJECT = PDO::FETCH_CLASS;
219 jpm 117 
				break;
118 
			case self::ABSTRACTION_MYSQL :
238 jpm 119 
				$this->ASSOC = 'mysql_fetch_assoc';
120 
				$this->OBJECT = 'mysql_fetch_object';
219 jpm 121 
				break;
122 
			case self::ABSTRACTION_MYSQLI :
238 jpm 123 
				$this->ASSOC = 'fetch_assoc';
124 
				$this->OBJECT = 'fetch_object';
219 jpm 125 
				break;
126 
			case self::ABSTRACTION_SQLITE3 :
238 jpm 127 
				$this->ASSOC = 'SQLITE3_ASSOC';
128 
				$this->OBJECT = 'SQLITE3_OBJECT';
219 jpm 129 
				break;
133 aurelien 130 
			default:
238 jpm 131 
				$m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
132 
				trigger_error($m, E_USER_WARNING);
133 aurelien 133 
		}
238 jpm 134 
	}
401 jpm 135 
 
238 jpm 136 
	/**
137 
	 * Connection à la base de données en utilisant les informations fournies par
138 
	 * le fichier de configuration.
139 
	 * Cette méthode est private et final car elle n'a pas vocation a être appelée par l'utilisateur.
140 
	 */
141 
	protected function connecter() {
142 
		if ($this->connexion == null) {
143 
			switch ($this->abstraction) {
144 
				case self::ABSTRACTION_PDO :
145 
					try {
146 
						$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
354 jpm 147 
						$this->connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
238 jpm 148 
					} catch (PDOException $e) {
149 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
150 
						trigger_error($e, E_USER_WARNING);
151 
					}
401 jpm 152 
					if ($this->encodage != null && $this->type == 'mysql') {
427 raphael 153 
						$this->connexion->query("SET names '".$this->encodage."'");
401 jpm 154 
					} else if ($this->type == 'sqlite') {
427 raphael 155 
						$this->connexion->query("PRAGMA case_sensitive_like = false");
401 jpm 156 
					}
238 jpm 157 
					break;
158 
				case self::ABSTRACTION_MYSQL :
159 
					$this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
160 
					if ($this->connexion !== false) {
161 
						$selection = mysql_select_db($this->bdd_nom, $this->connexion);
162 
						if ($selection === false) {
163 
							$e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
164 
							trigger_error($e, E_USER_WARNING);
165 
						}
166 
					} else {
167 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
168 
						trigger_error($e, E_USER_WARNING);
169 
					}
401 jpm 170 
					if ($this->encodage != null) {
171 
						$this->requeter("SET names '".$this->encodage."'");
172 
					}
238 jpm 173 
					break;
174 
				case self::ABSTRACTION_MYSQLI :
175 
					$this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
176 
					if ($this->connexion->connect_errno) {
177 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
178 
						trigger_error($e, E_USER_WARNING);
179 
					}
401 jpm 180 
					if ($this->encodage != null) {
181 
						$this->requeter("SET names '".$this->encodage."'");
182 
					}
238 jpm 183 
					break;
184 
				case self::ABSTRACTION_SQLITE3 :
185 
					// cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
186 
					$this->connexion = new SQLite3($this->bdd_nom);
187 
					if (!$this->connexion) {
188 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, '');
189 
						trigger_error($e, E_USER_WARNING);
190 
					}
401 jpm 191 
					$this->requeter("PRAGMA case_sensitive_like = false");
238 jpm 192 
					break;
193 
				default:
194 
					$this->connexion = null;
195 
			}
401 jpm 196 
 
238 jpm 197 
			if ($this->encodage != null) {
198 
				$this->requete("SET names '".$this->encodage."'");
199 
			}
133 aurelien 200 
		}
201 
	}
401 jpm 202 
 
133 aurelien 203 
	/**
239 jpm 204 
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see requeter
205 
	 */
206 
	final protected function requete($requete) {
329 delphine 207 
		return $this->requeter($requete);
239 jpm 208 
	}
401 jpm 209 
 
239 jpm 210 
	/**
238 jpm 211 
	 * Execute une requête et retourne le résultat tel que renvoyé par l'abstraction courante.
120 aurelien 212 
	 *
238 jpm 213 
	 * @param string la requête à effectuer
214 
	 * @return mixed un objet contenant le résultat de la requête
120 aurelien 215 
	 */
239 jpm 216 
	public function requeter($requete) {
238 jpm 217 
		$this->connecter();
218 
 
133 aurelien 219 
		$retour = null;
220 
		switch ($this->abstraction) {
219 jpm 221 
			case self::ABSTRACTION_PDO :
222 
				try {
223 
					$retour = $this->connexion->query($requete);
224 
				} catch (PDOException $e) {
225 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
226 
					trigger_error($m, E_USER_WARNING);
227 
				}
140 jpm 228 
				break;
219 jpm 229 
			case self::ABSTRACTION_MYSQL :
230 
				$retour = mysql_query($requete, $this->connexion);
140 jpm 231 
				break;
219 jpm 232 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 233 
				$retour = $this->connexion->query($requete);
140 jpm 234 
				break;
219 jpm 235 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 236 
				$retour = $this->connexion->exec($requete);
140 jpm 237 
				break;
133 aurelien 238 
		}
239 
		return $retour;
120 aurelien 240 
	}
401 jpm 241 
 
238 jpm 242 
	/**
239 jpm 243 
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recuperer
244 
	 */
245 
	final protected function requeteUn($requete, $mode = self::MODE_ASSOC) {
246 
		return $this->recuperer($requete, $mode);
247 
	}
401 jpm 248 
 
239 jpm 249 
	/**
238 jpm 250 
	 * Execute une requête et retourne le premier résultat sous forme de tableau (par défaut) ou d'objet.
251 
	 * 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.
252 
	 *
253 
	 * @param string la requête à effectuer
254 
	 * @param string le mode de retour ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
255 
	 * @return mixed un objet ou un tableau contenant le résultat de la requête
256 
	 */
239 jpm 257 
	public function recuperer($requete, $mode = self::MODE_ASSOC) {
238 jpm 258 
		$this->connecter();
133 aurelien 259 
 
260 
		$retour = null;
261 
		switch ($this->abstraction) {
219 jpm 262 
			case self::ABSTRACTION_PDO :
173 aurelien 263 
				try {
238 jpm 264 
					$resultat = $this->connexion->query($requete);
355 jpm 265 
					$retour = ($resultat !== false) ? $resultat->fetch($this->$mode) : $resultat;
173 aurelien 266 
				} catch (PDOException $e) {
219 jpm 267 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
268 
					trigger_error($m, E_USER_WARNING);
173 aurelien 269 
				}
140 jpm 270 
				break;
219 jpm 271 
			case self::ABSTRACTION_MYSQL :
238 jpm 272 
				$res = mysql_query($requete, $this->connexion);
133 aurelien 273 
				$fonction_fetch = $this->$mode;
274 
				$retour = $fonction_fetch($res);
140 jpm 275 
				break;
219 jpm 276 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 277 
				$res = $this->connexion->query($requete);
278 
				$fonction_fetch = $this->$mode;
279 
				$retour = $res->$fonction_fetch();
140 jpm 280 
				break;
219 jpm 281 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 282 
				$retour = $this->connexion->querySingle($requete);
140 jpm 283 
				break;
133 aurelien 284 
		}
285 
		return $retour;
120 aurelien 286 
	}
401 jpm 287 
 
238 jpm 288 
	/**
239 jpm 289 
	 * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recupererTous
290 
	 */
291 
	final protected function requeteTous($requete, $mode = self::MODE_ASSOC) {
292 
		return $this->recupererTous($requete, $mode);
293 
	}
401 jpm 294 
 
239 jpm 295 
	/**
401 jpm 296 
	 * Execute une requête et retourne un tableau de résultats. Un résultat peut être présentés sous forme
238 jpm 297 
	 * de tableau (par défaut) ou d'objet.
401 jpm 298 
	 * Les noms des champs de la base de données correspondent aux noms des clés du tableau résultat ou
238 jpm 299 
	 * aux noms des attributs de l'objet résultat.
300 
	 *
301 
	 * @param string la requête à effectuer
302 
	 * @param string le mode de retour des résultats : ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
303 
	 * @return array un tableau contenant les résultats sous forme d'objets ou de tableau (par défaut).
304 
	 */
239 jpm 305 
	public function recupererTous($requete, $mode = self::MODE_ASSOC) {
238 jpm 306 
		$this->connecter();
401 jpm 307 
 
133 aurelien 308 
		$retour = null;
309 
		switch ($this->abstraction) {
219 jpm 310 
			case self::ABSTRACTION_PDO :
143 jpm 311 
				try {
238 jpm 312 
					$resultat = $this->connexion->query($requete);
355 jpm 313 
					$retour = ($resultat !== false) ? $resultat->fetchAll($this->$mode) : $resultat;
143 jpm 314 
				} catch (PDOException $e) {
219 jpm 315 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
316 
					trigger_error($m, E_USER_WARNING);
140 jpm 317 
				}
318 
				break;
219 jpm 319 
			case self::ABSTRACTION_MYSQL :
238 jpm 320 
				$resultat = mysql_query($requete, $this->connexion);
133 aurelien 321 
				$fonction_fetch = $this->$mode;
238 jpm 322 
				while ($ligne = $fonction_fetch($resultat)) {
133 aurelien 323 
					$retour[] = $ligne;
324 
				}
140 jpm 325 
				break;
219 jpm 326 
			case self::ABSTRACTION_MYSQLI :
238 jpm 327 
				$resultat = $this->connexion->query($requete);
133 aurelien 328 
				$function_fetch = $this->$mode;
238 jpm 329 
				while ($ligne = $resultat->$function_fetch()) {
133 aurelien 330 
					$retour[] = $ligne;
331 
				}
140 jpm 332 
				break;
219 jpm 333 
			case self::ABSTRACTION_SQLITE3 :
238 jpm 334 
				$resultat = $this->connexion->query($requete);
335 
				while ($ligne = $resultat->fetch_array($this->ASSOC)) {
219 jpm 336 
					if ($mode == self::MODE_OBJET) {
337 
						// Cas particulier de sqllite qui n'a pas de fonction fetch_object
133 aurelien 338 
						$ligneObjet = new stdClass();
140 jpm 339 
						foreach ($ligne as $colonne => $valeur) {
133 aurelien 340 
							$ligneObjet->$colonne = $valeur;
341 
						}
219 jpm 342 
						$ligne = $ligneObjet;
133 aurelien 343 
					}
219 jpm 344 
					$retour[] = $ligne;
133 aurelien 345 
				}
140 jpm 346 
				break;
133 aurelien 347 
		}
348 
		return $retour;
349 
	}
350 
 
120 aurelien 351 
	/**
238 jpm 352 
	 * Protège une chaine de caractères avant l'insertion dans la base de données (ajout de quotes ou guillemets).
353 
	 * @param string la chaine à protéger
354 
	 * @return string la chaine protégée
120 aurelien 355 
	 */
238 jpm 356 
	public function proteger($chaine) {
357 
		$this->connecter();
133 aurelien 358 
 
359 
		$retour = $chaine;
360 
		switch ($this->abstraction) {
219 jpm 361 
			case self::ABSTRACTION_PDO :
133 aurelien 362 
				$retour = $this->connexion->quote($chaine);
140 jpm 363 
				break;
219 jpm 364 
			case self::ABSTRACTION_MYSQL :
133 aurelien 365 
				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
140 jpm 366 
				break;
219 jpm 367 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 368 
				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';
140 jpm 369 
				break;
219 jpm 370 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 371 
				$retour = $this->connexion->escapeString($chaine);
140 jpm 372 
				break;
133 aurelien 373 
		}
374 
		return $retour;
120 aurelien 375 
	}
406 gduche 376 
 
377 
	/**
378 
	* Protège les chaines d'un tableau de caractères avant l'insertion dans la base de données (ajout de quotes ou guillemets).
379 
	* @param array le tableau de chaines à protéger
380 
	* @return array le tableau avec les chaines protégées
381 
	*/
408 gduche 382 
	public function protegerTableau($tableau) {
406 gduche 383 
		$champsProteges = array();
384 
		foreach($tableau as $champ => $valeur) {
385 
			$champsProteges[$champ] = $this->proteger($valeur);
386 
		}
387 
		return $champsProteges;
388 
	}
120 aurelien 389 
 
390 
	/**
239 jpm 391 
	 * 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
392 
	 * le cas de PDO, du driver utilisé. Les méthodes utilisées pour retourner l'identifiant peuvent avoir des comportements
393 
	 * différent. Consulter la documentation PHP correspondant à l'abstraction choisie avant de l'utiliser :
394 
	 * @link(http://fr.php.net/manual/fr/pdo.lastinsertid.php, PDO::lastInsertId([ string $name = NULL ]))
401 jpm 395 
	 * @link(http://php.net/manual/en/mysqli.insert-id.php, mysqli->insert_id())
239 jpm 396 
	 * @link(http://fr.php.net/manual/fr/function.mysql-insert-id.php, mysql_insert_id())
401 jpm 397 
	 * @link(http://fr.php.net/manual/fr/sqlite3.lastinsertrowid.php, SQLite3::lastInsertRowID())
239 jpm 398 
	 * @param mixed un paramètre éventuel à transmettre (en fonction de l'abstraction de BDD utilisée).
399 
	 * @return mixed le dernier identifiant de clé primaire ajouté dans la base de données (string ou int).
400 
	 */
401 
	public function recupererIdDernierAjout($parametres = null) {
402 
		$this->connecter();
403 
 
420 gduche 404 
		$retour = null;
239 jpm 405 
		switch ($this->abstraction) {
406 
			case self::ABSTRACTION_PDO :
407 
				$retour = $this->connexion->lastInsertId($parametres);
408 
				break;
409 
			case self::ABSTRACTION_MYSQL :
410 
				$retour = mysql_insert_id($this->connexion);
411 
				break;
412 
			case self::ABSTRACTION_MYSQLI :
413 
				$retour = $this->connexion->insert_id();
414 
				break;
415 
			case self::ABSTRACTION_SQLITE3 :
416 
				$retour = $this->connexion->lastInsertRowID();
417 
				break;
418 
		}
419 
		return $retour;
420 
	}
401 jpm 421 
 
239 jpm 422 
	/**
219 jpm 423 
	 * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
120 aurelien 424 
	 */
247 jpm 425 
	public function __destruct() {
340 jpm 426 
		if (isset($this->connexion)) {
427 
			switch ($this->abstraction) {
428 
				case self::ABSTRACTION_PDO :
429 
					$this->connexion = null;
430 
					break;
431 
				case self::ABSTRACTION_MYSQL :
432 
					if (isset($this->connexion)) {
433 
						return mysql_close($this->connexion);
401 jpm 434 
					}
340 jpm 435 
					break;
436 
				case self::ABSTRACTION_MYSQLI :
437 
					$this->connexion->close();
438 
					break;
439 
				case self::ABSTRACTION_SQLITE3 :
440 
					$this->connexion->close();
441 
					break;
442 
			}
120 aurelien 443 
		}
444 
	}
5 aurelien 445 
}
446 
?>