Subversion Repositories Applications.framework

Rev

Rev 500 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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