Google is committed to advancing racial equity for Black communities. See how.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Bestellen und begrenzen Sie Daten mit Cloud Firestore

Cloud Firestore bietet leistungsstarke Abfragefunktionen zum Festlegen, welche Dokumente Sie aus einer Sammlung abrufen möchten. Diese Abfragen können auch mit get() oder addSnapshotListener() , wie unter Get Data beschrieben .

Daten bestellen und begrenzen

Standardmäßig ruft eine Abfrage alle Dokumente, die die Abfrage erfüllen, in aufsteigender Reihenfolge nach Dokument-ID ab. Sie können die Sortierreihenfolge für Ihre Daten mit orderBy() angeben und die Anzahl der mit limit() abgerufenen Dokumente limit() .

Sie können beispielsweise die ersten drei Städte alphabetisch abfragen mit:

Netz
citiesRef.orderBy("name").limit(3)
Schnell
citiesRef.order(by: "name").limit(to: 3)
Ziel c
[[citiesRef queryOrderedByField:@"name"] queryLimitedTo:3];
  

Java

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

Kotlin + KTX

citiesRef.orderBy("name").limit(3)
Java
Query query = cities.orderBy("name").limit(3);
Query query = cities.orderBy("name").limitToLast(3);
Python
db.collection(u'cities').order_by(u'name').limit(3).stream()
C ++
cities_ref.OrderBy("name").Limit(3);
  
Node.js
const firstThreeRes = await citiesRef.orderBy('name').limit(3).get();
Gehen
query := cities.OrderBy("name", firestore.Asc).Limit(3)
PHP
$query = $citiesRef->orderBy('name')->limit(3);
Einheit
Query query = citiesRef.OrderBy("Name").Limit(3);
C #
Query query = citiesRef.OrderBy("Name").Limit(3);
Rubin
query = cities_ref.order("name").limit(3)

Sie können auch in absteigender Reihenfolge sortieren, um die letzten 3 Städte zu erhalten:

Netz
citiesRef.orderBy("name", "desc").limit(3)
Schnell
citiesRef.order(by: "name", descending: true).limit(to: 3)
Ziel c
[[citiesRef queryOrderedByField:@"name" descending:YES] queryLimitedTo:3];
  

Java

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

Kotlin + KTX

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()
C ++
cities_ref.OrderBy("name", Query::Direction::kDescending).Limit(3);
  
Node.js
const lastThreeRes = await citiesRef.orderBy('name', 'desc').limit(3).get();
Gehen
query := cities.OrderBy("name", firestore.Desc).Limit(3)
PHP
$query = $citiesRef->orderBy('name', 'DESC')->limit(3);
Einheit
Query query = citiesRef.OrderByDescending("Name").Limit(3);
C #
Query query = citiesRef.OrderByDescending("Name").Limit(3);
Rubin
query = cities_ref.order("name", "desc").limit(3)

Sie können auch nach mehreren Feldern bestellen. Wenn Sie beispielsweise nach Bundesstaat und innerhalb jedes Bundesstaates nach Bevölkerung in absteigender Reihenfolge sortieren möchten:

Netz
citiesRef.orderBy("state").orderBy("population", "desc")
Schnell
citiesRef
    .order(by: "state")
    .order(by: "population", descending: true)
Ziel c
[[citiesRef queryOrderedByField:@"state"] queryOrderedByField:@"population" descending:YES];
  

Java

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

Kotlin + KTX

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)
C ++
cities_ref.OrderBy("state").OrderBy("name", Query::Direction::kDescending);
  
Node.js
const byStateByPopRes = await citiesRef.orderBy('state').orderBy('population', 'desc').get();
Gehen
query := client.Collection("cities").OrderBy("state", firestore.Asc).OrderBy("population", firestore.Desc)
PHP
$query = $citiesRef->orderBy('state')->orderBy('population', 'DESC');
Einheit
Query query = citiesRef.OrderBy("State").OrderByDescending("Population");
C #
Query query = citiesRef.OrderBy("State").OrderByDescending("Population");
Rubin
query = cities_ref.order("state").order("population", "desc")

Sie können where() orderBy() mit orderBy() und limit() kombinieren. Im folgenden Beispiel definieren die Abfragen einen Populationsschwellenwert, sortieren nach Population in aufsteigender Reihenfolge und geben nur die ersten Ergebnisse zurück, die den Schwellenwert überschreiten:

Netz
citiesRef.where("population", ">", 100000).orderBy("population").limit(2)
Schnell
citiesRef
    .whereField("population", isGreaterThan: 100000)
    .order(by: "population")
    .limit(to: 2)
Ziel c
[[[citiesRef queryWhereField:@"population" isGreaterThan:@100000]
    queryOrderedByField:@"population"]
    queryLimitedTo:2];
  

Java

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

Kotlin + KTX

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()
C ++
cities_ref.WhereGreaterThan("population", FieldValue::Integer(100000))
    .OrderBy("population")
    .Limit(2);
  
Node.js
const biggestRes = await citiesRef.where('population', '>', 2500000)
  .orderBy('population').limit(2).get();
Gehen
query := cities.Where("population", ">", 2500000).OrderBy("population", firestore.Desc).Limit(2)
PHP
$query = $citiesRef
    ->where('population', '>', 2500000)
    ->orderBy('population')
    ->limit(2);
Einheit
Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Population")
    .Limit(2);
C #
Query query = citiesRef
    .WhereGreaterThan("Population", 2500000)
    .OrderBy("Population")
    .Limit(2);
Rubin
query = cities_ref.where("population", ">", 2_500_000).order("population").limit(2)

Wenn Sie jedoch einen Filter mit einem Bereichsvergleich ( < , <= , > , >= ) haben, muss sich Ihre erste Bestellung im selben Feld befinden (siehe Liste der Einschränkungen von orderBy() unten).

Einschränkungen

Beachten Sie die folgenden Einschränkungen für orderBy() -Klauseln:

  • Eine orderBy() -Klausel filtert auch nach der Existenz der angegebenen Felder. Die Ergebnismenge enthält keine Dokumente, die die angegebenen Felder nicht enthalten.
  • Wenn Sie einen Filter mit einem Bereichsvergleich ( < , <= , > , >= ) einschließen, muss sich Ihre erste Bestellung im selben Feld befinden:

    Gültig : orderBy und orderBy im selben Feld

    Netz
    citiesRef.where("population", ">", 100000).orderBy("population")
    
    Schnell
    citiesRef
        .whereField("population", isGreaterThan: 100000)
        .order(by: "population")
    
    Ziel c
    [[citiesRef queryWhereField:@"population" isGreaterThan:@100000]
        queryOrderedByField:@"population"];
      

    Java

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

    Kotlin + KTX

    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');
    
    Gehen
    query := cities.Where("population", ">", 2500000).OrderBy("population", firestore.Asc)
    
    PHP
    $query = $citiesRef
        ->where('population', '>', 2500000)
        ->orderBy('population');
    
    Einheit
    Query query = citiesRef
        .WhereGreaterThan("Population", 2500000)
        .OrderBy("Population");
    
    C #
    Query query = citiesRef
        .WhereGreaterThan("Population", 2500000)
        .OrderBy("Population");
    
    Rubin
    query = cities_ref.where("population", ">", 2_500_000).order("population")
    

    Ungültig : orderBy und erste orderBy durch verschiedene Felder

    Netz
    citiesRef.where("population", ">", 100000).orderBy("country")
    
    Schnell
    citiesRef
        .whereField("population", isGreaterThan: 100000)
        .order(by: "country")
    
    Ziel c
    [[citiesRef queryWhereField:@"population" isGreaterThan:@100000] queryOrderedByField:@"country"];
      

    Java

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

    Kotlin + KTX

    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()
    
    C ++
    // BAD EXAMPLE -- will crash the program:
    cities_ref.WhereGreaterThan("population", FieldValue::Integer(100000))
        .OrderBy("country");
      
    Node.js
    citiesRef.where('population', '>', 2500000).orderBy('country');
    
    Gehen
    // 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');
    
    Einheit
    Query query = citiesRef
        .WhereGreaterThan("Population", 2500000)
        .OrderBy("Country");
    
    C #
    Query query = citiesRef
        .WhereGreaterThan("Population", 2500000)
        .OrderBy("Country");
    
    Rubin
    query = cities_ref.where("population", ">", 2_500_000).order("country")
    
  • Sie können Ihre Abfrage nicht nach einem Feld sortieren, das in einer Gleichheit ( = ) oder in Klausel enthalten ist.