Obtenez le rang d'un utilisateur dans un tableau de score

J'ai une table MySQL très simple où j'enregistre les meilleurs scores. Cela ressemble à ça:

Id     Name     Score

Jusqu'ici tout va bien. La question est: comment obtenir le classement d'un utilisateur? Par exemple, j'ai un utilisateur Nameou Idet je veux obtenir son rang, où toutes les lignes sont ordonnées en ordre décroissant pour le Score.

Un exemple

Id  Name    Score
1   Ida     100
2   Boo     58
3   Lala    88
4   Bash    102
5   Assem   99

Dans ce cas précis, Assemle rang de 'serait 3, car il a obtenu le 3e score le plus élevé.

La requête doit renvoyer une ligne, qui contient (uniquement) le rang requis.

SELECT id, name, score, FIND_IN_SET( score, (
SELECT GROUP_CONCAT( score
ORDER BY score DESC ) 
FROM scores )
) AS rank
FROM scores

donne cette liste:

id name  score rank
1  Ida   100   2
2  Boo    58   5
3  Lala   88   4
4  Bash  102   1
5  Assem  99   3

Obtenir un score pour une personne seule:

SELECT id, name, score, FIND_IN_SET( score, (    
SELECT GROUP_CONCAT( score
ORDER BY score DESC ) 
FROM scores )
) AS rank
FROM scores
WHERE name =  'Assem'

Donne ce résultat:

id name score rank
5 Assem 99 3

Vous aurez un scan pour obtenir la liste des scores, et un autre scan ou chercher à faire quelque chose d'utile avec. Un index sur la scorecolonne améliorerait les performances sur les grandes tables.

Lorsque plusieurs entrées ont le même score, le rang suivant ne doit pas être consécutif. Le rang suivant doit être incrémenté du nombre de scores partageant le même rang.

Pour afficher des scores comme celui-ci, il faut deux variables de classement

• variable de rang à afficher
• variable de rang à calculer

Voici une version plus stable du classement avec égalité:

SET @rnk=0; SET @rank=0; SET @curscore=0;
SELECT score,ID,rank FROM
(
    SELECT AA.*,BB.ID,
    (@rnk:=@rnk+1) rnk,
    (@rank:=IF(@curscore=score,@rank,@rnk)) rank,
    (@curscore:=score) newscore
    FROM
    (
        SELECT * FROM
        (SELECT COUNT(1) scorecount,score
        FROM scores GROUP BY score
    ) AAA
    ORDER BY score DESC
) AA LEFT JOIN scores BB USING (score)) A;

Essayons cela avec des exemples de données. Voici d'abord les exemples de données:

use test
DROP TABLE IF EXISTS scores;
CREATE TABLE scores
(
    id int not null auto_increment,
    score int not null,
    primary key (id),
    key score (score)
);
INSERT INTO scores (score) VALUES
(50),(40),(75),(80),(55),
(40),(30),(80),(70),(45),
(40),(30),(65),(70),(45),
(55),(45),(83),(85),(60);

Chargeons les exemples de données

mysql> DROP TABLE IF EXISTS scores;
Query OK, 0 rows affected (0.15 sec)

mysql> CREATE TABLE scores
    -> (
    ->     id int not null auto_increment,
    ->     score int not null,
    ->     primary key (id),
    ->     key score (score)
    -> );
Query OK, 0 rows affected (0.16 sec)

mysql> INSERT INTO scores (score) VALUES
    -> (50),(40),(75),(80),(55),
    -> (40),(30),(80),(70),(45),
    -> (40),(30),(65),(70),(45),
    -> (55),(45),(83),(85),(60);
Query OK, 20 rows affected (0.04 sec)
Records: 20  Duplicates: 0  Warnings: 0

Ensuite, laissez initialiser les variables utilisateur:

mysql> SET @rnk=0; SET @rank=0; SET @curscore=0;
Query OK, 0 rows affected (0.01 sec)

Query OK, 0 rows affected (0.00 sec)

Query OK, 0 rows affected (0.00 sec)

Maintenant, voici la sortie de la requête:

mysql> SELECT score,ID,rank FROM
    -> (
    ->     SELECT AA.*,BB.ID,
    ->     (@rnk:=@rnk+1) rnk,
    ->     (@rank:=IF(@curscore=score,@rank,@rnk)) rank,
    ->     (@curscore:=score) newscore
    ->     FROM
    ->     (
    ->         SELECT * FROM
    ->         (SELECT COUNT(1) scorecount,score
    ->         FROM scores GROUP BY score
    ->     ) AAA
    ->     ORDER BY score DESC
    -> ) AA LEFT JOIN scores BB USING (score)) A;
+-------+------+------+
| score | ID   | rank |
+-------+------+------+
|    85 |   19 |    1 |
|    83 |   18 |    2 |
|    80 |    4 |    3 |
|    80 |    8 |    3 |
|    75 |    3 |    5 |
|    70 |    9 |    6 |
|    70 |   14 |    6 |
|    65 |   13 |    8 |
|    60 |   20 |    9 |
|    55 |    5 |   10 |
|    55 |   16 |   10 |
|    50 |    1 |   12 |
|    45 |   10 |   13 |
|    45 |   15 |   13 |
|    45 |   17 |   13 |
|    40 |    2 |   16 |
|    40 |    6 |   16 |
|    40 |   11 |   16 |
|    30 |    7 |   19 |
|    30 |   12 |   19 |
+-------+------+------+
20 rows in set (0.18 sec)

Veuillez noter que plusieurs identifiants qui partagent le même score ont le même rang. Notez également que le classement n'est pas consécutif.

Essaie !!!

SELECT 
    id, 
    Name,
    1+(SELECT count(*) from table_name a WHERE a.Score > b.Score) as RNK,
    Score
FROM table_name b;

Une option serait d'utiliser des variables USER:

SET @i=0;
SELECT id, name, score, @i:=@i+1 AS rank 
 FROM ranking 
 ORDER BY score DESC;

La réponse acceptée a un problème potentiel. S'il y a deux scores identiques ou plus, il y aura des lacunes dans le classement. Dans cet exemple modifié:

 id name  score rank
 1  Ida   100   2
 2  Boo    58   5
 3  Lala   99   3
 4  Bash  102   1
 5  Assem  99   3

Le score de 58 a le rang 5, et il n'y a pas de rang 4.

Si vous voulez vous assurer qu'il n'y a pas de lacunes dans les classements, utilisez- DISTINCTle GROUP_CONCATpour construire une liste de scores distincts:

SELECT id, name, score, FIND_IN_SET( score, (
SELECT GROUP_CONCAT( DISTINCT score
ORDER BY score DESC ) FROM scores)
) AS rank
FROM scores

Résultat:

id name  score rank
1  Ida   100   2
2  Boo    58   4
3  Lala   99   3   
4  Bash  102   1
5  Assem  99   3

Cela fonctionne également pour obtenir le rang d'un seul utilisateur:

SELECT id, name, score, FIND_IN_SET( score, (    
SELECT GROUP_CONCAT(DISTINCT score
ORDER BY score DESC ) 
FROM scores )
) AS rank
FROM scores
WHERE name =  'Boo'

Résultat:

id name score rank
 2  Boo   58    4

Voici la meilleure réponse:

SELECT 1 + (SELECT count( * ) FROM highscores a WHERE a.score > b.score ) AS rank FROM
highscores b WHERE Name = 'Assem' ORDER BY rank LIMIT 1 ;

Cette requête renverra:

3

Cette solution donne DENSE_RANKen cas d'égalité:

SELECT *,
IF (@score=s.Score, @rank:=@rank, @rank:=@rank+1) rank,
@score:=s.Score score
FROM scores s,
(SELECT @score:=0, @rank:=0) r
ORDER BY points DESC

Le travail suivant ne fonctionnerait-il pas (en supposant que votre table s'appelle Scores)?

SELECT COUNT(id) AS rank FROM Scores 
WHERE score <= (SELECT score FROM Scores WHERE Name = "Assem")

J'ai ceci, qui donne les mêmes résultats que celui avec des variables. Cela fonctionne avec des liens et cela peut être plus rapide:

SELECT COUNT(*)+1 as rank
FROM 
(SELECT score FROM scores ORDER BY score) AS sc
WHERE score <
(SELECT score FROM scores WHERE Name="Assem")

Je ne l'ai pas testé, mais j'en utilise un qui fonctionne parfaitement, que j'ai adapté à cela avec les variables que vous utilisiez ici.