Discussion :

[DC]

Bonjour,

Je vous explique le contexte de mon problème. Il s'agit d'un système de gestion de tournoi.

Je rentre dans ma table 't2005', le numero de tounoi, l'id de l'utilisateur et son nombre de points. Pour mon classement final, je cherche à faire la somme que des 4 meilleurs scores de chaque utilisateur.

Je vois bien comment faire ça en PHP, mais j'aimerais pouvoir le realiser dans ma requete.

Voici ma requete pour l'instant, elle n'inclus pas les "4 meilleurs scores".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT user,fname,lname,SUM(points) AS points from `t2005` WHERE cat='U9' GROUP BY user ORDER BY points DESC

J'espere que j'ai été assez clair dans mon explication.

Merci d'avance

DC

[Médiat]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
SELECT a.user, a.fname, a.lname,SUM(b.points) AS points 
FROM `t2005` a INNER JOIN `t2005` b ON a.user    = b.user 
                                   AND a.points <= b.points
WHERE a.cat = 'U9' 
  AND b.cat = 'U9'
GROUP BY a.user, a.fname, a.lname
HAVING COUNT(*) = 4
ORDER BY points DESC

b.cat = 'U9'est inutile si U9 est une caractéristique du user et non du tournoi

[Maljuna Kris]

Saluton,

J'espere que j'ai été assez clair dans mon explication.

Je crains que non.
Comment pouvons nous savoir ce que tu entends par score ?
Est-ce la somme des points obtenus par un joueur pour un tournoi ?
Auquel cas il faudrait faire un regroupement non seulement sur le joueur, mais aussi sur le tournoi, or, nous ne savons rien de la colonne identifiant le tournoi dans la table t2005.
D'autre part, pour limiter les résultats aux quatre meilleurs pour chaque joueur dans une requête traitant tous les joueurs, je ne vois pas de solution et, s'il en existe une, elle sera tellement gourmande en ressources qu'il vaut laisser à php le soin de s'occuper du traitement procédural du résultat d'une requête plus simple.

[pcaboche]

Je ne pense pas que la solution de Médiat marche. En effet, le HAVING COUNT(*)=4 va limiter les résultats aux joueurs ayant exactement 4 scores, ce qui n'est pas ce que l'on veut.

Tu peux faire ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
SELECT user, fname, lname, points
FROM `t2005`
WHERE cat='U9' 
ORDER BY user, points DESC

De cette façon, les résultats seront triés d'abord par user et ensuite par point (décroissant). Lors du parcours des résultats, tu ne relèves que les 4 plus hauts scores de chaque utilisateur et tu en fais la somme. (c'est peut-être la solution que tu as envisagée en PHP)

Sinon, on pourrait peut-être envisager des solutions plus compliquées avec des procédures stockées, reste à savoir si c'est vraiment utile (et si l'environnement d'y prête...)

[Médiat]

J'avais, effectivement oublié un bout de la requête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
SELECT a.user, a.fname, a.lname,SUM(b.points) AS points 
FROM `t2005` a INNER JOIN `t2005` b ON a.user    = b.user 
                                   AND a.points <= b.points 
WHERE a.cat = 'U9' 
  AND b.cat = 'U9' 
GROUP BY a.user, a.fname, a.lname, "Identifiant de t2005" 
HAVING COUNT(*) = 4 
ORDER BY points DESC

[DC]

Merci de vos reponses. Je vais essayer d'etre plus clair:

- le champ idevent est donc le numero de mon tournoi
- cat est une categorie de personnes participant au tournoi, il y en a plusieurs par tournoi (ici, c'est U9 pour les moins de 9ans).
- Enfin, chaque joueur se voit attribué des points à chaque tournoi en fonction de son classement.

Pour le classement final, on ne retient que les quatres meilleurs scores par joueur que l'on additionne.


Médiat

Peut tu m'expliqué le fonctionnement de ta requete. merci, je vais la tester des que je peux.

[Médiat]

A chaque ligne de t2005 (c'est pourquoi on a besoin de l'identifiant de la ligne), on associe les lignes de tournoi du même user et dont le nombre de points est >=, on totalise les points des lignes associées, mais on ne garde que les lignes qui ont 4 lignes <=.
Si il y a un risque d'avoir plusieurs fois le même nombre de points, il faudrait compléter la condition AND a.points <= b.points afin de gérer les ex-aequos.

Exemple
Si le User 1 a les points suivants (12, 23, 20, 52, 33), les regroupements seront :

12, {12}
23, {12, 20, 23}
20, {12, 20}
52, {12, 20, 23, 52, 33}
33, {12, 20, 23, 33}

Un seul de ce groupes est de taille 4, c'est celui que l'on garde pour faire la somme.

[pcaboche]

N'empêche, ça m'a l'air tout aussi compliqué...

<edit>
Et si un joueur n'a réalisé que 3 scores, comment on fait pour prendre ses 4 meilleurs? Et ben on peut pas !
</edit>

Au chapitre des solutions tirées par les cheveux, on a aussi ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
SELECT user, fname, lname, SUM(points) AS totalPoints
FROM t2005 a
 
WHERE a.cat = 'U9' 
AND a.points IN 
  (SELECT b.points
   FROM t2005 b
   WHERE b.user = a.user
   ORDER BY b.points DESC
   LIMIT 4)
 
GROUP BY a.user
ORDER BY totalPoints DESC

Mais:
- On a une requête imbriquée (non supportée par MySQL < 4.1)
- Question perfs, c'est pas ce qu'il y a de mieux
- C'est assez crade quand même...
- Si tu as 5 fois le même score, ton calcul est faux (parce qu'on fait une comparaison sur des points, et non pas sur des clefs primaires)

D'ailleurs à ce sujet:
- c'est quoi ta clef primaire dans la table tournoi?
- dans ta table "t2005", tu as comme champs: user (la clef primaire?), fname et lname. A chaque nouveau score tu rentres à nouveau le nom et le prénom? Ca te choque pas cette redondance d'informations?

Sinon, j'en reviens à ma solution précédente :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
SELECT user, fname, lname, points
FROM `t2005`
WHERE cat='U9'
ORDER BY user, points DESC

Et pour chaque joueur tu ne gardes que le 4 meilleurs scores (par un petit traitement PHP). Comme ça:
- pas de requêtes imbriquées
- pas de jointure réflexive avec une condition sur un COUNT
- juste une requête toute simple avec un ORDER BY que tout le monde comprend (pense au pauvre type qui va devoir maintenir ton appli, stp )