Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

डेटा वापस लाया जा रहा है

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

शुरू करने से पहले

Realtime Database का इस्तेमाल करने से पहले, आपको ये काम करने होंगे:

अपने Unity प्रोजेक्ट को रजिस्टर करें और Firebase का इस्तेमाल करने के लिए इसे कॉन्फ़िगर करें.
- अगर आपके Unity प्रोजेक्ट में पहले से ही Firebase का इस्तेमाल किया जा रहा है, तो यह Firebase के लिए पहले से ही रजिस्टर और कॉन्फ़िगर किया गया है.
- अगर आपके पास Unity प्रोजेक्ट नहीं है, तो सैंपल ऐप्लिकेशन डाउनलोड करें.
अपने Unity प्रोजेक्ट में Firebase Unity SDK (खास तौर पर, FirebaseDatabase.unitypackage) जोड़ें.

ध्यान दें कि Firebase को अपने यूनिटी प्रोजेक्ट में जोड़ने के लिए, आपको Firebase कंसोल और खुले हुए यूनिटी प्रोजेक्ट, दोनों में टास्क पूरे करने होंगे. उदाहरण के लिए, आपको कंसोल से Firebase कॉन्फ़िगरेशन फ़ाइलें डाउनलोड करनी होंगी. इसके बाद, उन्हें अपने यूनिटी प्रोजेक्ट में ले जाना होगा.

डेटा वापस लाया जा रहा है

Firebase डेटा को GetValueAsync() को एक बार कॉल करके या FirebaseDatabase रेफ़रंस पर किसी इवेंट से अटैच करके वापस पाया जाता है. इवेंट लिसनर को डेटा की शुरुआती स्थिति के लिए एक बार और डेटा में बदलाव होने पर फिर से कॉल किया जाता है.

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

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

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

using Firebase;
using Firebase.Database;
using Firebase.Extensions.TaskExtension; // for ContinueWithOnMainThread

public class MyScript: MonoBehaviour {
  void Start() {
    // Get the root reference location of the database.
    DatabaseReference reference = FirebaseDatabase.DefaultInstance.RootReference;
  }
}

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

GetValueAsync तरीके का इस्तेमाल करके, किसी पाथ पर मौजूद कॉन्टेंट का स्टैटिक स्नैपशॉट एक बार पढ़ा जा सकता है. टास्क के नतीजे में, स्नैपशॉट शामिल होगा. इसमें उस जगह का पूरा डेटा होगा. इसमें बच्चों का डेटा भी शामिल होगा. अगर कोई डेटा नहीं है, तो स्नैपशॉट के तौर पर null दिखता है.

    FirebaseDatabase.DefaultInstance
      .GetReference("Leaders")
      .GetValueAsync().ContinueWithOnMainThread(task =&gt {
        if (task.IsFaulted) {
          // Handle the error...
        }
        else if (task.IsCompleted) {
          DataSnapshot snapshot = task.Result;
          // Do something with snapshot...
        }
      });

इवेंट के इनपुट के लिए रीऐक्ट करना

डेटा में हुए बदलावों की सूचना पाने के लिए, इवेंट लिसनर जोड़े जा सकते हैं:

इवेंट	आम तौर पर इस्तेमाल
`ValueChanged`	किसी पाथ के पूरे कॉन्टेंट में हुए बदलावों को पढ़ना और सुनना.
`ChildAdded`	आइटम की सूचियां वापस पाना या आइटम की सूची में जोड़े गए आइटम के बारे में सुनना. सूचियों में हुए बदलावों को मॉनिटर करने के लिए, `ChildChanged` और `ChildRemoved` के साथ इस्तेमाल करने का सुझाव दिया गया है.
`ChildChanged`	किसी सूची में मौजूद आइटम में हुए बदलावों के बारे में सूचना पाना. सूचियों में हुए बदलावों को मॉनिटर करने के लिए, `ChildAdded` और `ChildRemoved` के साथ इसका इस्तेमाल करें.
`ChildRemoved`	किसी सूची से हटाए जा रहे आइटम के बारे में सूचना पाएं. इसका इस्तेमाल `ChildAdded` और `ChildChanged` के साथ करें, ताकि सूचियों में होने वाले बदलावों पर नज़र रखी जा सके.
`ChildMoved`	क्रम से लगाई गई सूची में आइटम के क्रम में हुए बदलावों को सुनें. `ChildMoved` इवेंट हमेशा उस `ChildChanged` इवेंट के बाद ट्रिगर होते हैं जिसकी वजह से आइटम के क्रम में बदलाव हुआ है. यह बदलाव, क्रम तय करने के मौजूदा तरीके के आधार पर होता है.

ValueChanged इवेंट

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

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

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

      FirebaseDatabase.DefaultInstance
        .GetReference("Leaders")
        .ValueChanged += HandleValueChanged;
    }

    void HandleValueChanged(object sender, ValueChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

ValueChangedEventArgs में DataSnapshot होता है. इसमें इवेंट के समय डेटाबेस में बताई गई जगह का डेटा होता है. स्नैपशॉट पर Value को कॉल करने पर, डेटा दिखाने वाला Dictionary<string, object> मिलता है. अगर किसी जगह का कोई डेटा मौजूद नहीं है, तो Value को कॉल करने पर null मिलता है.

इस उदाहरण में, args.DatabaseError की भी जांच की जाती है, ताकि यह पता चल सके कि रीड करने की प्रोसेस रद्द तो नहीं हुई है. उदाहरण के लिए, अगर क्लाइंट के पास Firebase डेटाबेस की किसी जगह से डेटा रीड करने की अनुमति नहीं है, तो रीड करने की प्रोसेस रद्द की जा सकती है. DatabaseError से पता चलेगा कि प्रोसेस क्यों पूरी नहीं हुई.

बाद में, उसी पाथ वाले किसी DatabaseReference का इस्तेमाल करके, इवेंट से सदस्यता छोड़ी जा सकती है. DatabaseReference इंस्टेंस कुछ समय के लिए होते हैं. इन्हें किसी भी पाथ और क्वेरी को ऐक्सेस करने के तरीके के तौर पर देखा जा सकता है.

      FirebaseDatabase.DefaultInstance
        .GetReference("Leaders")
        .ValueChanged -= HandleValueChanged; // unsubscribe from ValueChanged.
    }

बच्चों के लिए इवेंट

नोड के बच्चों के लिए, चाइल्ड इवेंट तब ट्रिगर होते हैं, जब कोई खास कार्रवाई की जाती है. जैसे, Push() तरीके से कोई नया चाइल्ड जोड़ा जाता है या UpdateChildrenAsync() तरीके से किसी चाइल्ड को अपडेट किया जाता है. इन सभी का एक साथ इस्तेमाल करके, डेटाबेस में किसी खास नोड में हुए बदलावों के बारे में सुना जा सकता है. उदाहरण के लिए, कोई गेम इन तरीकों का इस्तेमाल एक साथ कर सकता है, ताकि गेम सेशन की टिप्पणियों में होने वाली गतिविधि पर नज़र रखी जा सके. जैसा कि यहां दिखाया गया है:

      var ref = FirebaseDatabase.DefaultInstance
      .GetReference("GameSessionComments");

      ref.ChildAdded += HandleChildAdded;
      ref.ChildChanged += HandleChildChanged;
      ref.ChildRemoved += HandleChildRemoved;
      ref.ChildMoved += HandleChildMoved;
    }

    void HandleChildAdded(object sender, ChildChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

    void HandleChildChanged(object sender, ChildChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

    void HandleChildRemoved(object sender, ChildChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

    void HandleChildMoved(object sender, ChildChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

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

ChildChanged इवेंट तब ट्रिगर होता है, जब किसी चाइल्ड नोड में बदलाव किया जाता है. इसमें चाइल्ड नोड के डिसेंडेंट में किए गए बदलाव भी शामिल हैं. आम तौर पर, इसका इस्तेमाल ChildAdded और ChildRemoved इवेंट के साथ किया जाता है, ताकि आइटम की सूची में किए गए बदलावों का जवाब दिया जा सके. इवेंट लिसनर को पास किए गए स्नैपशॉट में, चाइल्ड के लिए अपडेट किया गया डेटा होता है.

किसी बच्चे को हटाए जाने पर, ChildRemoved इवेंट ट्रिगर होता है. आम तौर पर, इसका इस्तेमाल ChildAdded और ChildChanged कॉलबैक के साथ किया जाता है. इवेंट कॉलबैक को पास किए गए स्नैपशॉट में, हटाए गए बच्चे का डेटा होता है.

ChildMoved इवेंट तब ट्रिगर होता है, जब ChildChanged इवेंट को किसी ऐसे अपडेट से ट्रिगर किया जाता है जिसकी वजह से चाइल्ड के क्रम में बदलाव होता है. इसका इस्तेमाल ऐसे डेटा के साथ किया जाता है जिसे OrderByChild या OrderByValue के साथ क्रम में लगाया गया हो.

डेटा को क्रम से लगाना और फ़िल्टर करना

Realtime Database Query क्लास का इस्तेमाल करके, कुंजी, वैल्यू या चाइल्ड की वैल्यू के हिसाब से क्रम से लगाया गया डेटा वापस पाया जा सकता है. क्रम से लगाए गए नतीजों को, नतीजों की किसी खास संख्या या कुंजियों या वैल्यू की किसी सीमा के हिसाब से भी फ़िल्टर किया जा सकता है.

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

डेटा को क्रम से लगाना

क्रम से लगाया गया डेटा वापस पाने के लिए, सबसे पहले order-by के किसी एक तरीके को तय करें. इससे यह तय किया जा सकेगा कि नतीजों को किस क्रम में लगाया जाए:

तरीका	इस्तेमाल
`OrderByChild()`	किसी तय की गई चाइल्ड की के हिसाब से नतीजों को क्रम में लगाता है.
`OrderByKey()`	नतीजों को चाइल्ड की के हिसाब से क्रम में लगाएं.
`OrderByValue()`	चाइल्ड वैल्यू के हिसाब से नतीजों को क्रम से लगाएं.

एक बार में, सिर्फ़ एक ऑर्डर-बाय तरीके का इस्तेमाल किया जा सकता है. एक ही क्वेरी में order-by तरीके को कई बार कॉल करने पर गड़बड़ी होती है.

यहां दिए गए उदाहरण में, स्कोर के हिसाब से क्रम में लगे स्कोर लीडरबोर्ड पर सदस्यता लेने का तरीका बताया गया है.

      FirebaseDatabase.DefaultInstance
        .GetReference("Leaders").OrderByChild("score")
        .ValueChanged += HandleValueChanged;
    }

    void HandleValueChanged(object sender, ValueChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

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

OrderByChild() तरीके को कॉल करने पर, नतीजों को क्रम से लगाने के लिए चाइल्ड की तय की जाती है. इस मामले में, नतीजों को हर चाइल्ड में मौजूद "score" वैल्यू के हिसाब से क्रम से लगाया जाता है. अन्य डेटा टाइप को क्रम से लगाने के तरीके के बारे में ज़्यादा जानने के लिए, क्वेरी किए गए डेटा को क्रम से कैसे लगाया जाता है लेख पढ़ें.

डेटा फ़िल्टर करना

डेटा को फ़िल्टर करने के लिए, क्वेरी बनाते समय सीमा या रेंज के किसी भी तरीके को क्रम से लगाने के तरीके के साथ जोड़ा जा सकता है.

तरीका	इस्तेमाल
`LimitToFirst()`	इससे नतीजों की क्रम से लगाई गई सूची की शुरुआत से, दिखाए जाने वाले आइटम की ज़्यादा से ज़्यादा संख्या सेट की जाती है.
`LimitToLast()`	इससे, क्रम से लगाए गए नतीजों की सूची के आखिर से ज़्यादा से ज़्यादा आइटम वापस लाने की संख्या सेट की जाती है.
`StartAt()`	चुनी गई 'इसके हिसाब से क्रम लगाएं' विधि के आधार पर, दी गई कुंजी या वैल्यू से ज़्यादा या उसके बराबर आइटम दिखाएं.
`EndAt()`	चुनी गई 'इसके हिसाब से क्रम लगाएं' विधि के आधार पर, दी गई कुंजी या वैल्यू से कम या उसके बराबर आइटम दिखाएं.
`EqualTo()`	चुनी गई order-by विधि के आधार पर, दी गई कुंजी या वैल्यू के बराबर आइटम दिखाता है.

order-by के तरीकों के उलट, limit या range फ़ंक्शन को एक साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए, StartAt() और EndAt() तरीकों को एक साथ इस्तेमाल करके, नतीजों को वैल्यू की तय की गई सीमा तक सीमित किया जा सकता है.

क्वेरी के लिए सिर्फ़ एक मैच होने पर भी, स्नैपशॉट एक सूची होती है. इसमें सिर्फ़ एक आइटम होता है.

नतीजों की संख्या सीमित करना

LimitToFirst() और LimitToLast() तरीकों का इस्तेमाल करके, किसी दिए गए कॉलबैक के लिए सिंक किए जाने वाले बच्चों की ज़्यादा से ज़्यादा संख्या सेट की जा सकती है. उदाहरण के लिए, अगर आपने LimitToFirst() का इस्तेमाल करके 100 की सीमा सेट की है, तो आपको शुरुआत में सिर्फ़ 100 ChildAdded कॉलबैक मिलेंगे. अगर आपकी Firebase डेटाबेस में 100 से कम आइटम सेव हैं, तो हर आइटम के लिए ChildAdded कॉलबैक ट्रिगर होता है.

सामान बदलने पर, आपको क्वेरी में शामिल होने वाले सामान के लिए ChildAdded कॉलबैक और क्वेरी से बाहर निकलने वाले सामान के लिए ChildRemoved कॉलबैक मिलते हैं, ताकि कुल संख्या 100 पर बनी रहे.

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

      FirebaseDatabase.DefaultInstance
        .GetReference("Leaders").OrderByChild("score").LimitToLast(1)
        .ValueChanged += HandleValueChanged;
    }

    void HandleValueChanged(object sender, ValueChangedEventArgs args) {
      if (args.DatabaseError != null) {
        Debug.LogError(args.DatabaseError.Message);
        return;
      }
      // Do something with the data in args.Snapshot
    }

कुंजी या वैल्यू के हिसाब से फ़िल्टर करना

StartAt(), EndAt(), और EqualTo() का इस्तेमाल करके, क्वेरी के लिए आर्बिट्रेरी शुरुआती, आखिरी, और समानता वाले पॉइंट चुने जा सकते हैं. यह डेटा को पेज में बांटने या बच्चों के साथ ऐसे आइटम ढूंढने के लिए काम आ सकता है जिनकी कोई खास वैल्यू है.

क्वेरी के डेटा को कैसे क्रम से लगाया जाता है

इस सेक्शन में बताया गया है कि Query क्लास में, ऑर्डर करने के हर तरीके से डेटा को कैसे क्रम से लगाया जाता है.

`OrderByChild`

OrderByChild() का इस्तेमाल करते समय, दी गई चाइल्ड की के हिसाब से डेटा को इस तरह से क्रम में लगाया जाता है:

जिन बच्चों के लिए, दी गई चाइल्ड की की null वैल्यू है उन्हें सबसे पहले दिखाया जाता है.
इसके बाद, उस चाइल्ड की के लिए false वैल्यू वाले बच्चे दिखते हैं. अगर एक से ज़्यादा बच्चों के लिए false वैल्यू है, तो उन्हें की के हिसाब से लेक्सिकोग्राफ़िक क्रम में लगाया जाता है.
इसके बाद, उन बच्चों को शामिल किया जाता है जिनके लिए, तय की गई चाइल्ड की वैल्यू true है. अगर एक से ज़्यादा चाइल्ड में true वैल्यू है, तो उन्हें कुंजी के हिसाब से लेक्सिकोग्राफ़िक क्रम में लगाया जाता है.
इसके बाद, संख्या वाली वैल्यू वाले बच्चे आते हैं. इन्हें बढ़ते क्रम में लगाया जाता है. अगर कई चाइल्ड नोड के लिए, तय किए गए चाइल्ड नोड की संख्यात्मक वैल्यू एक जैसी है, तो उन्हें कुंजी के हिसाब से क्रम में लगाया जाता है.
स्ट्रिंग, संख्याओं के बाद आती हैं और इन्हें लेक्सिकोग्राफ़िक तरीके से बढ़ते क्रम में लगाया जाता है. अगर कई चाइल्ड नोड की वैल्यू एक जैसी है, तो उन्हें लेक्सिकोग्राफ़िक तरीके से कुंजी के हिसाब से क्रम में लगाया जाता है.
ऑब्जेक्ट आखिर में आते हैं और उन्हें लेक्सिकोग्राफ़िक क्रम में, कुंजी के हिसाब से बढ़ते क्रम में लगाया जाता है.

`OrderByKey`

अपने डेटा को क्रम से लगाने के लिए OrderByKey() का इस्तेमाल करने पर, डेटा को कुंजी के हिसाब से बढ़ते क्रम में दिखाया जाता है.

जिन बच्चों के पास ऐसी कुंजी होती है जिसे 32-बिट पूर्णांक के तौर पर पार्स किया जा सकता है उन्हें सबसे पहले दिखाया जाता है. इन्हें बढ़ते क्रम में क्रमबद्ध किया जाता है.
इसके बाद, वे बच्चे आते हैं जिनकी कुंजी के तौर पर स्ट्रिंग वैल्यू होती है. इन्हें लेक्सिकोग्राफ़िक क्रम में बढ़ते क्रम में क्रमबद्ध किया जाता है.

`OrderByValue`

OrderByValue() का इस्तेमाल करने पर, बच्चों को उनकी वैल्यू के हिसाब से क्रम में लगाया जाता है. क्रम से लगाने के मानदंड, OrderByChild() में दिए गए मानदंडों के जैसे ही होते हैं. हालांकि, इसमें किसी तय की गई चाइल्ड कुंजी की वैल्यू के बजाय नोड की वैल्यू का इस्तेमाल किया जाता है.