กำลังดึงข้อมูล

เอกสารนี้ครอบคลุมพื้นฐานของการดึงข้อมูลฐานข้อมูล วิธีการจัดเรียงข้อมูล และวิธีทำการค้นหาอย่างง่ายในข้อมูล การดึงข้อมูลใน Admin SDK จะมีการนำไปใช้งานแตกต่างกันเล็กน้อยในภาษาโปรแกรมต่างๆ

1. เครื่องมือฟังแบบอะซิงโครนัส: ระบบจะเรียกข้อมูลที่เก็บไว้ใน Firebase Realtime Database โดยการแนบเครื่องมือฟังแบบอะซิงโครนัสกับ การอ้างอิงฐานข้อมูล ระบบจะเรียกใช้ Listener 1 ครั้งสำหรับสถานะเริ่มต้นของข้อมูล และ อีกครั้งเมื่อใดก็ตามที่ข้อมูลมีการเปลี่ยนแปลง เครื่องมือฟังเหตุการณ์อาจได้รับประเภทเหตุการณ์ที่แตกต่างกันหลายรายการ โหมดการดึงข้อมูลนี้รองรับ ใน Java, Node.js และ Python Admin SDK
2. การอ่านแบบบล็อก: ระบบจะเรียกข้อมูลที่จัดเก็บไว้ใน Firebase Realtime Database โดยการเรียกใช้เมธอดการบล็อกในการอ้างอิงฐานข้อมูล ซึ่งจะแสดงผลข้อมูลที่จัดเก็บไว้ในการอ้างอิง การเรียกใช้แต่ละเมธอดเป็นการดำเนินการแบบครั้งเดียว ซึ่งหมายความว่า SDK จะไม่ลงทะเบียนการเรียกกลับใดๆ ที่รับฟังการอัปเดตข้อมูลในภายหลัง SDK ผู้ดูแลระบบ Python และ Go รองรับรูปแบบการดึงข้อมูลนี้

ปัจจุบัน Go Admin SDK รองรับเฉพาะการบล็อกการอ่าน ใช้เพื่อเพิ่มเครื่องมือฟังเหตุการณ์ ที่รับการแจ้งเตือนการอัปเดตแบบเรียลไทม์ไม่ได้

เริ่มต้นใช้งาน

มาดูตัวอย่างการเขียนบล็อกจากบทความก่อนหน้าอีกครั้งเพื่อทำความเข้าใจวิธีอ่านข้อมูลจากฐานข้อมูล Firebase โปรดทราบ ว่าระบบจะจัดเก็บโพสต์ในบล็อกในแอปตัวอย่างไว้ที่ URL ของฐานข้อมูล https://docs-examples.firebaseio.com/server/saving-data/fireblog/posts.json หากต้องการอ่านข้อมูลโพสต์ ให้ทำดังนี้

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

ใน Java และ Node.js คุณสามารถส่งแฮนเดิลการเรียกกลับการยกเลิกที่ไม่บังคับไปยังการสมัครใช้บริการเหตุการณ์ที่จะเรียกใช้หากมีการยกเลิกการอ่าน ระบบจะยกเลิกการอ่านหากไคลเอ็นต์แอปไม่มีสิทธิ์อ่านจากการอ้างอิงฐานข้อมูลนั้น ระบบจะส่งerrorออบเจ็กต์ที่ระบุสาเหตุที่ทำให้เกิดข้อผิดพลาดไปยังการเรียกกลับนี้ ใน Python และ Go การดำเนินการ get() / Get() จะล้มเหลวโดยการยกเว้นในกรณีที่เกิดข้อผิดพลาด

หากเรียกใช้โค้ดข้างต้น คุณจะเห็นออบเจ็กต์ที่มีโพสต์ทั้งหมดที่บันทึกไว้ในคอนโซล ในกรณีของ Node.js และ Java ฟังก์ชัน Listener จะเรียกใช้ทุกครั้งที่มีการเพิ่มข้อมูลใหม่ลงในการอ้างอิงฐานข้อมูล และคุณไม่จำเป็นต้องเขียนโค้ดเพิ่มเติมเพื่อให้เกิดการดำเนินการนี้

ใน Java และ Node.js ฟังก์ชัน Callback จะได้รับ DataSnapshot ซึ่งเป็นสแนปชอตของข้อมูล สแนปชอตคือภาพของข้อมูลที่การอ้างอิงฐานข้อมูลที่เฉพาะเจาะจง ณ จุดใดจุดหนึ่งในเวลา การเรียก val() / getValue() ในสแนปชอตจะแสดงผลการแสดงออบเจ็กต์ของข้อมูลที่เฉพาะเจาะจงภาษา หากไม่มีข้อมูลในตำแหน่งของข้อมูลอ้างอิง ค่าของสแนปชอตจะเป็น null get() ใน Python จะแสดงการแสดงข้อมูลใน Python โดยตรง ฟังก์ชัน Get() ใน Go จะยกเลิกการมาร์กอัปข้อมูลเป็นโครงสร้างข้อมูลที่กำหนด

โปรดสังเกตว่าเราใช้valueประเภทเหตุการณ์ในตัวอย่างข้างต้น ซึ่งจะอ่านเนื้อหาทั้งหมดของการอ้างอิงฐานข้อมูล Firebase แม้ว่าจะมีข้อมูลเพียงรายการเดียวที่เปลี่ยนแปลงก็ตาม value เป็นหนึ่งในเหตุการณ์ 5 ประเภทที่แตกต่างกันซึ่งแสดงอยู่ด้านล่างที่คุณใช้เพื่ออ่านข้อมูลจากฐานข้อมูลได้

อ่านประเภทเหตุการณ์ใน Java และ Node.js

ค่า

ระบบจะใช้เหตุการณ์ value เพื่ออ่านสแนปชอตแบบคงที่ของเนื้อหาในเส้นทางฐานข้อมูลที่กําหนด ณ เวลาที่เกิดเหตุการณ์อ่าน โดยจะทริกเกอร์ 1 ครั้งพร้อมข้อมูลเริ่มต้น และอีกครั้งทุกครั้งที่ข้อมูลเปลี่ยนแปลง ระบบจะส่งสแนปชอตที่มีข้อมูลทั้งหมดในตำแหน่งนั้น รวมถึงข้อมูลย่อย ไปยังการเรียกกลับของเหตุการณ์ ในตัวอย่างโค้ดด้านบน value จะแสดงบล็อกโพสต์ทั้งหมดในแอปของคุณ ทุกครั้งที่มีการเพิ่มบล็อกโพสต์ใหม่ ฟังก์ชัน Callback จะแสดงโพสต์ทั้งหมด

เพิ่มบุตรหลานแล้ว

โดยปกติแล้วจะใช้เหตุการณ์ child_added เมื่อดึงข้อมูลรายการจากฐานข้อมูล child_added จะทริกเกอร์ 1 ครั้งสำหรับเด็กที่มีอยู่แต่ละคน และจะทริกเกอร์อีกครั้งทุกครั้งที่มีการเพิ่มเด็กคนใหม่ลงในเส้นทางที่ระบุ ซึ่งแตกต่างจาก value ที่จะแสดงเนื้อหาทั้งหมดของสถานที่ตั้ง ระบบจะส่งสแนปชอตที่มีข้อมูลของโหนดลูกใหม่ไปยังการเรียกกลับของเหตุการณ์ นอกจากนี้ ยังมีการส่งอาร์กิวเมนต์ที่ 2 ซึ่งมีคีย์ขององค์ประกอบย่อยก่อนหน้าเพื่อใช้ในการจัดลำดับ

หากต้องการดึงเฉพาะข้อมูลในโพสต์ใหม่แต่ละรายการที่เพิ่มลงในแอปบล็อก คุณสามารถใช้ child_added ได้โดยทำดังนี้

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

ในตัวอย่างนี้ สแนปชอตจะมีออบเจ็กต์ที่มีบล็อกโพสต์แต่ละรายการ เนื่องจาก SDK จะแปลงโพสต์เป็นออบเจ็กต์โดยการดึงค่า คุณจึงมีสิทธิ์เข้าถึงพร็อพเพอร์ตี้ผู้เขียนและชื่อของโพสต์โดยการเรียกใช้ author และ title ตามลำดับ นอกจากนี้ คุณยังมีสิทธิ์เข้าถึงรหัสโพสต์ก่อนหน้าจากอาร์กิวเมนต์ที่ 2 ของ prevChildKey ด้วย

มีการเปลี่ยนแปลงในบัญชีของบุตรหลาน

ระบบจะทริกเกอร์เหตุการณ์ child_changed ทุกครั้งที่มีการแก้ไขโหนดลูก ซึ่งรวมถึงการแก้ไขใดๆ ในลูกหลานของโหนดลูก โดยปกติจะใช้ร่วมกับ child_added และ child_removed เพื่อตอบสนองต่อการเปลี่ยนแปลงในรายการสินค้า สแนปชอตที่ส่งไปยังการเรียกกลับของเหตุการณ์จะมีข้อมูลที่อัปเดตแล้วสำหรับองค์ประกอบย่อย

คุณใช้ child_changed เพื่ออ่านข้อมูลที่อัปเดตในบล็อกโพสต์เมื่อมีการแก้ไขได้โดยทำดังนี้

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

นำบุตรหลานออกแล้ว

ระบบจะทริกเกอร์เหตุการณ์ child_removed เมื่อนำบุตรหลานออก โดยปกติจะใช้ร่วมกับ child_added และ child_changed สแนปชอตที่ส่งไปยังการเรียกกลับของเหตุการณ์จะมีข้อมูลสำหรับบุตรหลานที่ถูกนำออก

ในตัวอย่างบล็อก คุณสามารถใช้ child_removed เพื่อบันทึกการแจ้งเตือนเกี่ยวกับโพสต์ที่ถูกลบไปยังคอนโซลได้ดังนี้

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

ย้ายบุตรหลาน

ระบบจะใช้เหตุการณ์ child_moved เมื่อทำงานกับข้อมูลที่เรียงลำดับ ซึ่งจะกล่าวถึงในส่วนถัดไป

การรับประกันเกี่ยวกับกิจกรรม

ฐานข้อมูล Firebase รับประกันที่สำคัญหลายประการเกี่ยวกับเหตุการณ์ ดังนี้

การรับประกันเหตุการณ์ในฐานข้อมูล
ระบบจะทริกเกอร์เหตุการณ์เสมอเมื่อสถานะในเครื่องมีการเปลี่ยนแปลง
เหตุการณ์จะแสดงสถานะที่ถูกต้องของข้อมูลเสมอ แม้ในกรณีที่การดำเนินการในพื้นที่หรือ เวลาทำให้เกิดความแตกต่างชั่วคราว เช่น ในกรณีที่การเชื่อมต่อเครือข่ายขาดหายไปชั่วคราว
การเขียนจากไคลเอ็นต์เดียวจะเขียนไปยังเซิร์ฟเวอร์และออกอากาศไปยังผู้ใช้รายอื่นตามลำดับเสมอ
ระบบจะทริกเกอร์เหตุการณ์มูลค่าเป็นรายการสุดท้ายเสมอ และรับประกันว่าจะมีข้อมูลอัปเดตจากเหตุการณ์อื่นๆ ที่เกิดขึ้น ก่อนที่จะมีการถ่ายสแนปชอตนั้น

เนื่องจากระบบจะทริกเกอร์เหตุการณ์มูลค่าเป็นรายการสุดท้ายเสมอ ตัวอย่างต่อไปนี้จึงใช้งานได้เสมอ

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

การยกเลิกการเชื่อมต่อ Callback

ระบบจะนำการเรียกกลับออกโดยการระบุประเภทเหตุการณ์และฟังก์ชันการเรียกกลับที่จะนำออก เช่น

Java

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

// Remove listener
ref.removeEventListener(listener);

Node.js

ref.off('value', originalCallback);

หากคุณส่งบริบทขอบเขตไปยัง on() คุณต้องส่งบริบทดังกล่าวเมื่อยกเลิกการเชื่อมต่อแฮนเดิลการเรียกกลับ

Java

// Not applicable for Java

Node.js

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

หากมีการเพิ่มการเรียกกลับหลายครั้งไปยังตำแหน่งข้อมูล ระบบจะเรียกการเรียกกลับหลายครั้งสำหรับแต่ละเหตุการณ์ และคุณต้องยกเลิกการเชื่อมต่อหลายครั้งเพื่อนำออกโดยสมบูรณ์

หากต้องการนำการโทรกลับทั้งหมดในสถานที่ตั้งออก ให้ทำดังนี้

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

อ่านข้อมูลครั้งเดียว

ในบางกรณี การเรียกใช้ฟังก์ชันเรียกกลับเพียงครั้งเดียวแล้วนำออกทันทีอาจมีประโยชน์ เราได้สร้างฟังก์ชันตัวช่วย เพื่อให้การดำเนินการนี้ง่ายขึ้น

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

การค้นหาข้อมูล

การค้นหาฐานข้อมูล Firebase ช่วยให้คุณดึงข้อมูลได้ตามต้องการโดยอิงตามปัจจัยต่างๆ หากต้องการสร้างคําค้นหาในฐานข้อมูล คุณต้องเริ่มด้วยการระบุวิธีที่ต้องการจัดเรียงข้อมูลโดยใช้ฟังก์ชันการจัดเรียงอย่างใดอย่างหนึ่ง ได้แก่ orderByChild(), orderByKey() หรือ orderByValue() จากนั้นคุณจะรวมสิ่งเหล่านี้กับอีก 5 วิธีเพื่อทำการค้นหาที่ซับซ้อนได้ ได้แก่ limitToFirst(), limitToLast(), startAt(), endAt() และ equalTo()

เนื่องจากพวกเราทุกคนที่ Firebase คิดว่าไดโนเสาร์เจ๋งมาก เราจึงจะใช้ข้อมูลจากฐานข้อมูลตัวอย่างข้อเท็จจริงเกี่ยวกับไดโนเสาร์เพื่อแสดงให้เห็นวิธีค้นหาข้อมูลในฐานข้อมูล Firebase

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

คุณสามารถจัดเรียงข้อมูลได้ 3 วิธี ได้แก่ ตามคีย์ย่อย ตามคีย์ หรือตามค่า การค้นหาฐานข้อมูลพื้นฐานจะเริ่มต้นด้วยฟังก์ชันการจัดเรียงอย่างใดอย่างหนึ่งต่อไปนี้ ซึ่งแต่ละฟังก์ชันจะอธิบายไว้ด้านล่าง

การเรียงลำดับตามคีย์ย่อยที่ระบุ

คุณสามารถจัดเรียงโหนดตามคีย์ย่อยทั่วไปได้โดยส่งคีย์นั้นไปยัง orderByChild() ตัวอย่างเช่น หากต้องการอ่านไดโนเสาร์ทั้งหมดที่จัดเรียงตามความสูง คุณสามารถทำดังนี้

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(f'{key} was {val} meters tall')

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

โหนดที่ไม่มีคีย์ย่อยที่เรากำลังค้นหาจะได้รับการจัดเรียงด้วยค่า null ซึ่งหมายความว่าโหนดดังกล่าวจะมาเป็นอันดับแรกในการจัดเรียง ดูรายละเอียดเกี่ยวกับวิธีจัดเรียงข้อมูลได้ที่ส่วนวิธีจัดเรียงข้อมูล

นอกจากนี้ ยังจัดเรียงการค้นหาตามองค์ประกอบย่อยที่ซ้อนกันลึกได้ด้วย ไม่ใช่แค่องค์ประกอบย่อยที่อยู่ระดับล่างลงไปเพียงระดับเดียว วิธีนี้มีประโยชน์หากคุณมีข้อมูลที่ซ้อนกันลึก เช่น

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

หากต้องการค้นหาความสูงตอนนี้ คุณสามารถใช้เส้นทางแบบเต็มไปยังออบเจ็กต์แทนที่จะใช้คีย์เดียวได้

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(f'{key} was {val} meters tall')

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

การค้นหาจะจัดเรียงตามคีย์ได้ครั้งละ 1 รายการเท่านั้น การเรียกใช้ orderByChild() หลายครั้งในคำค้นหาเดียวกันจะทำให้เกิดข้อผิดพลาด

การใช้ดัชนีเพื่อปรับปรุงประสิทธิภาพ

หากต้องการใช้ orderByChild() ในแอปที่ใช้งานจริง คุณควรระบุคีย์ที่จัดทำดัชนีผ่านกฎ .indexOn ในกฎความปลอดภัยและกฎ Firebase แม้ว่าคุณจะได้รับอนุญาตให้สร้างการค้นหาเหล่านี้เฉพาะกิจในไคลเอ็นต์ แต่คุณจะเห็นประสิทธิภาพที่ดียิ่งขึ้นเมื่อใช้ .indexOn อ่านเอกสารประกอบเกี่ยวกับกฎ .indexOn เพื่อดูข้อมูลเพิ่มเติม

การเรียงลำดับตามคีย์

นอกจากนี้ คุณยังจัดเรียงโหนดตามคีย์ได้โดยใช้เมธอด orderByKey() ตัวอย่างต่อไปนี้จะอ่านไดโนเสาร์ทั้งหมดตามลำดับตัวอักษร

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)

การเรียงตามมูลค่า

คุณจัดเรียงโหนดตามค่าของคีย์ย่อยได้โดยใช้เมธอด orderByValue() สมมติว่าไดโนเสาร์กำลังจัดการแข่งขันกีฬาระหว่างไดโนเสาร์ และคุณกำลังติดตามคะแนนของไดโนเสาร์ในรูปแบบต่อไปนี้

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

หากต้องการจัดเรียงไดโนเสาร์ตามคะแนน คุณสามารถสร้างคำค้นหาต่อไปนี้

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(f'The {key} dinosaur\'s score is {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)
}

ดูส่วนวิธีจัดเรียงข้อมูลเพื่อดูคำอธิบายเกี่ยวกับวิธีจัดเรียงค่า null, บูลีน, สตริง และออบเจ็กต์เมื่อใช้ orderByValue()

การจัดทำดัชนีตามค่าเพื่อปรับปรุงประสิทธิภาพ

หากต้องการใช้ orderByValue() ในแอปเวอร์ชันที่ใช้งานจริง คุณควรเพิ่ม .value ลงในกฎที่ดัชนีที่เหมาะสม อ่านเอกสารประกอบเกี่ยวกับกฎ .indexOn เพื่อดูข้อมูลเพิ่มเติม

คำค้นหาที่ซับซ้อน

เมื่อทราบลำดับของข้อมูลแล้ว คุณจะใช้วิธีการ limit หรือ range ที่อธิบายไว้ด้านล่างเพื่อสร้างการค้นหาที่ซับซ้อนยิ่งขึ้นได้

คำค้นหาที่จำกัด

ระบบจะใช้คำค้นหา limitToFirst() และ limitToLast() เพื่อกำหนดจำนวนบุตรหลานสูงสุดที่จะซิงค์สำหรับการเรียกกลับที่ระบุ หากตั้งค่าขีดจํากัดไว้ที่ 100 คุณจะได้รับเหตุการณ์ child_added ไม่เกิน 100 รายการในตอนแรก หากคุณมีข้อความที่จัดเก็บไว้ในฐานข้อมูลน้อยกว่า 100 ข้อความ ระบบจะทริกเกอร์เหตุการณ์ child_added สำหรับข้อความแต่ละข้อความ อย่างไรก็ตาม หากมีข้อความมากกว่า 100 รายการ คุณจะได้รับเหตุการณ์ child_added สำหรับข้อความ 100 รายการเท่านั้น โดยจะเป็นข้อความ 100 รายการแรกที่เรียงตามลำดับหากคุณใช้ limitToFirst() หรือข้อความ 100 รายการสุดท้ายที่เรียงตามลำดับหากคุณใช้ limitToLast() เมื่อสินค้ามีการเปลี่ยนแปลง คุณจะได้รับเหตุการณ์ child_added สำหรับสินค้าที่เข้าสู่การค้นหาและเหตุการณ์ child_removed สำหรับสินค้าที่ออกจากการค้นหา เพื่อให้จำนวนรวมยังคงอยู่ที่ 100

คุณสามารถค้นหาไดโนเสาร์ 2 ตัวที่มีน้ำหนักมากที่สุดได้โดยใช้ฐานข้อมูลข้อเท็จจริงเกี่ยวกับไดโนเสาร์และ orderByChild()

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

child_addedการเรียกกลับจะทริกเกอร์ 2 ครั้งอย่างแน่นอน เว้นแต่จะมีไดโนเสาร์เก็บไว้ในฐานข้อมูลน้อยกว่า 2 ตัว นอกจากนี้ ระบบจะทริกเกอร์สำหรับไดโนเสาร์ตัวใหม่ที่มีน้ำหนักมากขึ้นทุกตัวที่เพิ่มลงในฐานข้อมูลด้วย ใน Python การค้นหาจะแสดง OrderedDict ที่มีไดโนเสาร์ 2 ตัวที่มีน้ำหนักมากที่สุดโดยตรง

ในทำนองเดียวกัน คุณสามารถค้นหาสัตว์โลกล้านปี 2 ชนิดที่สั้นที่สุดได้โดยใช้ limitToFirst() ดังนี้

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

child_addedการเรียกกลับจะทริกเกอร์ 2 ครั้งอย่างแน่นอน เว้นแต่จะมีไดโนเสาร์เก็บไว้ในฐานข้อมูลน้อยกว่า 2 ตัว นอกจากนี้ ระบบจะเรียกใช้ฟังก์ชันอีกครั้งหากนำไดโนเสาร์ 2 ตัวแรกออกจากฐานข้อมูล เนื่องจากไดโนเสาร์ตัวใหม่จะกลายเป็นตัวที่สั้นที่สุดเป็นอันดับ 2 ใน Python การค้นหาจะแสดง OrderedDict ที่มีไดโนเสาร์ที่สั้นที่สุดโดยตรง

นอกจากนี้ คุณยังทำการค้นหาขีดจำกัดด้วย orderByValue() ได้ด้วย หากต้องการสร้างลีดเดอร์บอร์ดที่มีไดโนเสาร์นักกีฬา 3 อันดับแรกที่ทำคะแนนได้สูงสุด คุณสามารถทำดังนี้

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(f'The {key} dinosaur\'s score is {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)
}

การค้นหาช่วง

การใช้ startAt(), endAt() และ equalTo() ช่วยให้คุณ เลือกจุดเริ่มต้นและจุดสิ้นสุดที่ต้องการสำหรับคำค้นหาได้ เช่น หากต้องการ ค้นหาไดโนเสาร์ทั้งหมดที่มีความสูงอย่างน้อย 3 เมตร คุณสามารถรวม orderByChild() และ startAt() ได้ดังนี้

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

คุณใช้ endAt() เพื่อค้นหาไดโนเสาร์ทั้งหมดที่มีชื่อมาก่อน Pterodactyl ตามลำดับตัวอักษรได้

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() และ endAt() เป็นแบบรวม ซึ่งหมายความว่า "pterodactyl" จะ ตรงกับคำค้นหาด้านบน

คุณสามารถรวม startAt() และ endAt() เพื่อจำกัดทั้ง 2 ด้านของ การค้นหา ตัวอย่างต่อไปนี้จะค้นหาไดโนเสาร์ทั้งหมดที่มีชื่อขึ้นต้นด้วยตัวอักษร "b"

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

อักขระ \uf8ff ที่ใช้ในคำค้นหาด้านบนเป็นจุดรหัสที่สูงมากใน ช่วง Unicode เนื่องจากอยู่หลังอักขระปกติส่วนใหญ่ใน Unicode การค้นหาจึงตรงกับค่าทั้งหมดที่ ขึ้นต้นด้วย b

วิธี equalTo() ช่วยให้คุณกรองตามการจับคู่ที่ตรงกันทั้งหมดได้ เช่นเดียวกับ การค้นหาช่วงอื่นๆ ระบบจะเรียกใช้สำหรับโหนดลูกที่ตรงกันแต่ละรายการ เช่น คุณสามารถใช้การค้นหาต่อไปนี้เพื่อค้นหาไดโนเสาร์ทั้งหมดที่มีความสูง 25 เมตร

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

การค้นหาช่วงยังมีประโยชน์เมื่อคุณต้องการแบ่งหน้าข้อมูลด้วย

คุณยังรวม orderByValue() กับ startAt() และ endAt() เพื่อสร้างการค้นหาช่วงได้ด้วย

สรุปข้อมูลทั้งหมด

คุณสามารถรวมเทคนิคทั้งหมดนี้เพื่อสร้างการค้นหาที่ซับซ้อนได้ ตัวอย่างเช่น คุณสามารถค้นหา ชื่อของไดโนเสาร์ที่สั้นกว่าสเตโกซอรัสได้ดังนี้

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(f'The dinosaur just shorter than the stegosaurus is {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")
}

วิธีจัดเรียงข้อมูล

ส่วนนี้อธิบายวิธีจัดเรียงข้อมูลเมื่อใช้ฟังก์ชันการจัดเรียงทั้ง 4 แบบ

orderByChild

เมื่อใช้ orderByChild() ระบบจะจัดเรียงข้อมูลที่มีคีย์ย่อยที่ระบุตามลำดับต่อไปนี้

1. เด็กที่มีค่า null สำหรับคีย์ของเด็กที่ระบุจะแสดงก่อน
2. จากนั้นจะเป็นเด็กที่มีค่า false สำหรับคีย์ย่อยที่ระบุ หากมีบุตรหลายคนที่มีค่าเป็น false ระบบจะจัดเรียงตามพจนานุกรมตามคีย์
3. จากนั้นจะเป็นเด็กที่มีค่า true สำหรับคีย์ย่อยที่ระบุ หากมีบุตรหลายคนที่มีค่าเป็น true ระบบจะจัดเรียงตามพจนานุกรมตามคีย์
4. จากนั้นจะเป็นชื่อที่มีค่าตัวเลข โดยเรียงลำดับจากน้อยไปมาก หากโหนดย่อยหลายรายการมีค่าตัวเลขเดียวกันสำหรับโหนดย่อยที่ระบุ ระบบจะจัดเรียงตามคีย์
5. โดยสตริงจะอยู่หลังตัวเลข และจะจัดเรียงตามลำดับตัวอักษรจากน้อยไปมาก หากโหนดลูกหลายโหนดมีค่าเดียวกันสำหรับโหนดลูกที่ระบุ ระบบจะจัดเรียงโหนดเหล่านั้นตามลำดับพจนานุกรมตามคีย์
6. ออบเจ็กต์จะอยู่สุดท้ายและจัดเรียงตามพจนานุกรมตามคีย์จากน้อยไปมาก

orderByKey

เมื่อใช้ orderByKey() เพื่อจัดเรียงข้อมูล ระบบจะแสดงข้อมูลตามลำดับจากน้อยไปมากตามคีย์ดังนี้ โปรดทราบว่าคีย์ต้องเป็นสตริงเท่านั้น

1. เด็กที่มีคีย์ที่แยกวิเคราะห์เป็นจำนวนเต็ม 32 บิตได้จะแสดงก่อน โดยเรียงตามลำดับจากน้อยไปมาก
2. จากนั้นจะเป็นเด็กที่มีค่าสตริงเป็นคีย์ โดยจะจัดเรียงตามลำดับแบบพจนานุกรมจากน้อยไปมาก

orderByValue

เมื่อใช้ orderByValue() ระบบจะจัดเรียงเด็กตามมูลค่า เกณฑ์การจัดเรียงจะเหมือนกับใน orderByChild() ยกเว้นจะใช้ค่าของโหนดแทนค่าของคีย์ย่อยที่ระบุ