Subversion Repositories Applications.framework

Rev

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

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