Subversion Repositories Applications.framework

Rev

Rev 500 | 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.
401 jpm 5
 * Elle fait office d'abstraction légère de base de données en utilisant diverses possibilités d'accès aux
238 jpm 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>
241 jpm 17
 * @copyright   Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
238 jpm 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 501 2020-04-23 16:15:01Z killian $
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';
401 jpm 26
 
219 jpm 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.';
401 jpm 29
 
219 jpm 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.';
401 jpm 32
 
219 jpm 33
        /** Constante stockant le code pour l'abstraction de PDO. */
34
        const ABSTRACTION_PDO = 'pdo';
401 jpm 35
 
219 jpm 36
        /** Constante stockant le code pour l'abstraction de mysql. */
37
        const ABSTRACTION_MYSQL = 'mysql';
401 jpm 38
 
219 jpm 39
        /** Constante stockant le code pour l'abstraction de mysqli. */
40
        const ABSTRACTION_MYSQLI = 'mysqli';
401 jpm 41
 
219 jpm 42
        /** Constante stockant le code pour l'abstraction de SQLite3. */
43
        const ABSTRACTION_SQLITE3 = 'sqlite3';
401 jpm 44
 
219 jpm 45
        /** Constante stockant le code pour le mode tableau associatif des résultats des requêtes. */
46
        const MODE_ASSOC = 'ASSOC';
401 jpm 47
 
219 jpm 48
        /** Constante stockant le code pour le mode objet des résultats des requêtes. */
49
        const MODE_OBJET = 'OBJECT';
401 jpm 50
 
219 jpm 51
        /** Mode de fetch associatif */
238 jpm 52
        protected $ASSOC = '';
401 jpm 53
 
219 jpm 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;
401 jpm 59
 
219 jpm 60
        /** DSN pour accéder à la base de données */
238 jpm 61
        protected $dsn;
401 jpm 62
 
219 jpm 63
        /** Type de base de données (mysql, mysqli, etc ...) */
238 jpm 64
        protected $type;
401 jpm 65
 
219 jpm 66
        /** Hote herbergeant la base de données */
238 jpm 67
        protected $hote;
401 jpm 68
 
219 jpm 69
        /** Nom de la base de données à laquelle le modèle doit se connecter */
238 jpm 70
        protected $bdd_nom;
401 jpm 71
 
219 jpm 72
        /** Nom d'utilisateur */
238 jpm 73
        protected $utilisateur;
401 jpm 74
 
219 jpm 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;
401 jpm 80
 
219 jpm 81
        /** Connexion à la base de données */
501 killian 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.*/
401 jpm 85
        protected $parametres_obligatoires = array('bdd_abstraction', 'bdd_protocole', 'bdd_serveur', 'bdd_nom',
247 jpm 86
                'bdd_utilisateur', 'bdd_mot_de_passe', 'bdd_encodage');
401 jpm 87
 
238 jpm 88
        /** Constructeur par défaut, appelé à l'initialisation. */
145 jpm 89
        public function __construct() {
241 jpm 90
                Config::verifierPresenceParametres($this->parametres_obligatoires);
133 aurelien 91
                $this->abstraction = strtolower(Config::get('bdd_abstraction'));
120 aurelien 92
                $this->type = Config::get('bdd_protocole');
93
                $this->hote = Config::get('bdd_serveur');
94
                $this->bdd_nom = Config::get('bdd_nom');
95
                $this->utilisateur = Config::get('bdd_utilisateur');
96
                $this->pass = Config::get('bdd_mot_de_passe');
459 jpm 97
 
120 aurelien 98
                $this->encodage = Config::get('bdd_encodage');
99
 
430 raphael 100
                if ($this->type == 'sqlite' || $this->type == 'sqlite2') {
101
                        $this->dsn = $this->type.':'.$this->hote;
102
                } else {
103
                        $this->dsn = $this->type.':dbname='.$this->bdd_nom.';host='.$this->hote;
401 jpm 104
                }
133 aurelien 105
                $this->initialiserProtocole();
120 aurelien 106
        }
107
 
238 jpm 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() {
133 aurelien 110
                switch ($this->abstraction) {
219 jpm 111
                        case self::ABSTRACTION_PDO :
238 jpm 112
                                $this->ASSOC = PDO::FETCH_ASSOC;
429 raphael 113
                                $this->OBJECT = PDO::FETCH_OBJ;
219 jpm 114
                                break;
115
                        case self::ABSTRACTION_MYSQL :
238 jpm 116
                                $this->ASSOC = 'mysql_fetch_assoc';
117
                                $this->OBJECT = 'mysql_fetch_object';
219 jpm 118
                                break;
119
                        case self::ABSTRACTION_MYSQLI :
238 jpm 120
                                $this->ASSOC = 'fetch_assoc';
121
                                $this->OBJECT = 'fetch_object';
219 jpm 122
                                break;
123
                        case self::ABSTRACTION_SQLITE3 :
238 jpm 124
                                $this->ASSOC = 'SQLITE3_ASSOC';
125
                                $this->OBJECT = 'SQLITE3_OBJECT';
219 jpm 126
                                break;
133 aurelien 127
                        default:
238 jpm 128
                                $m = "Erreur : l'abstraction '{$this->abstraction}' n'est pas prise en charge";
501 killian 129
                                throw new Exception($m);
133 aurelien 130
                }
238 jpm 131
        }
401 jpm 132
 
238 jpm 133
        /**
134
         * Connection à la base de données en utilisant les informations fournies par
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.
433 jpm 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)
238 jpm 139
         */
140
        protected function connecter() {
141
                if ($this->connexion == null) {
142
                        switch ($this->abstraction) {
143
                                case self::ABSTRACTION_PDO :
144
                                        try {
145
                                                $this->connexion = new PDO($this->dsn, $this->utilisateur, $this->pass);
354 jpm 146
                                                $this->connexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
238 jpm 147
                                        } catch (PDOException $e) {
148
                                                $e = sprintf(self::ERREUR_CONNEXION_TPL, $e->getMessage());
501 killian 149
                                                throw new Exception($e);
238 jpm 150
                                        }
401 jpm 151
                                        if ($this->encodage != null && $this->type == 'mysql') {
427 raphael 152
                                                $this->connexion->query("SET names '".$this->encodage."'");
401 jpm 153
                                        } else if ($this->type == 'sqlite') {
427 raphael 154
                                                $this->connexion->query("PRAGMA case_sensitive_like = false");
401 jpm 155
                                        }
238 jpm 156
                                        break;
157
                                case self::ABSTRACTION_MYSQL :
158
                                        $this->connexion = mysql_connect($this->hote, $this->utilisateur, $this->pass);
159
                                        if ($this->connexion !== false) {
160
                                                $selection = mysql_select_db($this->bdd_nom, $this->connexion);
161
                                                if ($selection === false) {
162
                                                        $e = sprintf(self::ERREUR_SELECTION_BDD_TPL, mysql_error());
163
                                                        trigger_error($e, E_USER_WARNING);
164
                                                }
165
                                        } else {
166
                                                $e = sprintf(self::ERREUR_CONNEXION_TPL, mysql_error());
167
                                                trigger_error($e, E_USER_WARNING);
168
                                        }
401 jpm 169
                                        if ($this->encodage != null) {
170
                                                $this->requeter("SET names '".$this->encodage."'");
171
                                        }
238 jpm 172
                                        break;
173
                                case self::ABSTRACTION_MYSQLI :
174
                                        $this->connexion = @new mysqli($this->hote, $this->utilisateur, $this->pass, $this->bdd_nom);
175
                                        if ($this->connexion->connect_errno) {
176
                                                $e = sprintf(self::ERREUR_CONNEXION_TPL, $this->connexion->connect_error);
177
                                                trigger_error($e, E_USER_WARNING);
178
                                        }
401 jpm 179
                                        if ($this->encodage != null) {
180
                                                $this->requeter("SET names '".$this->encodage."'");
181
                                        }
238 jpm 182
                                        break;
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
185
                                        $this->connexion = new SQLite3($this->bdd_nom);
186
                                        if (!$this->connexion) {
187
                                                $e = sprintf(self::ERREUR_CONNEXION_TPL, '');
188
                                                trigger_error($e, E_USER_WARNING);
189
                                        }
401 jpm 190
                                        $this->requeter("PRAGMA case_sensitive_like = false");
238 jpm 191
                                        break;
192
                                default:
193
                                        $this->connexion = null;
194
                        }
401 jpm 195
 
238 jpm 196
                        if ($this->encodage != null) {
197
                                $this->requete("SET names '".$this->encodage."'");
198
                        }
133 aurelien 199
                }
200
        }
401 jpm 201
 
133 aurelien 202
        /**
239 jpm 203
         * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see requeter
204
         */
205
        final protected function requete($requete) {
329 delphine 206
                return $this->requeter($requete);
239 jpm 207
        }
401 jpm 208
 
239 jpm 209
        /**
482 jpm 210
         * Effectue une requête et retourne le résultat tel que renvoyé par l'abstraction courante.
120 aurelien 211
         *
238 jpm 212
         * @param string la requête à effectuer
213
         * @return mixed un objet contenant le résultat de la requête
120 aurelien 214
         */
239 jpm 215
        public function requeter($requete) {
238 jpm 216
                $this->connecter();
217
 
133 aurelien 218
                $retour = null;
219
                switch ($this->abstraction) {
219 jpm 220
                        case self::ABSTRACTION_PDO :
221
                                try {
222
                                        $retour = $this->connexion->query($requete);
223
                                } catch (PDOException $e) {
224
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
501 killian 225
                                        throw new Exception($m);
219 jpm 226
                                }
140 jpm 227
                                break;
219 jpm 228
                        case self::ABSTRACTION_MYSQL :
229
                                $retour = mysql_query($requete, $this->connexion);
140 jpm 230
                                break;
219 jpm 231
                        case self::ABSTRACTION_MYSQLI :
133 aurelien 232
                                $retour = $this->connexion->query($requete);
140 jpm 233
                                break;
219 jpm 234
                        case self::ABSTRACTION_SQLITE3 :
133 aurelien 235
                                $retour = $this->connexion->exec($requete);
140 jpm 236
                                break;
133 aurelien 237
                }
238
                return $retour;
120 aurelien 239
        }
401 jpm 240
 
238 jpm 241
        /**
482 jpm 242
         * Execute une requête (Utile pour UPDATE, INSERT, DELETE) et retourne le résultat tel que renvoyé par l'abstraction courante.
243
         *
244
         * @param string la requête à effectuer
245
         * @return mixed le nombre de résultat affecté par la  requête
246
         */
247
        public function executer($requete) {
248
                $this->connecter();
249
 
250
                $retour = null;
251
                switch ($this->abstraction) {
252
                        case self::ABSTRACTION_PDO :
253
                                try {
254
                                        $retour = $this->connexion->exec($requete);
255
                                } catch (PDOException $e) {
256
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
501 killian 257
                                        throw new Exception($m);
482 jpm 258
                                }
259
                                break;
260
                        default:
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);
263
                }
264
                return $retour;
265
        }
266
 
267
        /**
239 jpm 268
         * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recuperer
269
         */
270
        final protected function requeteUn($requete, $mode = self::MODE_ASSOC) {
271
                return $this->recuperer($requete, $mode);
272
        }
401 jpm 273
 
239 jpm 274
        /**
238 jpm 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.
277
         *
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.
280
         * @return mixed un objet ou un tableau contenant le résultat de la requête
281
         */
239 jpm 282
        public function recuperer($requete, $mode = self::MODE_ASSOC) {
238 jpm 283
                $this->connecter();
133 aurelien 284
 
285
                $retour = null;
286
                switch ($this->abstraction) {
219 jpm 287
                        case self::ABSTRACTION_PDO :
173 aurelien 288
                                try {
238 jpm 289
                                        $resultat = $this->connexion->query($requete);
355 jpm 290
                                        $retour = ($resultat !== false) ? $resultat->fetch($this->$mode) : $resultat;
173 aurelien 291
                                } catch (PDOException $e) {
219 jpm 292
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
501 killian 293
                                        throw new Exception($m);
173 aurelien 294
                                }
140 jpm 295
                                break;
219 jpm 296
                        case self::ABSTRACTION_MYSQL :
238 jpm 297
                                $res = mysql_query($requete, $this->connexion);
133 aurelien 298
                                $fonction_fetch = $this->$mode;
299
                                $retour = $fonction_fetch($res);
140 jpm 300
                                break;
219 jpm 301
                        case self::ABSTRACTION_MYSQLI :
133 aurelien 302
                                $res = $this->connexion->query($requete);
303
                                $fonction_fetch = $this->$mode;
304
                                $retour = $res->$fonction_fetch();
140 jpm 305
                                break;
219 jpm 306
                        case self::ABSTRACTION_SQLITE3 :
133 aurelien 307
                                $retour = $this->connexion->querySingle($requete);
140 jpm 308
                                break;
133 aurelien 309
                }
310
                return $retour;
120 aurelien 311
        }
401 jpm 312
 
238 jpm 313
        /**
239 jpm 314
         * @deprecated changement de nom. Disparaîtra dans la version 0.4. Utiliser à la place : @see recupererTous
315
         */
316
        final protected function requeteTous($requete, $mode = self::MODE_ASSOC) {
317
                return $this->recupererTous($requete, $mode);
318
        }
401 jpm 319
 
239 jpm 320
        /**
401 jpm 321
         * Execute une requête et retourne un tableau de résultats. Un résultat peut être présentés sous forme
238 jpm 322
         * de tableau (par défaut) ou d'objet.
401 jpm 323
         * Les noms des champs de la base de données correspondent aux noms des clés du tableau résultat ou
238 jpm 324
         * aux noms des attributs de l'objet résultat.
325
         *
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.
328
         * @return array un tableau contenant les résultats sous forme d'objets ou de tableau (par défaut).
329
         */
239 jpm 330
        public function recupererTous($requete, $mode = self::MODE_ASSOC) {
238 jpm 331
                $this->connecter();
401 jpm 332
 
133 aurelien 333
                $retour = null;
334
                switch ($this->abstraction) {
219 jpm 335
                        case self::ABSTRACTION_PDO :
143 jpm 336
                                try {
238 jpm 337
                                        $resultat = $this->connexion->query($requete);
355 jpm 338
                                        $retour = ($resultat !== false) ? $resultat->fetchAll($this->$mode) : $resultat;
143 jpm 339
                                } catch (PDOException $e) {
219 jpm 340
                                        $m = sprintf(self::ERREUR_REQUETE_TPL, $e->getFile(), $e->getLine(), $e->getMessage(), $requete);
501 killian 341
                                        throw new Exception($m);
140 jpm 342
                                }
343
                                break;
219 jpm 344
                        case self::ABSTRACTION_MYSQL :
238 jpm 345
                                $resultat = mysql_query($requete, $this->connexion);
133 aurelien 346
                                $fonction_fetch = $this->$mode;
238 jpm 347
                                while ($ligne = $fonction_fetch($resultat)) {
133 aurelien 348
                                        $retour[] = $ligne;
349
                                }
140 jpm 350
                                break;
219 jpm 351
                        case self::ABSTRACTION_MYSQLI :
238 jpm 352
                                $resultat = $this->connexion->query($requete);
133 aurelien 353
                                $function_fetch = $this->$mode;
238 jpm 354
                                while ($ligne = $resultat->$function_fetch()) {
133 aurelien 355
                                        $retour[] = $ligne;
356
                                }
140 jpm 357
                                break;
219 jpm 358
                        case self::ABSTRACTION_SQLITE3 :
238 jpm 359
                                $resultat = $this->connexion->query($requete);
360
                                while ($ligne = $resultat->fetch_array($this->ASSOC)) {
219 jpm 361
                                        if ($mode == self::MODE_OBJET) {
362
                                                // Cas particulier de sqllite qui n'a pas de fonction fetch_object
133 aurelien 363
                                                $ligneObjet = new stdClass();
140 jpm 364
                                                foreach ($ligne as $colonne => $valeur) {
133 aurelien 365
                                                        $ligneObjet->$colonne = $valeur;
366
                                                }
219 jpm 367
                                                $ligne = $ligneObjet;
133 aurelien 368
                                        }
219 jpm 369
                                        $retour[] = $ligne;
133 aurelien 370
                                }
140 jpm 371
                                break;
133 aurelien 372
                }
373
                return $retour;
374
        }
375
 
120 aurelien 376
        /**
459 jpm 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).
379
         * @param Mixed une chaine ou un tableau à protéger
380
         * @return mixed la chaine ou le tableau à protégé
381
         */
382
        public function proteger($donnees) {
383
                $this->connecter();
384
                if (is_array($donnees)) {
385
                        $retour = $this->protegerTableau($donnees);
386
                } else {
387
                        $retour = $this->protegerChaine($donnees);
388
                }
389
                return $retour;
390
        }
391
 
392
        /**
238 jpm 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
395
         * @return string la chaine protégée
120 aurelien 396
         */
459 jpm 397
        private function protegerChaine($chaine) {
133 aurelien 398
                $retour = $chaine;
399
                switch ($this->abstraction) {
219 jpm 400
                        case self::ABSTRACTION_PDO :
133 aurelien 401
                                $retour = $this->connexion->quote($chaine);
140 jpm 402
                                break;
219 jpm 403
                        case self::ABSTRACTION_MYSQL :
133 aurelien 404
                                $retour = '"'.mysql_real_escape_string($chaine, $this->connexion).'"';
140 jpm 405
                                break;
219 jpm 406
                        case self::ABSTRACTION_MYSQLI :
133 aurelien 407
                                $retour = '"'.$this->connexion->real_escape_string($chaine).'"';
140 jpm 408
                                break;
219 jpm 409
                        case self::ABSTRACTION_SQLITE3 :
133 aurelien 410
                                $retour = $this->connexion->escapeString($chaine);
140 jpm 411
                                break;
133 aurelien 412
                }
413
                return $retour;
120 aurelien 414
        }
459 jpm 415
 
406 gduche 416
        /**
459 jpm 417
         * @deprecated changement de nom. Deviendra "private" dans la version 0.5. Utiliser à la place : @see proteger
418
         */
461 jpm 419
        public function protegerTableau(Array $tableau) {
459 jpm 420
                foreach ($tableau as $id => $val) {
421
                        if (is_array($val)) {
422
                                $tableau[$id] = $this->protegerTableau($val);
423
                        } else {
424
                                $tableau[$id] = $this->protegerChaine($val);
425
                        }
406 gduche 426
                }
459 jpm 427
                return $tableau;
406 gduche 428
        }
120 aurelien 429
 
430
        /**
239 jpm 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
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 ]))
401 jpm 435
         * @link(http://php.net/manual/en/mysqli.insert-id.php, mysqli->insert_id())
239 jpm 436
         * @link(http://fr.php.net/manual/fr/function.mysql-insert-id.php, mysql_insert_id())
401 jpm 437
         * @link(http://fr.php.net/manual/fr/sqlite3.lastinsertrowid.php, SQLite3::lastInsertRowID())
239 jpm 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).
440
         */
441
        public function recupererIdDernierAjout($parametres = null) {
442
                $this->connecter();
443
 
420 gduche 444
                $retour = null;
239 jpm 445
                switch ($this->abstraction) {
446
                        case self::ABSTRACTION_PDO :
447
                                $retour = $this->connexion->lastInsertId($parametres);
448
                                break;
449
                        case self::ABSTRACTION_MYSQL :
450
                                $retour = mysql_insert_id($this->connexion);
451
                                break;
452
                        case self::ABSTRACTION_MYSQLI :
453
                                $retour = $this->connexion->insert_id();
454
                                break;
455
                        case self::ABSTRACTION_SQLITE3 :
456
                                $retour = $this->connexion->lastInsertRowID();
457
                                break;
458
                }
459
                return $retour;
460
        }
401 jpm 461
 
239 jpm 462
        /**
219 jpm 463
         * Destructeur de classe, se contente de fermer explicitement la connexion à la base de donnée.
120 aurelien 464
         */
247 jpm 465
        public function __destruct() {
340 jpm 466
                if (isset($this->connexion)) {
467
                        switch ($this->abstraction) {
468
                                case self::ABSTRACTION_PDO :
469
                                        $this->connexion = null;
470
                                        break;
471
                                case self::ABSTRACTION_MYSQL :
472
                                        if (isset($this->connexion)) {
473
                                                return mysql_close($this->connexion);
401 jpm 474
                                        }
340 jpm 475
                                        break;
476
                                case self::ABSTRACTION_MYSQLI :
477
                                        $this->connexion->close();
478
                                        break;
479
                                case self::ABSTRACTION_SQLITE3 :
480
                                        $this->connexion->close();
481
                                        break;
482
                        }
120 aurelien 483
                }
484
        }
5 aurelien 485
}
486
?>