Daten werden abgerufen

In diesem Dokument werden die Grundlagen des Abrufens von Datenbankdaten, die Sortierung von Daten und die Ausführung einfacher Abfragen zu Daten behandelt. Die Datenabfrage im Admin SDK wird in verschiedenen Programmiersprachen etwas unterschiedlich implementiert.

1. Asynchrone Listener: Daten, die in einer Firebase Realtime Database gespeichert sind, werden abgerufen, indem ein asynchroner Listener an eine Datenbankreferenz angehängt wird. Der Listener wird einmal für den anfänglichen Status der Daten und dann bei jeder Änderung der Daten ausgelöst. Ein Ereignis-Listener kann mehrere Ereignistypen empfangen. Dieser Datenabrufmodus wird in den Admin SDKs für Java, Node.js und Python unterstützt.
2. Blockierende Lesevorgänge: Daten, die in einer Firebase Realtime Database gespeichert sind, werden durch Aufrufen einer blockierenden Methode auf einer Datenbankreferenz abgerufen. Dabei werden die unter der Referenz gespeicherten Daten zurückgegeben. Jeder Methodenaufruf ist ein einmaliger Vorgang. Das SDK registriert also keine Callbacks, die auf nachfolgende Datenaktualisierungen warten. Dieses Datenabrufmodell wird in den Admin SDKs für Python und Go unterstützt.

Das Go Admin SDK unterstützt derzeit nur blockierende Lesevorgänge. Es kann nicht verwendet werden, um Ereignis-Listener hinzuzufügen, die Echtzeit-Aktualisierungsbenachrichtigungen erhalten.

Einstieg

Sehen wir uns noch einmal das Beispiel für das Bloggen aus dem vorherigen Artikel an, um zu verstehen, wie Daten aus einer Firebase-Datenbank gelesen werden. Die Blogbeiträge in der Beispiel-App werden unter der Datenbank-URL https://docs-examples.firebaseio.com/server/saving-data/fireblog/posts.json gespeichert. So rufen Sie Ihre Post-Daten ab:

Java

public static class Post {

  public String author;
  public String title;

  public Post(String author, String title) {
    // ...
  }

}

// Get a reference to our posts
final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog/posts");

// Attach a listener to read the data at our posts reference
ref.addValueEventListener(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    Post post = dataSnapshot.getValue(Post.class);
    System.out.println(post);
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {
    System.out.println("The read failed: " + databaseError.getCode());
  }
});

Node.js

// Get a database reference to our posts
const db = getDatabase();
const ref = db.ref('server/saving-data/fireblog/posts');

// Attach an asynchronous callback to read the data at our posts reference
ref.on('value', (snapshot) => {
  console.log(snapshot.val());
}, (errorObject) => {
  console.log('The read failed: ' + errorObject.name);
}); 

Python

# Import database module.
from firebase_admin import db

# Get a database reference to our posts
ref = db.reference('server/saving-data/fireblog/posts')

# Read the data at the posts reference (this is a blocking operation)
print(ref.get())

Go

// Post is a json-serializable type.
type Post struct {
	Author string `json:"author,omitempty"`
	Title  string `json:"title,omitempty"`
}

// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our posts
ref := client.NewRef("server/saving-data/fireblog/posts")

// Read the data at the posts reference (this is a blocking operation)
var post Post
if err := ref.Get(ctx, &post); err != nil {
	log.Fatalln("Error reading value:", err)
}

In Java und Node.js können Sie einem Ereignisabo einen optionalen Rückruf übergeben, der aufgerufen wird, wenn die Lesevorgänge abgebrochen werden. Ein Lesevorgang wird abgebrochen, wenn der App-Client keine Leseberechtigung für diese Datenbankreferenz hat. Diesem Rückruf wird ein error-Objekt übergeben, das angibt, warum der Fehler aufgetreten ist. In Python und Go schlägt der Vorgang get() / Get() fehl, indem bei einem Fehler eine Ausnahme ausgelöst wird.

Wenn Sie den Code oben ausführen, sehen Sie ein Objekt mit allen Ihren Beiträgen, die in der Konsole protokolliert wurden. Bei Node.js und Java wird die Listenerfunktion immer dann aufgerufen, wenn Ihrer Datenbankreferenz neue Daten hinzugefügt werden. Dazu müssen Sie keinen zusätzlichen Code schreiben.

In Java und Node.js erhält die Callback-Funktion einen DataSnapshot, also einen Snapshot der Daten. Ein Snapshot ist ein Abbild der Daten zu einer bestimmten Datenbankreferenz zu einem bestimmten Zeitpunkt. Wenn Sie val() / getValue() auf einen Snapshot anwenden, wird eine sprachspezifische Objektdarstellung der Daten zurückgegeben. Wenn an der Position der Referenz keine Daten vorhanden sind, ist der Wert des Snapshots null. Die Methode get() in Python gibt direkt eine Python-Darstellung der Daten zurück. Die Funktion Get() in Go unmarshals die Daten in eine bestimmte Datenstruktur.

Im Beispiel oben haben wir den Ereignistyp value verwendet, bei dem der gesamte Inhalt einer Firebase-Datenbankreferenz gelesen wird, auch wenn sich nur ein Datenelement geändert hat. value ist einer der fünf unten aufgeführten Ereignistypen, mit denen Sie Daten aus der Datenbank lesen können.

Ereignistypen in Java und Node.js lesen

Wert

Mit dem Ereignis value wird ein statischer Snapshot des Inhalts an einem bestimmten Datenbankpfad gelesen, wie er zum Zeitpunkt des Leseereignisses vorhanden war. Er wird einmal mit den ursprünglichen Daten und dann bei jeder Änderung der Daten ausgelöst. Dem Ereignis-Callback wird ein Snapshot mit allen Daten an diesem Speicherort übergeben, einschließlich untergeordneter Daten. Im obigen Codebeispiel gab value alle Blogbeiträge in Ihrer App zurück. Jedes Mal, wenn ein neuer Blogbeitrag hinzugefügt wird, gibt die Callback-Funktion alle Beiträge zurück.

Untergeordneter hinzugefügt

Das Ereignis child_added wird in der Regel verwendet, wenn eine Liste von Elementen aus der Datenbank abgerufen wird. Im Gegensatz zu value, das den gesamten Inhalt des Speicherorts zurückgibt, wird child_added einmal für jedes vorhandene untergeordnete Element und dann jedes Mal wieder ausgelöst, wenn dem angegebenen Pfad ein neues untergeordnetes Element hinzugefügt wird. Dem Ereignis-Callback wird ein Snapshot mit den Daten des neuen Kindes übergeben. Für die Sortierung wird auch ein zweites Argument übergeben, das den Schlüssel des vorherigen untergeordneten Elements enthält.

Wenn Sie nur die Daten zu jedem neuen Beitrag abrufen möchten, der Ihrer Blogging-App hinzugefügt wurde, können Sie child_added verwenden:

Java

ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    Post newPost = dataSnapshot.getValue(Post.class);
    System.out.println("Author: " + newPost.author);
    System.out.println("Title: " + newPost.title);
    System.out.println("Previous Post ID: " + prevChildKey);
  }

  @Override
  public void onChildChanged(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildRemoved(DataSnapshot dataSnapshot) {}

  @Override
  public void onChildMoved(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});

Node.js

// Retrieve new posts as they are added to our database
ref.on('child_added', (snapshot, prevChildKey) => {
  const newPost = snapshot.val();
  console.log('Author: ' + newPost.author);
  console.log('Title: ' + newPost.title);
  console.log('Previous Post ID: ' + prevChildKey);
});

In diesem Beispiel enthält der Snapshot ein Objekt mit einem einzelnen Blogpost. Da das SDK Beiträge in Objekte umwandelt, indem es den Wert abruft, hast du Zugriff auf die Eigenschaften „Autor“ und „Titel“ des Beitrags, indem du author bzw. title aufrufst. Über das zweite prevChildKey-Argument hast du auch Zugriff auf die ID des vorherigen Beitrags.

Kind geändert

Das Ereignis child_changed wird jedes Mal ausgelöst, wenn ein untergeordneter Knoten geändert wird. Dazu gehören auch alle Änderungen an Nachkommen des untergeordneten Knotens. Sie wird in der Regel in Verbindung mit child_added und child_removed verwendet, um auf Änderungen an einer Liste von Elementen zu reagieren. Der an den Ereignis-Callback übergebene Snapshot enthält die aktualisierten Daten für das untergeordnete Element.

Mit child_changed können Sie aktualisierte Daten in Blogposts lesen, wenn sie bearbeitet werden:

Java

ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildChanged(DataSnapshot dataSnapshot, String prevChildKey) {
    Post changedPost = dataSnapshot.getValue(Post.class);
    System.out.println("The updated post title is: " + changedPost.title);
  }

  @Override
  public void onChildRemoved(DataSnapshot dataSnapshot) {}

  @Override
  public void onChildMoved(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});

Node.js

// Get the data on a post that has changed
ref.on('child_changed', (snapshot) => {
  const changedPost = snapshot.val();
  console.log('The updated post title is ' + changedPost.title);
});

Kind entfernt

Das Ereignis child_removed wird ausgelöst, wenn ein unmittelbares untergeordnetes Element entfernt wird. Sie wird in der Regel in Kombination mit child_added und child_changed verwendet. Der Snapshot, der an den Ereignis-Callback übergeben wird, enthält die Daten für das entfernte untergeordnete Element.

Im Blogbeispiel können Sie mit child_removed eine Benachrichtigung über den gelöschten Beitrag in der Konsole protokollieren:

Java

ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildChanged(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildRemoved(DataSnapshot dataSnapshot) {
    Post removedPost = dataSnapshot.getValue(Post.class);
    System.out.println("The blog post titled " + removedPost.title + " has been deleted");
  }

  @Override
  public void onChildMoved(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});

Node.js

// Get a reference to our posts
const ref = db.ref('server/saving-data/fireblog/posts');

// Get the data on a post that has been removed
ref.on('child_removed', (snapshot) => {
  const deletedPost = snapshot.val();
  console.log('The blog post titled \'' + deletedPost.title + '\' has been deleted');
});

Untergeordnetes Element ist umgezogen

Das Ereignis child_moved wird bei der Arbeit mit sortierten Daten verwendet. Weitere Informationen finden Sie im nächsten Abschnitt.

Veranstaltungsgarantien

Die Firebase-Datenbank bietet mehrere wichtige Garantien für Ereignisse:

Garantien für Datenbankereignisse
Ereignisse werden immer ausgelöst, wenn sich der lokale Status ändert.
Ereignisse spiegeln immer den korrekten Status der Daten wider, auch wenn lokale Vorgänge oder das Timing zu vorübergehenden Abweichungen führen, z. B. bei einem vorübergehenden Verlust der Netzwerkverbindung.
Schreibvorgänge von einem einzelnen Client werden immer auf den Server geschrieben und in der richtigen Reihenfolge an andere Nutzer gesendet.
Wertereignisse werden immer als Letztes ausgelöst und enthalten garantiert Aktualisierungen von allen anderen Ereignissen, die vor diesem Snapshot stattgefunden haben.

Da Wert-Ereignisse immer als letztes ausgelöst werden, funktioniert das folgende Beispiel immer:

Java

final AtomicInteger count = new AtomicInteger();

ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    // New child added, increment count
    int newCount = count.incrementAndGet();
    System.out.println("Added " + dataSnapshot.getKey() + ", count is " + newCount);
  }

  // ...
});

// The number of children will always be equal to 'count' since the value of
// the dataSnapshot here will include every child_added event triggered before this point.
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    long numChildren = dataSnapshot.getChildrenCount();
    System.out.println(count.get() + " == " + numChildren);
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});

Node.js

let count = 0;

ref.on('child_added', (snap) => {
  count++;
  console.log('added:', snap.key);
});

// length will always equal count, since snap.val() will include every child_added event
// triggered before this point
ref.once('value', (snap) => {
  console.log('initial data loaded!', snap.numChildren() === count);
});

Callbacks trennen

Callbacks werden entfernt, indem der Ereignistyp und die zu entfernende Callback-Funktion angegeben werden, z. B. so:

Java

// Create and attach listener
ValueEventListener listener = new ValueEventListener() {
    // ...
};
ref.addValueEventListener(listener);

// Remove listener
ref.removeEventListener(listener);

Node.js

ref.off('value', originalCallback);

Wenn Sie einen Kontext übergeben haben, muss dieser auch beim Trennen des Rückrufs übergeben werden:on()

Java

// Not applicable for Java

Node.js

ref.off('value', originalCallback, ctx);

Wenn einem Datenspeicherplatz ein Rückruf mehrmals hinzugefügt wurde, wird er für jedes Ereignis mehrmals aufgerufen. Sie müssen ihn mehrmals trennen, um ihn vollständig zu entfernen.

So entfernen Sie alle Rückrufe an einem Standort:

Java

// No Java equivalent, listeners must be removed individually.

Node.js

// Remove all value callbacks
ref.off('value');

// Remove all callbacks of any type
ref.off();

Daten einmal lesen

In einigen Fällen kann es nützlich sein, einen Rückruf einmal aufzurufen und dann sofort zu entfernen. Wir haben eine Hilfsfunktion erstellt, die Ihnen dabei hilft:

Java

ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    // ...
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {
    // ...
  }
});

Node.js

ref.once('value', (data) => {
  // do some stuff once
});

Python

# Import database module.
from firebase_admin import db

# Get a database reference to our posts
ref = db.reference('server/saving-data/fireblog/posts')

# Read the data at the posts reference (this is a blocking operation)
print(ref.get())

Go

// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our posts
ref := client.NewRef("server/saving-data/fireblog/posts")

// Read the data at the posts reference (this is a blocking operation)
var post Post
if err := ref.Get(ctx, &post); err != nil {
	log.Fatalln("Error reading value:", err)
}

Daten abfragen

Mit Firebase-Datenbankabfragen können Sie Daten anhand verschiedener Faktoren selektiv abrufen. Wenn Sie eine Abfrage in Ihrer Datenbank erstellen, müssen Sie zuerst mit einer der Sortierfunktionen angeben, wie Ihre Daten sortiert werden sollen: orderByChild(), orderByKey() oder orderByValue(). Sie können diese dann mit fünf weiteren Methoden kombinieren, um komplexe Abfragen durchzuführen: limitToFirst(), limitToLast(), startAt(), endAt() und equalTo().

Da wir bei Firebase Dinosaurier ziemlich cool finden, verwenden wir ein Snippet aus einer Beispieldatenbank mit Dinosaurierfakten, um zu zeigen, wie Sie Daten in Ihrer Firebase-Datenbank abfragen können:

{
  "lambeosaurus": {
    "height" : 2.1,
    "length" : 12.5,
    "weight": 5000
  },
  "stegosaurus": {
    "height" : 4,
    "length" : 9,
    "weight" : 2500
  }
}

Sie können Daten auf drei Arten sortieren: nach untergeordnetem Schlüssel, nach Schlüssel oder nach Wert. Eine grundlegende Datenbankabfrage beginnt mit einer dieser Sortierfunktionen, die unten erläutert werden.

Nach einem bestimmten untergeordneten Schlüssel sortieren

Sie können Knoten nach einem gemeinsamen untergeordneten Schlüssel sortieren, indem Sie diesen Schlüssel an orderByChild() übergeben. Wenn Sie beispielsweise alle Dinosaurier nach Größe sortiert abrufen möchten, gehen Sie so vor:

Java

public static class Dinosaur {

  public int height;
  public int weight;

  public Dinosaur(int height, int weight) {
    // ...
  }

}

final DatabaseReference dinosaursRef = database.getReference("dinosaurs");
dinosaursRef.orderByChild("height").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    Dinosaur dinosaur = dataSnapshot.getValue(Dinosaur.class);
    System.out.println(dataSnapshot.getKey() + " was " + dinosaur.height + " meters tall.");
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');

ref.orderByChild('height').on('child_added', (snapshot) => {
  console.log(snapshot.key + ' was ' + snapshot.val().height + ' meters tall');
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').get()
for key, val in snapshot.items():
    print('{0} was {1} meters tall'.format(key, val))

Go

// Dinosaur is a json-serializable type.
type Dinosaur struct {
	Height int `json:"height"`
	Width  int `json:"width"`
}

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var d Dinosaur
	if err := r.Unmarshal(&d); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("%s was %d meteres tall", r.Key(), d.Height)
}

Alle Knoten, die nicht den untergeordneten Schlüssel haben, auf den wir eine Abfrage ausführen, werden mit dem Wert null sortiert. Das bedeutet, dass sie an erster Stelle in der Sortierung stehen. Weitere Informationen zur Sortierung von Daten finden Sie im Abschnitt Sortierung von Daten.

Abfragen können auch nach tief verschachtelten untergeordneten Elementen sortiert werden, nicht nur nach untergeordneten Elementen auf einer Ebene. Das ist nützlich, wenn Sie verschachtelte Daten wie diese haben:

{
  "lambeosaurus": {
    "dimensions": {
      "height" : 2.1,
      "length" : 12.5,
      "weight": 5000
    }
  },
  "stegosaurus": {
    "dimensions": {
      "height" : 4,
      "length" : 9,
      "weight" : 2500
    }
  }
}

Wenn Sie die Höhe jetzt abfragen möchten, können Sie den vollständigen Pfad zum Objekt anstelle eines einzelnen Schlüssels verwenden:

Java

dinosaursRef.orderByChild("dimensions/height").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    // ...
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');
ref.orderByChild('dimensions/height').on('child_added', (snapshot) => {
  console.log(snapshot.key + ' was ' + snapshot.val().height + ' meters tall');
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('dimensions/height').get()
for key, val in snapshot.items():
    print('{0} was {1} meters tall'.format(key, val))

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("dimensions/height").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var d Dinosaur
	if err := r.Unmarshal(&d); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("%s was %d meteres tall", r.Key(), d.Height)
}

Abfragen können nur nach einem Schlüssel sortiert werden. Wenn orderByChild() mehrmals für dieselbe Abfrage aufgerufen wird, wird ein Fehler ausgegeben.

Indexe für eine bessere Leistung verwenden

Wenn Sie orderByChild() in einer Produktions-App verwenden möchten, sollten Sie die Schlüssel, die Sie indexieren, in Ihren Sicherheits- und Firebase-Regeln über die .indexOn-Regel definieren. Sie können diese Abfragen zwar ad hoc auf dem Client erstellen, die Leistung wird jedoch deutlich verbessert, wenn Sie .indexOn verwenden. Weitere Informationen finden Sie in der Dokumentation zur Regel .indexOn.

Nach Schlüssel sortieren

Mit der orderByKey()-Methode können Sie Knoten auch nach ihren Schlüsseln sortieren. Im folgenden Beispiel werden alle Dinosaurier in alphabetischer Reihenfolge gelesen:

Java

dinosaursRef.orderByKey().addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

var ref = db.ref('dinosaurs');
ref.orderByKey().on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().get()
print(snapshot)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByKey().GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
snapshot := make([]Dinosaur, len(results))
for i, r := range results {
	var d Dinosaur
	if err := r.Unmarshal(&d); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	snapshot[i] = d
}
fmt.Println(snapshot)

Nach Wert sortieren

Mit der Methode orderByValue() können Sie Knoten nach dem Wert ihrer untergeordneten Schlüssel sortieren. Angenommen, die Dinosaurier veranstalten einen Dino-Sportwettbewerb und Sie führen die Punkte im folgenden Format auf:

{
  "scores": {
    "bruhathkayosaurus" : 55,
    "lambeosaurus" : 21,
    "linhenykus" : 80,
    "pterodactyl" : 93,
    "stegosaurus" : 5,
    "triceratops" : 22
  }
}

Wenn Sie die Dinosaurier nach ihrem Wert sortieren möchten, könnten Sie die folgende Abfrage erstellen:

Java

DatabaseReference scoresRef = database.getReference("scores");
scoresRef.orderByValue().addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println("The " + dataSnapshot.getKey() + " score is " + dataSnapshot.getValue());
  }

  // ...
});

Node.js

const scoresRef = db.ref('scores');
scoresRef.orderByValue().on('value', (snapshot) => {
  snapshot.forEach((data) => {
    console.log('The ' + data.key + ' dinosaur\'s score is ' + data.val());
  });
});

Python

ref = db.reference('scores')
snapshot = ref.order_by_value().get()
for key, val in snapshot.items():
    print('The {0} dinosaur\'s score is {1}'.format(key, val))

Go

ref := client.NewRef("scores")

results, err := ref.OrderByValue().GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var score int
	if err := r.Unmarshal(&score); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("The %s dinosaur's score is %d\n", r.Key(), score)
}

Im Abschnitt Sortierung von Daten wird erläutert, wie null-, boolesche, String- und Objektwerte bei Verwendung von orderByValue() sortiert werden.

Indexierung nach Werten für eine bessere Leistung

Wenn Sie orderByValue() in einer Produktions-App verwenden möchten, sollten Sie .value an der entsprechenden Stelle in Ihren Regeln hinzufügen. Weitere Informationen finden Sie in der Dokumentation zur Regel .indexOn.

Komplexe Abfragen

Nachdem Sie nun wissen, wie Ihre Daten sortiert sind, können Sie mit den unten beschriebenen Methoden limit oder range komplexere Abfragen erstellen.

Abfragen begrenzen

Mit den Abfragen limitToFirst() und limitToLast() wird die maximale Anzahl der Kinder festgelegt, die für einen bestimmten Rückruf synchronisiert werden sollen. Wenn Sie ein Limit von 100 festlegen, erhalten Sie anfangs nur bis zu 100 child_added-Ereignisse. Wenn in Ihrer Datenbank weniger als 100 Nachrichten gespeichert sind, wird für jede Nachricht ein child_added-Ereignis ausgelöst. Wenn Sie jedoch mehr als 100 Nachrichten haben, erhalten Sie nur für 100 dieser Nachrichten ein child_added-Ereignis. Das sind die ersten 100 sortierten Nachrichten, wenn Sie limitToFirst() verwenden, oder die letzten 100 sortierten Nachrichten, wenn Sie limitToLast() verwenden. Wenn sich Artikel ändern, erhalten Sie child_added Ereignisse für Artikel, die in die Abfrage aufgenommen werden, und child_removed Ereignisse für Artikel, die sie verlassen. Die Gesamtzahl bleibt also bei 100.

Mithilfe der Datenbank mit Dinosaurierfakten und orderByChild() können Sie die beiden schwersten Dinosaurier finden:

Java

dinosaursRef.orderByChild("weight").limitToLast(2).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');
ref.orderByChild('weight').limitToLast(2).on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('weight').limit_to_last(2).get()
for key in snapshot:
    print(key)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("weight").LimitToLast(2).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

Der child_added-Callback wird genau zweimal ausgelöst, es sei denn, in der Datenbank sind weniger als zwei Dinosaurier gespeichert. Außerdem wird sie für jeden neuen, schwereren Dinosaurier ausgelöst, der der Datenbank hinzugefügt wird. In Python gibt die Abfrage direkt eine OrderedDict mit den beiden schwersten Dinosauriern zurück.

So finden Sie mit limitToFirst() die beiden kürzesten Dinosaurier:

Java

dinosaursRef.orderByChild("weight").limitToFirst(2).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');
ref.orderByChild('height').limitToFirst(2).on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').limit_to_first(2).get()
for key in snapshot:
    print(key)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").LimitToFirst(2).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

Der child_added-Callback wird genau zweimal ausgelöst, es sei denn, in der Datenbank sind weniger als zwei Dinosaurier gespeichert. Außerdem wird er noch einmal ausgelöst, wenn einer der ersten beiden Dinosaurier aus der Datenbank entfernt wird, da dann ein neuer Dinosaurier der zweitkürzeste ist. In Python gibt die Abfrage direkt ein OrderedDict mit den kürzesten Dinosauriern zurück.

Sie können mit orderByValue() auch Abfragen mit Begrenzungen ausführen. Wenn Sie eine Bestenliste mit den drei Dinosauriern mit den meisten Punkten erstellen möchten, gehen Sie so vor:

Java

scoresRef.orderByValue().limitToFirst(3).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println("The " + dataSnapshot.getKey() + " score is " + dataSnapshot.getValue());
  }

  // ...
});

Node.js

const scoresRef = db.ref('scores');
scoresRef.orderByValue().limitToLast(3).on('value', (snapshot)  =>{
  snapshot.forEach((data) => {
    console.log('The ' + data.key + ' dinosaur\'s score is ' + data.val());
  });
});

Python

scores_ref = db.reference('scores')
snapshot = scores_ref.order_by_value().limit_to_last(3).get()
for key, val in snapshot.items():
    print('The {0} dinosaur\'s score is {1}'.format(key, val))

Go

ref := client.NewRef("scores")

results, err := ref.OrderByValue().LimitToLast(3).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var score int
	if err := r.Unmarshal(&score); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("The %s dinosaur's score is %d\n", r.Key(), score)
}

Bereichsabfragen

Mit startAt(), endAt() und equalTo() können Sie beliebige Start- und Endpunkte für Ihre Abfragen auswählen. Wenn Sie beispielsweise alle Dinosaurier finden möchten, die mindestens drei Meter hoch sind, können Sie orderByChild() und startAt() kombinieren:

Java

dinosaursRef.orderByChild("height").startAt(3).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');
ref.orderByChild('height').startAt(3).on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').start_at(3).get()
for key in snapshot:
    print(key)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").StartAt(3).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

Mit endAt() können Sie alle Dinosaurier finden, deren Namen lexikalisch vor „Pterodactyl“ stehen:

Java

dinosaursRef.orderByKey().endAt("pterodactyl").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');
ref.orderByKey().endAt('pterodactyl').on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().end_at('pterodactyl').get()
for key in snapshot:
    print(key)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByKey().EndAt("pterodactyl").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

startAt() und endAt() sind inkludierend. Das bedeutet, dass „Pterodactyl“ mit der obigen Suchanfrage übereinstimmt.

Sie können startAt() und endAt() kombinieren, um beide Enden der Abfrage einzugrenzen. Im folgenden Beispiel werden alle Dinosaurier gefunden, deren Name mit dem Buchstaben „b“ beginnt:

Java

dinosaursRef.orderByKey().startAt("b").endAt("b\uf8ff").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

var ref = db.ref('dinosaurs');
ref.orderByKey().startAt('b').endAt('b\uf8ff').on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().start_at('b').end_at(u'b\uf8ff').get()
for key in snapshot:
    print(key)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByKey().StartAt("b").EndAt("b\uf8ff").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

Das Zeichen \uf8ff in der obigen Abfrage hat einen sehr hohen Codepunkt im Unicode-Bereich. Da es sich nach den meisten regulären Zeichen in Unicode befindet, werden mit der Abfrage alle Werte gefunden, die mit einem „b“ beginnen.

Mit der Methode equalTo() können Sie nach genauen Übereinstimmungen filtern. Wie bei den anderen Bereichsabfragen wird sie für jeden übereinstimmenden untergeordneten Knoten ausgelöst. Mit der folgenden Abfrage können Sie beispielsweise alle Dinosaurier finden, die 25 Meter hoch sind:

Java

dinosaursRef.orderByChild("height").equalTo(25).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});

Node.js

const ref = db.ref('dinosaurs');
ref.orderByChild('height').equalTo(25).on('child_added', (snapshot) => {
  console.log(snapshot.key);
});

Python

ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').equal_to(25).get()
for key in snapshot:
    print(key)

Go

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").EqualTo(25).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

Bereichsabfragen sind auch nützlich, wenn Sie Ihre Daten auf Seiten aufteilen möchten.

Sie können orderByValue() auch mit startAt() und endAt() kombinieren, um Bereichsabfragen zu erstellen.

Zusammenfassung

Sie können alle diese Techniken kombinieren, um komplexe Abfragen zu erstellen. So können Sie beispielsweise den Namen des Dinosauriers finden, der nur etwas kürzer als Stegosaurus ist:

Java

dinosaursRef.child("stegosaurus").child("height").addValueEventListener(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot stegoHeightSnapshot) {
    Integer favoriteDinoHeight = stegoHeightSnapshot.getValue(Integer.class);
    Query query = dinosaursRef.orderByChild("height").endAt(favoriteDinoHeight).limitToLast(2);
    query.addValueEventListener(new ValueEventListener() {
      @Override
      public void onDataChange(DataSnapshot dataSnapshot) {
        // Data is ordered by increasing height, so we want the first entry
        DataSnapshot firstChild = dataSnapshot.getChildren().iterator().next();
        System.out.println("The dinosaur just shorter than the stegosaurus is: " + firstChild.getKey());
      }

      @Override
      public void onCancelled(DatabaseError databaseError) {
        // ...
      }
    });
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {
    // ...
  }
});

Node.js

  const ref = db.ref('dinosaurs');
  ref.child('stegosaurus').child('height').on('value', (stegosaurusHeightSnapshot) => {
    const favoriteDinoHeight = stegosaurusHeightSnapshot.val();

    const queryRef = ref.orderByChild('height').endAt(favoriteDinoHeight).limitToLast(2);
    queryRef.on('value', (querySnapshot) => {
      if (querySnapshot.numChildren() === 2) {
        // Data is ordered by increasing height, so we want the first entry
        querySnapshot.forEach((dinoSnapshot) => {
          console.log('The dinosaur just shorter than the stegasaurus is ' + dinoSnapshot.key);

          // Returning true means that we will only loop through the forEach() one time
          return true;
        });
      } else {
        console.log('The stegosaurus is the shortest dino');
      }
    });
});

Python

ref = db.reference('dinosaurs')
favotire_dino_height = ref.child('stegosaurus').child('height').get()
query = ref.order_by_child('height').end_at(favotire_dino_height).limit_to_last(2)
snapshot = query.get()
if len(snapshot) == 2:
    # Data is ordered by increasing height, so we want the first entry.
    # Second entry is stegosarus.
    for key in snapshot:
        print('The dinosaur just shorter than the stegosaurus is {0}'.format(key))
        return
else:
    print('The stegosaurus is the shortest dino')

Go

ref := client.NewRef("dinosaurs")

var favDinoHeight int
if err := ref.Child("stegosaurus").Child("height").Get(ctx, &favDinoHeight); err != nil {
	log.Fatalln("Error querying database:", err)
}

query := ref.OrderByChild("height").EndAt(favDinoHeight).LimitToLast(2)
results, err := query.GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
if len(results) == 2 {
	// Data is ordered by increasing height, so we want the first entry.
	// Second entry is stegosarus.
	fmt.Printf("The dinosaur just shorter than the stegosaurus is %s\n", results[0].Key())
} else {
	fmt.Println("The stegosaurus is the shortest dino")
}

Sortierung von Daten

In diesem Abschnitt wird beschrieben, wie Ihre Daten bei Verwendung der vier Sortierfunktionen sortiert werden.

orderByChild

Bei Verwendung von orderByChild() werden Daten, die den angegebenen untergeordneten Schlüssel enthalten, so sortiert:

1. Untergeordnete Elemente mit einem null-Wert für den angegebenen untergeordneten Schlüssel werden zuerst angezeigt.
2. Als Nächstes folgen untergeordnete Elemente mit dem Wert false für den angegebenen untergeordneten Schlüssel. Wenn mehrere untergeordnete Elemente den Wert false haben, werden sie lexikografisch nach Schlüssel sortiert.
3. Als Nächstes folgen untergeordnete Elemente mit dem Wert true für den angegebenen untergeordneten Schlüssel. Wenn mehrere untergeordnete Elemente den Wert true haben, werden sie nach Schlüssel sortiert.
4. Als Nächstes folgen untergeordnete Elemente mit einem numerischen Wert, sortiert in aufsteigender Reihenfolge. Wenn mehrere untergeordnete Elemente denselben numerischen Wert für den angegebenen untergeordneten Knoten haben, werden sie nach Schlüssel sortiert.
5. Strings folgen nach Zahlen und werden lexikografisch in aufsteigender Reihenfolge sortiert. Wenn mehrere untergeordnete Elemente denselben Wert für den angegebenen untergeordneten Knoten haben, werden sie nach Schlüssel sortiert.
6. Objekte kommen zuletzt und werden in aufsteigender lexikografischer Reihenfolge nach Schlüssel sortiert.

orderByKey

Wenn Sie Ihre Daten mit orderByKey() sortieren, werden sie in aufsteigender Reihenfolge nach Schlüssel zurückgegeben. Schlüssel können nur Strings sein.

1. Untergeordnete Elemente mit einem Schlüssel, der als 32‑Bit-Ganzzahl geparst werden kann, werden zuerst in aufsteigender Reihenfolge sortiert.
2. Als Nächstes folgen untergeordnete Elemente mit einem Stringwert als Schlüssel, sortiert in aufsteigender lexikografischer Reihenfolge.

orderByValue

Bei Verwendung von orderByValue() werden untergeordnete Elemente nach ihrem Wert sortiert. Die Sortierkriterien sind dieselben wie bei orderByChild(), mit der Ausnahme, dass der Wert des Knotens anstelle des Werts eines angegebenen untergeordneten Schlüssels verwendet wird.