Minimalteck.fr

Un PEAR Pager_Wrapper pour PDO

Minimalteck — 2008-10-31T17:32:13Z

Selon le PEAR ::Pager tutorials de Lorenzo Alberton, voici un Wrapper Pager/PDO, inspiré largement du Pager_Wrapper contenu dans la doc du package.

 // SAMPLE USAGE
 // ------------
 //
 // $query = 'SELECT this, that FROM mytable';
 // require_once 'Pager_Wrapper.php'; //this file
 // $pagerOptions = array(
 // 'mode' => 'Sliding',
 // 'delta' => 2,
 // 'perPage' => 15,
 // );
 // $paged_data = Pager_Wrapper_MDB2($db, $query, $pagerOptions);
 // //$paged_data['data']; //paged data
 // //$paged_data['links']; //xhtml links for page navigation
 // //$paged_data['page_numbers']; //array('current', 'total');
 //
 
 /**
 * Helper method - Rewrite the query into a "SELECT COUNT(*)" query.
 * @param string $sql query
 * @return string rewritten query OR false if the query can't be rewritten
 * @access private
 */
 function rewriteCountQuery($sql)
 {
 if (preg_match('/^\s*SELECT\s+\bDISTINCT\b/is', $sql) ||
 preg_match('/\s+GROUP\s+BY\s+/is', $sql) ||
 preg_match('/\s+UNION\s+/is', $sql)) {
 return false;
 }
 $open_parenthesis = '(?:\()';
 $close_parenthesis = '(?:\))';
 $subquery_in_select = $open_parenthesis.'.*\bFROM\b.*'.$close_parenthesis;
 $pattern = '/(?:.*'.$subquery_in_select.'.*)\bFROM\b\s+/Uims';
 if (preg_match($pattern, $sql)) {
 return false;
 }
 $subquery_with_limit_order = $open_parenthesis.'.*\b(LIMIT|ORDER)\b.*'.$close_parenthesis;
 $pattern = '/.*\bFROM\b.*(?:.*'.$subquery_with_limit_order.'.*).*/Uims';
 if (preg_match($pattern, $sql)) {
 return false;
 }
 $queryCount = preg_replace('/(?:.*)\bFROM\b\s+/Uims', 'SELECT COUNT(*) FROM ', $sql, 1);
 list($queryCount, ) = preg_split('/\s+ORDER\s+BY\s+/is', $queryCount);
 list($queryCount, ) = preg_split('/\bLIMIT\b/is', $queryCount);
 return trim($queryCount);
 }
 
 /**
 * PDO's version of Pager_Wrapper
 * @param object PDO instance
 * @param string db query
 * @param array PEAR::Pager options
 * @param boolean Disable pagination (get all results)
 * @param integer fetch mode constant
 * @return array with links and paged data
 */
 function Pager_Wrapper_PDO($db, $query, $pager_options = array(), $disabled = false, $fetchMode = PDO::FETCH_ASSOC){
 if (!array_key_exists('totalItems', $pager_options)) {
 if ($countQuery = rewriteCountQuery($query)) {
 $stmt = $db->prepare($countQuery);
 $stmt->execute();
 $totalItems = $stmt->fetchColumn();
 }else{
 $stmt = $db->prepare($query);
 if (!$stmt) {
 echo "\nPDO::errorCode(): ";
 print $db->errorCode();
 die();
 }
 $stmt->execute();
 if ($stmt->execute() === FALSE) {
 echo "\nPDO::errorCode()toto: ";
 print $db->errorCode();
 die();
 }
 $rows = $stmt->fetchAll(PDO::FETCH_COLUMN);
 $totalItems = count($rows);
 
 }
 $pager_options['totalItems'] = $totalItems;
 }
 require_once 'Pager/Pager.php';
 $pager = Pager::factory($pager_options);
 
 $page = array();
 $page['links'] = $pager->links;
 $page['totalItems'] = $pager_options['totalItems'];
 $page['page_numbers'] = array(
 'current' => $pager->getCurrentPageID(),
 'total' => $pager->numPages()
 );
 list($page['from'], $page['to']) = $pager->getOffsetByPageId();
 $page['limit'] = $page['to'] - $page['from'] +1;
 
 // fix offset
 // limit 1,10 can not retrive the first record of result set.
 $page['from'] = $page['from'] - 1;
 
 if (!$disabled) {
 $query .= ' LIMIT ' . $page['from'] . ', ' . $pager_options['perPage'];
 }
 // var_dump($query);
 $stmt = $db->prepare($query);
 if (!$stmt) {
 echo "\nPDO::errorCode(): ";
 print $db->errorCode();print_r($db->errorInfo());
 die();
 }
 $stmt->execute();
 $page['data'] = $stmt->fetchAll($fetchMode); 
 if ($disabled) {
 $page['links'] = '';
 $page['page_numbers'] = array(
 'current' => 1,
 'total' => 1
 );
 } 
 
 // var_dump($pager);
 return $page;
 }
 
 
 
 ?>

Bon le code est pas fignolé… mais on peut déjà l'utiliser à des fins de tests :

 require_once('DatabaseConnection.class.php');
 //copy the Pager_Wrapper file where you can include it
 require_once './Pager_Wrapper.php';
 $db = DatabaseConnection::get()->handle();
 $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
 //skipped the db connection code...
 //let's just suppose we have a valid db connection in $db.
 
 $pager_options = array(
 'mode' => 'Sliding',
 'perPage' => 2,
 'delta' => 2,
 );
 $query = 'SELECT * FROM person';
 $paged_data = Pager_Wrapper_PDO($db, $query, $pager_options);
 
 //show the results
 echo '';
 foreach ($paged_data['data'] as $product) {
 echo ''.$product['id_person'].': '.$product['name'].'
';
 }
 echo '
';
 
 //show the links
 echo $paged_data['links'];
 ?>

le PDO ::MYSQL_ATTR_USE_BUFFERED_QUERY est mis à TRUE pour permettre d'effectuer des requêtes multiples sur la même connexion…
Sinon 'a marche pô !!!
Du moins sur ma plateforme de test à l'arrache…

Alors que dans la littérature, j'eu appris que la fermeture du 'PDO cursor' règlait le pb, via la PDOStatement ::closeCursor…
c'est même indiqué dans la doc PDO : "PDOStatement->closeCursor — Ferme le curseur, permettant à la requête d'être de nouveau exécutée"

PDO vite dit...

Minimalteck — 2008-10-31T11:23:52Z

Sommaire

PDO en bref :

Introduit en PHP 5.1, cette extension PECL permet d'utiliser de façon standardisée plusieurs types de SGBD via l'utilisation de drivers spécifiques. Proche de PEAR DB dans son utilisation, PDO est beaucoup plus rapide car écrite en C : ses performances sont proches des anciens drivers natifs.

Les Classes de PDO :

3 principales :

PDO, gérant la connexion entre PHP et un serveur de base de données ;
PDOStatement, représentant une requête préparée et qui fournit une fois cette dernière exécutée, le jeu de résultats associé ;
PDOException, permettant le traitement des erreurs.

Connexion à un SGDB :
PDO utlise un DSN pour décrire la base de données à laquelle on souhaite se connecter, comme pour PEAR DB…
Ce DSN va être passer en paramêtre au moment de l'instanciation de la classe PDO :

PDO::__construct ( string $dsn [, string $username [, string $password [, array $driver_options ]]] )

$db = new PDO ('driver_type:host=hostname;dbname=name_of_db', 'user', 'user_password');

Mais attention, la syntaxe du DSN varie en fonction du SGDB utilisé (cf. http://fr.php.net/manual/fr/pdo.dri…) !
Ainsi, pour Mysql (driver : pdo_mysql et DSN) on peut avoir en DSN :

mysql:host=hostname;dbname=name_of_database
 mysql:host=hostname;port=num_port;dbname=name_of_database
 mysql:unix_socket=/path/to/mysql.sock;dbname=name_of_database

Gestion des erreurs et fermeture de connexions :

 $dsn = 'mysql:host=127.0.0.1;port=3306;dbname=dbtest';
 $user = 'user';
 $password = 'passwd';
 try {
 $db = new PDO ($dsn,$user,$password);
 } catch (PDOException $e) {
 var_dump($e->getMessage());
 die();
 }
 if ($db) {
 $db = NULL; //On ferme la connexion en assignant la valeur "NULL" à la variable gérant l'instance PDO 
 }
 
 ?>

- Méthodes pour exécuter une requête :

Il existe 2 méthodes : exec() et query().

query() : Pour les requêtes du type SELECT, EXPLAIN, SHOW, DESC, SET… Retourne une instance PDOStatement pour le traitement des résultats
exec() : Pour les requêtes ne renvoyant pas de jeu de résultats, comme INSERT, DELETE, UPDATE , REPLACE.
Cette méthode retourne le nombre de lignes affectées [*]

En cas d'erreur ces 2 méthodes renvoient FALSE.
Il est donc impératif d'utiliser le comparateur de valeur "===" et non le comparateur de type "==" si l'on veut effectuer un test sur la requête… car une requête valide peut retourner la valeur 0 (aucun résultat) !

if ($db->query($request) === FALSE){
 echo 'Peste ! Une erreur inopinée est survenue !';
 die();
 }

- Requête de selection, traitement des résultats

2 Méthodes :

PDOStatement ::fetch : récupère une ligne depuis un jeu de résultats associé à l'objet PDOStatement. PDOStatement ::closeCursor() libère la connexion du serveur, permettant ainsi à d'autres requêtes SQL d'être exécutées, mais quitte la requête, permettant ainsi qu'elle soit de nouveau exécutée.
PDOStatement ::fetchAll : retourne un tableau contenant toutes les lignes du jeu d'enregistrements.

Traitements de tous les résultats :

La méthode fetchAll() renvoie un tableau contenant TOUS les résultats de la requête : il suffit donc de parcourir ce tableau pour extraire les résultats :

$sth = $db->query('SELECT id, name FROM person WHERE 1');
 $results = $sth->fetchAll(PDO::FECTH_ASSOC);
 foreach ($result as $row){
 echo $row['id']. ': '.$row['name'].'
';
 }
 $db = NULL;

La méthode séquentielle fetch() retourne les résultats ligne par ligne permettant ainsi de ne pas charger l'ensemble des résultats en mémoire, utile surtout pour un grand nombre d'enregistrements.

$sth = $db->query('SELECT id, name FROM person WHERE 1');
 while ($row = $sth->fetch(PDO::FECTH_ASSOC);){
 echo $row['id']. ': '.$row['name'].'
';
 }
 /* L'appel suivant à closeCursor() peut être requis par quelques drivers, notamment Mysql */
 $sth->closeCursor();
 $db = NULL;

Bon, maintenant qu'on a appréhender la bête, Allez on code ! Voir comment se passe l'interfaçage avec les autres packages PEAR, je pense à PAGER notamment…

[*] 2 dans le cas d'un REPLACE !!! petit rappel pour un dév fatigué qui se reconnaîtra…

Plus d'infos : http://fr.php.net/manual/fr/book.pdo.php

Singleton PDO

Minimalteck — 2008-10-31T09:58:21Z

Sommaire

La classe singleton :

 class DatabaseConnection {
 
 public static function get() {
 static $db = null;
 if ( $db == null ) {
 $db = new DatabaseConnection();
 }
 return $db;
 }
 
 private $_handle = null;
 
 private function __construct() {
 $this->engine = 'mysql';
 $this->host = 'localhost';
 $this->database = 'nom_base';
 $this->user = 'user';
 $this->pass = 'user_password';
 $dns = $this->engine.':dbname='.$this->database.";host=".$this->host;
 try {
 $this->_handle = new PDO( $dns, $this->user, $this->pass );
 $this->_handle->query("SET NAMES utf8");//FOR USING UTF-8
 $this->_handle->query("SET CHARACTER SET 'utf8'");//FOR USING UTF-8
 return true;
 } catch (PDOException $e){
 print 'Erreur : '.$e->getMessage().'
';
 die();
 }
 }
 
 public function handle() {
 return $this->_handle;
 }
 }
 ?>

Son utilisation :

 $dbx = DatabaseConnection::get()->handle();
 $results=$dbx->query('SELECT * FROM bidule'); 
 $results->setFetchMode(PDO::FETCH_OBJ); // retour d'un objet std
 while( $row = $resultats->fetch() ) {
 echo 'Utilisateur : '.$row->id.'
'; // on affiche l'id des entrées de la table bidule
 }
 $results->closeCursor(); // on ferme le curseur des résultats : nécessaire pour pouvoir réutiliser la connexion $dbx pour exécuter une nouvelle requête...
 ?>