Ir para o console

Ordenar e limitar dados com o Cloud Firestore

O Cloud Firestore oferece uma poderosa funcionalidade de consulta para especificar quais documentos você quer recuperar em uma coleção. Essas consultas também podem ser usadas com get() ou addSnapshotListener(), conforme descrito em Receber dados.

Ordenar e limitar dados

Por padrão, uma consulta recupera todos os documentos que atendem a ela em ordem crescente por ID. Use orderBy() para especificar a ordem de classificação dos dados e limit()para limitar o número de documentos recuperados.

Por exemplo, para consultar as três primeiras cidades em ordem alfabética, use:

Web
citiesRef.orderBy("name").limit(3)
Swift
citiesRef.order(by: "name").limit(to: 3)
Objective-C
[[citiesRef queryOrderedByField:@"name"] queryLimitedTo:3];
  
Java
citiesRef.orderBy("name").limit(3);
Kotlin
citiesRef.orderBy("name").limit(3)
Java
Query query = cities.orderBy("name").limit(3);
Python
db.collection(u'cities').order_by(u'name').limit(3).stream()
Node.js
let firstThree = citiesRef.orderBy('name').limit(3);
Go
query := cities.OrderBy("name", firestore.Asc).Limit(3)
PHP
$query = $citiesRef->orderBy('name')->limit(3);
C#
Query query = citiesRef.OrderBy("Name").Limit(3);
Ruby
query = cities_ref.order("name").limit(3)

Para ver as três últimas cidades, classifique em ordem decrescente:

Web
citiesRef.orderBy("name", "desc").limit(3)
Swift
citiesRef.order(by: "name", descending: true).limit(to: 3)
Objective-C
[[citiesRef queryOrderedByField:@"name" descending:YES] queryLimitedTo:3];
  
Java
citiesRef.orderBy("name", Direction.DESCENDING).limit(3);
Kotlin
citiesRef.orderBy("name", Query.Direction.DESCENDING).limit(3)
Java
Query query = cities.orderBy("name", Direction.DESCENDING).limit(3);
Python
cities_ref = db.collection(u'cities')
query = cities_ref.order_by(
    u'name', direction=firestore.Query.DESCENDING).limit(3)
results = query.stream()
Node.js
let lastThree = citiesRef.orderBy('name', 'desc').limit(3);
Go
query := cities.OrderBy("name", firestore.Desc).Limit(3)
PHP
$query = $citiesRef->orderBy('name', 'DESC')->limit(3);
C#
Query query = citiesRef.OrderByDescending("Name").Limit(3);
Ruby
query = cities_ref.order("name", "desc").limit(3)

Também é possível ordenar por vários campos. Por exemplo, se você quiser ordenar por estado e, em cada ordenação por estado, ordenar por população em ordem decrescente:

Web
citiesRef.orderBy("state").orderBy("population", "desc")
Swift
citiesRef
    .order(by: "state")
    .order(by: "population", descending: true)
Objective-C
[[citiesRef queryOrderedByField:@"state"] queryOrderedByField:@"population" descending:YES];
  
Java
citiesRef.orderBy("state").orderBy("population", Direction.DESCENDING);
Kotlin
citiesRef.orderBy("state").orderBy("population", Query.Direction.DESCENDING)
Java
Query query = cities.orderBy("state").orderBy("population", Direction.DESCENDING);
Python
cities_ref = db.collection(u'cities')
cities_ref.order_by(u'state').order_by(
    u'population', direction=firestore.Query.DESCENDING)
Node.js
let byStateByPop = citiesRef.orderBy('state').orderBy('population', 'desc');
Go
query := client.Collection("cities").OrderBy("state", firestore.Asc).OrderBy("population", firestore.Desc)
PHP
$query = $citiesRef->orderBy('state')->orderBy('population', 'DESC');
C#
Query query = citiesRef.OrderBy("State").OrderByDescending("Population");
Ruby
query = cities_ref.order("state").order("population", "desc")

É possível combinar filtros where() com orderBy() e limit(). No exemplo a seguir, as consultas definem um limite para população, ordenam por esse valor em ordem crescente e retornam apenas os primeiros resultados que excedem o limite:

Web
citiesRef.where("population", ">", 100000).orderBy("population").limit(2)
Swift
citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "population")
    .limit(to: 2)
Objective-C
[[[citiesRef queryWhereField:@"population" isGreaterThan:@100000]
    queryOrderedByField:@"population"]
    queryLimitedTo:2];
  
Java
citiesRef.whereGreaterThan("population", 100000).orderBy("population").limit(2);
Kotlin
citiesRef.whereGreaterThan("population", 100000).orderBy("population").limit(2)
Java
Query query = cities.whereGreaterThan("population", 2500000L).orderBy("population").limit(2);
Python
cities_ref = db.collection(u'cities')
query = cities_ref.where(
    u'population', u'>', 2500000).order_by(u'population').limit(2)
results = query.stream()
Node.js
let biggest = citiesRef.where('population', '>', 2500000)
  .orderBy('population').limit(2);
Go
query := cities.Where("population", ">", 2500000).OrderBy("population", firestore.Desc).Limit(2)
PHP
$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('population')
    ->limit(2);
C#
Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Population")
    .Limit(2);
Ruby
query = cities_ref.where("population", ">", 2_500_000).order("population").limit(2)

No entanto, se você tiver um filtro com uma comparação de intervalo (<, <=, >, >=), será preciso que sua primeira ordenação esteja no mesmo campo:

Válido: filtro de intervalo e orderBy no mesmo campo

Web
citiesRef.where("population", ">", 100000).orderBy("population")
Swift
citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "population")
Objective-C
[[citiesRef queryWhereField:@"population" isGreaterThan:@100000]
    queryOrderedByField:@"population"];
  
Java
citiesRef.whereGreaterThan("population", 100000).orderBy("population");
Kotlin
citiesRef.whereGreaterThan("population", 100000).orderBy("population")
Java
Query query = cities.whereGreaterThan("population", 2500000L).orderBy("population");
Python
cities_ref = db.collection(u'cities')
query = cities_ref.where(
    u'population', u'>', 2500000).order_by(u'population')
results = query.stream()
Node.js
citiesRef.where('population', '>', 2500000).orderBy('population');
Go
query := cities.Where("population", ">", 2500000).OrderBy("population", firestore.Asc)
PHP
$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('population');
C#
Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Population");
Ruby
query = cities_ref.where("population", ">", 2_500_000).order("population")

Inválido: filtro de intervalo e primeiro orderBy em campos diferentes

Web
citiesRef.where("population", ">", 100000).orderBy("country")
Swift
citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "country")
Objective-C
[[citiesRef queryWhereField:@"population" isGreaterThan:@100000] queryOrderedByField:@"country"];
  
Java
citiesRef.whereGreaterThan("population", 100000).orderBy("country");
Kotlin
citiesRef.whereGreaterThan("population", 100000).orderBy("country")
Java
Query query = cities.whereGreaterThan("population", 2500000L).orderBy("country");
Python
cities_ref = db.collection(u'cities')
query = cities_ref.where(u'population', u'>', 2500000).order_by(u'country')
results = query.stream()
Node.js
citiesRef.where('population', '>', 2500000).orderBy('country');
Go
// 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)
PHP
$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('country');
C#
Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Country");
Ruby
query = cities_ref.where("population", ">", 2_500_000).order("country")