Check out what’s new from Firebase@ Google I/O 2021, and join our alpha program for early access to the new Remote Config personalization feature. Learn more

Bestellen und begrenzen Sie Daten mit Cloud Firestore

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

Bestell- und Limitdaten

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

Sie können beispielsweise nach den ersten 3 Städten alphabetisch suchen mit:

Web v8

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

Web v9

import { query, orderBy, limit } from "firebase/firestore";  

const q = query(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
cities_ref = db.collection("cities")
query = cities_ref.order_by("name").limit_to_last(2)
results = query.get()
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)
query := cities.OrderBy("name", firestore.Asc).LimitToLast(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:

Web v8

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

Web v9

import { query, orderBy, limit } from "firebase/firestore";  

const q = query(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:

Web v8

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

Web v9

import { query, orderBy } from "firebase/firestore";  

const q = query(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
05448dez40
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() Filter mit orderBy() und limit() kombinieren. Im folgenden Beispiel definieren die Abfragen einen Bevölkerungsschwellenwert, sortieren nach Bevölkerung in aufsteigender Reihenfolge und geben nur die ersten Ergebnisse zurück, die den Schwellenwert überschreiten:

Web v8

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

Web v9

import { query, where, orderBy, limit } from "firebase/firestore";  

const q = query(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 Bereichsvergleich ( < , <= , > , >= ) verwenden, muss Ihre erste Bestellung im selben Feld erfolgen, siehe die Liste der Einschränkungen für 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 Bereichsvergleich ( < , <= , > , >= ) einschließen, muss Ihre erste Bestellung im selben Feld erfolgen:

    Gültig : orderBy und orderBy im selben Feld

    Web v8

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

    Web v9

    import { query, where, orderBy } from "firebase/firestore";  
    
    const q = query(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 in verschiedenen Feldern

    Web v8

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

    Web v9

    import { query, where, orderBy } from "firebase/firestore";  
    
    const q = query(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
    $invalidRangeQuery = $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 Feldern sortieren, die in einer Gleichheit ( = ) oder in Klausel enthalten sind.