Subversion Repositories Applications.framework

Rev

Rev 231 | Rev 239 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5 aurelien 1 
<?php
105 aurelien 2 
// declare(encoding='UTF-8');
5 aurelien 3 
/**
238 jpm 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
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
8 
 * Vous pouvez aussi utiliser : "php:Bdd::ABSTRACTION_PDO","php:Bdd::ABSTRACTION_MYSQL", "php:Bdd::ABSTRACTION_MYSQLI",
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 à
11 
 * un type d'abstraction.
12 
 *
13 
 * @category	php 5.2
14 
 * @package	Framework
15 
 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>
16 
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
17 
 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
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
20 
 * @version	$Id: Bdd.php 238 2010-11-24 17:53:29Z jpm $
21 
 * @link		/doc/framework/
22 
 */
23 
class Bdd {
219 jpm 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';
26 
 
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.';
29 
 
30 
	/** Constante stockant le squelette du message en cas d'erreur de sélection de la base de données. */
231 delphine 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.';
219 jpm 32 
 
33 
	/** Constante stockant le code pour l'abstraction de PDO. */
34 
	const ABSTRACTION_PDO = 'pdo';
35 
 
36 
	/** Constante stockant le code pour l'abstraction de mysql. */
37 
	const ABSTRACTION_MYSQL = 'mysql';
38 
 
39 
	/** Constante stockant le code pour l'abstraction de mysqli. */
40 
	const ABSTRACTION_MYSQLI = 'mysqli';
41 
 
42 
	/** Constante stockant le code pour l'abstraction de SQLite3. */
43 
	const ABSTRACTION_SQLITE3 = 'sqlite3';
44 
 
45 
	/** Constante stockant le code pour le mode tableau associatif des résultats des requêtes. */
46 
	const MODE_ASSOC = 'ASSOC';
47 
 
48 
	/** Constante stockant le code pour le mode objet des résultats des requêtes. */
49 
	const MODE_OBJET = 'OBJECT';
50 
 
51 
	/** Mode de fetch associatif */
238 jpm 52 
	protected $ASSOC = '';
219 jpm 53 
 
54 
	/** Mode de fetch objet */
238 jpm 55 
	protected $OBJECT = '';
133 aurelien 56 
 
219 jpm 57 
	/** abstraction de base de données utilisée */
238 jpm 58 
	protected $abstraction;
219 jpm 59 
 
60 
	/** DSN pour accéder à la base de données */
238 jpm 61 
	protected $dsn;
219 jpm 62 
 
63 
	/** Type de base de données (mysql, mysqli, etc ...) */
238 jpm 64 
	protected $type;
219 jpm 65 
 
66 
	/** Hote herbergeant la base de données */
238 jpm 67 
	protected $hote;
219 jpm 68 
 
69 
	/** Nom de la base de données à laquelle le modèle doit se connecter */
238 jpm 70 
	protected $bdd_nom;
219 jpm 71 
 
72 
	/** Nom d'utilisateur */
238 jpm 73 
	protected $utilisateur;
219 jpm 74 
 
75 
	/** Mot de passe */
238 jpm 76 
	protected $pass;
120 aurelien 77 
 
219 jpm 78 
	/** Encodage de la base de données */
238 jpm 79 
	protected $encodage = null;
219 jpm 80 
 
81 
	/** Connexion à la base de données */
238 jpm 82 
	protected $connexion = null;
5 aurelien 83 
 
238 jpm 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', '');
86 
 
87 
	/** Constructeur par défaut, appelé à l'initialisation. */
145 jpm 88 
	public function __construct() {
238 jpm 89 
		Debug::verifierParametresConfig($this->parametres_obligatoires);
133 aurelien 90 
		$this->abstraction = strtolower(Config::get('bdd_abstraction'));
120 aurelien 91 
		$this->type = Config::get('bdd_protocole');
92 
		$this->hote = Config::get('bdd_serveur');
93 
		$this->bdd_nom = Config::get('bdd_nom');
94 
		$this->utilisateur = Config::get('bdd_utilisateur');
95 
		$this->pass = Config::get('bdd_mot_de_passe');
96 
		$this->encodage = Config::get('bdd_encodage');
97 
 
98 
		$this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
133 aurelien 99 
		$this->initialiserProtocole();
120 aurelien 100 
	}
101 
 
238 jpm 102 
	/** Initialise les constantes de classe à leur bonne valeur et déclenche une erreur si le protocole n'est pas bien défini. */
103 
	protected function initialiserProtocole() {
133 aurelien 104 
		switch ($this->abstraction) {
219 jpm 105 
			case self::ABSTRACTION_PDO :
238 jpm 106 
				$this->ASSOC = PDO::FETCH_ASSOC;
107 
				$this->OBJECT = PDO::FETCH_CLASS;
219 jpm 108 
				break;
109 
			case self::ABSTRACTION_MYSQL :
238 jpm 110 
				$this->ASSOC = 'mysql_fetch_assoc';
111 
				$this->OBJECT = 'mysql_fetch_object';
219 jpm 112 
				break;
113 
			case self::ABSTRACTION_MYSQLI :
238 jpm 114 
				$this->ASSOC = 'fetch_assoc';
115 
				$this->OBJECT = 'fetch_object';
219 jpm 116 
				break;
117 
			case self::ABSTRACTION_SQLITE3 :
238 jpm 118 
				$this->ASSOC = 'SQLITE3_ASSOC';
119 
				$this->OBJECT = 'SQLITE3_OBJECT';
219 jpm 120 
				break;
133 aurelien 121 
			default:
238 jpm 122 
				$m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
123 
				trigger_error($m, E_USER_WARNING);
133 aurelien 124 
		}
238 jpm 125 
	}
126 
 
127 
	/**
128 
	 * Connection à la base de données en utilisant les informations fournies par
129 
	 * le fichier de configuration.
130 
	 * Cette méthode est private et final car elle n'a pas vocation a être appelée par l'utilisateur.
131 
	 */
132 
	protected function connecter() {
133 
		if ($this->connexion == null) {
134 
			switch ($this->abstraction) {
135 
				case self::ABSTRACTION_PDO :
136 
					try {
137 
						$this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
138 
					} catch (PDOException $e) {
139 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
140 
						trigger_error($e, E_USER_WARNING);
141 
					}
142 
					break;
143 
				case self::ABSTRACTION_MYSQL :
144 
					$this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
145 
					if ($this->connexion !== false) {
146 
						$selection = mysql_select_db($this->bdd_nom, $this->connexion);
147 
						if ($selection === false) {
148 
							$e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
149 
							trigger_error($e, E_USER_WARNING);
150 
						}
151 
					} else {
152 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
153 
						trigger_error($e, E_USER_WARNING);
154 
					}
155 
					break;
156 
				case self::ABSTRACTION_MYSQLI :
157 
					$this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
158 
					if ($this->connexion->connect_errno) {
159 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
160 
						trigger_error($e, E_USER_WARNING);
161 
					}
162 
					break;
163 
				case self::ABSTRACTION_SQLITE3 :
164 
					// cas particulier de sqllite, on considère que le nom de la base de données correspond au fichier à ouvrir
165 
					$this->connexion = new SQLite3($this->bdd_nom);
166 
					if (!$this->connexion) {
167 
						$e = sprintf(self::ERREUR_CONNEXION_TPL, '');
168 
						trigger_error($e, E_USER_WARNING);
169 
					}
170 
					break;
171 
				default:
172 
					$this->connexion = null;
173 
			}
174 
 
175 
			if ($this->encodage != null) {
176 
				$this->requete("SET names '".$this->encodage."'");
177 
			}
133 aurelien 178 
		}
179 
	}
238 jpm 180 
 
133 aurelien 181 
	/**
238 jpm 182 
	 * Execute une requête et retourne le résultat tel que renvoyé par l'abstraction courante.
120 aurelien 183 
	 *
238 jpm 184 
	 * @param string la requête à effectuer
185 
	 * @return mixed un objet contenant le résultat de la requête
120 aurelien 186 
	 */
238 jpm 187 
	public function requete($requete) {
188 
		$this->connecter();
189 
 
133 aurelien 190 
		$retour = null;
191 
		switch ($this->abstraction) {
219 jpm 192 
			case self::ABSTRACTION_PDO :
193 
				try {
194 
					$retour = $this->connexion->query($requete);
195 
				} catch (PDOException $e) {
196 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
197 
					trigger_error($m, E_USER_WARNING);
198 
				}
140 jpm 199 
				break;
219 jpm 200 
			case self::ABSTRACTION_MYSQL :
201 
				$retour = mysql_query($requete, $this->connexion);
140 jpm 202 
				break;
219 jpm 203 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 204 
				$retour = $this->connexion->query($requete);
140 jpm 205 
				break;
219 jpm 206 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 207 
				$retour = $this->connexion->exec($requete);
140 jpm 208 
				break;
133 aurelien 209 
		}
210 
		return $retour;
120 aurelien 211 
	}
212 
 
238 jpm 213 
	/**
214 
	 * Execute une requête et retourne le premier résultat sous forme de tableau (par défaut) ou d'objet.
215 
	 * 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.
216 
	 *
217 
	 * @param string la requête à effectuer
218 
	 * @param string le mode de retour ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
219 
	 * @return mixed un objet ou un tableau contenant le résultat de la requête
220 
	 */
221 
	public function requeteUn($requete, $mode = self::MODE_ASSOC) {
222 
		$this->connecter();
133 aurelien 223 
 
224 
		$retour = null;
225 
		switch ($this->abstraction) {
219 jpm 226 
			case self::ABSTRACTION_PDO :
173 aurelien 227 
				try {
238 jpm 228 
					$resultat = $this->connexion->query($requete);
229 
					$retour = $resultat->fetch($this->$mode);
173 aurelien 230 
				} catch (PDOException $e) {
219 jpm 231 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
232 
					trigger_error($m, E_USER_WARNING);
173 aurelien 233 
				}
140 jpm 234 
				break;
219 jpm 235 
			case self::ABSTRACTION_MYSQL :
238 jpm 236 
				$res = mysql_query($requete, $this->connexion);
133 aurelien 237 
				$fonction_fetch = $this->$mode;
238 
				$retour = $fonction_fetch($res);
140 jpm 239 
				break;
219 jpm 240 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 241 
				$res = $this->connexion->query($requete);
242 
				$fonction_fetch = $this->$mode;
243 
				$retour = $res->$fonction_fetch();
140 jpm 244 
				break;
219 jpm 245 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 246 
				$retour = $this->connexion->querySingle($requete);
140 jpm 247 
				break;
133 aurelien 248 
		}
249 
		return $retour;
120 aurelien 250 
	}
251 
 
238 jpm 252 
	/**
253 
	 * Execute une requête et retourne un tableau de résultats. Un résultat peut être présentés sous forme
254 
	 * de tableau (par défaut) ou d'objet.
255 
	 * Les noms des champs de la base de données correspondent aux noms des clés du tableau résultat ou
256 
	 * aux noms des attributs de l'objet résultat.
257 
	 *
258 
	 * @param string la requête à effectuer
259 
	 * @param string le mode de retour des résultats : ASSOC (Bdd::MODE_ASSOC) pour un tableau ou OBJECT (Bdd::MODE_OBJET) pour un objet.
260 
	 * @return array un tableau contenant les résultats sous forme d'objets ou de tableau (par défaut).
261 
	 */
262 
	public function requeteTous($requete, $mode = self::MODE_ASSOC) {
263 
		$this->connecter();
133 aurelien 264 
 
265 
		$retour = null;
266 
		switch ($this->abstraction) {
219 jpm 267 
			case self::ABSTRACTION_PDO :
143 jpm 268 
				try {
238 jpm 269 
					$resultat = $this->connexion->query($requete);
270 
					if ($resultat !== false) {
271 
						$retour = $resultat->fetchAll($this->$mode);
143 jpm 272 
					} else {
273 
						$retour = false;
274 
					}
275 
				} catch (PDOException $e) {
219 jpm 276 
					$m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
277 
					trigger_error($m, E_USER_WARNING);
140 jpm 278 
				}
279 
				break;
219 jpm 280 
			case self::ABSTRACTION_MYSQL :
238 jpm 281 
				$resultat = mysql_query($requete, $this->connexion);
133 aurelien 282 
				$fonction_fetch = $this->$mode;
238 jpm 283 
				while ($ligne = $fonction_fetch($resultat)) {
133 aurelien 284 
					$retour[] = $ligne;
285 
				}
140 jpm 286 
				break;
219 jpm 287 
			case self::ABSTRACTION_MYSQLI :
238 jpm 288 
				$resultat = $this->connexion->query($requete);
133 aurelien 289 
				$function_fetch = $this->$mode;
238 jpm 290 
				while ($ligne = $resultat->$function_fetch()) {
133 aurelien 291 
					$retour[] = $ligne;
292 
				}
140 jpm 293 
				break;
219 jpm 294 
			case self::ABSTRACTION_SQLITE3 :
238 jpm 295 
				$resultat = $this->connexion->query($requete);
296 
				while ($ligne = $resultat->fetch_array($this->ASSOC)) {
219 jpm 297 
					if ($mode == self::MODE_OBJET) {
298 
						// Cas particulier de sqllite qui n'a pas de fonction fetch_object
133 aurelien 299 
						$ligneObjet = new stdClass();
140 jpm 300 
						foreach ($ligne as $colonne => $valeur) {
133 aurelien 301 
							$ligneObjet->$colonne = $valeur;
302 
						}
219 jpm 303 
						$ligne = $ligneObjet;
133 aurelien 304 
					}
219 jpm 305 
					$retour[] = $ligne;
133 aurelien 306 
				}
140 jpm 307 
				break;
133 aurelien 308 
		}
309 
		return $retour;
310 
	}
311 
 
120 aurelien 312 
	/**
238 jpm 313 
	 * Protège une chaine de caractères avant l'insertion dans la base de données (ajout de quotes ou guillemets).
314 
	 * @param string la chaine à protéger
315 
	 * @return string la chaine protégée
120 aurelien 316 
	 */
238 jpm 317 
	public function proteger($chaine) {
318 
		$this->connecter();
133 aurelien 319 
 
320 
		$retour = $chaine;
321 
		switch ($this->abstraction) {
219 jpm 322 
			case self::ABSTRACTION_PDO :
133 aurelien 323 
				$retour = $this->connexion->quote($chaine);
140 jpm 324 
				break;
219 jpm 325 
			case self::ABSTRACTION_MYSQL :
133 aurelien 326 
				$retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
140 jpm 327 
				break;
219 jpm 328 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 329 
				$retour = '"'.$this->connexion->real_escape_string($chaine).'"';
140 jpm 330 
				break;
219 jpm 331 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 332 
				$retour = $this->connexion->escapeString($chaine);
140 jpm 333 
				break;
133 aurelien 334 
		}
335 
		return $retour;
120 aurelien 336 
	}
337 
 
338 
	/**
219 jpm 339 
	 * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
120 aurelien 340 
	 */
238 jpm 341 
	protected function __destruct() {
133 aurelien 342 
		switch ($this->abstraction) {
219 jpm 343 
			case self::ABSTRACTION_PDO :
133 aurelien 344 
				$this->connexion = null;
140 jpm 345 
				break;
219 jpm 346 
			case self::ABSTRACTION_MYSQL :
133 aurelien 347 
				return mysql_close($this->connexion);
140 jpm 348 
				break;
219 jpm 349 
			case self::ABSTRACTION_MYSQLI :
133 aurelien 350 
				$this->connexion->close();
140 jpm 351 
				break;
219 jpm 352 
			case self::ABSTRACTION_SQLITE3 :
133 aurelien 353 
				$this->connexion->close();
140 jpm 354 
				break;
120 aurelien 355 
		}
356 
	}
5 aurelien 357 
}
358 
?>