How to get index/position of a node in a list without getting the complete list in firebase?

Question

I am using firebase to build a global leaderboard and social leaderboard for our mobile games. As the game would have 10s of 1000s of entries for highscores it would be not recommended to load the complete list of entries hence we would be using pagination. But I want to load the position of the current player without loading the entire list.

Example: A leaderboard has 100 players and user XYZ is on 65th position. Is there any way I can get 65 without loading the whole list?

Answer 1

There is no way to know the index of a specific key, without downloading all keys. It's simply an operation that doesn't match well with Firebase's API, mostly due to the realtime nature of the database.

Answer 2

There isn't necessarily a simple solution for this. If you're looking to return the nth item, this post might be useful: Can I get the nth item of a firebase "query"?

However, you can definitely do this without loading the entire list using orderBy and limitToFirst to return the top 65. Something like yourRef.orderByChild('points').limitToFirst(65).

Probably not as simple as what you were hoping for, but I hope it helps.

Answer 3

This may be a pretty simple answer but it really depends on how you structure your data.

If there are exactly 100 users at all times and you want everyone from position 65 to position 1, thats easy.

Likewise if you want what position user XYZ is, that's also easy.

There's also ways to load the top 2 users by position (or 35)

users:
   user_id_0
     position: 15
   user_id_1
     position: 32
   user_id_2
     position: 7

then to a query on the /users/position sort by position and then queryLimitedToFirst(2) will return user_id_2 and user_id_0.

Edit:

Based on more data, here are a couple more options. Given we have 5 users, each with a score (I noted their 'position' in the list)

uid_0: 50 //pos 2
uid_1: 25 //pos 1
uid_2: 73 //pos 4
uid_3: 10 //pos 0
uid_4: 58 //pos 3

If you want to know the position, based on score of uid_2 - I don't know your platform so I will give a generic flow:

step 1) query uid_2 to get his score, 73, then

step 2) queryOrderedByChild(score).startingAtValue(73), get nodes with scores from 73 to whatever the highest score is

step 3) then the result will be in a snapshot, so check snapshot.childrenCount, which will be the position if uid_2, which is 4. This will reduce the number of nodes loaded.

The downside is that the farther down the list, the more data would be loaded. If you only have 1000 nodes with just scores in them, that's not a lot of data.

The following solution avoids lots of data but requires more work by the app.

Of course, if your platform support array's this is a super simple task. Using the same structure above, load the children into and array and get the index number of the uid you want to know the position of.

Swift code

let ref = self.myRootRef.childByAppendingPath("scores")
ref.queryOrderedByValue().observeEventType(.Value, withBlock: { snapshot in

     var myArray = [String]()

     for child in snapshot.children {
          let key = child.key as String
          myArray.append(key)
     }

     let pos = myArray.indexOf("uid_0")
     print("postion = \(pos!)")
})

Answer 4

One way might be to run a process that updates the "Rank" property for each player. It wouldn't give them instant access to their current rank, but if you're ok with the ideas being updated daily or on a regularly scheduled timing, that could be an effective solution that doesn't require returning a ton of data to the user as your user base grows. The process could be something like @pufs recommendation for getting the nth item:

var ref = new Firebase('https://yours.firebaseio.com/users');
var lastKnownScore = null;
var firstQuery = ref.orderByChild('points').limitToFirst(100);
var newRank = 1;
firstQuery.once('value', function(snapshot) {
  snapshot.forEach(function(childSnapshot) {
    childSnapshot.update({ rank: newRank });
    lastKnownScore = childSnapshot.value();
    newRank++;
  });
});

while(lastKnownScore > 0) {
  var nextQuery = ref.orderByChild('points').startAt(lastKnownScore).limitToFirst(100);

  nextQuery.once('value', function(snapshot) {
    snapshot.forEach(function(childSnapshot) {
      childSnapshot.update({ rank: newRank });
      lastKnownScore = childSnapshot.value();
      newRank++;
    });
  });
}

This will need some refactoring if you expect multiple players to have identical scores or players who might have 0 points, but hopefully you can see what I'm getting at. If you set up a process to run this code regularly, it could keep your ranks relatively up to date.