Firebase database sort by deeper child

Question

Considering the following structure of the Firebase database:

• root
  • game1
    • $playerUidA
      • score: 50
    • $playerUidB

Answer 1

Although this question is rather old there might be people (like me) stumbling over it. Especially because it is pretty intuitive to structure the database in a similar way the author of the question did, to create (for example) a leaderboard system for a game. Since the answer is a bit outdated I wanted to add some things.

Some time ago the devs added the possibility to order by deeply nested children! (See Ordering by a specified child key) To do so you basically have to do the exact same thing the author did and additionally use the first part of the answer given by @adolfosrs. Basically you have to do two things:

1. Work with .indexOn (as described by @adolfosrs)
2. Use the OrderByChild() command.

To make this work on the example given by @steliosf you would have to do the following:

First set the .indexOn in your database rules:

{
  "rules": {
    "$gameId": {
      ".indexOn": "score",
      "$playerUid": {
        ...  
      }
    }
  }
}

Second use the Command the author of the question already used:

rootRef.Child("root").OrderByChild("score")

I would recommend that you always add a LimitToFirst() or LimitToLast() command to avoid that you pull the whole database which might be a lot of data (depending on the size of your database of course). To get for example the top 10 scores you could use:

rootRef.Child("root").OrderByChild("score").LimitToLast(10)

Since the data is ordered in ascending order you need to use LimitToLast().

Answer 2

If you want all the games sorted by the player score all you need to do is to work with your .indexOn rule.

{
  "rules": {
    "$gameId": {
      ".indexOn": "score",
      "$playerUid": {
        ...  
      }
    }
  }
}

This will keep your data sorted in the database so when you retrieve it you will have all the data ready. But keep in mind that if you want to retrieve all the games and all the players it means you will be fetching the whole database. So you should look at the needs of your application and maybe rethink the structure.

Something that could help when scaling is to iterate over the games and retrieve a limited amount of users with firebase.database().ref(gameId).limitToLast(10).

Update

For your example you will have all the games with the following request:

firebase.database().ref().once('value', snap => {
    //prints all players for each game sorted ascending.
    snap.forEach(game => {
        game.forEach(player => {
            console.log(player.val());
        });
    });
});