Nb requete / temps total requete

[conan]

Bonjour,

Je me suis fais une classe Mysql pour mes différents sites que je vais retaper petit à petit, et je me demander comment faire pour faire ce genre de chose que l'on voit par exemple sur les forum Invision.

- Le nombre de requetes utilisé pour généré la page finale

- Le temps total des requêtes

Je sais déjà comment faire pour avoir le temps total pour me généré la page par le serveur, mais là je souhaite avoir plus de précision pour avoir un ratio PHP/Mysql

Merci de votre aide.

Vincent.

[Compte supprimé]

Si tu fais bien les choses, ton code doit appeler une fonction unique pour toutes les requêtes à la base.

du genre

function sql_query($query)
	{
	global $marqueur_sql;
	$result=@mysql_query($query,$marqueur_sql);
		if (!$result) die ("Erreur fatale SQL. Contactez l'administrateur.");
	return $result;
	}

Rien de plus simple alors de placer dans cette fonction :

1/ un compteur pour savoir le nombre de fois qu'elle est appelée

2/ un compteur du temps mis pour la requête

[TheRec]

Bonsoir,

Fais comme l'a dit jeroen pour les requête et si tu n'utilise qu'une instance de ta base de données (ou même si tu en as plusieurs, simplement cela demandera un calcul supplémentaire), il suffit de créer une propriété supplémentaire à ta classe. Par exemple :

  var $query_count;

Ensuite dans ta fonction effectuant toutes les requêtes, incrémente cette variable :

 $result = mysql_query("SELECT * FROM table");
  $this->query_count++;

Ensuite à la fin de ta page, tu utiliseras quelque chose comme :

echo 'Nombre de requêtes : '.$instanceDeTaClass->query_count;

Si tu ne sais pas comment n'utiliser qu'une seule instance de ta classe dans tes autres classes je te suggère la lecture de cet article sur les singletons en PHP5

Pour calculer le temps utilisé par chaque requête, prends le temps avec cette fonction avant et après la requête :

function microtime_float()
{
   list($usec, $sec) = explode(" ", microtime());
   return ((float)$usec + (float)$sec);
}

Puis tu incrémentes une autre propriété de ta classe (comme pour le compteur de requêtes) avec la différence entre ces deux valeurs obtenues avec cette fonction (temps après - temps avant). Ainsi tu as le temps total quon pris les requêtes à sexécuter.

Bonne continuation.

[conan]

Merci pour vos réponses je vais regarder celles-ci de plus près.

le temps que je les regardes, je vous mets un peu ce que je suis entrain de faire, ca fais un bon moment que je suis la dessus (durant mes temps libre... après le travail le soir c'est dur de passer de .net à Php)

---

Bon ce n'est pas simple à expliquer... alors je procéde par étape

Nota : je migre vers php5 donc le maximum en classes pour pouvoir utiliser mes classes dans différents projets exemple :

j'ai un répertoire classes là où j'ai installé mon PHP/Mysql qui contient mes classes générales aux projets.

En fait j'ai :

- une classe Mysql

- une classe timer

Ma classe timer et utilisé pour :

- le temps de génération d'une page

- les requêtes (inclu dans la classe mysql)

Sinon dans mes pages j'ai un système de statistiques (toujours en dev) qui est générales aux sites (en gros je passe l'id du site) : donc des accès à la base stats

ensuite j'ai accès à la base du site en question.

Donc oui il faut que je puisse dans le calcul du temps des requêtes prendre le temps global (base stats et base du site)ainsi que le nombre total de requêtes.

Voici mes classes.

Cmysql

include 'IBaseDeDonnees.inc.php';
// Necessite la classe timer
require_once('d:\web\Classes\cTimer.inc.php');

include_once 'd:\web\Classes\commonFunctions.inc.php';
class MySql implements IBaseDeDonnees
{
  private $host = null;
  private $user = null;
  private $upass = null;
  private $base = null;

  private $connexion = null;
  private $id_resultat = null;
  private $last_id_insert = null;	   

  private $log = false;
  private $debug = true;

  private $nbres;			 /* Nombre de lignes retournées/affectées par la requête */
  private $nbQuery = 0;
  private $timer = 0;
  private $queryTime = 0;

  function __construct($host=null, $base=null, $user=null, $upass=null)
  { 
	$this->host=$host;
	$this->base=$base;
	$this->user=$user;
	$this->upass=$upass;
  }

  function setMyHost($host=null){$this->host=$host;}
  function setMyBase($base=null){$this->base=$base;}
  function setMyUser($user=null){$this->user=$user;}
  function setMyUpass($upass=null){$this->upass=$upass;}
  function setDebug($mode){$this->debug=$mode;}
  function setLog($mode){$this->log=$mode;}


  function connecter()
  {
	if (isset($this->host) AND isset($this->base) AND isset($this->user))
	  {		
		if (is_null($this->connexion))
		{	   
		 // Creation de la connexion
		 $this->id_connect = _AT_mysql_pconnect($this->host, $this->user, $this->upass)
   		 or $this->erreur('Echec de connexion !');
   		 /* connexion à la base de donnée. */
   		 _AT_mysql_select_db($this->base, $this->id_connect)
   		 or $this->erreur('Sélection de la base impossible !');
   		 if ($this->log){logfile('creation connexion SQL['.$this->id_connect.']');}
		}
		$this->timer = new timer();	   
	  }  
  }

  function query($query)
  {
	  $this->last_id_insert = null;
	  // Recuperation de la commande demandé
	  $commande = strtoupper(substr($query, 0, 6));	  

	  $this->id_resultat = _AT_mysql_query($query, $this->id_connect)
	  or $this->erreur('Execution de la requête impossible !: ' .$query);

	  /* Met à jour le nombre de lignes affectées par la requête */
	  if ($commande == 'INSERT')
		 $this->last_id_insert = _AT_mysql_insert_id($this->id_connect);
	  else if ($commande == 'SELECT')
		 $this->nbres = _AT_mysql_num_rows($this->id_resultat);
	  else
		 $this->nbres = _AT_mysql_affected_rows($this->id_resultat);

	  $this->nbQuery++;
	  if ($this->log){logfile('requete SQL;'.$commande.';'.$query);}
  }

	 /* ==========================================================================
   GetLastInsertId : retourne le dernier insert
   ========================================================================== */
  function GetLastInsertId()  
   {
	  return $this->last_id_insert;
   }
   /* === Fin GetLastInsertId */

   /* ==========================================================================
   GetNbQuery : retourne le nombre de requête courant
   ========================================================================== */
   function GetNbQuery()
   {
	  return $this->nbQuery;
   }
   /* === Fin GetNbQuery */

	/* ==========================================================================
   GetQueryTime : retourne le temps de traitement SQL actuel
   ========================================================================== */
   function GetQueryTime($type = NULL)
   {
	  if ($type == 'f')
		 return $this->timer->timeCalcul($this->queryTimer);
	  else
		 return $this->queryTimer;
   }
   /* === Fin GetQueryTime */

   /* ==========================================================================
   count : Retourne le nombre d'enregistrement résultant d'une requête
   ========================================================================== */
   function count()
   {
	  return $this->nbres;
   }
   /* === Fin count */


  /* ==========================================================================
   Fonctions qui retourne le resultat sous divers forme, au choix par le programmeur
   ========================================================================== */

   // Tableau accessible par indice : tab[0]...tab[n]
   function getRow()
   {
	  return mysql_fetch_row($this->id_resultat);
   }

   // Tableau accessible par indice : tab['nom']...tab['nnom']
   function getArray()
   {
	  return mysql_fetch_array($this->id_resultat,MYSQL_ASSOC);
   }

   // Objet accessible par nom : obj->nom...obj->nnom
   function getObject()
   {
	  return mysql_fetch_object($this->id_resultat);
   }

   // ==========================================================================





  function deconnecter()
  {}





  /* ==========================================================================
   isConnected : indique si une connexion à une base de donnée existe
   ========================================================================== */
  function isConnected()
  {	
	if (!is_null($this->connexion))
	  return true;
	else
	  return false;
  }
  /* === Fin isConnected */

   /* ==========================================================================
   freeRes : Libére les résultats de la mémoire
   ========================================================================== */
   function freeRes()
   {
	  echo 'cnx : '.$this->id_resultat . '--';
	  mysql_free_result($this->id_resultat);
	  echo 'cnx : '.$this->id_resultat . '--';
	  //$this->id_resultat = null;
   }
   /* === Fin freeRes */  

   /* ==========================================================================
   close : Ferme la connexion à la base de donnée
   ========================================================================== */
   function close()
   {
	  if (! is_null($this->id_resultat)) {echo 'mmm';}

	  //if (!is_null($this->id_resultat)) then  
	  mysql_close($this->id_connect);
	  if ($this->log){logfile('CloseCnx['.$this->id_connect.']');}
   }
   /* === Fin close */

   /* ==========================================================================
   erreur : Affiche l'erreur en cours
   ========================================================================== */
   Function erreur($errorString)
   {
	  $this->sqlerreurno = mysql_errno();
	  if ($this->log){logfile('Erreur: '.$this->sqlerreurno);}

	  if ($this->debug)
	  {
		 echo '<div class=\'sqlError\'>Erreur : '.$errorString."\r\n".mysql_errno().'-'.mysql_error().'</div>';
		 die();
	  }
   }
   /* === Fin erreur */
}

CTimer

define ('CTIMER',TRUE);

class timer
{
   var $CName = "timer"; // Nom de la classe
   var $scriptTime;
   var $timeStart = NULL;

   // Constructeur
   function timer()
   {
   }

   // Démarre le chrono
   function on()
   {
	  $this->timeStart = $this->microtime_float();
   }

   // Stop le chrono
   function off()
   {
	  $timeEnd = $this->microtime_float();
	  $this->scriptTime = $timeEnd - $this->timeStart;
	  $this->timeStart = NULL;
   }

   function isStart()
   {
	if (is_null($this->timeStart))
	  return false;
	else
	  return true;
   }

   // Recuperation du temps courant
   function microtime_float()
   {
	 list($usec, $sec) = explode(' ', microtime());
	 return ((float)$usec + (float)$sec);
   }

   // Retourne la durée au format brut qui correspond à l'écart entre la methode on et off
   function GetDuree()
   {
	  return $this->scriptTime;
   }

   // retourne le temps entre la methode on et off formaté automatiquement
   function GetFormatedTime()
   {
	  return $this->timeCalcul($this->scriptTime);
   }

   //retourne le temps donné en paramètre ( Milliseconde ) formaté automatiquement
   function timeCalcul($temps)
   {
	 $tempsEnSeconde = floor($temps);
	 //combien d'heures ?
	 $hours = floor($tempsEnSeconde / 3600);
	 if ($hours>0) {$retour.=$hours.'h ';}

	 //combien de minutes ?
	 $min = floor(($tempsEnSeconde - ($hours * 3600)) / 60);
	 if ($min < 10)
	   $min = "0".$min;
	 if ($min>0) {$retour.=$min.'m ';}

	 //combien de secondes
	 $sec = ($tempsEnSeconde - ($hours * 3600) - ($min * 60));
	 if ($sec < 10)
	   $sec = "0".$sec;
	 if ($sec>0) {$retour.=$sec.'s ';}
	 // Millisecondes

	 $ms = number_format($temps-$tempsEnSeconde,3)*1000;
	 if (!empty($retour)) // Uniquement s'il n'y a pas que des millisecondes
	 {
		if ($ms < 100)
		  $ms = "0".$ms;
		if ($ms < 10)
		  $ms = "0".$ms;
	 }

	 return $retour.$ms.' ms';
   }
}
// Fin Class timer

J'ai regardé le Singleton et Multiton, c'est ce qui semblait être le plus adapté mais voilà, en créant un exemple simple multiton, je remarque que si je fais une autre connexion à Mysql pour accéder à une autre base durant la même page (donc nouvelle instance de ma classe) je perdrais mon timer et mon compte.

il faudrait quelque chose au dessus de ma classe mysql je pense

en fait je pense me faire une classe qui sera appelé en début de page et en fin de page.

je me suis basé sur un exemple de singleton :

La classe :

class Singleton 
{ 
	private static $_instance; 
	private $v;

	private function __construct() 
	{ 
		echo 'construction du singleton<br/><br/>'; 
	}//fin constructeur 

	public static function GetInstance() 
	{ 
		if (!isset(self::$_instance)) 
		{ 
			self::$_instance = new Singleton(); 
		}
		echo self::$_instance->v+=1;				
		return self::$_instance; 
	}//fin fonction GetInstance 
}//fin classe Singleton

la boucle de test

require_once ('singleton.php');

for($i=0; $i < 10; $i++) 
{ 
	$var = Singleton::getInstance(); 
	echo '<pre>'; 
	var_dump($var); 
	echo '</pre>'; 
}

On voit bien que v augmente tout le temps ! donc je pense qu'il faut partir dans cette direction. A suivre...

Si vous trouvez de quoi améliorer n'hésitez pas !!

[conan]

Voilà je me suis fait ma classe qui marche bien (cf code plus bas)

mais maintenant je bute sur un problème c'est le fait que puisse à chaque fin de requete ajouter le temps et ma requete +1

pour celà il faut que je fasse un require dans ma classe mysql.

mais lors de la génération de la page il faut que j'appele mon GetNbQuery et GetQueryTime de ma classe cQueryStats

soit via ma classe mysql ( pas très propre je trouve car normalement je ne devrais pas laisser ma classe mysql accessible de partout, car si je déclare un accès à ma classe mysql dans une sous fonction de mon site je suis "foutu" car hors de ma fonction elle n'est plus présente et il vaut mieux éviter de la passer en variable globale. voilà donc maintenant où je bute.

Merci d'avance de votre aide.

class cQueryStats
{
  private static $_Time = 0;
  private static $_Numbers = 0;

  public static function Add($nbQuery = 0, $time = 0)
  {	
	self::$_Numbers += $nbQuery;
	self::$_Time += $time;
  }

  public function GetNbQuery() {return self::$_Numbers;}
  public function GetQueryTime(){return self::$_Time;}

}