Class SPDO PDO

Bonjour à toutes et à tous ! :)

je suis nouveau ici et je debute dans la POO !

Suite à un tutoriel sur apprendre-php.com j'ai repris la source puis j'y ai redefini les methode

je voulais savoir

1) si ma classe etait correcte (ci-dessous)

2) devrais rajouter quelque chose ? (type exception ou autre idée)

j'ai bien aimer cette source car elle reprend bien le concept du singleton avec un constructeur private !

mais j'ai aussi vu d'autre source dans le meme style mais avec un constructeur public de facon à herité de la class PDO !

quel d'après vous la meilleur sollution? si y'en a t'il une ou bien les 2 styles sont très bien aussi

auquel cas on choisi en fonction de ses besoins ?

je connais pas bien ici j'ai inserer mon code je sais pas pourquoi ca ne la pas pris !

j'ai du faire une betise!

le liens vers le tutorial d'origine :

Liens vers la source

class SPDO {
/**
     * Instance de la classe PDO
     *
     * @var PDO
     * @acces private
     */
private $PDOInstance = null;
/**
     * Instance de la class SPDO
     *
     * @var SPDO
     * @access private
     * @static
     */
private static $instance = null;
/**
     * Constante: User name from the Database
     * @var String
     */
const USERNAME = 'root';
/**
     * Constante: Server host
     * @var String
     */
const HOST     = 'localhost';
/**
     * Constante: Password
     * @var String
     */
const PASSWORD = 'Nemesis';
/**
     * Constante: Database name
     * @var String
     */
const DATABASE = 'agenda';
/**
     * Constructor
     * @access private
     * @param void
     * @return void
     * @see PDO::__construct()
     */
private function __construct() {
try {
$this->PDOInstance = new PDO('mysql:dbname='.self::DATABASE.';host='.self::HOST,self::USERNAME,self::PASSWORD);
$this->PDOInstance->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_WARNING);
} catch (PDOException $e) {
echo "<b>Error PDO:</b> ".$e->getMessage()."<br />\n";
}
}
/**
     * Empeche la copie externe de l'instance
     * @access private
     */
private function __clone() {
throw new Exception('Le clonage de SPDO n\'est pas autoris&eacute;');
}
/**
     * Create and return SPDO Object
     *
     * @access public
     * @static
     * @param void
     * @return SPDO $instance
     */
public static function getInstance()
{
if(is_null(self::$instance))
{
self::$instance = new SPDO();
}
return self::$instance;
}
/**
     * Initiates a transaction
     *
     * @return <bool>
     */
public function beginTransaction() {
return $this->PDOInstance->beginTransaction();
}
/**
     * Commits a transaction
     *
     * @return <bool>
     */
public function commit() {
return $this->PDOInstance->commit();
}
/**
     * Fetch the SQLSTATE associated with the
     * last operation on the database handle
     *
     * @return <string>
     */
public function errorCode() {
return $this->PDOInstance->errorCode();
}
/**
     * Fetch extended error information associated with
     * the last operation on the database handle
     *
     * @return <array>
     */
public function erroInfo() {
return $this->PDOInstance->errorInfo();
}
/**
     * Executes an SQL statement, return the number of affected row
     *
     * @param <String> $statement
     * @return <int>
     */
public function exec($statement) {
return $this->PDOInstance->exec($statement);
}
/**
     * Retrieve a database connection attribute
     *
     * @param <int> $attribute
     * @return <mixed>
     */
public function getAttribute($attribute) {
return $this->PDOInstance->getAttribute($attribute);
}
/**
     * Return an array of available PDO drivers
     *
     * @return <array>
     */
public function getAvailabelDrivers() {
return $this->PDOInstance->getAvailableDrivers();
}
/**
     * Returns the ID of the last inserted row or sequence value
     *
     * @param <type> $name
     * @return <type>
     */
public function lastInsertId($name) {
return $this->PDOInstance->lastInsertId($name);
}
/**
     *
     * @param <String> $statement
     * @return <type>
     */
public function prepare($statement,$driver_options=false) {
if(!$driver_options) $driver_options=array();
return $this->PDOInstance->prepare($statement,$driver_options);;
}
/**
     * Executes an SQL statement, returning a result set as PDOStatement object
     *
     * @param <string> $statement
     * @return PDOStatement
     */
public function query($statement) {
try {
return $this->PDOInstance->query($statement);
} catch (PDOException $e) {
echo $e->getMessage();
}
}
/**
     * Quotes a string for use in a query
     *
     * @param <type> $input
     * @param <type> $parametre_type
     * @return <type>
     */
public function quote($input, $parametre_type=0) {
return $this->PDOInstance->quote($input,$parametre_type);
}
/**
     * Rolls back a transaction
     *
     * @return <bool>
     */
public function rollBack() {
return $this->PDOInstance->rollBack();
}
/**
     * Set an attribute
     *
     * @param <int> $attribute
     * @param <mixed> $value
     * @return <bool>
     */
public function setAttribute($attribute, $value) {
return $this->PDOInstance->setAttribute($attribute,$value);
}
/**
     * Execute query and return one row in assoc array
     *
     * @param <string> $statement
     * @return <type>
     */
public function queryFetchAllAssoc($statement) {
return $this->PDOInstance->query($statement)->fetchAll(PDO::FETCH_ASSOC);
}
/**
     * @param <type> $statement
     * @return <type>
     */
public function queryFetchAllObj($statement) {
return $this->PDOInstance->query($statement)->fetchAll(PDO::FETCH_OBJ);
}
public function queryFetchAllBoth($statement) {
return $this->query($statement)->fetchAll(PDO::FETCH_BOTH);
}
/**
     * Close a connection database
     *
     * @access public
     * @return <void>
     */
public function close() {
$this->PDOInstance = null;
}
}
?>

voila j'ai compris

Salut et bienvenue sur Apprendre-PHP.com,

Ton implémentation est parfaitement correcte. Content de savoir que les tutoriels présentés sont utiles :)

La méthode avec constructeur public et héritage direct de la classe PDO ne permet pas de faire de l'instance unique puisque le pattern singleton n'est pas implémenté. Il est donc du devoir du développeur de choisir s'il veut ou non pouvoir réaliser des instances uniques ou pas issues de ses classes. Ce n'est qu'une question de goût ensuite.

Concernant ce que tu pourrais ajouter, il y'a par exemple les logs. Par exemple, avant d'exécuter les requêtes SQL avec query() ou execute(), tu loggues les requêtes SQL dans un fichier texte pour pouvoir ensuite tracer toutes les requêtes exécutées et les optimiser si besoin.

++

Hugo.

merci à toi Emacs !

je connaissais pas ce site et j'avoue il est très efficasse et j'espere le voir s'etendre encore plus !

je vais faire ce que tu me conseille !

pour les logs faut que je travaille un peu l'algo car je suis pas encore très fort en orienté objet !

je sais ecrire dans un fichier mais la ou il faut que je reflechisse c'est comment savoir si une requete à été executé !

je me doute que ca dois pas etre très compliqué mais j'y reflechi !

et si tu as une piste ou 2 je suis prenneur :D

merci pour ton aide

Salut Vini,

Merci pour tes compliments, ça fait plaisir de savoir qu'Apprendre-PHP plait autant. Je suis entrain de revoir l'architecture du site. Une nouvelle version du site enrichit est prévue dans quelques mois.

En ce qui concerne les exécutions de requêtes, tu as plusieurs moyens de savoir si elles se sont bien exécutées. Tout d'abord, tu peux encapsuler tes méthodes query() et exec() dans un bloc try { } catch { }. En cas d'erreur, une exception est levée et ainsi tu peux logguer à la fois l'exception et la requête défectueuse dans un fichier de log particulier. Ensuite, tu peux également tester les valeurs de retour de certaines méthodes comme celles qui te retournent le nombre de lignes récupérées dans le cas d'une requête SELECT ou bien celle qui te donnent le nombre de lignes affectées par une requête de type UPDATE ou DELETE.

++

hello !

J'ai pas trop eu le temps de finir mais me revoila !

donc si j'ai bien compris je prend par exemple la methode exec() !

<?php
public function exec($statement)
{
   try {
      return $this->PDOInstance->exec($statement);
   } catch (PDOExecption $e) {
     echo $e->getMessage(); // pour afficher l'erreur
    // et la par exemple j'insert dans un fichier text
    // avec une autre methode que je pourrais créer par exemple,
    // l'erreur getMessage() en y ajoutant l'heure et ce que je veux quoi
    //?
}
?>

j'espere avoir bien compris si c'est ca alors je pourrais fermer le post !

Merci pour ton aide Emacs :D

Salut Vini,

Oui tu as bien compris le principe. Pour pousser le bouchon un peu plus loin, tu peux opter pour une classe MyLogger utilisant elle aussi le pattern singleton. Cela donne par exemple :

<?php class MyLoggerException{} class MyLogger{  const ERROR_FATAL = 'Fatal';  const ERROR_WARNING = 'Warning';  const ERROR_SYSTEM = 'System';  const ERROR_SERVER = 'Server';  const ERROR_QUERY = 'Query';   /**   * Unique instance of MyLogger   *   * @var MyLogger|null   * @access private   * @static    */  private static $_instance = null;   /**   * Log file path   *    * @var string   * @access private   * @static    */  private static $_logFile = null;   /**   * Constructor   *    * @access private   */  private function __construct()  {  }   /**   * Returns the unique instance   *    * Creates the object if doesn't exist   *   * @return unknown   */  public function getInstance()  {    if(null === self::$_instance)    {      self::$_instance = new MyLogger();    }    return self::$_instance;  }   /**   * Defines the log file   *   * @param strign $filePath   * @return MyLogger MyLogger::$_instance   */  public function setLogFile($filePath)  {    if(!file_exists($filePath)) {      throw new MyLoggerException(sprintf("%s doesn't exists !", $filePath));    }     if(!is_writeable($filePath)) {      throw new MyLoggerException(sprintf("%s is not writeable !", $filePath));    }     self::$_logFile = $filePath;    return self::$_instance;  }   /**   * Log an error   *   * @param string $message   * @param string $date   * @param string $type   */  public function log($message, $date = null, $type = self::ERROR_WARNING)  {    // Là tu loggues    return self::$_instance;  }}?>

Et tu utilises la classe comme ça :

public function exec($statement){   try {      return $this->PDOInstance->exec($statement);   } catch (PDOExecption $e) {       try {         MyLogger::getInstance()->           setLogFile('/var/log/mon_site.log')->           log('Exécution impossible de la requête préparée', strftime('%Y-%m-%d %H:%M:%s'), MyLogger::ERROR_FATAL)->           log($statement, strftime('%Y-%m-%d %H:%M:%s'), MyLogger::ERROR_QUERY)->           log($e->getMessage(), strftime('%Y-%m-%d %H:%M:%s'), MyLogger::ERROR_SERVER);            // Redirection vers erreur 500           header('HTTP/1.0 500 Internal Server Error');           header('Location: http://www.tonsite.com/500.php');           exit;        } catch(MyLoggerException $e) {         // En prod il faudrait rediriger vers une erreur 500         //die($e->getMessage());       }   }}

C'est une ébauche pour t'aider :)

++

Hugo.

Hi Emacs !

c'est une ebauche certe mais très bien expliquer !

cela me donne à reflechir et de nouvelle idées !

et je t'en remercie beaucoup ! :D

c'est pour ca que j' aime ce site simple, efficace un acceuil chaleureux !

et une réel motivation à vouloir partager les connaissances ! ;)

bref je kiff lool :D

De rien :)

N'hésite pas à repasser régulièrement sur le site, mais visiblement c'est ce que tu fais ^^

oui tinquiete pas pour ça, tu risque de me voir souvent venir t'embeter mdrr

que veux tu on ne change pas une equipe qui gagne !

l'avantage ici c'est quand j'ai des questions liée à des prob je suis sur d'y trouvé une aide bien dirigée, et expliquée !

et puis les infos et tutos sont interessante

alors oui je vais squaté souvent ici c'est claire d'ailleur c'est devenu pas page d'acceuil de mon FireFox :D

Vini ++

Bonjour,

Comment utiliser cette class, avez vous un exemple de selection et d'ajout de base ?!

Je souhaite adapter cette class aux class du logiciel Thelia (http://www.thelia.fr)