firebase - फायरबेस फायरस्टार संग्रह संख्या




google-cloud-firestore (7)

अपडेट (अप्रैल 2019) - FieldValue.increment (बड़े संग्रह समाधान देखें)

कई सवालों के साथ, जवाब है - यह निर्भर करता है

सामने के छोर पर बड़ी मात्रा में डेटा को संभालते समय आपको बहुत सावधान रहना चाहिए। अपने फ्रंट एंड को सुस्त महसूस करने के लिए, फायरस्टार आपसे $ 0.60 प्रति मिलियन की दर से आपके द्वारा पढ़े जाने का शुल्क भी लेता है

छोटा संग्रह (100 से कम दस्तावेज)

देखभाल के साथ उपयोग करें - फ्रंटेंड उपयोगकर्ता अनुभव हिट हो सकता है

जब तक आप इस लौटे सरणी के साथ बहुत अधिक तर्क नहीं कर रहे हैं तब तक इसे फ्रंट एंड पर संभालना ठीक होना चाहिए।

db.collection('...').get().then(snap => {
   size = snap.size // will return the collection size
});

मध्यम संग्रह (100 से 1000 दस्तावेज)

देखभाल के साथ उपयोग करें - फायरस्टार पढ़े गए इनवोकेशन में बहुत अधिक लागत आ सकती है

इसे फ्रंट एंड पर हैंडल करना संभव नहीं है क्योंकि इसमें यूजर्स सिस्टम को धीमा करने की बहुत अधिक क्षमता है। हमें इस लॉजिक सर्वर साइड को हैंडल करना चाहिए और केवल साइज वापस करना चाहिए।

इस पद्धति की खामी यह है कि आप अभी भी फायरस्टार रीड (आपके संग्रह के आकार के बराबर) को आमंत्रित कर रहे हैं, जो लंबे समय में आपको उम्मीद से अधिक लागत तक खत्म कर सकता है।

बादल समारोह:

...
db.collection('...').get().then(snap => {
    res.status(200).send({length: snap.size});
});

फ़्रंट एंड:

yourHttpClient.post(yourCloudFunctionUrl).toPromise().then(snap => {
     size = snap.length // will return the collection size
})

बड़ा संग्रह (1000+ दस्तावेज)

सबसे स्केलेबल समाधान

FieldValue.increment ()

अप्रैल 2019 तक फायरस्टार अब काउंटर्स बढ़ाने की अनुमति देता है, पूरी तरह से एटोमिक रूप से और बिना डेटा पढ़े यह सुनिश्चित करता है कि हमारे पास कई स्रोतों से एक साथ अपडेट करते समय (पहले लेन-देन का उपयोग करके हल किया गया) भी सही काउंटर वैल्यू है, जबकि डेटाबेस रीड्स की संख्या को कम करके हम प्रदर्शन करते हैं।

किसी भी डॉक्यूमेंट को डिलीट या क्रिएट करके हम डेटाबेस में बैठे काउंट फील्ड से जोड़ या हटा सकते हैं।

फायरस्टार डॉक्स - डिस्ट्रीब्यूटेड काउंटर्स देखें या जेफ डेलानी द्वारा डेटा एकत्रीकरण पर एक नज़र डालें। AngularFire का उपयोग करने वाले किसी के लिए भी उसके मार्गदर्शक वास्तव में शानदार हैं लेकिन उसके पाठों को अन्य रूपरेखाओं पर भी ले जाना चाहिए।

बादल समारोह:

export const documentWriteListener = 
    functions.firestore.document('collection/{documentUid}')
    .onWrite((change, context) => {

    if (!change.before.exists) {
        // New document Created : add one to count

        db.doc(docRef).update({numberOfDocs: FieldValue.increment(1)});

    } else if (change.before.exists && change.after.exists) {
        // Updating existing document : Do nothing

    } else if (!change.after.exists) {
        // Deleting document : subtract one from count

        db.doc(docRef).update({numberOfDocs: FieldValue.increment(-1)});

    }

return;
});

अब दृश्यपटल पर आप संग्रह के आकार को प्राप्त करने के लिए इस नंबरऑफ़डॉक्स फ़ील्ड को क्वेरी कर सकते हैं।

क्या यह गणना करना संभव है कि नए फायरबेस डेटाबेस, फायरस्टार का उपयोग करके कितने आइटमों का संग्रह है?

अगर ऐसा है, तो मैं वह कैसे करू?


ऊपर दिए गए कुछ उत्तरों के आधार पर मुझे यह काम करने में थोड़ा समय लगा, इसलिए मैंने सोचा कि मैं इसे दूसरों के उपयोग के लिए साझा करूँगा। मुझे आशा है कि यह उपयोगी है।

'use strict';

const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();
const db = admin.firestore();

exports.countDocumentsChange = functions.firestore.document('library/{categoryId}/documents/{documentId}').onWrite((change, context) => {

    const categoryId = context.params.categoryId;
    const categoryRef = db.collection('library').doc(categoryId)
    let FieldValue = require('firebase-admin').firestore.FieldValue;

    if (!change.before.exists) {

        // new document created : add one to count
        categoryRef.update({numberOfDocs: FieldValue.increment(1)});
        console.log("%s numberOfDocs incremented by 1", categoryId);

    } else if (change.before.exists && change.after.exists) {

        // updating existing document : Do nothing

    } else if (!change.after.exists) {

        // deleting document : subtract one from count
        categoryRef.update({numberOfDocs: FieldValue.increment(-1)});
        console.log("%s numberOfDocs decremented by 1", categoryId);

    }

    return 0;
});

कोई प्रत्यक्ष विकल्प उपलब्ध नहीं है। आप db.collection("CollectionName").count() नीचे दो तरीके दिए गए हैं जिनके द्वारा आप एक संग्रह के भीतर दस्तावेजों की संख्या की गिनती पा सकते हैं।

1: - संग्रह में सभी दस्तावेज प्राप्त करें और फिर उसका आकार प्राप्त करें। (सबसे अच्छा समाधान नहीं)

db.collection("CollectionName").get().subscribe(doc=>{
console.log(doc.size)
})

उपरोक्त कोड का उपयोग करके आपके दस्तावेज़ पढ़ता है एक संग्रह के भीतर दस्तावेजों के आकार के बराबर होगा और यही कारण है कि किसी को उपरोक्त समाधान का उपयोग करने से बचना चाहिए।

2: - अपने संग्रह के साथ एक अलग दस्तावेज़ बनाएँ जो संग्रह में दस्तावेजों की संख्या की गणना करेगा। (सर्वश्रेष्ठ समाधान)

db.collection("CollectionName").doc("counts")get().subscribe(doc=>{
console.log(doc.count)
})

ऊपर हमने सभी गणना की जानकारी संग्रहीत करने के लिए नाम के साथ एक दस्तावेज बनाया है। आप निम्नलिखित तरीके से गणना दस्तावेज़ को अपडेट कर सकते हैं: -

  • दस्तावेज़ काउंट पर एक फायरस्टार ट्रिगर बनाएँ
  • जब कोई नया दस्तावेज़ बनाया जाता है तो काउंट डॉक्यूमेंट की गिनती संपत्ति में वृद्धि।
  • दस्तावेज़ हटाए जाने पर काउंट डॉक्यूमेंट की गिनती संपत्ति में कमी।

wrt मूल्य (दस्तावेज़ पढ़ें = 1) और तेजी से डेटा पुनर्प्राप्ति उपरोक्त समाधान अच्छा है।


जहां तक ​​मुझे पता है कि इसके लिए कोई बिल्ड-इन समाधान नहीं है और यह केवल नोड एसडीके में ही संभव है। अगर आपके पास एक है

db.collection ( 'someCollection')

आप उपयोग कर सकते हैं

.Select ([क्षेत्रों])

परिभाषित करना कि आप किस क्षेत्र का चयन करना चाहते हैं। यदि आप एक खाली चयन () करते हैं तो आपको दस्तावेज़ संदर्भों की एक सरणी मिलेगी।

उदाहरण:

db.collection('someCollection').select().get().then( (snapshot) => console.log(snapshot.docs.length) );

यह समाधान केवल सभी दस्तावेजों को डाउनलोड करने के सबसे खराब स्थिति के लिए एक अनुकूलन है और बड़े संग्रह पर स्केल नहीं करता है!

इस पर भी एक नजर:
क्लाउड फायरस्टार के साथ एक संग्रह में दस्तावेजों की संख्या की संख्या कैसे प्राप्त करें


मैं @ मैथ्यू के साथ सहमत हूं, अगर आप इस तरह की क्वेरी करते हैं तो बहुत अधिक खर्च होगा।

[विकासकर्ताओं के लिए सलाहें आगे बढ़ती हैं]

चूँकि हमने इस स्थिति को शुरू में ही समझ लिया है, इसलिए हम वास्तव में एक number साथ एक काउंटर बना सकते हैं, जिसमें डॉक्यूमेंट के साथ टाइप number सभी काउंटरों को संग्रहीत किया जा सकता है।

उदाहरण के लिए:

संग्रह पर प्रत्येक CRUD ऑपरेशन के लिए, काउंटर दस्तावेज़ अपडेट करें:

  1. जब आप एक नया संग्रह / सबकोलिक्शन बनाते हैं : (काउंटर में +1) [1 राइट ऑपरेशन]
  2. जब आप कोई संग्रह / सब-कलेक्शन हटाते हैं : (काउंटर में -1) [1 राइट ऑपरेशन]
  3. जब आप किसी मौजूदा संग्रह / सबकोलेक्शन को अपडेट करते हैं, तो काउंटर डॉक्यूमेंट पर कुछ भी न करें: (0)
  4. जब आप एक मौजूदा संग्रह / सब-कलेक्शन पढ़ते हैं , तो काउंटर दस्तावेज़ पर कुछ भी न करें: (0)

अगली बार, जब आप संग्रह की संख्या प्राप्त करना चाहते हैं, तो आपको बस दस्तावेज़ फ़ील्ड को क्वेरी / इंगित करना होगा। [1 रीड ऑपरेशन]

इसके अलावा, आप संग्रह नाम को किसी सरणी में संग्रहीत कर सकते हैं, लेकिन यह मुश्किल होगा, फायरबेस में सरणी की स्थिति नीचे दी गई है:

// we send this
['a', 'b', 'c', 'd', 'e']
// Firebase stores this
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

// since the keys are numeric and sequential,
// if we query the data, we get this
['a', 'b', 'c', 'd', 'e']

// however, if we then delete a, b, and d,
// they are no longer mostly sequential, so
// we do not get back an array
{2: 'c', 4: 'e'}

इसलिए, यदि आप संग्रह को हटाने नहीं जा रहे हैं, तो आप वास्तव में हर बार सभी संग्रह को क्वेरी करने के बजाय संग्रह नाम की सूची संग्रहीत करने के लिए सरणी का उपयोग कर सकते हैं।

आशा करता हूँ की ये काम करेगा!


admin.firestore.FieldValue.increment का उपयोग कर एक काउंटर admin.firestore.FieldValue.increment :

exports.onInstanceCreate = functions.firestore.document('projects/{projectId}/instances/{instanceId}')
  .onCreate((snap, context) =>
    db.collection('projects').doc(context.params.projectId).update({
      instanceCount: admin.firestore.FieldValue.increment(1),
    })
  );

exports.onInstanceDelete = functions.firestore.document('projects/{projectId}/instances/{instanceId}')
  .onDelete((snap, context) =>
    db.collection('projects').doc(context.params.projectId).update({
      instanceCount: admin.firestore.FieldValue.increment(-1),
    })
  );

इस उदाहरण में हम एक instanceCount में परियोजना में प्रत्येक बार एक दस्तावेज बढ़ाते हैं जब एक दस्तावेज instances उप संग्रह में जोड़ा जाता है। यदि फ़ील्ड अभी तक मौजूद नहीं है, तो इसे बनाया जाएगा और 1 के लिए बढ़ाया जाएगा।

वृद्धिशील आंतरिक रूप से लेन-देन होता है, लेकिन यदि आपको प्रत्येक 1 सेकंड से अधिक बार वेतन वृद्धि की आवश्यकता है, तो आपको एक वितरित काउंटर का उपयोग करना चाहिए।

यह अक्सर onDelete - onDelete और onDelete - onDelete को लागू करने के बजाए onDelete बजाय बेहतर होगा क्योंकि आप अपडेट के लिए onWrite को कॉल onWrite , जिसका अर्थ है कि आप अनावश्यक फ़ंक्शन onWrite पर अधिक पैसा खर्च कर रहे हैं (यदि आप अपने संग्रह में डॉक्स अपडेट करते हैं)।


firebaseFirestore.collection("...").addSnapshotListener(new EventListener<QuerySnapshot>() {
        @Override
        public void onEvent(QuerySnapshot documentSnapshots, FirebaseFirestoreException e) {

            int Counter = documentSnapshots.size();

        }
    });




google-cloud-firestore