หน้านี้ได้รับการแปลโดย Cloud Translation API

กำลังบันทึกข้อมูล

เอกสารนี้อธิบาย 4 วิธีในการเขียนข้อมูลไปยัง Firebase Realtime Database ได้แก่ การรองรับการตั้งค่า อัปเดต การพุช และธุรกรรม

วิธีประหยัดอินเทอร์เน็ต

ตั้งค่า	เขียนหรือแทนที่ข้อมูลในเส้นทางที่กําหนด เช่น `messages/users/<username>`
อัปเดต	อัปเดตคีย์บางรายการสำหรับเส้นทางที่กําหนดไว้โดยไม่ต้องแทนที่ข้อมูลทั้งหมด
พุช	เพิ่มลงในรายการข้อมูลในฐานข้อมูล ทุกครั้งที่คุณพุชโหนดใหม่ลงในรายการ ฐานข้อมูลจะสร้างคีย์ที่ไม่ซ้ำกัน เช่น `messages/users/<unique-user-id>/<username>`
ธุรกรรม	ใช้ธุรกรรมเมื่อทำงานกับข้อมูลที่ซับซ้อนซึ่งอาจเสียหายจากการอัปเดตพร้อมกัน

การประหยัดอินเทอร์เน็ต

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

Java

final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog");

Node.js

// Import Admin SDK
const { getDatabase } = require('firebase-admin/database');

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

Python

# Import database module.
from firebase_admin import db

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

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 blog.
ref := client.NewRef("server/saving-data/fireblog")

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

ก่อนอื่น ให้สร้างการอ้างอิงฐานข้อมูลไปยังข้อมูลผู้ใช้ จากนั้นใช้ set() / setValue() เพื่อบันทึกออบเจ็กต์ผู้ใช้ลงในฐานข้อมูลพร้อมชื่อผู้ใช้ ชื่อเต็ม และวันเกิดของผู้ใช้ โดยคุณส่งชุดสตริง, ตัวเลข, บูลีน, null, อาร์เรย์ หรือออบเจ็กต์ JSON ใดก็ได้ การส่ง null จะนําข้อมูลในตําแหน่งดังกล่าวออก ในกรณีนี้ คุณจะต้องส่งออบเจ็กต์ต่อไปนี้

Java

public static class User {

  public String date_of_birth;
  public String full_name;
  public String nickname;

  public User(String dateOfBirth, String fullName) {
    // ...
  }

  public User(String dateOfBirth, String fullName, String nickname) {
    // ...
  }

}

DatabaseReference usersRef = ref.child("users");

Map<String, User> users = new HashMap<>();
users.put("alanisawesome", new User("June 23, 1912", "Alan Turing"));
users.put("gracehop", new User("December 9, 1906", "Grace Hopper"));

usersRef.setValueAsync(users);

Node.js

const usersRef = ref.child('users');
usersRef.set({
  alanisawesome: {
    date_of_birth: 'June 23, 1912',
    full_name: 'Alan Turing'
  },
  gracehop: {
    date_of_birth: 'December 9, 1906',
    full_name: 'Grace Hopper'
  }
});

Python

users_ref = ref.child('users')
users_ref.set({
    'alanisawesome': {
        'date_of_birth': 'June 23, 1912',
        'full_name': 'Alan Turing'
    },
    'gracehop': {
        'date_of_birth': 'December 9, 1906',
        'full_name': 'Grace Hopper'
    }
})

Go

// User is a json-serializable type.
type User struct {
	DateOfBirth string `json:"date_of_birth,omitempty"`
	FullName    string `json:"full_name,omitempty"`
	Nickname    string `json:"nickname,omitempty"`
}

usersRef := ref.Child("users")
err := usersRef.Set(ctx, map[string]*User{
	"alanisawesome": {
		DateOfBirth: "June 23, 1912",
		FullName:    "Alan Turing",
	},
	"gracehop": {
		DateOfBirth: "December 9, 1906",
		FullName:    "Grace Hopper",
	},
})
if err != nil {
	log.Fatalln("Error setting value:", err)
}

เมื่อบันทึกออบเจ็กต์ JSON ลงในฐานข้อมูล ระบบจะแมปพร็อพเพอร์ตี้ออบเจ็กต์ไปยังตําแหน่งย่อยของฐานข้อมูลโดยอัตโนมัติในลักษณะที่ซ้อนกัน ตอนนี้หากคุณไปที่ URL https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name เราจะเห็นค่า "Alan Turing" นอกจากนี้ คุณยังบันทึกข้อมูลไปยังตำแหน่งของบุตรหลานโดยตรงได้ด้วย โดยทำดังนี้

Java

usersRef.child("alanisawesome").setValueAsync(new User("June 23, 1912", "Alan Turing"));
usersRef.child("gracehop").setValueAsync(new User("December 9, 1906", "Grace Hopper"));

Node.js

const usersRef = ref.child('users');
usersRef.child('alanisawesome').set({
  date_of_birth: 'June 23, 1912',
  full_name: 'Alan Turing'
});
usersRef.child('gracehop').set({
  date_of_birth: 'December 9, 1906',
  full_name: 'Grace Hopper'
});

Python

users_ref.child('alanisawesome').set({
    'date_of_birth': 'June 23, 1912',
    'full_name': 'Alan Turing'
})
users_ref.child('gracehop').set({
    'date_of_birth': 'December 9, 1906',
    'full_name': 'Grace Hopper'
})

Go

if err := usersRef.Child("alanisawesome").Set(ctx, &User{
	DateOfBirth: "June 23, 1912",
	FullName:    "Alan Turing",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

if err := usersRef.Child("gracehop").Set(ctx, &User{
	DateOfBirth: "December 9, 1906",
	FullName:    "Grace Hopper",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

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

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper"
    }
  }
}

ตัวอย่างแรกจะทริกเกอร์เหตุการณ์เพียงรายการเดียวในไคลเอ็นต์ที่ดูข้อมูลอยู่ ส่วนตัวอย่างที่ 2 จะทริกเกอร์ 2 รายการ โปรดทราบว่าหากมีข้อมูลอยู่ใน usersRef อยู่แล้ว วิธีการแรกจะเขียนทับข้อมูลนั้น แต่วิธีการที่ 2 จะแก้ไขเฉพาะค่าของโหนดย่อยแต่ละโหนดแยกกัน โดยไม่เปลี่ยนแปลงโหนดย่อยอื่นๆ ของ usersRef

การอัปเดตข้อมูลที่บันทึกไว้

หากต้องการเขียนไปยังรายการย่อยหลายรายการของตำแหน่งฐานข้อมูลพร้อมกันโดยไม่เขียนทับโหนดย่อยอื่นๆ ให้ใช้เมธอดอัปเดตดังที่แสดงด้านล่าง

Java

DatabaseReference hopperRef = usersRef.child("gracehop");
Map<String, Object> hopperUpdates = new HashMap<>();
hopperUpdates.put("nickname", "Amazing Grace");

hopperRef.updateChildrenAsync(hopperUpdates);

Node.js

const usersRef = ref.child('users');
const hopperRef = usersRef.child('gracehop');
hopperRef.update({
  'nickname': 'Amazing Grace'
});

Python

hopper_ref = users_ref.child('gracehop')
hopper_ref.update({
    'nickname': 'Amazing Grace'
})

Go

hopperRef := usersRef.Child("gracehop")
if err := hopperRef.Update(ctx, map[string]interface{}{
	"nickname": "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating child:", err)
}

ซึ่งจะอัปเดตข้อมูลของ Grace ให้รวมชื่อเล่นของเธอ หากคุณใช้ set here แทน update ระบบจะลบทั้ง full_name และ date_of_birth ออกจาก hopperRef

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

Java

Map<String, Object> userUpdates = new HashMap<>();
userUpdates.put("alanisawesome/nickname", "Alan The Machine");
userUpdates.put("gracehop/nickname", "Amazing Grace");

usersRef.updateChildrenAsync(userUpdates);

Node.js

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome/nickname': 'Alan The Machine',
  'gracehop/nickname': 'Amazing Grace'
});

Python

users_ref.update({
    'alanisawesome/nickname': 'Alan The Machine',
    'gracehop/nickname': 'Amazing Grace'
})

Go

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome/nickname": "Alan The Machine",
	"gracehop/nickname":      "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

หลังจากการอัปเดตครั้งนี้ ทั้ง Alan และ Grace ได้เพิ่มชื่อเล่นของพวกเขา ดังนี้

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing",
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper",
      "nickname": "Amazing Grace"
    }
  }
}

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

Java

Map<String, Object> userNicknameUpdates = new HashMap<>();
userNicknameUpdates.put("alanisawesome", new User(null, null, "Alan The Machine"));
userNicknameUpdates.put("gracehop", new User(null, null, "Amazing Grace"));

usersRef.updateChildrenAsync(userNicknameUpdates);

Node.js

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome': {
    'nickname': 'Alan The Machine'
  },
  'gracehop': {
    'nickname': 'Amazing Grace'
  }
});

Python

users_ref.update({
    'alanisawesome': {
        'nickname': 'Alan The Machine'
    },
    'gracehop': {
        'nickname': 'Amazing Grace'
    }
})

Go

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome": &User{Nickname: "Alan The Machine"},
	"gracehop":      &User{Nickname: "Amazing Grace"},
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

การดำเนินการนี้จะส่งผลให้เกิดพฤติกรรมที่ต่างกัน กล่าวคือ การเขียนทับโหนด /users ทั้งโหนด:

{
  "users": {
    "alanisawesome": {
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "nickname": "Amazing Grace"
    }
  }
}

การอัปเดตข้อมูลที่ฝัง

เมื่อระบุเส้นทางคีย์เดียว เช่น alanisawesome ระบบจะอัปเดตเฉพาะข้อมูลที่ระดับบุตรแรก และข้อมูลที่ส่งผ่านนอกเหนือจากระดับบุตรแรกจะถือว่ามีการดำเนินการชุด ลักษณะการทำงานแบบหลายเส้นทางช่วยให้ใช้เส้นทางที่ยาวกว่า (เช่น alanisawesome/nickname) ได้โดยไม่ต้องเขียนทับข้อมูล ด้วยเหตุนี้ ตัวอย่างแรกจึงแตกต่างจากตัวอย่างที่ 2

การเพิ่มการโทรกลับเมื่อดำเนินการเสร็จสมบูรณ์

ใน Node.js และ Java Admin SDKs หากต้องการทราบว่ามีการบันทึกข้อมูลแล้วเมื่อใด คุณสามารถเพิ่มการเรียกกลับเมื่อเสร็จสมบูรณ์ได้ ทั้งเมธอด set และ update ใน SDK เหล่านี้ใช้การเรียกกลับเมื่อเสร็จสิ้นซึ่งไม่บังคับ ซึ่งจะเรียกใช้เมื่อมีการบันทึกข้อมูลลงในฐานข้อมูลแล้ว หากการเรียกไม่สําเร็จเนื่องจากเหตุผลบางอย่าง ระบบจะส่งออบเจ็กต์ข้อผิดพลาดที่ระบุสาเหตุของการไม่สําเร็จไปยังการเรียกกลับ ใน Admin SDK ของ Python และ Go วิธีการเขียนทั้งหมดจะบล็อก กล่าวคือ เมธอดการเขียนจะไม่แสดงผลจนกว่าจะมีการบันทึกการเขียนลงในฐานข้อมูล

Java

DatabaseReference dataRef = ref.child("data");
dataRef.setValue("I'm writing data", new DatabaseReference.CompletionListener() {
  @Override
  public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
    if (databaseError != null) {
      System.out.println("Data could not be saved " + databaseError.getMessage());
    } else {
      System.out.println("Data saved successfully.");
    }
  }
});

Node.js

dataRef.set('I\'m writing data', (error) => {
  if (error) {
    console.log('Data could not be saved.' + error);
  } else {
    console.log('Data saved successfully.');
  }
});

การบันทึกรายการข้อมูล

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

// NOT RECOMMENDED - use push() instead!
{
  "posts": {
    "0": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "1": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

พุชเทียบกับธุรกรรม

เมื่อทำงานกับรายการข้อมูล push() จะตรวจสอบคีย์ที่ไม่ซ้ำกันและเรียงตามลำดับเวลา คุณอาจอยากใช้ธุรกรรมเพื่อสร้างคีย์ของคุณเองแทน แต่การพุชเป็นทางเลือกที่ดีกว่ามาก ธุรกรรมจะช้าลงและซับซ้อนมากขึ้น ซึ่งกำหนดให้เซิร์ฟเวอร์ต้องมีการเดินทางไป-กลับอย่างน้อย 1 รอบ คีย์ที่สร้างขึ้นโดย `push()` ในไคลเอ็นต์จะทํางานขณะออฟไลน์และได้รับการเพิ่มประสิทธิภาพ

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

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

Java

public static class Post {

  public String author;
  public String title;

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

}

DatabaseReference postsRef = ref.child("posts");

DatabaseReference newPostRef = postsRef.push();
newPostRef.setValueAsync(new Post("gracehop", "Announcing COBOL, a New Programming Language"));

// We can also chain the two calls together
postsRef.push().setValueAsync(new Post("alanisawesome", "The Turing Machine"));

Node.js

const newPostRef = postsRef.push();
newPostRef.set({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});

// we can also chain the two calls together
postsRef.push().set({
  author: 'alanisawesome',
  title: 'The Turing Machine'
});

Python

posts_ref = ref.child('posts')

new_post_ref = posts_ref.push()
new_post_ref.set({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

# We can also chain the two calls together
posts_ref.push().set({
    'author': 'alanisawesome',
    'title': 'The Turing Machine'
})

Go

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

postsRef := ref.Child("posts")

newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

if err := newPostRef.Set(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

// We can also chain the two calls together
if _, err := postsRef.Push(ctx, &Post{
	Author: "alanisawesome",
	Title:  "The Turing Machine",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

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

{
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "-JRHTHaKuITFIhnj02kE": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

ใน JavaScript, Python และ Go รูปแบบการเรียก push() แล้วเรียก set() ทันทีนั้นพบได้ทั่วไป Firebase SDK จึงให้คุณรวมรูปแบบการเรียกเหล่านี้เข้าด้วยกันได้โดยส่งข้อมูลที่กําหนดให้กับ push() โดยตรง ดังนี้

Java

// No Java equivalent

Node.js

// This is equivalent to the calls to push().set(...) above
postsRef.push({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});;

Python

# This is equivalent to the calls to push().set(...) above
posts_ref.push({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

Go

if _, err := postsRef.Push(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

รับคีย์ที่ไม่ซ้ำกันที่ push() สร้างขึ้น

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

Java

// Generate a reference to a new location and add some data using push()
DatabaseReference pushedPostRef = postsRef.push();

// Get the unique ID generated by a push()
String postId = pushedPostRef.getKey();

Node.js

// Generate a reference to a new location and add some data using push()
const newPostRef = postsRef.push();

// Get the unique key generated by push()
const postId = newPostRef.key;

Python

# Generate a reference to a new location and add some data using push()
new_post_ref = posts_ref.push()

# Get the unique key generated by push()
post_id = new_post_ref.key

Go

// Generate a reference to a new location and add some data using Push()
newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

// Get the unique key generated by Push()
postID := newPostRef.Key

อย่างที่เห็น คุณรับค่าของคีย์ที่ไม่ซ้ำกันได้จากข้อมูลอ้างอิง push()

ในส่วนถัดไปเกี่ยวกับการดึงข้อมูล เราจะดูวิธีอ่านข้อมูลจากฐานข้อมูล Firebase

การบันทึกข้อมูลธุรกรรม

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

ใน Java และ Node.js คุณจะส่งการเรียกกลับ 2 รายการให้กับการดำเนินการธุรกรรม ได้แก่ ฟังก์ชันอัปเดตและการเรียกกลับเมื่อเสร็จสิ้น (ไม่บังคับ) ใน Python และ Go การดำเนินการธุรกรรมจะบล็อกและยอมรับเฉพาะฟังก์ชันการอัปเดตเท่านั้น

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

Java

DatabaseReference upvotesRef = ref.child("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.runTransaction(new Transaction.Handler() {
  @Override
  public Transaction.Result doTransaction(MutableData mutableData) {
    Integer currentValue = mutableData.getValue(Integer.class);
    if (currentValue == null) {
      mutableData.setValue(1);
    } else {
      mutableData.setValue(currentValue + 1);
    }

    return Transaction.success(mutableData);
  }

  @Override
  public void onComplete(
      DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) {
    System.out.println("Transaction completed");
  }
});

Node.js

const upvotesRef = db.ref('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes');
upvotesRef.transaction((current_value) => {
  return (current_value || 0) + 1;
});

Python

def increment_votes(current_value):
    return current_value + 1 if current_value else 1

upvotes_ref = db.reference('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes')
try:
    new_vote_count = upvotes_ref.transaction(increment_votes)
    print('Transaction completed')
except db.TransactionAbortedError:
    print('Transaction failed to commit')

Go

fn := func(t db.TransactionNode) (interface{}, error) {
	var currentValue int
	if err := t.Unmarshal(&currentValue); err != nil {
		return nil, err
	}
	return currentValue + 1, nil
}

ref := client.NewRef("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes")
if err := ref.Transaction(ctx, fn); err != nil {
	log.Fatalln("Transaction failed to commit:", err)
}

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

หากเรียกใช้โค้ดข้างต้นโดยไม่มีฟังก์ชันธุรกรรมและไคลเอ็นต์ 2 รายพยายามเพิ่มโค้ดพร้อมกัน ทั้ง 2 โค้ดจะเขียน 1 เป็นค่าใหม่ ซึ่งทำให้เพิ่มขึ้น 1 ค่าแทนที่จะเป็น 2 รายการ

เรียกใช้ฟังก์ชันธุรกรรมหลายครั้ง

ระบบจะเรียกใช้ตัวแฮนเดิลธุรกรรมหลายครั้ง และต้องจัดการข้อมูล null ได้ แม้ว่าจะมีข้อมูลอยู่ในฐานข้อมูล แต่ระบบอาจไม่แคชข้อมูลไว้ในเครื่องเมื่อเรียกใช้ฟังก์ชันธุรกรรม

การเชื่อมต่อเครือข่ายและการเขียนแบบออฟไลน์

ใน Node.js และ Java หากไคลเอ็นต์ตัดการเชื่อมต่อเครือข่าย แอปจะยังคงทํางานต่อไปอย่างถูกต้อง SDK สำหรับผู้ดูแลระบบ Python และ Go ต้องใช้การเชื่อมต่อเครือข่ายเนื่องจากใช้ Firebase REST API เพื่อสื่อสารกับเซิร์ฟเวอร์ฐานข้อมูล การเรียกใช้การดำเนินการฐานข้อมูลใน Python หรือ Go Admin SDK โดยไม่มีการเชื่อมต่อเครือข่ายจะทำให้มีข้อยกเว้น

ไคลเอ็นต์ Firebase Node.js และ Java จะเก็บรักษาข้อมูลเวอร์ชันภายในของตนเอง เมื่อมีการเขียนข้อมูล ระบบจะเขียนไปยังเวอร์ชันภายในนี้ก่อน จากนั้นไคลเอ็นต์จะซิงค์ข้อมูลนั้นกับฐานข้อมูลและกับไคลเอ็นต์รายอื่นๆ ตาม "ความพยายามอย่างเต็มที่"

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

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

การรักษาความปลอดภัยข้อมูลของคุณ

Firebase Realtime Database มีภาษาความปลอดภัยที่ช่วยให้คุณกำหนดได้ว่าผู้ใช้รายใดมีสิทธิ์อ่านและเขียนโหนดต่างๆ ของข้อมูล อ่านข้อมูลเพิ่มเติมได้ในหัวข้อรักษาความปลอดภัยข้อมูลของคุณ