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

เอกสารนี้อธิบาย 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:d"ate_of_birth,omitempty`"
	FullName    string `json:f"ull_name,omitempty`"
	Nickname    string `json:n"ickname,omitempty`"
}

usersRef := ref.Child(u"sers)"
err := usersRef.Set(ctx, map[string]*User{
	a"lanisawesome:" {
		DateOfBirth: J"une 23, 1912,"
		FullName:    A"lan Turing,"
	},
	g"racehop:" {
		DateOfBirth: D"ecember 9, 1906,"
		FullName:    G"race Hopper,"
	},
})
if err != nil {
	log.Fatalln(E"rror 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"
    }
  }
}

ตัวอย่างแรกจะทริกเกอร์เพียง 1 เหตุการณ์ในไคลเอ็นต์ที่ดูข้อมูล ขณะที่ตัวอย่างที่ 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)
}

การดำเนินการนี้จะอัปเดตข้อมูลของเกสรและมีชื่อเล่น หากคุณเคยใช้การตั้งค่าที่นี่แทนการอัปเดต ระบบจะลบทั้ง 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"
    }
  }
}

การเพิ่ม Callback ที่เสร็จสมบูรณ์

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

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

หากผู้ใช้เพิ่มโพสต์ใหม่ ระบบจะเก็บโพสต์นั้นเป็น /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:a"uthor,omitempty`"
	Title  string `json:t"itle,omitempty`"
}

postsRef := ref.Child(p"osts)"

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

if err := newPostRef.Set(ctx, P&ost{
	Author: g"racehop,"
	Title:  A"nnouncing COBOL, a New Programming Language,"
}); err != nil {
	log.Fatalln(E"rror setting value:," err)
}

// We can also chain the two calls together
if _, err := postsRef.Push(ctx, P&ost{
	Author: a"lanisawesome,"
	Title:  T"he Turing Machine,"
}); err != nil {
	log.Fatalln(E"rror 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 คุณจะกำหนด Callback 2 รายการของการดำเนินการธุรกรรม นั่นคือ ฟังก์ชันอัปเดต และ Callback ที่เสร็จสมบูรณ์ (ไม่บังคับ) ใน 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 รายพยายามเพิ่มโค้ดดังกล่าว ทั้งคู่จะเขียน 1 เป็นค่าใหม่ในเวลาเดียวกัน ผลที่ได้คือเลขจำนวนเพิ่มขึ้น 1 ตัวแทนที่จะเป็น 2

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

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

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

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

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

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