Catch up on everthing we announced at this year's Firebase Summit. 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 jedem verwendet werden , get() oder addSnapshotListener() , wie in den Daten importieren .

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 angeben , mit orderBy() , und Sie können die Anzahl der Dokumente begrenzen abgerufen wird limit() .

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

Webversion 9

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

const q = query(citiesRef, orderBy("name"), limit(3));

Webversion 8

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()

Python

cities_ref = db.collection("cities")
query = cities_ref.order_by("name").limit_to_last(2)
results = await 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önnten auch sortieren in absteigender Reihenfolge die letzten drei Städte zu bekommen:

Webversion 9

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

const q = query(citiesRef, orderBy("name", "desc"), limit(3));

Webversion 8

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()

Python

cities_ref = db.collection("cities")
query = cities_ref.order_by("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:

Webversion 9

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

const q = query(citiesRef, orderBy("state"), orderBy("population", "desc"));

Webversion 8

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)

Python

cities_ref = db.collection("cities")
cities_ref.order_by("state").order_by(
    "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 kombinieren where() Filter mit orderBy() und limit() . 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:

Webversion 9

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

const q = query(citiesRef, where("population", ">", 100000), orderBy("population"), limit(2));

Webversion 8

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()

Python

cities_ref = db.collection("cities")
query = cities_ref.where("population", ">", 2500000).order_by("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 ( < , <= , > , >= ), die erste Bestellung auf dem gleichen Feld sein müssen, finden Sie in der Liste der orderBy() Einschränkungen unten.

Einschränkungen

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

  • Eine orderBy() Klausel filtert auch die Existenz der angegebenen Felder. Die Ergebnismenge enthält keine Dokumente, die die angegebenen Felder nicht enthalten.
  • Wenn Sie einen Filter mit einem Bereichsvergleich umfassen ( < , <= , > , >= ), die erste Bestellung auf dem gleichen Feld sein müssen:

    Gültig: Bereichsfilter und orderBy auf dem gleichen Feld

    Webversion 9

    import { query, where, orderBy } from "firebase/firestore";  
    
    const q = query(citiesRef, where("population", ">", 100000), orderBy("population"));

    Webversion 8

    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()

    Python

    cities_ref = db.collection("cities")
    query = cities_ref.where("population", ">", 2500000).order_by("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: Bereichsfilter und erste orderBy auf verschiedenen Feldern

    Webversion 9

    import { query, where, orderBy } from "firebase/firestore";  
    
    const q = query(citiesRef, where("population", ">", 100000), orderBy("country"));

    Webversion 8

    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()

    Python

    cities_ref = db.collection("cities")
    query = cities_ref.where("population", ">", 2500000).order_by("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 Anfrage nach einem beliebigen Feld in einer Gleichheit (nicht enthalten bestellen = ) oder in - Klausel.