Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Verileri Alma

Bu belge, veritabanı verilerinin alınması, verilerin nasıl sıralandığı ve veriler üzerinde basit sorguların nasıl gerçekleştirileceği ile ilgili temel bilgileri içerir. Yönetici SDK'sındaki veri alımı, farklı programlama dillerinde biraz farklı şekilde uygulanır.

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

Başlangıç

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 saklandığını unutmayın. Kayıt verilerinizi okumak için aşağıdakileri yapabilirsiniz:

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
// 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);
});
piton
# 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())
Git

// 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 kaydedilmiş tüm yayınlarınızı içeren bir nesne görürsünüz. Node.js ve Java durumunda, veritabanı başvurunuza yeni veriler eklendiğinde dinleyici işlevi çağrılır ve bunun gerçekleşmesi için fazladan kod yazmanız gerekmez.

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ı başvurusundaki verilerin tek bir noktada resmidir. Anlık görüntüde val() / getValue() , verilerin dile özgü nesne temsili döndürülür. Referansın konumunda hiçbir 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ıyla eşleştirir.

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

Java ve Node.js'deki Olay Türlerini Okuyun

değer

value olayı, okuma olayı sırasında var oldukları için 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ına, alt konum verileri de dahil olmak üzere o konumdaki tüm verileri içeren bir anlık görüntü iletilir. Yukarıdaki kod örneğinde, value uygulamanızdaki tüm blog yayınlarını döndürdü. Her yeni blog yazısı eklendiğinde, geri arama işlevi tüm yayınları 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 , varolan her çocuk için bir kez ve sonra belirtilen yola her yeni çocuk eklendiğinde yeniden tetiklenir. Olay geri aramasına, yeni çocuğun verilerini içeren bir anlık görüntü iletilir. Sipariş verme amacıyla, önceki çocuğun anahtarını içeren ikinci bir argüman da iletilir.

child_added uygulamanıza eklenen her yeni yayındaki verileri yalnızca almak istiyorsanız child_added kullanabilirsiniz:

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", 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ü tek bir blog gönderisine sahip bir nesne içerecektir. SDK, değeri alarak iletileri nesnelere dönüştürdüğü için, sırasıyla author ve title çağırarak gönderinin yazar ve başlık özelliklerine erişebilirsiniz. İkinci prevChildKey bağımsız değişkeninden önceki gönderi kimliğine de erişebilirsiniz.

Çocuk Değişti

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

Düzenlendiğinde blog yayınlarındaki güncellenmiş verileri okumak için child_changed kullanabilirsiniz:

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", function(snapshot) {
  var changedPost = snapshot.val();
  console.log("The updated post title is " + changedPost.title);
});

Çocuk Kaldırıldı

Acil bir çocuk kaldırıldığında child_removed olayı tetiklenir. Genellikle child_added ve child_changed ile birlikte kullanılır. Olay geri aramasına iletilen 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:

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
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 garanti verir:

Veritabanı Olay Garantileri
Yerel durum değiştiğinde olaylar her zaman tetiklenir.
Olaylar, yerel işlemlerin veya zamanlamanın ağ bağlantısının geçici olarak kaybedilmesi gibi geçici farklılıklara neden olduğu durumlarda bile her zaman verilerin doğru durumunu yansıtacaktır.
Tek bir istemciden yazma işlemleri her zaman sunucuya yazılır ve sırayla diğer kullanıcılara yayınlanır.
Değer olayları her zaman en son tetiklenir ve bu anlık görüntü çekilmeden önce gerçekleşen diğer tüm olaylardan güncellemeler içereceği garanti edilir.

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

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
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ın Ayrılması

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

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

// Remove listener
ref.removeEventListener(listener);
node.js
ref.off("value", originalCallback);

Bir kapsam bağlamını on() öğesine aktardıysanız, geri arama ayrılırken bu bağlamın geçirilmesi gerekir:

Java
// Not applicable for Java
node.js
ref.off("value", originalCallback, this);

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

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

Verileri Bir Kez Okuma

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

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

  @Override
  public void onCancelled(DatabaseError databaseError) {
    // ...
  }
});
node.js
ref.once("value", function(data) {
  // do some stuff once
});
piton
# 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())
Git
// 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 dayalı olarak verileri seçici olarak alabilirsiniz. Veritabanınızda bir sorgu oluşturmak için, sipariş işlevlerinden birini kullanarak verilerinizin nasıl sıralanmasını istediğinizi belirterek başlarsınız: orderByChild() , orderByKey() veya orderByValue() . Daha sonra bunları karmaşık sorgular yürütmek için diğer beş yöntemle birleştirebilirsiniz: limitToFirst() , limitToLast() , startAt() , endAt() ve equalTo() .

Firebase'deki 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 veritabanından bir pasaj kullanacağız .:

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

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

Belirtilen bir alt anahtarla sipariş verme

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

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

// 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 anahtarı olmayan herhangi bir düğüm null değerine göre sıralanır, yani siparişte ilk sırada gelir. Verilerin nasıl sipariş edildiğiyle ilgili ayrıntılar için Verilerin Nasıl Sipariş Edildiği bölümüne bakın .

Sorgular, yalnızca bir düzeyden küçük çocuklar yerine derin yuvalanmış çocuklar tarafından da sipariş edilebilir. Bunun gibi derinden iç içe geçmiş verileriniz varsa bu yararlı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, nesnenin tam yolunu tek bir anahtar yerine kullanabilirsiniz:

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

  // ...
});
node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("dimensions/height").on("child_added", function(snapshot) {
  console.log(snapshot.key + " was " + snapshot.val().height + " meters tall");
});
piton
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))
Git
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 aynı anda yalnızca bir anahtarla sipariş verebilir. Aynı sorguda orderByChild() birden çok kez çağırmak hata verir.

Anahtarla sipariş verme

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

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", function(snapshot) {
  console.log(snapshot.key);
});
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().get()
print(snapshot)
Git
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 sipariş edebilirsiniz. Dinozorların bir dino spor yarışması düzenlediğini ve puanlarını aşağıdaki biçimde izlediğinizi varsayalım:

{
  "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:

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
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());
  });
});
piton
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))
Git
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, dize ve nesne değerlerinin nasıl sıralandığına ilişkin açıklama için Verilerin Nasıl orderByValue() .

Karmaşık Sorgular

Verilerinizin nasıl sipariş edildiğine göre artık 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 için bir sınır belirlerseniz, başlangıçta en fazla 100 child_added olayı alırsınız. Veritabanınızda 100'den az mesajınız varsa, her mesaj için child_added olayı child_added . Ancak, 100'den fazla iletiniz varsa, bu iletilerin yalnızca child_added için child_added etkinliği alırsınız. Bunlar limitToFirst() kullanıyorsanız ilk 100 sıralı mesaj veya limitToFirst() kullanıyorsanız limitToFirst() son 100 limitToLast() . Öğeler değiştikçe, sorguyu child_removed öğeler için child_removed olaylarını ve child_removed öğeler için child_added olaylarını alırsınız, böylece toplam sayı 100'de kalır.

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

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

  // ...
});
node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("weight").limitToLast(2).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('weight').limit_to_last(2).get()
for key in snapshot:
    print(key)
Git
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 depolanan ikiden az dinozor yoksa, child_added geri child_added tam olarak iki kez tetiklenir. Ayrıca, veritabanına eklenen her yeni, daha ağır dinozor için kovulacak. Python'da, sorgu doğrudan en ağır iki dinozoru içeren bir OrderedDict döndürür.

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

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

  // ...
});
node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("height").limitToFirst(2).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').limit_to_first(2).get()
for key in snapshot:
    print(key)
Git
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 depolanan ikiden az dinozor yoksa, child_added geri child_added tam olarak iki kez tetiklenir. Yeni bir dinozor şimdi en kısa ikinci dinozor olacağından, ilk iki dinozordan biri veritabanından çıkarılırsa da tekrar ateşlenir. Python'da, sorgu doğrudan en kısa dinozorları içeren bir OrderedDict döndürür.

Ayrıca orderByValue() ile sınır sorguları gerçekleştirebilirsiniz. En yüksek puan alan dino spor dinozorlarının bulunduğu bir skor tablosu oluşturmak istiyorsanız, aşağıdakileri yapabilirsiniz:

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
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());
  });
});
piton
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))
Git
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() kullanmak, sorgularınız için isteğe bağlı başlangıç ​​ve bitiş noktalarını seçmenize olanak tanır. Örneğin, en az üç metre yüksekliğindeki tüm dinozorları bulmak istiyorsanız, orderByChild() ve startAt() birleştirebilirsiniz:

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

  // ...
});
node.js
  var ref = db.ref("dinosaurs");
  ref.orderByChild("height").startAt(3).on("child_added", function(snapshot) {
    console.log(snapshot.key);
  });
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').start_at(3).get()
for key in snapshot:
    print(key)
Git
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ı Pterodactyl'den önce sözlükbilimsel olarak gelen tüm dinozorları bulmak için endAt() kullanabilirsiniz:

Java
dinosaursRef.orderByKey().endAt("pterodactyl").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().endAt("pterodactyl").on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().end_at('pterodactyl').get()
for key in snapshot:
    print(key)
Git
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() birleştirebilirsiniz. Aşağıdaki örnek, adı "b" ile başlayan tüm dinozorları bulur:

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", function(snapshot) {
  console.log(snapshot.key);
});
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().start_at('b').end_at(u'b\uf8ff').get()
for key in snapshot:
    print(key)
Git
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, kesin eşleşmelere göre filtrelemenize olanak tanır. Diğer aralık sorgularında olduğu gibi, eşleşen her alt düğüm için tetiklenir. Örneğin, 25 metre yüksekliğindeki tüm dinozorları bulmak için aşağıdaki sorguyu kullanabilirsiniz:

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

  // ...
});
node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("height").equalTo(25).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
piton
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').equal_to(25).get()
for key in snapshot:
    print(key)
Git
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())
}

Aralık sorguları, verilerinizi sayfalandırmanız gerektiğinde de yararlı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:

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
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");
    }
  });
});
piton
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')
Git
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 sipariş işlevinin her birini kullanırken verilerinizin nasıl sıralandığını açıklar.

orderByChild

orderByChild() kullanılırken, belirtilen alt anahtarı içeren veriler aşağıdaki gibi sıralanır:

  1. Belirtilen çocuk anahtarı için null değeri olan çocuklar önce gelir.
  2. Ardından, belirtilen alt anahtar için false değeri olan çocuklar gelir. Birden fazla çocuğun false değeri varsa, anahtar sözcüklere göre sözlükbilimsel olarak sıralanır.
  3. Ardından, belirtilen çocuk anahtarı için true değerine sahip çocuklar gelir. Birden çok çocuğun değeri true , anahtar sözcüklere göre sözlükbilimsel olarak sıralanır.
  4. Sayısal değere sahip çocuklar, artan sırada sıralanmış olarak gelir. Birden çok alt öğe, belirtilen alt düğüm için aynı sayısal değere sahipse, bunlar anahtarlarına göre sıralanır.
  5. Dizeler sayılardan sonra gelir ve sözcük sırasına göre artan sırada sıralanır. Birden çok alt öğe belirtilen alt düğüm için aynı değere sahipse, anahtar sözcükle sözlükbilimsel olarak sıralanır.
  6. Nesneler en son sırada gelir ve anahtar kelimelerle artan sırayla sözlükbilimsel olarak sıralanır.

orderByKey

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

  1. 32 bit tam sayı olarak ayrıştırılabilen bir anahtarı olan çocuklar önce artan düzende sıralanır.
  2. Anahtar olarak dize değerine sahip çocuklar, sözcük sırasına göre artan sırada sıralanır.

orderByValue

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