Subversion Repositories Applications.framework

Rev

Rev 173 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 173 Rev 219
Line 1... Line 1...
1 
<?php
 1 
<?php
2 
// declare(encoding='UTF-8');
 2 
// declare(encoding='UTF-8');
3 
/**
 3 
/**
4 
* Classe modèle, donc d'accés au données, elle ne devrait pas être appelée de l'extérieur.
 4 
* Classe modèle, d'accés au données, elle ne devrait pas être appelée de l'extérieur.
5 
* Elle fait office d'abstraction légère de base de données en utilisant diveres possibilités
 5 
* Elle fait office d'abstraction légère de base de données en utilisant diverses possibilités
6 
* d'abstraction de base de données (PDO, mysql, mysqli, sqlite)
 6 
* d'abstraction de base 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
7 
* Elle est abstraite donc doit obligatoirement être étendue.
 8 
* Elle est abstraite et doit donc obligatoirement être étendue.
8 
*
 9 
*
9 
* PHP Version 5
 - 
 
10 
*
 - 
 
11 
* @category  Class
 10 
* @category	php 5.2
12 
* @package   Framework
 11 
* @package		Framework
13 
* @author	aurelien <aurelien@tela-botanica.org>
 12 
* @author		Aurélien PERONNET <aurelien@tela-botanica.org>
14 
* @copyright 2009 Tela-Botanica
 13 
* @copyright	2009 Tela-Botanica
15 
* @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 14 
* @license		http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
16 
* @license   http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 15 
* @license		http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
17 
* @version   SVN: $$Id: Modele.php 173 2010-04-02 14:03:08Z aurelien $$
 16 
* @version		SVN: $Id: Modele.php 219 2010-11-10 13:27:48Z jpm $
18 
* @link	  /doc/framework/
 17 
* @link		/doc/framework/
19 
*
 18 
*
20 
*/
 19 
*/
21 
abstract class Modele {
 20 
abstract class Modele {
- 
 
 21 
	/** Constante stockant le squelette du message en cas d'erreur de requête sql. */
- 
 
 22 
	const ERREUR_REQUETE_TPL = 'Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s';
22 
 
 23
- 
 
 24 
	/** Constante stockant le squelette du message en cas d'erreur de connexion à la base de données. */
- 
 
 25 
	const ERREUR_CONNEXION_TPL = 'Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration.\nMessage : %S.';
- 
 
 26
- 
 
 27 
	/** Constante stockant le squelette du message en cas d'erreur de sélection de la base de données. */
- 
 
 28 
	const ERREUR_CONNEXION_TPL = 'Erreur de sélection de la base de données, vérifiez les paramètres du fichier de configuration.\nMessage : %S.';
- 
 
 29
- 
 
 30 
	/** Constante stockant le code pour l'abstraction de PDO. */
- 
 
 31 
	const ABSTRACTION_PDO = 'pdo';
- 
 
 32
- 
 
 33 
	/** Constante stockant le code pour l'abstraction de mysql. */
- 
 
 34 
	const ABSTRACTION_MYSQL = 'mysql';
- 
 
 35
- 
 
 36 
	/** Constante stockant le code pour l'abstraction de mysqli. */
- 
 
 37 
	const ABSTRACTION_MYSQLI = 'mysqli';
- 
 
 38
- 
 
 39 
	/** Constante stockant le code pour l'abstraction de SQLite3. */
- 
 
 40 
	const ABSTRACTION_SQLITE3 = 'sqlite3';
- 
 
 41
- 
 
 42 
	/** Constante stockant le code pour le mode tableau associatif des résultats des requêtes. */
- 
 
 43 
	const MODE_ASSOC = 'ASSOC';
- 
 
 44
- 
 
 45 
	/** Constante stockant le code pour le mode objet des résultats des requêtes. */
- 
 
 46 
	const MODE_OBJET = 'OBJECT';
23 
	/**
 47
24 
	 * Mode de fetch associatif
 48 
	/** Mode de fetch associatif */
25 
	 */
 - 
 
26 
	private $ASSOC = '';
 49 
	private $ASSOC = '';
27 
	/**
 50
28 
	 * Mode de fetch objet
 51 
	/** Mode de fetch objet */
29 
	 */
 - 
 
30 
	private $OBJECT = '';
 52 
	private $OBJECT = '';
Line 31... Line -...
31 
 
 - 
 
32 
	/**
 53 
 
33 
	 * abstraction de base de données utilisée
 - 
 
34 
	 */
 54 
	/** abstraction de base de données utilisée */
35 
	private $abstraction;
 - 
 
36 
	/**
 - 
 
37 
	 * registre global
 - 
 
38 
	 */
 - 
 
39 
	private $registre;
 55 
	private $abstraction;
40 
	/**
 56
41 
	 * DSN pour accéder à la base de données
 - 
 
42 
	 */
 57 
	/** DSN pour accéder à la base de données */
43 
	private $dsn;
 58 
	private $dsn;
44 
	/**
 59
45 
	 * Type de base de données (mysql, mysqli, etc ...)
 - 
 
46 
	 */
 60 
	/** Type de base de données (mysql, mysqli, etc ...) */
47 
	private $type;
 61 
	private $type;
48 
	/**
 62
49 
	 * Hote herbergeant la base de données
 - 
 
50 
	 */
 63 
	/** Hote herbergeant la base de données */
51 
	private $hote;
 64 
	private $hote;
52 
	/**
 65
53 
	 * Nom de la base de données à laquelle le modèle doit se connecter
 - 
 
54 
	 */
 66 
	/** Nom de la base de données à laquelle le modèle doit se connecter */
55 
	private $bdd_nom;
 67 
	private $bdd_nom;
56 
	/**
 68
57 
	 * Nom d'utilisateur
 - 
 
58 
	 */
 69 
	/** Nom d'utilisateur */
59 
	private $utilisateur;
 70 
	private $utilisateur;
60 
	/**
 71
61 
	 * Mot de passe
 - 
 
62 
	 */
 72 
	/** Mot de passe */
Line 63... Line -...
63 
	private $pass;
 - 
 
64 
 
 73 
	private $pass;
65 
	/**
 - 
 
66 
	 * Encodage de la base de données
 74 
 
67 
	 */
 75 
	/** Encodage de la base de données */
68 
	 private $encodage = null;
 76 
	 private $encodage = null;
69 
	/**
 - 
 
70 
	 * Connexion à la base de données
 77
Line 71... Line 78...
71 
	 */
 78 
	/** Connexion à la base de données */
72 
	private $connexion = null;
 79 
	private $connexion = null;
73 
 
 80 
 
74 
	/**
 81 
	/**
75 
	 * Constructeur par défaut, appelé à l'initialisation.
 - 
 
76 
	 */
 - 
 
77 
	public function __construct() {
 82 
	 * Constructeur par défaut, appelé à l'initialisation.
78 
		// les différents paramètres nécessaires sont lus à partir du registre
 83 
	 */
79 
		$this->registre = Registre::getInstance();
 84 
	public function __construct() {
80 
		$this->abstraction = strtolower(Config::get('bdd_abstraction'));
 85 
		$this->abstraction = strtolower(Config::get('bdd_abstraction'));
81 
		$this->type = Config::get('bdd_protocole');
 86 
		$this->type = Config::get('bdd_protocole');
Line 96... Line 101...
96 
	 *
 101 
	 *
97 
	 * @throws Exception une exception dans le cas ou là connexion échoue
 102 
	 * @throws Exception une exception dans le cas ou là connexion échoue
98 
	 */
 103 
	 */
99 
	final private function connecter() {
 104 
	final private function connecter() {
100 
		switch ($this->abstraction) {
 105 
		switch ($this->abstraction) {
- 
 
 106 
			case self::ABSTRACTION_PDO :
101 
			case 'pdo':
 107 
				try {
102 
				$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
 108 
					$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
- 
 
 109 
				} catch (PDOException $e) {
- 
 
 110 
					$e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
- 
 
 111 
					trigger_error($e, E_USER_WARNING);
- 
 
 112 
				}
103 
			break;
 113 
				break;
104 
 
 - 
 
105 
			case 'mysql':
 114 
			case self::ABSTRACTION_MYSQL :
106 
				$this->connexion = mysql_connect($this->hote,$this->utilisateur,$this->pass);
 115 
				$this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
107 
				if ($this->connexion != null) {
 116 
				if ($this->connexion !== false) {
108 
					mysql_select_db($this->bdd_nom, $this->connexion);
 117 
					$selection = mysql_select_db($this->bdd_nom, $this->connexion);
- 
 
 118 
					if ($selection === false) {
- 
 
 119 
						$e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
- 
 
 120 
						trigger_error($e, E_USER_WARNING);
- 
 
 121 
					}
109 
				} else {
 122 
				} else {
110 
					throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');
 123 
					$e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
- 
 
 124 
					trigger_error($e, E_USER_WARNING);
111 
				}
 125 
				}
112 
			break;
 126 
				break;
113 
 
 - 
 
114 
			case 'mysqli':
 127 
			case self::ABSTRACTION_MYSQLI :
115 
				$this->connexion = new mysqli($this->hote,$this->utilisateur,$this->pass, $this->bdd_nom);
 128 
				$this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
116 
				if (!$this->connexion) {
 129 
				if ($this->connexion->connect_errno) {
117 
					throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');
 130 
					$e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
118 
					return;
 131 
					trigger_error($e, E_USER_WARNING);
119 
				}
 132 
				}
120 
			break;
 133 
				break;
121 
 
 - 
 
122 
			case 'sqlite3':
 134 
			case self::ABSTRACTION_SQLITE3 :
123 
				// cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
 135 
				// cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
124 
				$this->connexion = new SQLite3($this->bdd_nom);
 136 
				$this->connexion = new SQLite3($this->bdd_nom);
125 
				if (!$this->connexion) {
 137 
				if (!$this->connexion) {
126 
					throw new Exception('Erreur de connexion à la base de données, vérifiez les paramètres du fichier de configuration');
 138 
					$e = sprintf(self::ERREUR_CONNEXION_TPL, '');
127 
					return;
 139 
					trigger_error($e, E_USER_WARNING);
128 
				}
 140 
				}
129 
			break;
 141 
				break;
130 
 
 - 
 
131 
			default:
 142 
			default:
132 
				$this->connexion = null;
 143 
				$this->connexion = null;
133 
		}
 144 
		}
Line 134... Line 145...
134 
 
 145 
 
Line 142... Line 153...
142 
	 *
 153 
	 *
143 
	 * @param string la requete à effectuer
 154 
	 * @param string la requete à effectuer
144 
	 * @return PDOStatement un objet contenant le résultat de la requête
 155 
	 * @return PDOStatement un objet contenant le résultat de la requête
145 
	 */
 156 
	 */
146 
	final protected function requete($requete) {
 157 
	final protected function requete($requete) {
147 
		// on ne se connecte que lors du premier appel à une requete (lazy connexion)
 - 
 
148 
		if ($this->connexion == null) {
 158 
		if ($this->connexion == null) {
149 
			$this->connecter();
 159 
			$this->connecter();
150 
		}
 160 
		}
151 
 
 - 
 
152 
		$retour = null;
 161 
		$retour = null;
153 
 
 162
154 
		switch ($this->abstraction) {
 163 
		switch ($this->abstraction) {
- 
 
 164 
			case self::ABSTRACTION_PDO :
155 
			case 'pdo':
 165 
				try {
156 
				$retour = $this->connexion->query($requete);
 166 
					$retour = $this->connexion->query($requete);
- 
 
 167 
				} catch (PDOException $e) {
- 
 
 168 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
- 
 
 169 
					trigger_error($m, E_USER_WARNING);
- 
 
 170 
				}
157 
				break;
 171 
				break;
158 
			case 'mysql':
 172 
			case self::ABSTRACTION_MYSQL :
159 
				$retour = mysql_query($requete,$this->connexion);
 173 
				$retour = mysql_query($requete, $this->connexion);
160 
				break;
 174 
				break;
161 
			case 'mysqli':
 175 
			case self::ABSTRACTION_MYSQLI :
162 
				$retour = $this->connexion->query($requete);
 176 
				$retour = $this->connexion->query($requete);
163 
				break;
 177 
				break;
164 
			case 'sqlite3':
 178 
			case self::ABSTRACTION_SQLITE3 :
165 
				$retour = $this->connexion->exec($requete);
 179 
				$retour = $this->connexion->exec($requete);
166 
				break;
 180 
				break;
167 
		}
 181 
		}
168 
 
 - 
 
169 
		return $retour;
 182 
		return $retour;
170 
	}
 183 
	}
Line 171... Line 184...
171 
 
 184 
 
172 
	final protected function requeteUn($requete,$mode = 'ASSOC') {
 - 
 
173 
		// Connection seulement lors du premier appel à une requete (lazy connexion)
 185 
	final protected function requeteUn($requete, $mode = self::MODE_ASSOC) {
174 
		if ($this->connexion == null) {
 186 
		if ($this->connexion == null) {
175 
			$this->connecter();
 187 
			$this->connecter();
Line 176... Line 188...
176 
		}
 188 
		}
177 
 
 189 
 
178 
		$retour = null;
 190 
		$retour = null;
179 
		switch ($this->abstraction) {
 191 
		switch ($this->abstraction) {
180 
			case 'pdo':
 192 
			case self::ABSTRACTION_PDO :
181 
				try {
 193 
				try {
182 
					$res_req = $this->connexion->query($requete);
 194 
					$res_req = $this->connexion->query($requete);
183 
					$retour =$res_req->fetch($this->$mode);
 195 
					$retour =$res_req->fetch($this->$mode);
184 
				} catch (PDOException $e) {
 196 
				} catch (PDOException $e) {
185 
					$message = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s';
 197 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
186 
					trigger_error(sprintf($message, $e->getFile(), $e->getLine(), $e->getMessage()), E_USER_WARNING);
 198 
					trigger_error($m, E_USER_WARNING);
187 
				}
 199 
				}
188 
				break;
 200 
				break;
189 
			case 'mysql':
 201 
			case self::ABSTRACTION_MYSQL :
190 
				$res = mysql_query($requete,$this->connexion);
 202 
				$res = mysql_query($requete,$this->connexion);
191 
				$fonction_fetch = $this->$mode;
 203 
				$fonction_fetch = $this->$mode;
192 
				$retour = $fonction_fetch($res);
 204 
				$retour = $fonction_fetch($res);
193 
				break;
 205 
				break;
194 
			case 'mysqli':
 206 
			case self::ABSTRACTION_MYSQLI :
195 
				$res = $this->connexion->query($requete);
 207 
				$res = $this->connexion->query($requete);
196 
				$fonction_fetch = $this->$mode;
 208 
				$fonction_fetch = $this->$mode;
197 
				$retour = $res->$fonction_fetch();
 209 
				$retour = $res->$fonction_fetch();
198 
				break;
 210 
				break;
199 
			case 'sqlite3':
 211 
			case self::ABSTRACTION_SQLITE3 :
200 
				$retour = $this->connexion->querySingle($requete);
 212 
				$retour = $this->connexion->querySingle($requete);
Line 201... Line 213...
201 
				break;
 213 
				break;
202 
		}
 214 
		}
Line 203... Line 215...
203 
 
 215 
 
204 
		return $retour;
 - 
 
205 
	}
 216 
		return $retour;
206 
 
 217 
	}
207 
 
 218 
 
Line 208... Line 219...
208 
	final protected function requeteTous($requete,$mode = 'ASSOC') {
 219 
 
Line 209... Line 220...
209 
		// Connexion seulement lors du premier appel à une requete (lazy connexion)
 220 
	final protected function requeteTous($requete, $mode = self::MODE_ASSOC) {
210 
		if ($this->connexion == null) {
 221 
		if ($this->connexion == null) {
211 
			$this->connecter();
 222 
			$this->connecter();
212 
		}
 223 
		}
213 
 
 224 
 
214 
		$retour = null;
 225 
		$retour = null;
215 
 
 226 
 
216 
		switch ($this->abstraction) {
 227 
		switch ($this->abstraction) {
217 
			case 'pdo':
 228 
			case self::ABSTRACTION_PDO :
218 
				try {
 229 
				try {
219 
					$res_req = $this->connexion->query($requete);
 230 
					$res_req = $this->connexion->query($requete);
220 
					if ($res_req !== false) {
 231 
					if ($res_req !== false) {
221 
						$retour = $res_req->fetchAll($this->$mode);
 232 
						$retour = $res_req->fetchAll($this->$mode);
222 
					} else {
 233 
					} else {
223 
						$retour = false;
 234 
						$retour = false;
224 
					}
 235 
					}
225 
				} catch (PDOException $e) {
 236 
				} catch (PDOException $e) {
226 
					$message = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s';
 237 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
227 
					trigger_error(sprintf($message, $e->getFile(), $e->getLine(), $e->getMessage()), E_USER_WARNING);
 238 
					trigger_error($m, E_USER_WARNING);
228 
				}
 239 
				}
229 
				break;
 240 
				break;
230 
			case 'mysql':
 241 
			case self::ABSTRACTION_MYSQL :
231 
				$res = mysql_query($requete, $this->connexion);
 242 
				$res = mysql_query($requete, $this->connexion);
232 
				$fonction_fetch = $this->$mode;
 243 
				$fonction_fetch = $this->$mode;
233 
				while ($ligne = $fonction_fetch($res)) {
 244 
				while ($ligne = $fonction_fetch($res)) {
234 
					$retour[] = $ligne;
 245 
					$retour[] = $ligne;
235 
				}
 246 
				}
236 
				break;
 247 
				break;
237 
			case 'mysqli':
 248 
			case self::ABSTRACTION_MYSQLI :
238 
				$res = $this->connexion->query($requete);
 249 
				$res = $this->connexion->query($requete);
239 
				$function_fetch = $this->$mode;
 250 
				$function_fetch = $this->$mode;
240 
				while ($ligne = $res->$function_fetch()) {
 251 
				while ($ligne = $res->$function_fetch()) {
241 
					$retour[] = $ligne;
 - 
 
242 
				}
 - 
 
243 
				break;
 - 
 
244 
			case 'sqlite3':
 252 
					$retour[] = $ligne;
245 
				$res = $this->connexion->query($requete);
 253 
				}
246 
				while ($ligne = $res->fetch_array($this->ASSOC)) {
 254 
				break;
247 
					if ($mode == $this->ASSOC) {
 255 
			case self::ABSTRACTION_SQLITE3 :
248 
						$retour[] = $ligne;
 256 
				$res = $this->connexion->query($requete);
249 
					} elseif ($mode == $this->OBJECT) {
 257 
				while ($ligne = $res->fetch_array($this->ASSOC)) {
250 
						// cas particulier de sqllite
 258 
					if ($mode == self::MODE_OBJET) {
- 
 
 259 
						// Cas particulier de sqllite qui n'a pas de fonction fetch_object
251 
						// qui n'a pas de fonction fetch_object
 260 
						$ligneObjet = new stdClass();
252 
						$ligneObjet = new stdClass();
 261 
						foreach ($ligne as $colonne => $valeur) {
253 
						foreach ($ligne as $colonne => $valeur) {
 262 
							$ligneObjet->$colonne = $valeur;
Line 254... Line 263...
254 
							$ligneObjet->$colonne = $valeur;
 263 
						}
255 
						}
 264 
						$ligne = $ligneObjet;
Line 256... Line 265...
256 
						$retour[] = $ligneObjet;
 265 
					}
257 
					}
 266 
					$retour[] = $ligne;
258 
				}
 267 
				}
259 
				break;
 268 
				break;
260 
		}
 - 
 
261 
 
 - 
 
262 
		return $retour;
 269 
		}
263 
	}
 270 
 
264 
 
 271 
		return $retour;
Line 265... Line 272...
265 
	/**
 272 
	}
Line 266... Line 273...
266 
	 * protège une chaine de caractères avant l'insertion dans la base de données
 273 
 
267 
	 */
 274 
	/**
268 
	final protected function proteger($chaine) {
 275 
	 * Protège une chaine de caractères avant l'insertion dans la base de données.
269 
 
 276 
	 */
270 
		// on ne se connecte que lors du premier appel à une requete
 277 
	final protected function proteger($chaine) {
271 
		if ($this->connexion == null) {
 278 
		if ($this->connexion == null) {
272 
			$this->connecter();
 279 
			$this->connecter();
273 
		}
 280 
		}
274 
 
 281 
 
275 
		$retour = $chaine;
 282 
		$retour = $chaine;
276 
 
 283 
 
277 
		switch ($this->abstraction) {
 284 
		switch ($this->abstraction) {
278 
			case 'pdo':
 285 
			case self::ABSTRACTION_PDO :
279 
				$retour = $this->connexion->quote($chaine);
 286 
				$retour = $this->connexion->quote($chaine);
Line 280... Line 287...
280 
				break;
 287 
				break;
281 
			case 'mysql':
 288 
			case self::ABSTRACTION_MYSQL :
Line 282... Line 289...
282 
				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
 289 
				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
283 
				break;
 - 
 
284 
			case 'mysqli':
 290 
				break;
285 
				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';
 - 
 
286 
				break;
 291 
			case self::ABSTRACTION_MYSQLI :
287 
			case 'sqlite3':
 292 
				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';
288 
				$retour = $this->connexion->escapeString($chaine);
 - 
 
289 
				break;
 293 
				break;
290 
		}
 294 
			case self::ABSTRACTION_SQLITE3 :
291 
 
 295 
				$retour = $this->connexion->escapeString($chaine);
292 
		return $retour;
 296 
				break;
293 
	}
 297 
		}
294 
 
 298 
 
295 
	/**
 299 
		return $retour;
296 
	 * initialise les constantes de classe à leur bonne valeur
 300 
	}
297 
	 * et lance une exception si le protocole n'est pas bien défini
 301 
 
298 
	 * @throws Exception
 302 
	/**
299 
	 */
 303 
	 * Initialise les constantes de classe à leur bonne valeur et déclenche une erreur si le protocole n'est pas bien défini.
300 
	final public function initialiserProtocole() {
 304 
	 */
301 
 
 305 
	final public function initialiserProtocole() {
302 
		switch ($this->abstraction) {
 306 
		switch ($this->abstraction) {
303 
			case 'pdo':
 307 
			case self::ABSTRACTION_PDO :
304 
				$this->ASSOC = PDO::FETCH_ASSOC;
 308 
				$this->ASSOC = PDO::FETCH_ASSOC;
305 
				$this->OBJECT = PDO::FETCH_CLASS;
 309 
				$this->OBJECT = PDO::FETCH_CLASS;
306 
				break;
 310 
				break;
307 
			case 'mysql':
 311 
			case self::ABSTRACTION_MYSQL :
308 
				$this->ASSOC = 'mysql_fetch_assoc';
 312 
				$this->ASSOC = 'mysql_fetch_assoc';
309 
				$this->OBJECT = 'mysql_fetch_object';
 313 
				$this->OBJECT = 'mysql_fetch_object';
310 
				break;
 314 
				break;
Line 311... Line 315...
311 
			case 'mysqli':
 315 
			case self::ABSTRACTION_MYSQLI :
312 
				$this->ASSOC = 'fetch_assoc';
 316 
				$this->ASSOC = 'fetch_assoc';
313 
				$this->OBJECT = 'fetch_object';
 317 
				$this->OBJECT = 'fetch_object';
314 
				break;
 318 
				break;
315 
			case 'sqlite3':
 319 
			case self::ABSTRACTION_SQLITE3 :
316 
				$this->ASSOC = 'SQLITE3_ASSOC';
 320 
				$this->ASSOC = 'SQLITE3_ASSOC';
317 
				$this->OBJECT = 'SQLITE3_OBJECT';
 321 
				$this->OBJECT = 'SQLITE3_OBJECT';
318 
				break;
 322 
				break;
319 
			default:
 323 
			default:
320 
				throw new Exception('Erreur : l\'abstraction '.$this->abstraction.' n\'est pas prise en charge');
 324 
				$m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
321 
				break;
 325 
				trigger_error($m, E_USER_WARNING);
322 
		}
 326 
		}
323 
	}
 327 
	}
324 
 
 328 
 
325 
	/**
 329 
	/**
326 
	 * Destructeur de classe, se contente de fermer explicitement la connexion
 330 
	 * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
327 
	 */
 331 
	 */
328 
	final public function __destruct() {
 332 
	final public function __destruct() {
329 
		switch ($this->abstraction) {
 333 
		switch ($this->abstraction) {
330 
			case 'pdo':
 334 
			case self::ABSTRACTION_PDO :