เอกสารนี้ครอบคลุมข้อมูลพื้นฐานเกี่ยวกับการดึงข้อมูลฐานข้อมูล การจัดเรียงข้อมูล และวิธีดำเนินการค้นหาข้อมูลอย่างง่าย การนำข้อมูลใน Admin SDK ไปใช้จะแตกต่างกันเล็กน้อยในภาษาการเขียนโปรแกรมต่างๆ
- ตัวรับฟังแบบไม่พร้อมกัน: ระบบจะดึงข้อมูลที่จัดเก็บไว้ใน Firebase Realtime Database โดยการแนบตัวรับฟังแบบไม่พร้อมกันเข้ากับการอ้างอิงฐานข้อมูล โปรแกรมฟังจะทริกเกอร์ 1 ครั้งสําหรับสถานะเริ่มต้นของข้อมูล และทริกเกอร์อีกครั้งเมื่อใดก็ตามที่ข้อมูลมีการเปลี่ยนแปลง โปรแกรมรับฟังเหตุการณ์อาจได้รับเหตุการณ์หลายประเภท โหมดการดึงข้อมูลนี้ใช้ได้ใน Java, Node.js และ Python Admin SDK
- การบล็อกการอ่าน: ระบบจะดึงข้อมูลที่จัดเก็บใน Firebase Realtime Database โดยเรียกใช้เมธอดการบล็อกในการอ้างอิงฐานข้อมูล ซึ่งจะแสดงผลข้อมูลที่จัดเก็บที่ข้อมูลอ้างอิง การเรียกใช้เมธอดแต่ละครั้งเป็นการดำเนินการแบบครั้งเดียว ซึ่งหมายความว่า SDK จะไม่ลงทะเบียนการเรียกกลับที่คอยฟังการอัปเดตข้อมูลในภายหลัง รูปแบบการดึงข้อมูลนี้ใช้ได้ใน Python และ 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) }
หากเรียกใช้โค้ดข้างต้น คุณจะเห็นออบเจ็กต์ที่มีโพสต์ทั้งหมดที่บันทึกไว้ในคอนโซล สำหรับ 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 ครั้งด้วยข้อมูลเริ่มต้น และอีกครั้งทุกครั้งที่มีการเปลี่ยนแปลงข้อมูล Callback ของเหตุการณ์จะส่งผ่านสแนปชอตที่มีข้อมูลในตำแหน่งดังกล่าว รวมถึงข้อมูลย่อย ในตัวอย่างโค้ดด้านบน value
จะแสดงผลบล็อกโพสต์ทั้งหมดในแอปของคุณ เมื่อมีการเพิ่มบล็อกโพสต์ใหม่ ฟังก์ชัน Callback จะแสดงผลโพสต์ทั้งหมด
เพิ่มรายการย่อยแล้ว
โดยทั่วไปเหตุการณ์ child_added
จะใช้เมื่อดึงข้อมูลรายการจากฐานข้อมูล ซึ่งแตกต่างจาก value
ที่แสดงผลเนื้อหาทั้งหมดของตำแหน่ง child_added
จะทริกเกอร์ 1 ครั้งสำหรับรายการย่อยที่มีอยู่แต่ละรายการ และทริกเกอร์อีกครั้งทุกครั้งที่มีการเพิ่มรายการย่อยใหม่ลงในเส้นทางที่ระบุ แคล็กแบ็กเหตุการณ์จะได้รับสแนปชอตที่มีข้อมูลของบุตรหลานใหม่ ระบบจะส่งอาร์กิวเมนต์ที่ 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
ตามลำดับ นอกจากนี้ คุณยังมีสิทธิ์เข้าถึงรหัสโพสต์ก่อนหน้าจากอาร์กิวเมนต์ prevChildKey
ลำดับที่ 2 ด้วย
เปลี่ยนแปลงรายการย่อยแล้ว
ระบบจะทริกเกอร์เหตุการณ์ 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
สแนปชอตที่ส่งไปยัง Callback ของเหตุการณ์มีข้อมูลสำหรับผู้เผยแพร่โฆษณาย่อยที่นำออก
ในตัวอย่างบล็อก คุณสามารถใช้ 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()
จะต้องส่งผ่านบริบทเมื่อปลด Callback ออก
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();
การอ่านข้อมูลครั้งเดียว
ในบางกรณี อาจเป็นประโยชน์สำหรับการเรียกกลับให้ถูกเรียก 1 ครั้งแล้วนำออกทันที เราได้สร้างฟังก์ชันตัวช่วยต่อไปนี้เพื่อให้ดำเนินการนี้ได้ง่ายขึ้น
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('{0} was {1} meters tall'.format(key, val))
Go
// Dinosaur is a json-serializable type. type Dinosaur struct { Height int `json:"height"` Width int `json:"width"` } ref := client.NewRef("dinosaurs") results, err := ref.OrderByChild("height").GetOrdered(ctx) if err != nil { log.Fatalln("Error querying database:", err) } for _, r := range results { var d Dinosaur if err := r.Unmarshal(&d); err != nil { log.Fatalln("Error unmarshaling result:", err) } fmt.Printf("%s was %d meteres tall", r.Key(), d.Height) }
โหนดที่ไม่มีคีย์ย่อยที่เรากำลังค้นหาจะได้รับการจัดเรียงตามค่า null
ซึ่งหมายความว่าโหนดจะมาก่อนในลำดับ ดูรายละเอียดเกี่ยวกับวิธีจัดเรียงข้อมูลได้ที่ส่วนวิธีจัดเรียงข้อมูล
นอกจากนี้ คุณยังจัดเรียงการค้นหาตามรายการย่อยที่ฝังลึกลงไปได้ด้วย ไม่ใช่แค่รายการย่อยที่อยู่ 1 ระดับด้านล่าง ซึ่งจะมีประโยชน์หากคุณมีข้อมูลที่ฝังอยู่ลึกๆ เช่นนี้
{ "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('{0} was {1} meters tall'.format(key, val))
Go
ref := client.NewRef("dinosaurs") results, err := ref.OrderByChild("dimensions/height").GetOrdered(ctx) if err != nil { log.Fatalln("Error querying database:", err) } for _, r := range results { var d Dinosaur if err := r.Unmarshal(&d); err != nil { log.Fatalln("Error unmarshaling result:", err) } fmt.Printf("%s was %d meteres tall", r.Key(), d.Height) }
การค้นหาจะจัดเรียงตามคีย์ได้ทีละรายการเท่านั้น การเรียก orderByChild()
หลายครั้งในการค้นหาเดียวกันจะทำให้เกิดข้อผิดพลาด
การจัดเรียงตามคีย์
นอกจากนี้ คุณยังจัดเรียงโหนดตามคีย์ได้โดยใช้เมธอด 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('The {0} dinosaur\'s score is {1}'.format(key, val))
Go
ref := client.NewRef("scores") results, err := ref.OrderByValue().GetOrdered(ctx) if err != nil { log.Fatalln("Error querying database:", err) } for _, r := range results { var score int if err := r.Unmarshal(&score); err != nil { log.Fatalln("Error unmarshaling result:", err) } fmt.Printf("The %s dinosaur's score is %d\n", r.Key(), score) }
ดูส่วนวิธีจัดเรียงข้อมูลเพื่อดูคำอธิบายเกี่ยวกับวิธีจัดเรียงค่า null
, บูลีน, สตริง และออบเจ็กต์เมื่อใช้ orderByValue()
การค้นหาที่ซับซ้อน
เมื่อทราบวิธีจัดเรียงข้อมูลแล้ว คุณสามารถใช้เมธอด limit หรือ range ที่อธิบายไว้ด้านล่างเพื่อสร้างการค้นหาที่ซับซ้อนมากขึ้น
จำกัดการค้นหา
คําค้นหา limitToFirst()
และ limitToLast()
ใช้เพื่อกําหนดจํานวนรายการย่อยสูงสุดที่จะซิงค์สําหรับการเรียกกลับหนึ่งๆ หากคุณกําหนดขีดจํากัดไว้ที่ 100 รายการ ในช่วงแรกคุณจะได้รับเหตุการณ์ child_added
สูงสุด 100 รายการเท่านั้น หากคุณมีข้อความน้อยกว่า 100 ข้อความที่จัดเก็บไว้ในฐานข้อมูล เหตุการณ์ child_added
จะเริ่มทำงานสำหรับแต่ละข้อความ อย่างไรก็ตาม หากมีข้อความเกิน 100 ข้อความ คุณจะได้รับเหตุการณ์ child_added
สําหรับ 100 ข้อความเท่านั้น ข้อความเหล่านี้คือข้อความที่สั่งซื้อ 100 รายการแรกหากคุณใช้ limitToFirst()
หรือข้อความที่สั่งซื้อ 100 รายการล่าสุดหากคุณใช้ limitToLast()
เมื่อรายการมีการเปลี่ยนแปลง คุณจะได้รับเหตุการณ์ child_added
รายการสําหรับรายการที่เข้าสู่การค้นหา และเหตุการณ์ child_removed
รายการสําหรับรายการที่ออกจากการค้นหา เพื่อให้จํานวนทั้งหมดยังคงอยู่ที่ 100
เมื่อใช้ฐานข้อมูลข้อเท็จจริงเกี่ยวกับไดโนเสาร์และ orderByChild()
คุณจะดูไดโนเสาร์ที่หนักที่สุด 2 ตัวต่อไปนี้ได้
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()) }
Callback ของ child_added
จะถูกเรียกใช้ 2 ครั้งพอดี เว้นแต่มีไดโนเสาร์น้อยกว่า 2 ตัวจัดเก็บไว้ในฐานข้อมูล นอกจากนี้ ระบบจะเรียกใช้คำค้นหาอีกครั้งหากนำไดโนเสาร์ 1 ใน 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('The {0} dinosaur\'s score is {1}'.format(key, val))
Go
ref := client.NewRef("scores") results, err := ref.OrderByValue().LimitToLast(3).GetOrdered(ctx) if err != nil { log.Fatalln("Error querying database:", err) } for _, r := range results { var score int if err := r.Unmarshal(&score); err != nil { log.Fatalln("Error unmarshaling result:", err) } fmt.Printf("The %s dinosaur's score is %d\n", r.Key(), score) }
การค้นหาช่วง
การใช้ 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()
ร่วมกันเพื่อจำกัดการค้นหาทั้ง 2 ด้านได้ ตัวอย่างต่อไปนี้จะค้นหาไดโนเสาร์ทั้งหมดที่มีชื่อขึ้นต้นด้วยตัวอักษร "ข"
Java
dinosaursRef.orderByKey().startAt("b").endAt("b\uf8ff").addChildEventListener(new ChildEventListener() { @Override public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) { System.out.println(dataSnapshot.getKey()); } // ... });
Node.js
var ref = db.ref('dinosaurs'); ref.orderByKey().startAt('b').endAt('b\uf8ff').on('child_added', (snapshot) => { console.log(snapshot.key); });
Python
ref = db.reference('dinosaurs') snapshot = ref.order_by_key().start_at('b').end_at(u'b\uf8ff').get() for key in snapshot: print(key)
Go
ref := client.NewRef("dinosaurs") results, err := ref.OrderByKey().StartAt("b").EndAt("b\uf8ff").GetOrdered(ctx) if err != nil { log.Fatalln("Error querying database:", err) } for _, r := range results { fmt.Println(r.Key()) }
วิธี 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()) }
การค้นหาช่วงยังมีประโยชน์เมื่อคุณต้องการแบ่งข้อมูลออกเป็นหน้าด้วย
กำลังประกอบรูปภาพเข้าด้วยกัน
โดยคุณจะรวมเทคนิคทั้งหมดเหล่านี้เข้าด้วยกันเพื่อสร้างคำค้นหาที่ซับซ้อนได้ เช่น คุณสามารถค้นหาชื่อไดโนเสาร์ที่สั้นกว่าสเตโกซอรัสได้ดังนี้
Java
dinosaursRef.child("stegosaurus").child("height").addValueEventListener(new ValueEventListener() { @Override public void onDataChange(DataSnapshot stegoHeightSnapshot) { Integer favoriteDinoHeight = stegoHeightSnapshot.getValue(Integer.class); Query query = dinosaursRef.orderByChild("height").endAt(favoriteDinoHeight).limitToLast(2); query.addValueEventListener(new ValueEventListener() { @Override public void onDataChange(DataSnapshot dataSnapshot) { // Data is ordered by increasing height, so we want the first entry DataSnapshot firstChild = dataSnapshot.getChildren().iterator().next(); System.out.println("The dinosaur just shorter than the stegosaurus is: " + firstChild.getKey()); } @Override public void onCancelled(DatabaseError databaseError) { // ... } }); } @Override public void onCancelled(DatabaseError databaseError) { // ... } });
Node.js
const ref = db.ref('dinosaurs'); ref.child('stegosaurus').child('height').on('value', (stegosaurusHeightSnapshot) => { const favoriteDinoHeight = stegosaurusHeightSnapshot.val(); const queryRef = ref.orderByChild('height').endAt(favoriteDinoHeight).limitToLast(2); queryRef.on('value', (querySnapshot) => { if (querySnapshot.numChildren() === 2) { // Data is ordered by increasing height, so we want the first entry querySnapshot.forEach((dinoSnapshot) => { console.log('The dinosaur just shorter than the stegasaurus is ' + dinoSnapshot.key); // Returning true means that we will only loop through the forEach() one time return true; }); } else { console.log('The stegosaurus is the shortest dino'); } }); });
Python
ref = db.reference('dinosaurs') favotire_dino_height = ref.child('stegosaurus').child('height').get() query = ref.order_by_child('height').end_at(favotire_dino_height).limit_to_last(2) snapshot = query.get() if len(snapshot) == 2: # Data is ordered by increasing height, so we want the first entry. # Second entry is stegosarus. for key in snapshot: print('The dinosaur just shorter than the stegosaurus is {0}'.format(key)) return else: print('The stegosaurus is the shortest dino')
Go
ref := client.NewRef("dinosaurs") var favDinoHeight int if err := ref.Child("stegosaurus").Child("height").Get(ctx, &favDinoHeight); err != nil { log.Fatalln("Error querying database:", err) } query := ref.OrderByChild("height").EndAt(favDinoHeight).LimitToLast(2) results, err := query.GetOrdered(ctx) if err != nil { log.Fatalln("Error querying database:", err) } if len(results) == 2 { // Data is ordered by increasing height, so we want the first entry. // Second entry is stegosarus. fmt.Printf("The dinosaur just shorter than the stegosaurus is %s\n", results[0].Key()) } else { fmt.Println("The stegosaurus is the shortest dino") }
การจัดเรียงข้อมูล
ส่วนนี้จะอธิบายวิธีจัดเรียงข้อมูลเมื่อใช้ฟังก์ชันการจัดเรียงทั้ง 4 รายการ
orderByChild
เมื่อใช้ orderByChild()
ระบบจะจัดเรียงข้อมูลที่มีคีย์ย่อยที่ระบุดังนี้
- รายการย่อยที่มีค่า
null
สำหรับคีย์ย่อยที่ระบุจะแสดงก่อน - รายการย่อยที่มีค่าเป็น
false
สำหรับคีย์ย่อยที่ระบุจะแสดงต่อจากนี้ หากมีเด็กหลายคนมีค่าfalse
ระบบจะจัดเรียงเด็กเหล่านั้นแบบพจนานุกรมตามคีย์ - รายการย่อยที่มีค่าเป็น
true
สำหรับคีย์ย่อยที่ระบุจะแสดงต่อจากนี้ หากรายการย่อยหลายรายการมีค่าเป็นtrue
ระบบจะจัดเรียงตามลําดับตัวอักษรตามคีย์ - รายการย่อยที่มีค่าตัวเลขจะแสดงต่อจากนี้โดยจัดเรียงจากน้อยไปมาก หากโหนดย่อยหลายรายการมีค่าตัวเลขเหมือนกันสําหรับโหนดย่อยที่ระบุ ระบบจะจัดเรียงตามคีย์
- สตริงจะอยู่หลังตัวเลขและจัดเรียงตามลําดับตัวอักษรจากน้อยไปมาก หากโหนดย่อยหลายรายการมีค่าเดียวกันสําหรับโหนดย่อยที่ระบุ ระบบจะจัดเรียงตามลําดับตัวอักษรตามคีย์
- ออบเจ็กต์จะอยู่ท้ายสุดและจัดเรียงตามลําดับตัวอักษรตามคีย์จากน้อยไปมาก
orderByKey
เมื่อใช้ orderByKey()
เพื่อจัดเรียงข้อมูล ระบบจะแสดงผลลัพธ์ตามลําดับจากน้อยไปมากตามคีย์ ดังนี้ โปรดทราบว่าคีย์ต้องเป็นสตริงเท่านั้น
- เด็กที่มีคีย์ซึ่งแยกวิเคราะห์ได้เป็นจำนวนเต็ม 32 บิตจะมีอยู่ก่อนแล้วโดยจัดเรียงจากน้อยไปมาก
- รายการย่อยที่มีค่าสตริงเป็นคีย์จะแสดงต่อจากนี้ โดยจัดเรียงตามลําดับตัวอักษรจากน้อยไปมาก
มูลค่าการสั่งซื้อ
เมื่อใช้ orderByValue()
ระบบจะจัดเรียงรายการย่อยตามค่า เกณฑ์การจัดเรียงจะเหมือนกับใน orderByChild()
ยกเว้นจะใช้ค่าของโหนดแทนค่าของคีย์ย่อยที่ระบุ