डेटा की बचत की जा रही है

इस दस्तावेज़ में आपके Firebase रीयल टाइम डेटाबेस में डेटा लिखने के चार तरीके दिए गए हैं: सेट, अपडेट, पुश, और लेन-देन से जुड़ी सहायता.

डेटा बचाने के तरीके

डेटा की बचत की जा रही है

डेटाबेस के डेटा में बदलाव करने की बेसिक कार्रवाई एक ऐसा सेट है जो बताए गए डेटाबेस रेफ़रंस में नया डेटा सेव करता है. साथ ही, उस पाथ के मौजूदा डेटा की जगह ले लेता है. सेट को समझने के लिए, हम एक आसान ब्लॉगिंग ऐप्लिकेशन बनाएंगे. आपके ऐप्लिकेशन का डेटा, इस डेटाबेस रेफ़रंस में सेव किया जाता है:

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

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

# Import database module.
from firebase_admin import db

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

// 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() / setValue() का इस्तेमाल करके, उपयोगकर्ता ऑब्जेक्ट को उपयोगकर्ता के उपयोगकर्ता नाम, पूरे नाम, और जन्म की तारीख के साथ डेटाबेस में सेव करें. आपके पास किसी स्ट्रिंग, संख्या, बूलियन, null, कलेक्शन या कोई भी JSON ऑब्जेक्ट को सेट करने का विकल्प होता है. null को पास करने पर, बताई गई जगह पर मौजूद डेटा हट जाएगा. इस मामले में, इसे एक ऑब्जेक्ट पास किया जाएगा:

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

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

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

// 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 ऑब्जेक्ट को डेटाबेस में सेव किया जाता है, तो ऑब्जेक्ट प्रॉपर्टी, नेस्ट किए गए तरीके से चाइल्ड लोकेशन के डेटाबेस के साथ अपने-आप मैप हो जाती हैं. अब अगर आप यूआरएल https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name पर जाते हैं, तो हमें "Alan ट्यूरिंग" वैल्यू दिखेगी. डेटा को बच्चे की जगह पर भी सेव किया जा सकता है:

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

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

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

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

ऊपर दिए गए दो उदाहरणों - दोनों वैल्यू को किसी ऑब्जेक्ट के साथ एक ही समय पर लिखने और उन्हें चाइल्ड लोकेशन में अलग-अलग लिखने पर, आपके डेटाबेस में भी वही डेटा सेव होगा:

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

पहला उदाहरण, डेटा देखने वाले क्लाइंट पर सिर्फ़ एक इवेंट को ट्रिगर करेगा. वहीं, दूसरा उदाहरण दो इवेंट को ट्रिगर करेगा. इस बात का ध्यान रखना ज़रूरी है कि अगर usersRef पर पहले से डेटा मौजूद है, तो पहला तरीका उसे ओवरराइट कर देगा. हालांकि, दूसरा तरीका सिर्फ़ हर एक चाइल्ड नोड की वैल्यू में बदलाव करेगा, जबकि usersRef के अन्य चाइल्ड नोड में कोई बदलाव नहीं होगा.

सेव किया गया डेटा अपडेट करना

अगर आपको अन्य चाइल्ड नोड को ओवरराइट किए बिना, एक ही समय में किसी डेटाबेस की लोकेशन के एक से ज़्यादा चाइल्ड को लिखना है, तो अपडेट करने के लिए नीचे दिया गया तरीका अपनाएं:

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

hopperRef.updateChildrenAsync(hopperUpdates);

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

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

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

इससे ग्रेस का डेटा अपडेट हो जाएगा और उसमें उसका निकनेम शामिल हो जाएगा. अगर आपने अपडेट के बजाय यहां 'सेट' का इस्तेमाल किया होता, तो आपके hopperRef से full_name और date_of_birth, दोनों मिट जाते.

Firebase रीयलटाइम डेटाबेस के साथ मल्टी-पाथ अपडेट भी काम करते हैं. इसका मतलब है कि अपडेट करने से, अब आपके डेटाबेस में एक ही समय पर कई जगहों पर वैल्यू अपडेट हो सकती हैं. इस सुविधा की मदद से, आपके डेटा को सामान्य तरीके से दिखाया जा सकता है. मल्टी-पाथ अपडेट का इस्तेमाल करके, ग्रेस और एलन, दोनों के लिए एक ही समय पर निकनेम जोड़े जा सकते हैं:

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

usersRef.updateChildrenAsync(userUpdates);

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

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

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

इस अपडेट के बाद, ऐलन और ग्रेस, दोनों के निकनेम जुड़ गए हैं:

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

ध्यान दें कि शामिल किए गए पाथ के साथ ऑब्जेक्ट लिखकर ऑब्जेक्ट अपडेट करने की कोशिश करने पर, अलग तरह का व्यवहार मिलेगा. आइए देखते हैं कि अगर ग्रेस और एलन को इस तरीके से अपडेट करने की कोशिश की जाती है, तो क्या होता है:

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

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

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

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

पूरा होने पर कॉलबैक जोड़ना

Node.js और Java एडमिन SDK में, अगर आपको यह जानना है कि आपका डेटा कब उपलब्ध होगा, तो पूरा होने वाला कॉलबैक जोड़ा जा सकता है. इन SDK टूल में, सेट और अपडेट करने के तरीके सेट करने और अपडेट करने के लिए एक वैकल्पिक कॉलबैक की ज़रूरत होती है. इस कॉलबैक को तब कॉल किया जाता है, जब डेटा को डेटाबेस में सेव किया जाता है. अगर किसी वजह से कॉल पूरा नहीं हो सका, तो कॉलबैक को गड़बड़ी वाले ऑब्जेक्ट के ज़रिए पास किया जाता है. इससे पता चलता है कि ऐसा क्यों हुआ है. Python और Go के एडमिन SDK टूल में, डेटा लिखने के सभी तरीके ब्लॉक हो रहे हैं. इसका मतलब है कि लिखने के तरीके तब तक नहीं दिखते, जब तक वे डेटाबेस के लिए तय नहीं हो जाते.

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

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 के तौर पर सेव किया जाएगा. यह तब काम करता है, जब सिर्फ़ एक लेखक पोस्ट जोड़ रहा हो. हालांकि, आपके सहयोगी ब्लॉगिंग ऐप्लिकेशन में, कई लोग एक साथ पोस्ट जोड़ सकते हैं. अगर दो लेखक एक साथ /posts/2 पर मैसेज लिखते हैं, तो कोई एक पोस्ट मिटा देगा.

इसे हल करने के लिए, Firebase क्लाइंट एक push() फ़ंक्शन उपलब्ध कराते हैं, जो हर नए बच्चे के लिए एक यूनीक कुंजी जनरेट करता है. यूनीक चाइल्ड कुंजियों का इस्तेमाल करके, कई क्लाइंट बच्चों को एक ही जगह पर, एक ही समय पर जोड़ सकते हैं. ऐसा करने से, उन्हें लिखने में हो रही दिक्कतों की चिंता नहीं होती.

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

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

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

// 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() पर सेट करके उन्हें आपस में जोड़ने की सुविधा देता है:

// No Java equivalent

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

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

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() को कॉल करने पर, नए डेटा पाथ का रेफ़रंस दिखेगा. इसका इस्तेमाल, कुंजी पाने या उसमें डेटा सेट करने के लिए किया जा सकता है. नीचे दिए गए कोड का भी वही डेटा होगा जो ऊपर दिए गए उदाहरण में दिया गया है. हालांकि, अब हमारे पास जनरेट की गई यूनीक कुंजी का ऐक्सेस होगा:

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

// 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;

# 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

// 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 में, लेन-देन की कार्रवाई को दो कॉलबैक दिए जाते हैं: अपडेट फ़ंक्शन और पूरा होने के लिए दूसरा कॉलबैक. Python और Go में, ट्रांज़ैक्शन की कार्रवाई ब्लॉक हो रही है. इसलिए, यह सिर्फ़ अपडेट फ़ंक्शन को स्वीकार करता है.

अपडेट फ़ंक्शन, डेटा की मौजूदा स्थिति को तर्क के तौर पर इस्तेमाल करता है. साथ ही, इसे फ़ंक्शन के हिसाब से नई स्थिति में बदलाव करना होता है. उदाहरण के लिए, अगर आपको किसी खास ब्लॉग पोस्ट पर 'पसंद है' की संख्या बढ़ानी है, तो आपको इस तरह का लेन-देन लिखना होगा:

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

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

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

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 के साथ कॉल किया जा सकता है.

अगर ऊपर दिया गया कोड ट्रांज़ैक्शन फ़ंक्शन के बिना चलाया गया था और दो क्लाइंट ने इसे एक साथ बढ़ाने की कोशिश की थी, तो वे दोनों 1 को नई वैल्यू के तौर पर लिखेंगे. इससे, दो के बजाय एक बढ़ोतरी होती है.

नेटवर्क कनेक्टिविटी और ऑफ़लाइन राइट्स

Firebase Node.js और Java क्लाइंट, किसी भी ऐक्टिव डेटा का खुद का इंटरनल वर्शन मैनेज करते हैं. जब डेटा को लिखा जाता है, तो सबसे पहले इस लोकल वर्शन में उसे लिखा जाता है. इसके बाद, क्लाइंट उस डेटा को डेटाबेस और अन्य क्लाइंट के साथ सिंक करता है. ऐसा 'बेहतरीन कोशिश' के आधार पर किया जाता है.

इस वजह से, डेटाबेस में कोई भी डेटा जोड़े जाने से पहले ही वे सभी लोकल इवेंट ट्रिगर हो जाएंगे. इसका मतलब है कि जब Firebase का इस्तेमाल करके कोई ऐप्लिकेशन लिखा जाता है, तो आपका ऐप्लिकेशन रिस्पॉन्सिव बना रहेगा, भले ही नेटवर्क इंतज़ार का समय या इंटरनेट कनेक्टिविटी न हो.

कनेक्टिविटी फिर से चालू हो जाने पर, हमें इवेंट के सही सेट मिलेंगे, ताकि क्लाइंट मौजूदा सर्वर स्थिति में "कैट अप" कर ले. ऐसा करने के लिए, हमें कस्टम कोड लिखने की ज़रूरत नहीं होगी.

अपने डेटा को सुरक्षित करना

Firebase रीयल टाइम डेटाबेस में एक सुरक्षा भाषा होती है. इसकी मदद से यह तय किया जा सकता है कि आपके डेटा के अलग-अलग नोड के लिए किन उपयोगकर्ताओं ने पढ़ने और लिखने का ऐक्सेस दिया है. अपना डेटा सुरक्षित करें पर जाकर, इस बारे में ज़्यादा जानकारी पाएं.