Avec MySQL, comment puis-je générer une colonne contenant l'index d'enregistrement dans une table?

Est-il possible d'obtenir le numéro de ligne réel à partir d'une requête?

Je veux pouvoir commander une table appelée league_girl par un champ appelé score; et renvoyez le nom d'utilisateur et la position de ligne réelle de ce nom d'utilisateur.

Je veux classer les utilisateurs afin que je puisse dire où se trouve un utilisateur particulier, c'est-à-dire. Joe est en position 100 sur 200, c'est-à-dire

User Score Row
Joe  100    1
Bob  50     2
Bill 10     3

J'ai vu quelques solutions ici, mais j'ai essayé la plupart d'entre elles et aucune d'entre elles ne renvoie le numéro de ligne.

J'ai essayé ceci:

SELECT position, username, score
FROM (SELECT @row := @row + 1 AS position, username, score 
       FROM league_girl GROUP BY username ORDER BY score DESC) 

Comme dérivé

... mais il ne semble pas retourner la position de la ligne.

Des idées?

Vous pouvez essayer ce qui suit:

SELECT  l.position, 
        l.username, 
        l.score,
        @curRow := @curRow + 1 AS row_number
FROM    league_girl l
JOIN    (SELECT @curRow := 0) r;

La JOIN (SELECT @curRow := 0)pièce permet l'initialisation de la variable sans nécessiter de SETcommande séparée .

Cas de test:

CREATE TABLE league_girl (position int, username varchar(10), score int);
INSERT INTO league_girl VALUES (1, 'a', 10);
INSERT INTO league_girl VALUES (2, 'b', 25);
INSERT INTO league_girl VALUES (3, 'c', 75);
INSERT INTO league_girl VALUES (4, 'd', 25);
INSERT INTO league_girl VALUES (5, 'e', 55);
INSERT INTO league_girl VALUES (6, 'f', 80);
INSERT INTO league_girl VALUES (7, 'g', 15);

Requête de test:

SELECT  l.position, 
        l.username, 
        l.score,
        @curRow := @curRow + 1 AS row_number
FROM    league_girl l
JOIN    (SELECT @curRow := 0) r
WHERE   l.score > 50;

Résultat:

+----------+----------+-------+------------+
| position | username | score | row_number |
+----------+----------+-------+------------+
|        3 | c        |    75 |          1 |
|        5 | e        |    55 |          2 |
|        6 | f        |    80 |          3 |
+----------+----------+-------+------------+
3 rows in set (0.00 sec)

SELECT @i:=@i+1 AS iterator, t.*
FROM tablename t,(SELECT @i:=0) foo

Voici la structure du modèle que j'ai utilisé:

  select
          /*this is a row number counter*/
          ( select @rownum := @rownum + 1 from ( select @rownum := 0 ) d2 ) 
          as rownumber,
          d3.*
  from 
  ( select d1.* from table_name d1 ) d3

Et voici mon code de travail:

select     
           ( select @rownum := @rownum + 1 from ( select @rownum := 0 ) d2 ) 
           as rownumber,
           d3.*
from
(   select     year( d1.date ), month( d1.date ), count( d1.id )
    from       maindatabase d1
    where      ( ( d1.date >= '2013-01-01' ) and ( d1.date <= '2014-12-31' ) )
    group by   YEAR( d1.date ), MONTH( d1.date ) ) d3

Vous pouvez aussi utiliser

SELECT @curRow := ifnull(@curRow,0) + 1 Row, ...

pour initialiser la variable de compteur.

En supposant que MySQL le prend en charge, vous pouvez facilement le faire avec une sous-requête SQL standard:

select 
    (count(*) from league_girl l1 where l2.score > l1.score and l1.id <> l2.id) as position,
    username,
    score
from league_girl l2
order by score;

Pour de grandes quantités de résultats affichés, ce sera un peu lent et vous voudrez passer à une auto-jointure à la place.

Si vous souhaitez simplement connaître la position d'un utilisateur spécifique après classement par score de champ, vous pouvez simplement sélectionner toutes les lignes de votre tableau où le score de champ est supérieur au score de l'utilisateur actuel. Et utilisez le numéro de ligne retourné + 1 pour savoir quelle position de cet utilisateur actuel.

En supposant que votre table est league_girlet que votre champ principal est id, vous pouvez utiliser ceci:

SELECT count(id) + 1 as rank from league_girl where score > <your_user_score>

J'ai trouvé la réponse originale incroyablement utile, mais je voulais également saisir un certain ensemble de lignes en fonction des numéros de ligne que j'insérais. En tant que tel, j'ai enveloppé toute la réponse d'origine dans une sous-requête afin de pouvoir référencer le numéro de ligne que j'insérais.

SELECT * FROM 
( 
    SELECT *, @curRow := @curRow + 1 AS "row_number"
    FROM db.tableName, (SELECT @curRow := 0) r
) as temp
WHERE temp.row_number BETWEEN 1 and 10;

Avoir une sous-requête dans une sous-requête n'est pas très efficace, il vaudrait donc la peine de tester si vous obtenez un meilleur résultat en demandant à votre serveur SQL de gérer cette requête, ou en récupérant la table entière et en demandant à l'application / serveur Web de manipuler les lignes après coup .

Personnellement, mon serveur SQL n'est pas trop occupé, il était donc préférable de le faire gérer les sous-requêtes imbriquées.

Je sais que l'OP demande une mysqlréponse, mais comme j'ai trouvé les autres réponses ne fonctionnant pas pour moi,

• La plupart d'entre eux échouent avec order by
• Ou ils sont tout simplement très inefficaces et rendent votre requête très lente pour une table grasse

Alors pour gagner du temps pour d'autres comme moi, indexez simplement la ligne après les avoir récupérées de la base de données

exemple en PHP:

$users = UserRepository::loadAllUsersAndSortByScore();

foreach($users as $index=>&$user){
    $user['rank'] = $index+1;
}

exemple en PHP utilisant offset et limit pour la pagination:

$limit = 20; //page size
$offset = 3; //page number

$users = UserRepository::loadAllUsersAndSortByScore();

foreach($users as $index=>&$user){
    $user['rank'] = $index+1+($limit*($offset-1));
}