Bonsoir,
@jojolapine
Je ne suis pas modérateur, mais tu as raisons sur tout le reste.
Comme tu peux le voir la personne en question ne s'identifie même pas,
elle n'a même pas pris le soin de lire tout le topic (ou si elle l'a lu elle n'a rien compris).
De plus ses deux interventions comme tu le constates n'apportent rien de constructif.
Je dirait tout simplement que tu ne devrais pas te sentir atteint par d'aussi petites choses.

j'ai confondu, je te voyait en violet alors ... j'ai pas fait gaffe!
Pour le fait de ne pas se sentir atteint, j'ai un peu de mal... mais bon je faire mon possible

Je n'ai pas inventé la question sur le message d'erreur, s'il y a hors-sujet c'est pas de moi, je répondais à une question de l'intéressé.
Si mettre le doigt sur le fait que le retour de la méthode n'est pas testé est considéré comme pas important, c'est assez dommage tout de même.
Si je résume, une question est posée, une réponse est apportée, on écrit qu'on devrait aller poster ailleurs sans prendre le soin de faire signe à son interlocuteur qu'on a lu son message n'est pas du mépris c'est quoi alors ?

Aussi c'est vrai que d'avoir un profil comme le vôtre apporte beaucoup plus d'informations sur la personne que de ne pas être identifié

J'ai comme l'impression que le mot Exception pour la gestion des erreurs t'est iconnu, c'est pas bien gràve.

Si tu lis le poste attentivement tu en auras une idée. Et ça te serais surement plus utile que d'essayer de pourir des topics.

Hop, on se calme

Je pense que tu (ami invité) as effectivement mal interprété le "je ne sais pas si je dois poster ici". Maintenant que jojolapine en a en plus excpliqué le sens, ce n'est pas peut-être pas la peine de revenir dessus.

Quand au profil, c'est vrai qu'il n'apporte pas beaucoup d'infos essentielles, mais il personnifie déjà un peu et c'est déjà beaucoup.

De plus, un membre avec 800 messages commence à être connu et généralement apprécie s'il est toujours là, alors qu'un invité, on ne sait pas trop d'où il vient, alors s'il pousse une gueulante direct...

Bref, reprenons une discussion un peu plus aimable, tout le monde appréciera.

Bon alors partant du principe que je souhaite seulement différencier les requêtes prepérées et non préparées, voici ce que j'ai fait:

<?php
/**
 * Compteur de requêtes.
 *
 * Classe étendue de PDO destinée à compter le nombre de requêtes envoyées.
 */
class SQL extends PDO
{

    /**
     *Définition des constantes pour la méthodes getnbrQuery
     *
     */
     const SUM=1;
     const PREPARED=2;
     const DIRECT=3;
     const BOTH=4;
                   
    /**
     * initialisation d'une variable de comptage
     *
     * @var Int
     */
    static $nbrQuery = 0;
    /**
     * initialisation d'une variable de comptage
     *
     * @var Int
     */
    static $nbrPreparedQuery = 0;

    /**
     * redéfinition des méthodes de PDO.
     * Chaque méthode utilisant une requête SQL incrémentera le compteur.
     * 
     * @todo faire de même avec les autres fonctions qui effectuent des requêtes.
     */
    
    /**
     *Méthode de contruction
     *
     *     
     */ 
      public function __construct($dsn, $user, $pass, $options=NULL){
        try{
             parent::__construct($dsn, $user, $pass, $options);
             
            // Activation du mode de gestion des erreurs par levée d'exception
            $this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        }catch(PDOException $e){
          throw $e;
        }
      }                   
    
    
    /**
     * Redéfinition de la methode parent::query()
     */
    public function query($q)
    {
      try{
        self::$nbrQuery+=1;
        return parent::query($q);
      }catch(PDOException $e){
          throw $e;
      }  
    }
    
    /**
     *Redéfinition de la méthode parent::exec()     
     */
     public function exec($q)
     {
      try{
        self::$nbrQuery+=1;
        return parent::exec($q);
      }catch (PDOException $e){
        throw $e;
      }
      }
      
    /**
     *Redéfinition de la méthode parent::execute()
     */
     public function execute($opt=NULL){
      try{
        self::$nbrPreparedQuery+=1;
        return parent::execute($opt);
      }catch (PDOException $e){
        throw $e;
      }
      }
     
              
    /**
     * Récupération du nombre de requêtes.
     *
     * @return Int/Array
     */
    public function getnbrQuery($opt=SUM)
    {
        switch ($opt) {
          case SUM:
            $retour=self::$nbrQuery+self::$nbrPreparedQuery;
            break;
          case PREPARED:
            $retour=self::$nbrPreparedQuery;
            break;
          case DIRECT:
            $retour=self::$nbrQuery;
            break;
          case BOTH:
            $retour=array('DirectQuery'=>self::$nbrQuery,'PreparedQuery'=>self::$nbrPreparedQuery);
            break;
        }
        return $retour;
    }
    

}
$user='xxx';
$pass='xxx';
try{
  $connec=new SQL('mysql:host=xxx;dbname=xxx', $user, $pass);
} catch (PDOException $e) {
  die("Erreur de connection: <br />".$e->getMessage());
}

$sql='SELECT * FROM `table`';
try{
  $resQrySel = $connec->query($sql);
} catch (PDOException $e){
  die("Erreur d'éxécution de la requête:<br />".$sql."<br />Erreur:<br />".$e->getMessage());
}
if($i == 0){
  try{
    $res = $resQrySel->fetchAll(PDO::FETCH_OBJ);
  } catch (PDOException $e){
    die("Erreur lors du traitement de la ressource: <br />".$e->getMessage());
  }
  foreach($res as $a=>$b){
    echo "<br />Enregistrement numéro ".$a."<br />";
    foreach($b as $cle=>$valeur){
      echo $cle." = ".$valeur."<br />";
    }
  }
}

$sql='SELECT * FROM `table` WHERE `champ` = ?';
try{
  $var=$connec->prepare($sql);
  $var->execute(array(5));
  $res=$var->fetchAll();
}catch(PDOException $e){
  die('Erreur d\'éxécution de la requête préparée: '.$e->getMessage());
}
print_r($re);


echo 'Nombre de requêtes effectuées: '.$connec->getnbrQuery();

?> 

Bon dans le principe, je pense être bon, seulement, ça ne me compte pas ma requête préparée dans l'exemple....?

Bonjour jojo,
Comme tu l'as remarqué exec() et execute() c'est pas la même chose, non seulement elles ont une orthographe différente mais aussi et SURTOUT elles n'appartiennent pas à la même class (elles ne sont pas applicabels au même objet).

Pour résumer :
$PDO_obj->exec()
$PDOStatment_obj->execute()

Ça te donne une idée ?

Bonjour Ajoloca,
Bon ça confirme ce que j'avais compris (arrête moi si je me trompe):
les requêtes préparées sont TOUJOURS exécutées avec PDOStatement::execute() et les requêtes directes avec PDO::exec() ou PDO::query(), c'est ça?
Bon ben si c'est ça, elle va pas mon idée que j'ai déja mise ci-dessus?

C'est bien ça!
C'est pour ça que quand je pensais que tu voulais distinguer le type de requête je te parlais de voir le retour de PDOStatment.

ça y est la lumière est revenu!!!!
Mon problème vient du faite que je ne peut pas définir la méthode PDOStatement::execute() comme je l'ai fait!!!
Bon j'ai localisé le problème, mais de là à le résoudre...
comment faire pour lui dire que c'est pas la même classe ou qu'elle ne travaille pas à partir des mêmes éléments?

Effectivement, le PB est identifié!
je dirais que c'est 80% du chemin. Car non seulement tu as identifié le PB mais compris la structure générale des class PDO.

Juste pour rappel :
PDO
PDOStatment
PDOException --> Execption (PDOException étends Execption)

Comme d'hab, je te laisse réflechir, mais tu est sur la bonne voie.

Bon je pense avoir un petit peu compris, en fait PDOStatement et dérivé de PDO, c'est bon là?
Bon alors je pourrait faire une classe dérivé de SQL en SQLStatement, seulement comment dire à SQL lors des méthodes prepare...etc, de créer des classe SQLStatement, plutôt que PDOStatement?
là, je croit que le pas est un peu plus grand à faire, et j'ai encore plus peur

Bon je pense avoir un petit peu compris, en fait PDOStatement et dérivé de PDO, c'est bon là?

Pas cette fois, si ça avais été le cas je te l'aurais indiqué comme pour PDOException, je t'ai précisé quelle est (comme tu dis - "dérivée") de Exception.

Alors, on peux définir les class PDO comme ceci :
PDO => Lien avec la base de données.
PDOStatment => Requêtes et résultats.
PDOException => Traitement des erreurs.

Rooo encore raté
Bon alors on à deux classes différents la classe PDO et la classe PDOStatement,
Moi je cherche à faire un comptage des requêtes, donc je fait une classe étendue de PDO qui compte les requêtes directes, et la je me dit que je veu aussi compter les requêtes préparées, donc je cherche où elles sont éxécutée, et paf c'est dans la classe PDOStatement ...
Qu'est-ce que je vais faire alors?
Bon la réponse doit être que je doit créer une classe étendue de PDOStatement (par exemple SQLStatement)
Là je croit que ça vient petit à petit...
seulement voici le problème que je ne voit pas comment résoudre:
Comment dire à ma classe SQL lorsqu'elle fait des prepare, etc, que les objets à renvoyer, sont des instances de classes SQLStatement plutôt que PDOStatement?
Ais-je touché le problème?

PS: merci encore pour le temps et la pédagogie que tu dispenses