Question

Possible Duplicate:
Mysql rank function

I am making a rank website and each user will have a unique rank based on level. #1 is the best rank and since there’s 350,000 users, the worst rank will be #350000.

No user can have the same rank as anyone else. Now, when a new user is added, their level is calculated. After calculation a script will “rebuild” the ranks, by going through each user one by one, and calculating their new rank.

Here’s an explanation of the queries:

• “Id” is the member’s ID in the database
• “RankNum” is their level. It needs to be renamed.
• “Rank” is their unique rank, #1 to #350000.

Here’s my current script:

function RebuildRanks() {
    $qD = mysql_query("SELECT `Id`,`RankNum` FROM `Members` ORDER BY `Rank` DESC, `Id` ASC");
    $rowsD = mysql_num_rows($qD);

    $curRank = 0;

    for($x = 1; $x <= $rowsD; $x++) {
        $rowD = mysql_fetch_array($qD);

        $curRank++;
        if($rowD['RankNum'] != $curRank) {
            if($curRank != 0) {
                mysql_query("UPDATE `Members` SET `RankNum`='$curRank' WHERE `Id`='".$rowD['Id']."'");
            }
        }
    }

    return true;
}

With 350,000 users, this tends to run very slow. Essentially, in the database the Rank (“ORDER BY `Rank` DESC”) is their level, so the query will order them. Unfortunately, the rest of the process is slow.

It takes about 97 seconds to process all 350,000 users this way. Is there any possible solution to running this more efficiently and quickly?

Answer 1

Your RebuildRanks() function will continue to be a performance bottleneck for you as your userbase grows; you best bet is to devise a system that avoids re-ranking every time a new user joins. Here is an example solution that might help:

Add a new table (ScoreMap) that is a sorted hash of your users by their Score (using this term instead of “Rank” to disambiguate).

CREATE TABLE ScoreMap (
  Score BIGINT NOT NULL, 
  Id BIGINT NOT NULL, 
  UNIQUE INDEX (Score), 
  UNIQUE INDEX (Id)
);

When a new user joins, compute their Score and insert into this new table. If there’s a collision on Score, you can solve for that (if no two users can have the same RankNum, you must have a tie-breaking function of some sort for Score; move users around in this table as necessary).

Now query the ScoreMap table:

SELECT COUNT(*) FROM ScoreMap WHERE Score >= [the score you just calculated]

That is your new user’s RankNum. Everyone with a worse Score than the new user gets their Rank increased by 1, which you can update immediately, periodically, as they log in, put a cache in front of, etc.

PS: Normalize your Rank scoring function to be a BIGINT between 0 and a very high number (e.g. a trillion). This will help you avoid collisions when inserting into the new table. You want to shoot for an even distribution over this range, since you’re essentially using score as a hashing function.