Subversion Repositories Applications.framework

Rev

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

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

            482
            
?>

          

          

            -
            
 

            483