Subversion Repositories Applications.framework

Rev

Rev 424 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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