Order and limit data with Cloud Firestore

Cloud Firestore provides powerful query functionality for specifying which documents you want to retrieve from a collection. These queries can also be used with either get() or addSnapshotListener(), as described in Get Data.

Order and limit data

By default, a query retrieves all documents that satisfy the query in ascending order by document ID. You can specify the sort order for your data using orderBy(), and you can limit the number of documents retrieved using limit().

For example, you could query for the first 3 cities alphabetically with:

citiesRef.orderBy("name").limit(3)

citiesRef.order(by: "name").limit(to: 3)

[[citiesRef queryOrderedByField:@"name"] queryLimitedTo:3];
  

citiesRef.orderBy("name").limit(3);

citiesRef.orderBy("name").limit(3)

Query query = cities.orderBy("name").limit(3);

db.collection(u'cities').order_by(u'name').limit(3).get()

var firstThree = citiesRef.orderBy('name').limit(3);

query := cities.OrderBy("name", firestore.Asc).Limit(3)

$query = $citiesRef->orderBy('name')->limit(3);

Query query = citiesRef.OrderBy("Name").Limit(3);

query = cities_ref.order("name").limit(3)

You could also sort in descending order to get the last 3 cities:

citiesRef.orderBy("name", "desc").limit(3)

citiesRef.order(by: "name", descending: true).limit(to: 3)

[[citiesRef queryOrderedByField:@"name" descending:YES] queryLimitedTo:3];
  

citiesRef.orderBy("name", Direction.DESCENDING).limit(3);

citiesRef.orderBy("name", Query.Direction.DESCENDING).limit(3)

Query query = cities.orderBy("name", Direction.DESCENDING).limit(3);

cities_ref = db.collection(u'cities')
query = cities_ref.order_by(
    u'name', direction=firestore.Query.DESCENDING).limit(3)
results = query.get()

var lastThree = citiesRef.orderBy('name', 'desc').limit(3);

query := cities.OrderBy("name", firestore.Desc).Limit(3)

$query = $citiesRef->orderBy('name', 'DESC')->limit(3);

Query query = citiesRef.OrderByDescending("Name").Limit(3);

query = cities_ref.order("name", "desc").limit(3)

You can also order by multiple fields. For example, if you wanted to order by state, and within each state order by population in descending order:

citiesRef.orderBy("state").orderBy("population", "desc")

citiesRef
    .order(by: "state")
    .order(by: "population", descending: true)

[[citiesRef queryOrderedByField:@"state"] queryOrderedByField:@"population" descending:YES];
  

citiesRef.orderBy("state").orderBy("population", Direction.DESCENDING);

citiesRef.orderBy("state").orderBy("population", Query.Direction.DESCENDING)

Query query = cities.orderBy("state").orderBy("population", Direction.DESCENDING);

cities_ref = db.collection(u'cities')
cities_ref.order_by(u'state').order_by(
    u'population', direction=firestore.Query.DESCENDING)

var byStateByPop = citiesRef.orderBy('state').orderBy('population', 'desc');

query := client.Collection("cities").OrderBy("state", firestore.Asc).OrderBy("population", firestore.Desc)

$query = $citiesRef->orderBy('state')->orderBy('population', 'DESC');

Query query = citiesRef.OrderBy("State").OrderByDescending("Population");

query = cities_ref.order("state").order("population", "desc")

You can combine where() filters with orderBy() and limit(). In the following example, the queries define a population threshold, sort by population in ascending order, and return only the first few results that exceed the threshold:

citiesRef.where("population", ">", 100000).orderBy("population").limit(2)

citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "population")
    .limit(to: 2)

[[[citiesRef queryWhereField:@"population" isGreaterThan:@100000]
    queryOrderedByField:@"population"]
    queryLimitedTo:2];
  

citiesRef.whereGreaterThan("population", 100000).orderBy("population").limit(2);

citiesRef.whereGreaterThan("population", 100000).orderBy("population").limit(2)

Query query = cities.whereGreaterThan("population", 2500000L).orderBy("population").limit(2);

cities_ref = db.collection(u'cities')
query = cities_ref.where(
    u'population', u'>', 2500000).order_by(u'population').limit(2)
results = query.get()

var biggest = citiesRef.where('population', '>', 2500000)
  .orderBy('population').limit(2);

query := cities.Where("population", ">", 2500000).OrderBy("population", firestore.Desc).Limit(2)

$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('population')
    ->limit(2);

Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Population")
    .Limit(2);

query = cities_ref.where("population", ">", 2_500_000).order("population").limit(2)

However, if you have a filter with a range comparison (<, <=, >, >=), your first ordering must be on the same field:

Valid: Range filter and orderBy on the same field

citiesRef.where("population", ">", 100000).orderBy("population")

citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "population")

[[citiesRef queryWhereField:@"population" isGreaterThan:@100000]
    queryOrderedByField:@"population"];
  

citiesRef.whereGreaterThan("population", 100000).orderBy("population");

citiesRef.whereGreaterThan("population", 100000).orderBy("population")

Query query = cities.whereGreaterThan("population", 2500000L).orderBy("population");

cities_ref = db.collection(u'cities')
query = cities_ref.where(
    u'population', u'>', 2500000).order_by(u'population')
results = query.get()

citiesRef.where('population', '>', 2500000).orderBy('population');

query := cities.Where("population", ">", 2500000).OrderBy("population", firestore.Asc)

$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('population');

Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Population");

query = cities_ref.where("population", ">", 2_500_000).order("population")

Invalid: Range filter and first orderBy on different fields

citiesRef.where("population", ">", 100000).orderBy("country")

citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "country")

[[citiesRef queryWhereField:@"population" isGreaterThan:@100000] queryOrderedByField:@"country"];
  

citiesRef.whereGreaterThan("population", 100000).orderBy("country");

citiesRef.whereGreaterThan("population", 100000).orderBy("country")

Query query = cities.whereGreaterThan("population", 2500000L).orderBy("country");

cities_ref = db.collection(u'cities')
query = cities_ref.where(u'population', u'>', 2500000).order_by(u'country')
results = query.get()

citiesRef.where('population', '>', 2500000).orderBy('country');

// Note: This is an invalid query. It violates the constraint that range
// and order by are required to be on the same field.
query := cities.Where("population", ">", 2500000).OrderBy("country", firestore.Asc)

$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('country');

Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Country");

query = cities_ref.where("population", ">", 2_500_000).order("country")