इस पेज का अनुवाद Cloud Translation API से किया गया है.

डेटा सहेजा जा रहा है

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

डेटा सेव करने के तरीके

सेट	`messages/users/<username>` जैसे किसी तय किए गए पाथ में डेटा लिखना या बदलना
अपडेट करें	पूरा डेटा बदले बिना, तय किए गए पाथ के लिए कुछ कुंजियां अपडेट करें
पुश	डेटाबेस में डेटा की सूची में जोड़ें. जब भी किसी सूची में नया नोड जोड़ा जाता है, तो आपका डेटाबेस एक यूनीक पासकोड जनरेट करता है, जैसे कि `messages/users/<unique-user-id>/<username>`
लेन-देन	जटिल डेटा के साथ काम करते समय लेन-देन का इस्तेमाल करें. ऐसा डेटा, एक साथ किए जाने वाले अपडेट की वजह से खराब हो सकता है

डेटा सेव करना

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

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

शुरू करें

// 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 पास करने पर, तय की गई जगह से डेटा हट जाएगा. इस मामले में, आपको इसमें कोई ऑब्जेक्ट पास करना होगा:

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

शुरू करें

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

शुरू करें

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 के अन्य चाइल्ड नोड में कोई बदलाव नहीं करेगा.

सेव किया गया डेटा अपडेट हो रहा है

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

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

शुरू करें

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 Realtime Database, एक से ज़्यादा पाथ वाले अपडेट के साथ भी काम करता है. इसका मतलब है कि अब आपके डेटाबेस में, अपडेट की वैल्यू एक ही समय पर कई जगहों पर अपडेट की जा सकती हैं. इस बेहतरीन सुविधा की मदद से, डेटा को फिर से सामान्य बनाने में मदद मिलती है. एक से ज़्यादा पाथ वाले अपडेट का इस्तेमाल करके, एक ही समय में ग्रेसी और ऐलन, दोनों के लिए कोई दूसरा नाम जोड़ा जा सकता है:

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

शुरू करें

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

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

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

शुरू करें

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 जैसे लंबे पाथ का इस्तेमाल किया जा सकता है. इसलिए, पहला उदाहरण दूसरे उदाहरण से अलग है.

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

Node.js और Java एडमिन SDK में, अगर आपको यह जानना है कि आपका डेटा कब जनरेट हुआ है, तो आपके पास पूरा होने वाला कॉलबैक जोड़ने का विकल्प होता है. इन SDK टूल में, सेट और अपडेट, दोनों तरीके के लिए एक वैकल्पिक कॉलबैक फ़ंक्शन का इस्तेमाल किया जाता है. इसे डेटाबेस में डेटा लिखने के बाद कॉल किया जाता है. अगर किसी वजह से कॉल पूरा नहीं हो पाता है, तो कॉलबैक में गड़बड़ी का एक ऑब्जेक्ट पास किया जाता है. इससे पता चलता है कि कॉल पूरा न होने की वजह क्या है. 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"
    }
  }
}

पुश बनाम लेन-देन

डेटा की सूचियों के साथ काम करते समय, push() एक यूनीक और क्रोनोलॉजिकल कुंजी बनाता है. हो सकता है कि आप अपनी कुंजियां जनरेट करने के लिए, लेन-देन का इस्तेमाल करना चाहें. हालांकि, पुश एक बेहतर विकल्प है. लेन-देन की प्रोसेस धीमी और मुश्किल होती है. उन्हें सर्वर के लिए एक या उससे ज़्यादा राउंड ट्रिप की ज़रूरत होती है. क्लाइंट पर `push()` से जनरेट की गई कुंजी, ऑफ़लाइन काम करती है और परफ़ॉर्मेंस के लिए ऑप्टिमाइज़ की जाती है.

अगर कोई उपयोगकर्ता नई पोस्ट जोड़ता है, तो उसे /posts/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'
})

शुरू करें

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

शुरू करें

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

शुरू करें

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

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

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

शुरू करें

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 लिखा होता. इस वजह से, दो के बजाय एक ही बार में वैल्यू बढ़ती.

लेन-देन फ़ंक्शन को कई बार कॉल किया जाता है

आपके ट्रांज़ैक्शन हैंडलर को कई बार कॉल किया जाता है. साथ ही, यह null डेटा को हैंडल कर सकता है. भले ही आपके डेटाबेस में मौजूदा डेटा हो, लेकिन हो सकता है कि लेन-देन की सुविधा चालू होने पर, वह डेटा स्थानीय तौर पर कैश मेमोरी में सेव न हो.

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

अगर क्लाइंट का इंटरनेट कनेक्शन बंद हो जाता है, तो Node.js और Java में आपका ऐप्लिकेशन सही तरीके से काम करता रहेगा. Python और Go Admin SDK टूल के लिए, नेटवर्क कनेक्टिविटी ज़रूरी है. ऐसा इसलिए, क्योंकि ये डेटाबेस सर्वर के साथ बातचीत करने के लिए, Firebase REST API का इस्तेमाल करते हैं. नेटवर्क कनेक्टिविटी के बिना, Python या Go Admin SDKs पर डेटाबेस ऑपरेशन शुरू करने पर, अपवाद मिलते हैं.

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

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

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

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

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