डेटा पढ़ें और लिखें

(ज़रूरी नहीं) Firebase Emulator Suite की मदद से प्रोटोटाइप बनाना और टेस्ट करना

इससे पहले कि हम यह बताएं कि आपका ऐप्लिकेशन, Realtime Database से डेटा कैसे पढ़ता है और उसमें डेटा कैसे लिखता है, आइए हम आपको टूल के एक ऐसे सेट के बारे में बताते हैं जिसका इस्तेमाल, Realtime Database की सुविधाओं का प्रोटोटाइप बनाने और उन्हें टेस्ट करने के लिए किया जा सकता है: Firebase Emulator Suite. अगर आपको अलग-अलग डेटा मॉडल आज़माने हैं, सुरक्षा नियमों को ऑप्टिमाइज़ करना है या बैक-एंड के साथ इंटरैक्ट करने का सबसे किफ़ायती तरीका ढूंढना है, तो लाइव सेवाओं को डिप्लॉय किए बिना स्थानीय तौर पर काम करना एक अच्छा विकल्प हो सकता है.

Realtime Database एम्युलेटर, Emulator Suite का हिस्सा है. इसकी मदद से, आपका ऐप्लिकेशन, एम्युलेट किए गए डेटाबेस के कॉन्टेंट और कॉन्फ़िगरेशन के साथ इंटरैक्ट कर सकता है. साथ ही, एम्युलेट किए गए प्रोजेक्ट के संसाधनों (फ़ंक्शन, अन्य डेटाबेस, और सुरक्षा नियम) के साथ भी इंटरैक्ट कर सकता है.emulator_suite_short

रीयलटाइम डेटाबेस एम्युलेटर का इस्तेमाल करने के लिए, आपको बस कुछ चरणों का पालन करना होगा:

1. एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन की टेस्ट कॉन्फ़िगरेशन में कोड की एक लाइन जोड़ना.
2. अपनी स्थानीय प्रोजेक्ट डायरेक्ट्री की रूट से, firebase emulators:start चलाएं.
3. Realtime Database प्लैटफ़ॉर्म के एसडीके का इस्तेमाल करके, अपने ऐप्लिकेशन के प्रोटोटाइप कोड से कॉल करना या Realtime Database REST API का इस्तेमाल करना.

Realtime Database और Cloud Functions का इस्तेमाल करने के बारे में पूरी जानकारी उपलब्ध है. आपको Emulator Suite के बारे में जानकारी भी देखनी चाहिए.

DatabaseReference ऑब्जेक्ट पाना

डेटाबेस से डेटा पढ़ने या उसमें डेटा लिखने के लिए, आपको DatabaseReference के इंस्टेंस की ज़रूरत होगी:

DatabaseReference ref = FirebaseDatabase.instance.ref();

डेटा सेव करने की अनुमति दें

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

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

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

लिखने की बुनियादी कार्रवाइयां

लिखने से जुड़ी बुनियादी कार्रवाइयों के लिए, set() का इस्तेमाल करके डेटा को किसी खास रेफ़रंस में सेव किया जा सकता है. इससे उस पाथ पर मौजूद मौजूदा डेटा बदल जाता है. इन टाइप के लिए रेफ़रंस सेट किया जा सकता है: String, boolean, int, double, Map, List.

उदाहरण के लिए, set() की भूमिका वाले उपयोगकर्ता को इस तरह जोड़ा जा सकता है:

DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");

await ref.set({
  "name": "John",
  "age": 18,
  "address": {
    "line1": "100 Mountain View"
  }
});

इस तरह set() का इस्तेमाल करने से, तय की गई जगह पर मौजूद डेटा मिट जाता है. इसमें चाइल्ड नोड भी शामिल हैं. हालांकि, पूरे ऑब्जेक्ट को फिर से लिखे बिना भी किसी बच्चे की जानकारी अपडेट की जा सकती है. अगर आपको उपयोगकर्ताओं को अपनी प्रोफ़ाइल अपडेट करने की अनुमति देनी है, तो उपयोगकर्ता नाम को इस तरह अपडेट करें:

DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");

// Only update the age, leave the name and address!
await ref.update({
  "age": 19,
});

update() तरीके से नोड का सब-पाथ स्वीकार किया जाता है. इससे आपको डेटाबेस पर एक साथ कई नोड अपडेट करने की सुविधा मिलती है:

DatabaseReference ref = FirebaseDatabase.instance.ref("users");

await ref.update({
  "123/age": 19,
  "123/address/line1": "1 Mountain View",
});

डेटा पढ़ने की अनुमति दें

वैल्यू इवेंट को मॉनिटर करके डेटा पढ़ना

किसी पाथ पर मौजूद डेटा को पढ़ने और उसमें होने वाले बदलावों को सुनने के लिए, DatabaseReference की onValue प्रॉपर्टी का इस्तेमाल करें. इससे DatabaseEvents को सुना जा सकता है.

DatabaseEvent का इस्तेमाल करके, किसी दिए गए पाथ पर मौजूद डेटा को पढ़ा जा सकता है. यह डेटा, इवेंट के समय मौजूद होता है. यह इवेंट तब ट्रिगर होता है, जब लिसनर अटैच होता है. इसके बाद, यह इवेंट तब ट्रिगर होता है, जब बच्चों के डेटा में कोई बदलाव होता है. इवेंट में एक snapshot प्रॉपर्टी होती है. इसमें उस जगह का पूरा डेटा होता है. इसमें चाइल्ड डेटा भी शामिल होता है. अगर कोई डेटा नहीं है, तो स्नैपशॉट की exists प्रॉपर्टी false होगी और इसकी value प्रॉपर्टी शून्य होगी.

अहम जानकारी: डेटाबेस के तय किए गए रेफ़रंस में डेटा बदलने पर, हर बार DatabaseEvent ट्रिगर होता है. इसमें बच्चों के डेटा में किए गए बदलाव भी शामिल हैं. स्नैपशॉट का साइज़ सीमित रखने के लिए, सिर्फ़ उस लेवल पर अटैच करें जिस पर बदलाव देखने के लिए ज़रूरी है. उदाहरण के लिए, अपने डेटाबेस के रूट से लिसनर को अटैच करने का सुझाव नहीं दिया जाता.

यहां दिए गए उदाहरण में, सोशल ब्लॉगिंग ऐप्लिकेशन को डेटाबेस से पोस्ट की जानकारी मिलती है:

DatabaseReference starCountRef =
        FirebaseDatabase.instance.ref('posts/$postId/starCount');
starCountRef.onValue.listen((DatabaseEvent event) {
    final data = event.snapshot.value;
    updateStarCount(data);
});

लिसनर को एक DataSnapshot मिलता है. इसमें इवेंट के समय, डेटाबेस में बताई गई जगह पर मौजूद डेटा होता है. यह डेटा, लिसनर की value प्रॉपर्टी में मौजूद होता है.

डेटा को एक बार पढ़ना

get() का इस्तेमाल करके एक बार पढ़ना

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

आम तौर पर, आपको ऊपर बताई गई वैल्यू इवेंट की तकनीकों का इस्तेमाल करना चाहिए, ताकि डेटा को पढ़ा जा सके. इससे आपको बैकएंड से डेटा में होने वाले अपडेट की सूचना मिल पाएगी. इन तकनीकों से, आपके इस्तेमाल और बिलिंग में कमी आती है. साथ ही, इन्हें इस तरह से ऑप्टिमाइज़ किया जाता है कि ऑनलाइन और ऑफ़लाइन होने पर, आपके उपयोगकर्ताओं को सबसे अच्छा अनुभव मिल सके.

अगर आपको डेटा सिर्फ़ एक बार चाहिए, तो डेटाबेस से डेटा का स्नैपशॉट पाने के लिए, get() का इस्तेमाल करें. अगर किसी वजह से get(), सर्वर वैल्यू नहीं दिखा पाता है, तो क्लाइंट लोकल स्टोरेज कैश मेमोरी की जांच करेगा. अगर वैल्यू अब भी नहीं मिलती है, तो वह गड़बड़ी दिखाएगा.

इस उदाहरण में, डेटाबेस से किसी उपयोगकर्ता का सार्वजनिक तौर पर दिखने वाला उपयोगकर्ता नाम सिर्फ़ एक बार वापस पाने का तरीका दिखाया गया है:

final ref = FirebaseDatabase.instance.ref();
final snapshot = await ref.child('users/$userId').get();
if (snapshot.exists) {
    print(snapshot.value);
} else {
    print('No data available.');
}

get() का ज़रूरत से ज़्यादा इस्तेमाल करने पर, बैंडविथ का इस्तेमाल बढ़ सकता है और परफ़ॉर्मेंस में गिरावट आ सकती है. इससे बचने के लिए, ऊपर दिखाए गए तरीके से रीयलटाइम लिसनर का इस्तेमाल करें.

once() का इस्तेमाल करके, डेटा को एक बार पढ़ना

कुछ मामलों में, आपको सर्वर पर अपडेट की गई वैल्यू की जांच करने के बजाय, स्थानीय कैश मेमोरी से वैल्यू तुरंत वापस चाहिए हो सकती है. ऐसे मामलों में, लोकल डिस्क कैश से डेटा तुरंत पाने के लिए, once() का इस्तेमाल किया जा सकता है.

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

final event = await ref.once(DatabaseEventType.value);
final username = event.snapshot.value?.username ?? 'Anonymous';

डेटा अपडेट करना या मिटाना

चुनिंदा फ़ील्ड अपडेट करना

अगर आपको किसी नोड के कुछ बच्चों को एक साथ लिखना है और अन्य चाइल्ड नोड को नहीं बदलना है, तो update() तरीके का इस्तेमाल करें.

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

void writeNewPost(String uid, String username, String picture, String title,
        String body) async {
    // A post entry.
    final postData = {
        'author': username,
        'uid': uid,
        'body': body,
        'title': title,
        'starCount': 0,
        'authorPic': picture,
    };

    // Get a key for a new Post.
    final newPostKey =
        FirebaseDatabase.instance.ref().child('posts').push().key;

    // Write the new post's data simultaneously in the posts list and the
    // user's post list.
    final Map<String, Map> updates = {};
    updates['/posts/$newPostKey'] = postData;
    updates['/user-posts/$uid/$newPostKey'] = postData;

    return FirebaseDatabase.instance.ref().update(updates);
}

इस उदाहरण में, push() का इस्तेमाल करके, /posts/$postid पर सभी उपयोगकर्ताओं के लिए पोस्ट वाले नोड में पोस्ट बनाई गई है. साथ ही, key की मदद से कुंजी को एक साथ वापस पाया गया है. इसके बाद, इस कुंजी का इस्तेमाल करके उपयोगकर्ता की पोस्ट में दूसरी एंट्री बनाई जा सकती है. इसके लिए, /user-posts/$userid/$postid पर जाएं.

इन पाथ का इस्तेमाल करके, JSON ट्री में मौजूद एक से ज़्यादा जगहों की जानकारी को एक साथ अपडेट किया जा सकता है. इसके लिए, update() को सिर्फ़ एक बार कॉल करना होगा. उदाहरण के लिए, इस उदाहरण में दिखाया गया है कि दोनों जगहों के लिए नई पोस्ट कैसे बनाई जाती है. इस तरीके से एक साथ किए गए अपडेट ऐटॉमिक होते हैं: या तो सभी अपडेट पूरे हो जाते हैं या सभी अपडेट पूरे नहीं होते.

पूरा होने पर वापस कॉल करने की सुविधा जोड़ना

अगर आपको यह जानना है कि आपका डेटा कब सेव किया गया है, तो पूरे होने पर सूचना देने वाले कॉलबैक रजिस्टर करें. set() और update(), दोनों Future दिखाते हैं. इनमें सफलता और गड़बड़ी के कॉलबैक अटैच किए जा सकते हैं. ये कॉलबैक तब कॉल किए जाते हैं, जब डेटाबेस में डेटा लिख दिया जाता है और जब कॉल पूरा नहीं होता है.

FirebaseDatabase.instance
    .ref('users/$userId/email')
    .set(emailAddress)
    .then((_) {
        // Data saved successfully!
    })
    .catchError((error) {
        // The write failed...
    });

डाटा हटाएं

डेटा मिटाने का सबसे आसान तरीका यह है कि उस डेटा के रेफ़रंस पर remove() कॉल करें.

set() या update() जैसे किसी अन्य राइट ऑपरेशन के लिए, वैल्यू के तौर पर शून्य तय करके भी मिटाया जा सकता है. इस तकनीक का इस्तेमाल update() के साथ किया जा सकता है. इससे एक ही एपीआई कॉल में कई बच्चों को मिटाया जा सकता है.

डेटा को लेन-देन के तौर पर सेव करना

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

उदाहरण के लिए, सोशल ब्लॉगिंग ऐप्लिकेशन में, उपयोगकर्ताओं को पोस्ट को स्टार करने और स्टार हटाने की अनुमति दी जा सकती है. साथ ही, यह ट्रैक किया जा सकता है कि किसी पोस्ट को कितने स्टार मिले हैं. इसके लिए, यह तरीका अपनाएं:

void toggleStar(String uid) async {
  DatabaseReference postRef =
      FirebaseDatabase.instance.ref("posts/foo-bar-123");

  TransactionResult result = await postRef.runTransaction((Object? post) {
    // Ensure a post at the ref exists.
    if (post == null) {
      return Transaction.abort();
    }

    Map<String, dynamic> _post = Map<String, dynamic>.from(post as Map);
    if (_post["stars"] is Map && _post["stars"][uid] != null) {
      _post["starCount"] = (_post["starCount"] ?? 1) - 1;
      _post["stars"][uid] = null;
    } else {
      _post["starCount"] = (_post["starCount"] ?? 0) + 1;
      if (!_post.containsKey("stars")) {
        _post["stars"] = {};
      }
      _post["stars"][uid] = true;
    }

    // Return the new data.
    return Transaction.success(_post);
  });
}

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

await ref.runTransaction((Object? post) {
  // ...
}, applyLocally: false);

लेन-देन का नतीजा TransactionResult होता है. इसमें यह जानकारी होती है कि लेन-देन पूरा हुआ या नहीं. साथ ही, इसमें नया स्नैपशॉट भी होता है:

DatabaseReference ref = FirebaseDatabase.instance.ref("posts/123");

TransactionResult result = await ref.runTransaction((Object? post) {
  // ...
});

print('Committed? ${result.committed}'); // true / false
print('Snapshot? ${result.snapshot}'); // DataSnapshot

लेन-देन रद्द करना

अगर आपको सुरक्षित तरीके से लेन-देन रद्द करना है, तो Transaction.abort() को कॉल करके AbortTransactionException:

TransactionResult result = await ref.runTransaction((Object? user) {
  if (user !== null) {
    return Transaction.abort();
  }

  // ...
});

print(result.committed); // false

सर्वर-साइड पर एक साथ कई वैल्यू बढ़ाना

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

void addStar(uid, key) async {
  Map<String, Object?> updates = {};
  updates["posts/$key/stars/$uid"] = true;
  updates["posts/$key/starCount"] = ServerValue.increment(1);
  updates["user-posts/$key/stars/$uid"] = true;
  updates["user-posts/$key/starCount"] = ServerValue.increment(1);
  return FirebaseDatabase.instance.ref().update(updates);
}

इस कोड में लेन-देन की कार्रवाई का इस्तेमाल नहीं किया जाता. इसलिए, अगर कोई अपडेट काम नहीं करता है, तो यह अपने-आप फिर से नहीं चलेगा. हालांकि, इंक्रीमेंट ऑपरेशन सीधे तौर पर डेटाबेस सर्वर पर होता है. इसलिए, टकराव की कोई संभावना नहीं होती.

अगर आपको ऐप्लिकेशन से जुड़ी समस्याओं का पता लगाना है और उन्हें ठीक करना है, तो आपको इस्तेमाल के इस उदाहरण के लिए सुरक्षा के कस्टम नियम लिखने चाहिए. जैसे, किसी उपयोगकर्ता ने ऐसी पोस्ट को स्टार किया है जिसे वह पहले ही स्टार कर चुका है.

डेटा के साथ ऑफ़लाइन काम करना

अगर किसी क्लाइंट का नेटवर्क कनेक्शन बंद हो जाता है, तो आपका ऐप्लिकेशन ठीक से काम करता रहेगा.

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

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

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

ध्यान दें: Firebase रीयलटाइम डेटाबेस के वेब एपीआई, सेशन के बाहर ऑफ़लाइन होने पर डेटा सेव नहीं करते. सर्वर पर डेटा सेव करने के लिए, यह ज़रूरी है कि डेटा को सर्वर पर सेव करने से पहले वेब पेज बंद न किया जाए

हम ऑनलाइन और ऑफ़लाइन सुविधाओं के बारे में ज़्यादा जानें लेख में, ऑफ़लाइन व्यवहार के बारे में ज़्यादा जानकारी देंगे.

अगले चरण

• डेटा की सूचियों का इस्तेमाल करना
• डेटा को स्ट्रक्चर करने का तरीका जानें
• ऑनलाइन और ऑफ़लाइन सुविधाओं के बारे में ज़्यादा जानें