Verileri Alma

Bu belge, veritabanı verilerini almanın temellerini, verilerin nasıl sıralanacağını ve veriler üzerinde basit sorguların nasıl gerçekleştirileceğini kapsar. Admin SDK'da veri alma, farklı programlama dillerinde biraz farklı şekilde uygulanır.

1. Eşzamansız dinleyiciler: Firebase Gerçek Zamanlı Veritabanında depolanan veriler, eşzamansız bir dinleyici veritabanı referansına eklenerek alınır. Dinleyici, verilerin ilk durumu için bir kez ve veriler her değiştiğinde tekrar tetiklenir. Bir olay dinleyicisi birkaç farklı tipte olay alabilir. Bu veri alma modu Java, Node.js ve Python Admin SDK'larında desteklenmektedir.
2. Okumaları engelleme: Firebase Realtime Database'de depolanan veriler, referansta depolanan verileri döndüren bir veritabanı referansında bir engelleme yöntemi çağrılarak alınır. Her yöntem çağrısı bir seferlik bir işlemdir. Bu, SDK'nın sonraki veri güncellemelerini dinleyen herhangi bir geri arama kaydetmediği anlamına gelir. Bu veri alma modeli Python ve Go Admin SDK'larında desteklenmektedir.

Başlarken

Bir Firebase veritabanından verilerin nasıl okunacağını anlamak için önceki makaledeki blog örneğini tekrar gözden geçirelim. Örnek uygulamadaki blog gönderilerinin https://docs-examples.firebaseio.com/server/saving-data/fireblog/posts.json veritabanı URL'sinde depolandığını hatırlayın. Gönderi verilerinizi okumak için aşağıdakileri yapabilirsiniz:

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

// Import Admin SDK
var admin = require("firebase-admin");

// Get a database reference to our posts
var db = admin.database();
var ref = db.ref("server/saving-data/fireblog/posts");

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

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

// 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)
}

Yukarıdaki kodu çalıştırırsanız, konsola kaydedilen tüm gönderilerinizi içeren bir nesne görürsünüz. Node.js ve Java söz konusu olduğunda, veritabanı referansınıza her yeni veri eklendiğinde dinleyici işlevi çağrılır ve bunun gerçekleşmesi için herhangi bir ekstra kod yazmanıza gerek yoktur.

Java ve Node.js'de, geri arama işlevi, verilerin anlık görüntüsü olan bir DataSnapshot alır. Anlık görüntü, belirli bir veritabanı referansındaki verilerin zaman içinde tek bir noktadaki bir resmidir. Bir anlık görüntüde val() / getValue() , verilerin dile özgü nesne temsilini döndürür. Referans konumunda veri yoksa anlık görüntünün değeri null . Python'daki get() yöntemi, verilerin doğrudan bir Python temsilini döndürür. Go'daki Get() işlevi, verileri belirli bir veri yapısına göre sıralar.

Yukarıdaki örnekte, yalnızca bir veri parçası değişmiş olsa bile bir Firebase veritabanı referansının tüm içeriğini okuyan value etkinlik türünü kullandığımıza dikkat edin. value , veritabanından veri okumak için kullanabileceğiniz aşağıda listelenen beş farklı olay türünden biridir.

Java ve Node.js'de Etkinlik Türlerini Okuyun

Değer

value olayı, read olayı sırasında var olan belirli bir veritabanı yolundaki içeriğin statik bir anlık görüntüsünü okumak için kullanılır. İlk verilerle bir kez ve veriler her değiştiğinde tekrar tetiklenir. Olay geri araması, alt veriler dahil olmak üzere o konumdaki tüm verileri içeren bir anlık görüntüden geçirilir. Yukarıdaki kod örneğinde, value uygulamanızdaki tüm blog gönderilerini döndürdü. Her yeni blog yazısı eklendiğinde, geri arama işlevi tüm gönderileri döndürür.

Çocuk Eklendi

child_added olayı, genellikle veritabanından bir öğe listesi alınırken kullanılır. child_added tüm içeriğini döndüren value farklı olarak, child_added , mevcut her çocuk için bir kez ve belirtilen yola her yeni çocuk eklendiğinde tekrar tetiklenir. Olay geri araması, yeni çocuğun verilerini içeren bir anlık görüntüden geçirilir. Sipariş verme amacıyla, önceki çocuğun anahtarını içeren ikinci bir argüman da iletilir.

Yalnızca blog uygulamanıza eklenen her yeni child_added verileri almak istiyorsanız, child_added kullanabilirsiniz:

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) {}
});

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

Bu örnekte anlık görüntü, ayrı bir blog gönderisine sahip bir nesne içerecektir. SDK, değeri alarak gönderileri nesnelere dönüştürdüğünden, sırasıyla author ve title çağırarak gönderinin yazarına ve başlık özelliklerine erişebilirsiniz. Ayrıca ikinci prevChildKey bağımsız değişkeninden önceki posta kimliğine de erişebilirsiniz.

Çocuk Değişti

child_changed olayı, bir alt düğüm her değiştirildiğinde tetiklenir. Bu, alt düğümün nesillerindeki tüm değişiklikleri içerir. Genellikle bir öğe listesindeki değişikliklere yanıt vermek için child_added ve child_removed ile birlikte kullanılır. Olay geri aramasına aktarılan anlık görüntü, alt öğe için güncellenmiş verileri içerir.

child_changed , düzenlendiklerinde blog gönderilerindeki güncellenmiş verileri okumak için kullanabilirsiniz:

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) {}
});

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

Çocuk Kaldırıldı

child_removed olayı, hemen bir çocuk kaldırıldığında tetiklenir. Genellikle child_added ve child_changed ile birlikte kullanılır. Olay geri aramasına aktarılan anlık görüntü, kaldırılan alt öğenin verilerini içerir.

Blog örneğinde, konsola silinen gönderi hakkında bir bildirim child_removed için child_removed kullanabilirsiniz:

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) {}
});

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

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

Çocuk Taşındı

child_moved olayı, bir sonraki bölümde ele alınan sıralı verilerle çalışırken kullanılır.

Etkinlik Garantileri

Firebase veritabanı, olaylarla ilgili birkaç önemli garantide bulunur:

Değer olayları her zaman en son tetiklendiğinden, aşağıdaki örnek her zaman işe yarar:

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) {}
});

var count = 0;

ref.on("child_added", function(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", function(snap) {
  console.log("initial data loaded!", snap.numChildren() === count);
});

Geri Aramaları Çıkarma

Geri aramalar, aşağıdaki gibi, olay türü ve kaldırılacak geri arama işlevi belirtilerek kaldırılır:

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

// Remove listener
ref.removeEventListener(listener);

ref.off("value", originalCallback);

Bir kapsam bağlamını on() ilettiyseniz, geri arama çıkarılırken bunun iletilmesi gerekir:

// Not applicable for Java

ref.off("value", originalCallback, this);

Bir konumdaki tüm geri aramaları kaldırmak isterseniz, aşağıdakileri yapabilirsiniz:

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

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

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

Verileri Bir Kez Okuma

Bazı durumlarda, bir geri aramanın bir kez çağrılması ve ardından hemen kaldırılması yararlı olabilir. Bunu kolaylaştırmak için bir yardımcı işlev oluşturduk:

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

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

ref.once("value", function(data) {
  // do some stuff once
});

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

// 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)
}

Verileri Sorgulama

Firebase veritabanı sorgularıyla, çeşitli faktörlere göre verileri seçerek alabilirsiniz. Veritabanınızda bir sorgu oluşturmak için, sıralama işlevlerinden birini kullanarak verilerinizin nasıl sıralanmasını istediğinizi belirterek başlarsınız: orderByChild() , orderByKey() veya orderByValue() . Daha sonra, karmaşık sorgular yürütmek için bunları diğer beş yöntemle birleştirebilirsiniz: limitToFirst() , limitToLast() , startAt() , endAt() ve equalTo() .

Firebase'de hepimiz dinozorların oldukça havalı olduğunu düşündüğümüz için, Firebase veritabanınızdaki verileri nasıl sorgulayabileceğinizi göstermek için dinozor gerçeklerinin örnek bir veritabanından bir snippet kullanacağız .:

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

Verileri üç şekilde sıralayabilirsiniz: alt anahtara göre , anahtara göre veya değere göre . Temel bir veritabanı sorgusu, her biri aşağıda açıklanan bu sıralama işlevlerinden biriyle başlar.

Belirli bir alt anahtara göre sıralama

Düğümleri, bu anahtarı orderByChild() ileterek ortak bir alt anahtara göre orderByChild() . Örneğin, yüksekliğe göre sıralanan tüm dinozorları okumak için aşağıdakileri yapabilirsiniz:

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.");
  }

  // ...
});

var db = firebaseAdmin.database();
var ref = db.ref("dinosaurs");
ref.orderByChild("height").on("child_added", function(snapshot) {
  console.log(snapshot.key + " was " + snapshot.val().height + " meters tall");
});

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

// 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)
}

Sorguladığımız alt anahtara sahip olmayan herhangi bir düğüm null değeriyle sıralanır, yani sıralamada ilk sırada yer alır. Verilerin nasıl sıralandığına ilişkin ayrıntılar için Veriler Nasıl Sıralanır bölümüne bakın .

Sorgular, yalnızca bir seviye altındaki çocuklar yerine, derinlemesine iç içe geçmiş çocuklar tarafından da sıralanabilir. Bu, aşağıdaki gibi derinlemesine iç içe geçmiş verileriniz varsa kullanışlıdır:

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

Yüksekliği şimdi sorgulamak için, tek bir anahtar yerine nesneye giden tam yolu kullanabilirsiniz:

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

  // ...
});

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

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

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

Sorgular bir seferde yalnızca bir anahtarla sıralanabilir. Aynı sorguda orderByChild() birden çok kez çağırmak bir hata atar.

Anahtar ile sıralama

orderByKey() yöntemini kullanarak düğümleri anahtarlarına göre de sipariş edebilirsiniz. Aşağıdaki örnek, tüm dinozorları alfabetik sırayla okur:

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

  // ...
});

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

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

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)

Değere göre sıralama

orderByValue() yöntemini kullanarak düğümleri alt anahtarlarının değerine göre orderByValue() . Diyelim ki dinozorlar bir dino sporu yarışması yapıyor ve puanlarını aşağıdaki formatta takip ediyorsunuz:

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

Dinozorları puanlarına göre sıralamak için aşağıdaki sorguyu oluşturabilirsiniz:

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

  // ...
});

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

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

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

orderByValue() kullanılırken null , boolean, string ve object değerlerinin nasıl sıralandığına ilişkin bir açıklama için Veriler Nasıl orderByValue() .

Karmaşık Sorgular

Verilerinizin nasıl sıralandığı artık netleştiğine göre, daha karmaşık sorgular oluşturmak için aşağıda açıklanan sınır veya aralık yöntemlerini kullanabilirsiniz.

Sorguları Sınırla

limitToFirst() ve limitToLast() sorguları, belirli bir geri arama için senkronize edilecek maksimum çocuk sayısını ayarlamak için kullanılır. 100'lük bir sınır belirlerseniz, başlangıçta yalnızca en fazla 100 child_added olay alırsınız. Veritabanınızda depolanan 100'den az mesajınız varsa, her mesaj için bir child_added olayı child_added . Ancak, 100'den fazla mesajınız varsa, bu mesajların yalnızca child_added için child_added olay alırsınız. Bunlar, limitToFirst() kullanıyorsanız sıralı ilk 100 mesaj veya limitToFirst() kullanıyorsanız son 100 sıralı limitToLast() . Öğeler değiştikçe, sorguyu child_removed öğeler için child_removed olayları ve child_removed öğeler için child_added olayları alırsınız, böylece toplam sayı 100'de kalır.

Dinozor gerçekler veritabanını ve orderByChild() kullanarak en ağır iki dinozoru bulabilirsiniz:

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

  // ...
});

var ref = db.ref("dinosaurs");
ref.orderByChild("weight").limitToLast(2).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});

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

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

Veritabanında depolanmış ikiden az dinozor olmadığı sürece, child_added geri arama tam olarak iki kez tetiklenir. Veritabanına eklenen her yeni, daha ağır dinozor için de ateşlenecek. Python'da, sorgu doğrudan en ağır iki dinozoru içeren bir OrderedDict döndürür.

Benzer şekilde, en kısa iki dinozoru limitToFirst() kullanarak limitToFirst() :

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

  // ...
});

var ref = db.ref("dinosaurs");
ref.orderByChild("height").limitToFirst(2).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});

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

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

Veritabanında depolanmış ikiden az dinozor olmadığı sürece, child_added geri arama tam olarak iki kez tetiklenir. Ayrıca, ilk iki dinozordan biri veri tabanından kaldırılırsa, yeni bir dinozor artık ikinci en kısa dinozor olacağı için tekrar ateşlenecektir. Python'da, sorgu doğrudan en kısa dinozorları içeren bir OrderedDict döndürür.

orderByValue() ile sınır sorguları da orderByValue() . En yüksek puanı alan ilk 3 dino spor dinozorunu içeren bir liderlik tablosu oluşturmak istiyorsanız, aşağıdakileri yapabilirsiniz:

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

  // ...
});

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

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

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

Aralık Sorguları

startAt() , endAt() ve equalTo() , sorgularınız için rastgele başlangıç ​​ve bitiş noktaları seçmenize olanak tanır. Örneğin, en az üç metre uzunluğundaki tüm dinozorları bulmak istiyorsanız, orderByChild() ve startAt() birleştirebilirsiniz:

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

  // ...
});

  var ref = db.ref("dinosaurs");
  ref.orderByChild("height").startAt(3).on("child_added", function(snapshot) {
    console.log(snapshot.key);
  });

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

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

Adları sözlükbilimsel olarak Pterodactyl'den önce gelen tüm dinozorları bulmak için endAt() kullanabilirsiniz:

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

  // ...
});

var ref = db.ref("dinosaurs");
ref.orderByKey().endAt("pterodactyl").on("child_added", function(snapshot) {
  console.log(snapshot.key);
});

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

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

Sorgunuzun her iki ucunu da sınırlamak için startAt() ve endAt() kombinasyonunu startAt() . Aşağıdaki örnek, adı "b" harfiyle başlayan tüm dinozorları bulur:

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

  // ...
});

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

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

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

equalTo() yöntemi, tam eşleşmelere göre filtreleme yapmanızı sağlar. Diğer aralık sorgularında olduğu gibi, eşleşen her bir alt düğüm için tetiklenecektir. Örneğin, 25 metre uzunluğundaki tüm dinozorları bulmak için aşağıdaki sorguyu kullanabilirsiniz:

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

  // ...
});

var ref = db.ref("dinosaurs");
ref.orderByChild("height").equalTo(25).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});

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

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

Verilerinizi sayfalandırmanız gerektiğinde aralık sorguları da kullanışlıdır.

Hepsini bir araya koy

Karmaşık sorgular oluşturmak için tüm bu teknikleri birleştirebilirsiniz. Örneğin, Stegosaurus'tan sadece daha kısa olan dinozorun adını bulabilirsiniz:

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) {
    // ...
  }
});

var ref = db.ref("dinosaurs");
ref.child("stegosaurus").child("height").on("value", function(stegosaurusHeightSnapshot) {
  var favoriteDinoHeight = stegosaurusHeightSnapshot.val();

  var queryRef = ref.orderByChild("height").endAt(favoriteDinoHeight).limitToLast(2)
  queryRef.on("value", function(querySnapshot) {
    if (querySnapshot.numChildren() === 2) {
      // Data is ordered by increasing height, so we want the first entry
      querySnapshot.forEach(function(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");
    }
  });
});

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

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")
}

Veriler Nasıl Sıralanır

Bu bölüm, dört sıralama işlevinin her birini kullanırken verilerinizin nasıl sıralandığını açıklamaktadır.

orderByChild

orderByChild() kullanılırken, belirtilen alt anahtarı içeren veriler şu şekilde sıralanır:

1. Belirtilen alt anahtar için null değeri olan çocuklar önce gelir.
2. Ardından, belirtilen alt anahtar için false değerine sahip çocuklar gelir. Birden fazla çocuk false değerine sahipse, bunlar sözlükbilimsel olarak anahtara göre sıralanır.
3. Ardından, belirtilen alt anahtar için true değerine sahip çocuklar gelir. Birden çok alt öğe true değerine sahipse, bunlar sözlükbilimsel olarak anahtara göre sıralanır.
4. Sırada sayısal değeri olan çocuklar artan sırada sıralanır. Birden çok alt öğe, belirtilen alt düğüm için aynı sayısal değere sahipse, bunlar anahtara göre sıralanır.
5. Dizeler sayılardan sonra gelir ve sözlükbilimsel olarak artan sırada sıralanır. Birden çok çocuk belirtilen alt düğüm için aynı değere sahipse, bunlar sözlükbilimsel olarak anahtarla sıralanır.
6. Nesneler en son gelir ve artan sırada anahtara göre sözlükbilimsel olarak sıralanır.

orderByKey

Verilerinizi sıralamak için orderByKey() kullanılırken, veriler aşağıdaki gibi anahtara göre artan sırada döndürülür. Anahtarların yalnızca dizeler olabileceğini unutmayın.

1. 32 bitlik tamsayı olarak ayrıştırılabilen bir anahtara sahip çocuklar önce gelir, artan sırada sıralanır.
2. Sırada anahtar olarak bir dize değeri olan çocuklar sözlükbilimsel olarak artan sırada sıralanır.

orderByValue

orderByValue() , çocuklar değerlerine göre sıralanır. Sıralama ölçütü, orderByChild() ile aynıdır, tek fark, belirtilen bir alt anahtarın değeri yerine düğümün değerinin kullanılmasıdır.