C++ के लिए Firebase रीयलटाइम डेटाबेस के साथ डेटा सहेजा जा रहा है

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

शुरू हो जाओ

यदि आपने अभी तक अपना ऐप और डेटाबेस तक पहुंच स्थापित नहीं की है, तो पहले Get Started मार्गदर्शिका देखें।

डेटाबेस संदर्भ प्राप्त करें

डेटाबेस में डेटा लिखने के लिए, आपको DatabaseReference का एक उदाहरण चाहिए:

    // Get the root reference location of the database.
    firebase::database::DatabaseReference dbref = database->GetReference();

डेटा सहेजना

फायरबेस रीयलटाइम डेटाबेस में डेटा लिखने के चार तरीके हैं:

तरीका सामान्य उपयोग
SetValue() किसी निर्धारित पथ पर डेटा लिखें या बदलें, जैसे कि users/<user-id>/<username>
PushChild() डेटा की सूची में जोड़ें। हर बार जब आप Push() कॉल करते हैं, तो Firebase एक अनूठी कुंजी उत्पन्न करता है जिसे एक विशिष्ट पहचानकर्ता के रूप में भी इस्तेमाल किया जा सकता है, जैसे कि user-scores/<user-id>/<unique-score-id>
UpdateChildren() सभी डेटा को बदले बिना परिभाषित पथ के लिए कुछ कुंजियों को अपडेट करें।
RunTransaction() जटिल डेटा का अद्यतन करें जो समवर्ती अद्यतनों द्वारा दूषित हो सकता है।

संदर्भ में डेटा लिखें, अपडेट करें या हटाएं

मूल लेखन कार्य

बुनियादी लेखन कार्यों के लिए, आप डेटा को निर्दिष्ट संदर्भ में सहेजने के लिए SetValue() का उपयोग कर सकते हैं, उस पथ पर किसी भी मौजूदा डेटा को प्रतिस्थापित कर सकते हैं। आप इस विधि का उपयोग JSON द्वारा स्वीकार किए गए प्रकारों को पास करने के लिए कर सकते हैं जो निम्न प्रकार का समर्थन करता है:

  • अशक्त (यह डेटा हटा देता है)
  • पूर्णांक (64-बिट)
  • डबल सटीक फ़्लोटिंग पॉइंट नंबर
  • बूलियन्स
  • स्ट्रिंग्स
  • वेरिएंट के वैक्टर
  • वेरिएंट के लिए स्ट्रिंग्स के मानचित्र

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

dbref.Child("users").Child(userId).Child("username").SetValue(name);

डेटा की सूची में संलग्न करें

बहुउपयोगकर्ता अनुप्रयोगों में सूची में डेटा जोड़ने के लिए PushChild() विधि का उपयोग करें। PushChild() विधि निर्दिष्ट फायरबेस संदर्भ में एक नया बच्चा जोड़े जाने पर हर बार एक अद्वितीय कुंजी उत्पन्न करती है। सूची में प्रत्येक नए तत्व के लिए इन ऑटो-जेनरेट की गई कुंजियों का उपयोग करके, कई ग्राहक एक ही स्थान पर एक ही समय में बिना किसी विरोध के बच्चों को जोड़ सकते हैं। PushChild() द्वारा उत्पन्न अद्वितीय कुंजी टाइमस्टैम्प पर आधारित है, इसलिए सूची आइटम स्वचालित रूप से कालानुक्रमिक रूप से क्रमबद्ध होते हैं।

आप PushChild() विधि द्वारा लौटाए गए नए डेटा के संदर्भ का उपयोग बच्चे की ऑटो-जेनरेट की गई कुंजी या बच्चे के लिए डेटा सेट करने के लिए कर सकते हैं। PushChild() संदर्भ पर GetKey() को कॉल करना ऑटो-जेनरेट की गई कुंजी का मान लौटाता है।

विशिष्ट क्षेत्रों को अद्यतन करें

अन्य चाइल्ड नोड्स को अधिलेखित किए बिना एक नोड के विशिष्ट चिल्ड्रन को एक साथ लिखने के लिए, UpdateChildren() विधि का उपयोग करें।

UpdateChildren() को कॉल करते समय, आप कुंजी के लिए पथ निर्दिष्ट करके निचले स्तर के बाल मूल्यों को अपडेट कर सकते हैं। यदि डेटा को बेहतर पैमाने पर रखने के लिए कई स्थानों पर संग्रहीत किया जाता है, तो आप डेटा फैन-आउट का उपयोग करके उस डेटा के सभी उदाहरणों को अपडेट कर सकते हैं। उदाहरण के लिए, एक गेम में LeaderboardEntry क्लास इस तरह हो सकती है:

class LeaderboardEntry {
  std::string uid;
  int score = 0;

 public:
  LeaderboardEntry() {
  }

  LeaderboardEntry(std::string uid, int score) {
    this->uid = uid;
    this->score = score;
  }

  std::map<std::string, Object> ToMap() {
    std::map<string, Variant> result = new std::map<string, Variant>();
    result["uid"] = Variant(uid);
    result["score"] = Variant(score);

    return result;
  }
}

LeaderboardEntry बनाने के लिए और साथ ही इसे हालिया स्कोर फ़ीड और उपयोगकर्ता की अपनी स्कोर सूची में अपडेट करने के लिए, गेम निम्न कोड का उपयोग करता है:

void WriteNewScore(std::string userId, int score) {
  // Create new entry at /user-scores/$userid/$scoreid and at
  // /leaderboard/$scoreid simultaneously
  std::string key = dbref.Child("scores").PushChild().GetKey();
  LeaderBoardEntry entry = new LeaderBoardEntry(userId, score);
  std::map<std::string, Variant> entryValues = entry.ToMap();

  std::map<string, Variant> childUpdates = new std::map<string, Variant>();
  childUpdates["/scores/" + key] = entryValues;
  childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

  dbref.UpdateChildren(childUpdates);
}

यह उदाहरण /scores/$key पर सभी उपयोगकर्ताओं के लिए प्रविष्टि वाले नोड में एक प्रविष्टि बनाने के लिए PushChild() का उपयोग करता है और साथ ही key() के साथ कुंजी को पुनः प्राप्त करता है। फिर कुंजी का उपयोग उपयोगकर्ता के स्कोर में /user-scores/$userid/$key पर दूसरी प्रविष्टि बनाने के लिए किया जा सकता है।

इन रास्तों का उपयोग करके, आप JSON ट्री में एक ही कॉल के साथ JSON ट्री में कई स्थानों पर एक साथ अपडेट कर सकते हैं UpdateChildren() , जैसे कि यह उदाहरण दोनों स्थानों में नई प्रविष्टि कैसे बनाता है। इस तरह से किए गए एक साथ अद्यतन परमाणु हैं: या तो सभी अद्यतन सफल होते हैं या सभी अद्यतन विफल होते हैं।

डेटा हटाएं

डेटा को हटाने का सबसे आसान तरीका उस डेटा के स्थान के संदर्भ में RemoveValue() को कॉल करना है।

आप किसी अन्य लेखन ऑपरेशन जैसे SetValue() या UpdateChildren() के मान के रूप में एक null Variant निर्दिष्ट करके भी हटा सकते हैं। आप इस तकनीक का उपयोग UpdateChildren() के साथ एक एपीआई कॉल में कई बच्चों को हटाने के लिए कर सकते हैं।

जानें कि आपका डेटा कब प्रतिबद्ध है।

यह जानने के लिए कि आपका डेटा फायरबेस रीयलटाइम डेटाबेस सर्वर के लिए कब प्रतिबद्ध है, सफलता के लिए भविष्य के परिणाम देखें।

डेटा को लेनदेन के रूप में सहेजें

डेटा के साथ काम करते समय जो समवर्ती संशोधनों, जैसे वृद्धिशील काउंटरों द्वारा दूषित हो सकता है, आप लेनदेन ऑपरेशन का उपयोग कर सकते हैं। आप इस ऑपरेशन को DoTransaction फंक्शन देते हैं। यह अद्यतन फ़ंक्शन डेटा की वर्तमान स्थिति को एक तर्क के रूप में लेता है और नई वांछित स्थिति देता है जिसे आप लिखना चाहते हैं। यदि कोई अन्य क्लाइंट आपके नए मान के सफलतापूर्वक लिखे जाने से पहले स्थान पर लिखता है, तो आपके अपडेट फ़ंक्शन को नए वर्तमान मान के साथ फिर से कॉल किया जाता है, और लिखने का पुनः प्रयास किया जाता है।

उदाहरण के लिए, किसी गेम में आप उपयोगकर्ताओं को पांच उच्चतम स्कोर वाले लीडरबोर्ड को अपडेट करने की अनुमति दे सकते हैं:

void AddScoreToLeaders(std::string email,
                       long score,
                       DatabaseReference leaderBoardRef) {
  leaderBoardRef.RunTransaction([](firebase::database::MutableData* mutableData) {
    if (mutableData.children_count() >= MaxScores) {
      long minScore = LONG_MAX;
      MutableData *minVal = null;
      std::vector<MutableData> children = mutableData.children();
      std::vector<MutableData>::iterator it;
      for (it = children.begin(); it != children.end(); ++it) {
        if (!it->value().is_map())
          continue;
        long childScore = (long)it->Child("score").value().int64_value();
        if (childScore < minScore) {
          minScore = childScore;
          minVal = &*it;
        }
      }
      if (minScore > score) {
        // The new score is lower than the existing 5 scores, abort.
        return kTransactionResultAbort;
      }

      // Remove the lowest score.
      children.Remove(minVal);
    }

    // Add the new high score.
    std::map<std::string, Variant> newScoreMap =
      new std::map<std::string, Variant>();
    newScoreMap["score"] = score;
    newScoreMap["email"] = email;
    children.Add(newScoreMap);
    mutableData->set_value(children);
    return kTransactionResultSuccess;
  });
}

लेन-देन का उपयोग करना लीडरबोर्ड को गलत होने से रोकता है यदि एक ही समय में कई उपयोगकर्ता स्कोर रिकॉर्ड करते हैं या क्लाइंट के पास पुराना डेटा है। यदि लेन-देन अस्वीकार कर दिया जाता है, तो सर्वर क्लाइंट को वर्तमान मान लौटाता है, जो अद्यतन मूल्य के साथ लेनदेन को फिर से चलाता है। यह तब तक दोहराता है जब तक लेन-देन स्वीकार नहीं किया जाता या बहुत अधिक प्रयास नहीं किए जाते।

डेटा ऑफ़लाइन लिखें

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

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

नतीजतन, सर्वर पर किसी भी डेटा को लिखे जाने से पहले, सभी डेटाबेस को लिखते हैं, तुरंत स्थानीय घटनाओं को ट्रिगर करते हैं। इसका मतलब है कि आपका ऐप नेटवर्क विलंबता या कनेक्टिविटी की परवाह किए बिना उत्तरदायी बना रहता है।

एक बार कनेक्टिविटी फिर से स्थापित हो जाने के बाद, आपके ऐप को ईवेंट का उपयुक्त सेट प्राप्त होता है ताकि क्लाइंट बिना किसी कस्टम कोड को लिखे वर्तमान सर्वर स्थिति के साथ सिंक हो सके।

अगले कदम