שמירת נתונים באמצעות מסד נתונים בזמן אמת ב-Firebase עבור C++

שנתחיל?

אם עדיין לא הגדרתם את האפליקציה ואת הגישה למסד הנתונים, קודם עיינו במדריך Get Started.

קבלת DatabaseReference

כדי לכתוב נתונים למסד הנתונים, צריך מופע של DatabaseReference:

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

שמירת נתונים

יש ארבע שיטות לכתיבת נתונים ב-Firebase Realtime Database:

כתיבה, עדכון או מחיקה של נתונים בהפניה

פעולות כתיבה בסיסיות

לפעולות כתיבה בסיסיות, אפשר להשתמש ב-SetValue() כדי לשמור נתונים בהפניה שצוינה, ולהחליף את הנתונים הקיימים בנתיב הזה. אפשר להשתמש בשיטה הזו כדי להעביר סוגים שנתמכים ב-JSON דרך סוג Variant שתומך ב:

• Null (האפשרות הזו מוחקת את הנתונים)
• מספרים שלמים (64 ביט)
• מספרים בשיטת נקודה צפה עם דיוק כפול
• בוליאני
• מיתרים
• וקטורים של וריאנטים
• מיפוי של מחרוזות לווריאציות

שימוש ב-SetValue() באופן הזה מחליף את הנתונים במיקום שצוין, כולל צומתי צאצא. עם זאת, עדיין אפשר לעדכן צאצא בלי לשכתב את כל האובייקט. אם רוצים לאפשר למשתמשים לעדכן את הפרופילים שלהם, אפשר לעדכן את שם המשתמש באופן הבא:

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

הוספה לרשימת נתונים

משתמשים ב-method‏ PushChild() כדי להוסיף נתונים לרשימה באפליקציות עם כמה משתמשים. השיטה PushChild() יוצרת מפתח ייחודי בכל פעם שנוסף צאצא חדש להפניה שצוינה ב-Firebase. כשמשתמשים במפתחות שנוצרים אוטומטית לכל רכיב חדש ברשימה, כמה לקוחות יכולים להוסיף צאצאים לאותו מיקום בו-זמנית בלי התנגשויות כתיבה. המפתח הייחודי שנוצר על ידי PushChild() מבוסס על חותמת זמן, כך שהפריטים ברשימה מסודרים באופן אוטומטי בסדר כרונולוגי.

אפשר להשתמש בהפניה לנתונים החדשים שהוחזרו על ידי השיטה PushChild() כדי לקבל את הערך של המפתח שנוצר באופן אוטומטי של הצאצא או להגדיר נתונים לצאצא. הפעלת GetKey() על הפניה מסוג PushChild() מחזירה את הערך של המפתח שנוצר באופן אוטומטי.

עדכון שדות ספציפיים

כדי לכתוב בו-זמנית לצאצאים ספציפיים של צומת בלי להחליף צמתים אחרים של צאצאים, משתמשים ב-method‏ 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&ltstd::string, Object&gt ToMap() {
    std::map&ltstring, Variant&gt result = new std::map&ltstring, Variant&gt();
    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&ltstd::string, Variant&gt entryValues = entry.ToMap();

  std::map&ltstring, Variant&gt childUpdates = new std::map&ltstring, Variant&gt();
  childUpdates["/scores/" + key] = entryValues;
  childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

  dbref.UpdateChildren(childUpdates);
}

בדוגמה הזו, משתמשים ב-PushChild() כדי ליצור רשומה בצומת שמכיל רשומות לכל המשתמשים ב-/scores/$key, ובמקביל מאחזרים את המפתח באמצעות key(). אחר כך אפשר להשתמש במפתח כדי ליצור רשומה שנייה בתוצאות של המשתמש בכתובת /user-scores/$userid/$key.

באמצעות הנתיבים האלה, אפשר לבצע עדכונים בו-זמנית בכמה מיקומים בעץ ה-JSON באמצעות קריאה אחת ל-UpdateChildren(), כמו בדוגמה הזו שבה נוצרת הרשומה החדשה בשני המיקומים. עדכונים בו-זמניים שמתבצעים בדרך הזו הם אטומיים: או שכל העדכונים מצליחים או שכולם נכשלים.

מחיקת נתונים

הדרך הפשוטה ביותר למחוק נתונים היא להפעיל את RemoveValue() בהפניה למיקום של הנתונים האלה.

אפשר גם למחוק על ידי ציון null Variant כערך לפעולת כתיבה אחרת, כמו SetValue() או UpdateChildren(). אפשר להשתמש בשיטה הזו עם UpdateChildren() כדי למחוק כמה צאצאים בקריאה אחת ל-API.

איך יודעים שהנתונים נשמרו.

כדי לדעת מתי הנתונים נשמרים בשרת Firebase Realtime Database, בודקים אם התוצאה של Future היא הצלחה.

שמירת נתונים כעסקאות

כשעובדים עם נתונים שעלולים להיפגם כתוצאה משינויים בו-זמניים, כמו מונים מצטברים, אפשר להשתמש בפעולת טרנזקציה. אתם נותנים לפעולה הזו פונקציה של DoTransaction. פונקציית העדכון הזו מקבלת את המצב הנוכחי של הנתונים כארגומנט, ומחזירה את המצב הרצוי החדש שרוצים לכתוב. אם לקוח אחר כותב למיקום לפני שהערך החדש נכתב בהצלחה, פונקציית העדכון נקראת שוב עם הערך הנוכחי החדש, והכתיבה מתבצעת שוב.

לדוגמה, במשחק אתם יכולים לאפשר למשתמשים לעדכן טבלת מובילים עם חמשת הניקודים הגבוהים ביותר:

void AddScoreToLeaders(std::string email,
                       long score,
                       DatabaseReference leaderBoardRef) {
  leaderBoardRef.RunTransaction([](firebase::database::MutableData* mutableData) {
    if (mutableData.children_count() &gt= MaxScores) {
      long minScore = LONG_MAX;
      MutableData *minVal = null;
      std::vector&ltMutableData&gt children = mutableData.children();
      std::vector&ltMutableData&gt::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 &lt minScore) {
          minScore = childScore;
          minVal = &amp*it;
        }
      }
      if (minScore &gt 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&ltstd::string, Variant&gt newScoreMap =
      new std::map&ltstd::string, Variant&gt();
    newScoreMap["score"] = score;
    newScoreMap["email"] = email;
    children.Add(newScoreMap);
    mutableData->set_value(children);
    return kTransactionResultSuccess;
  });
}

שימוש בטרנזקציה מונע שגיאות בטבלת המובילים אם כמה משתמשים מתעדים ניקוד בו-זמנית או אם הלקוח השתמש בנתונים לא עדכניים. אם הטרנזקציה נדחית, השרת מחזיר את הערך הנוכחי ללקוח, שמריץ את הטרנזקציה שוב עם הערך המעודכן. התהליך הזה חוזר על עצמו עד שהעסקה מאושרת או עד שמספר הניסיונות מגיע למגבלה.

כתיבת נתונים אופליין

אם לקוח מאבד את החיבור לרשת, האפליקציה תמשיך לפעול כראוי.

כל לקוח שמחובר למסד נתונים של Firebase שומר גרסה פנימית משלו של כל הנתונים הפעילים. כשנתונים נכתבים, הם נכתבים קודם כל בגרסה המקומית הזו. לאחר מכן, לקוח Firebase מסנכרן את הנתונים האלה עם שרתי מסד הנתונים המרוחקים ועם לקוחות אחרים על בסיס "המאמץ המרבי".

כתוצאה מכך, כל הכתיבות למסד הנתונים מפעילות אירועים מקומיים באופן מיידי, לפני שנתונים כלשהם נכתבים בשרת. זה אומר שהאפליקציה תמשיך להגיב בלי קשר לזמן האחזור או לקישוריות של הרשת.

אחרי שהקישוריות נוצרת מחדש, האפליקציה מקבלת את קבוצת האירועים המתאימה כדי שהלקוח יסתנכרן עם מצב השרת הנוכחי, בלי שתצטרכו לכתוב קוד בהתאמה אישית.

השלבים הבאים

• אחזור נתונים