Classement de résultat d'une requête

[nicco]

Bonjour le Hub,

J'utilise ce code pour classer les 10 premiers résultats d'une requête :

CODE

$sql = mysql_query("SELECT champ FROM table WHERE ((id >= x) and (id <= y)) ORDER BY champ.point DESC LIMIT 0,10");

while($resultat = mysql_fetch_array($sql)){

echo '<div>';

$rank = $rank + 1;

echo '<b>';

echo $rank;

echo '·</b> ';

echo $resultat['champ'];

echo '<br /></div>';}

Je me demande bien si ce n'est pas trop lourd ou si il existe des requetes de classement plus efficace.

Merci d'avance de vos contributions.

[Damien L]

Ta requête me parait bien !

Je ne connais pas d'autres solution non plus.

WHERE ((id >= x) and (id <= y))

Sauf erreur de ma part, les parenthèses sont inutiles.

[raptor]

$rank=0;
$sql = mysql_query("SELECT champ FROM table WHERE ((id >= x) and (id <= y)) ORDER BY champ DESC LIMIT 0,10");
while($resultat = mysql_fetch_row($sql)) 
  echo '<div><b>',($rank+1),'·</b> ',$resultat[0],'<br /></div>';

Comme çà sinon mais bon le gain est quasi nul

[captain_torche]

Pour faire un peu plus lisible, tu peux écrire :

SELECT champ FROM table WHERE id BETWEEN x AND y ORDER BY champ DESC LIMIT 0, 10

[raptor]

Un

limit 10

améliore encore un chouilla

[nicco]

Merci.

fetch_row plus rapide que fetch_array ça je l'avais lu, par contre quelle est la différence entre LIMITE 0,10 et LIMIT 10 et entre WHERE ((id >= x) and (id <= y)) et WHERE id BETWEEN x AND y ?

[raptor]

Limit 10 écnomise 2 octets d'espace disque et le between est plus rapide que la double condition.

[TheRec]

Bonsoir,

Tu me sembles bien affirmatif raptor, BETWEEN va faire exactement les mêmes opérations (au niveau du processeur) qu'une double comparaison (ou tu connais une manière logique de tester deux bornes plus efficacement qu'avec deux conditions ). La seule différence est que la double comparaison est plus flexible car on peut ou non inclure l'une, l'autre ou les deux bornes. Mais je te l'accorde, BETWEEN rend la requête bien plus lisible et il est préférable d'utiliser cette syntaxe.

Quant à LIMIT 0, 10, effectivement c'est 2 octets (ou plutôt 4, avec l'espace et la virgule... enfin ... si on considère qu'un caractère est un octet, ce qui est loin d'être le cas en UTF-8 par exemple) qui sont "économisés", mais à vrai dire j'ai rarement gagné en performance significatives avec ce genre "d'optimisation", même à grande échelle.

[captain_torche]

fetch_row plus rapide que fetch_array ça je l'avais lu[...]

Te rappelles-tu où tu as trouvé cette info ?

Je m'en étais inquiété il y a quelques années, mais le manuel PHP m'avait très vite rassuré :

Une chose importante à noter est que l'utilisation de mysql_fetch_array() n'est pas significativement plus lent que l'utilisation de mysql_fetch_row(), alors qu'il fournit des valeurs significatives ajoutées.

(

Source)

Personnellement, j'ai l'habitude d'utiliser mysql_fetch_assoc() qui ne renvoie que les indices associatifs (je ne me sers que de ceux-là); je trouve que mysql_fetch_row est peu lisible à l'usage, et peu pratique : une modification de la requête (changement de l'ordre des éléments retournés pas SELECT) oblige à revoir tout le script.

[raptor]

Bonsoir,

Tu me sembles bien affirmatif raptor, BETWEEN va faire exactement les mêmes opérations (au niveau du processeur) qu'une double comparaison (ou tu connais une manière logique de tester deux bornes plus efficacement qu'avec deux conditions ). La seule différence est que la double comparaison est plus flexible car on peut ou non inclure l'une, l'autre ou les deux bornes. Mais je te l'accorde, BETWEEN rend la requête bien plus lisible et il est préférable d'utiliser cette syntaxe.

Quant à LIMIT 0, 10, effectivement c'est 2 octets (ou plutôt 4, avec l'espace et la virgule... enfin ... si on considère qu'un caractère est un octet, ce qui est loin d'être le cas en UTF-8 par exemple) qui sont "économisés", mais à vrai dire j'ai rarement gagné en performance significatives avec ce genre "d'optimisation", même à grande échelle.

Au temps pour moi sur le between j'ai dis une boulette, ce n'est pas plus rapide. (j'avais le "in" en tete qui est a bannir sur les grosses requetes). Confusion de fin de journée

Pour le limite par contre, je partais du principe que les deux espaces apres la virgule dans son exemple volent, donc limit 0,10 -> limit 10 fait gagner au minimum deux octets

@+