क्लाउड फायरस्टोर में क्वेरीज़ आपको बड़े संग्रहों में दस्तावेज़ ढूंढने देती हैं। समग्र रूप से संग्रह के गुणों के बारे में जानकारी प्राप्त करने के लिए, आप किसी संग्रह में डेटा एकत्र कर सकते हैं।
आप डेटा को पढ़ने के समय या लिखने के समय एकत्र कर सकते हैं:
रीड-टाइम एकत्रीकरण अनुरोध के समय परिणाम की गणना करता है। क्लाउड फायरस्टोर रीड-टाइम पर
count()
,sum()
औरaverage()
एकत्रीकरण प्रश्नों का समर्थन करता है। राइट-टाइम एग्रीगेशन की तुलना में रीड-टाइम एग्रीगेशन क्वेरीज़ को आपके ऐप में जोड़ना आसान है। एकत्रीकरण प्रश्नों के बारे में अधिक जानकारी के लिए, एकत्रीकरण प्रश्नों के साथ डेटा का सारांश देखें।हर बार जब ऐप प्रासंगिक लेखन कार्य करता है तो लेखन-समय एकत्रीकरण एक परिणाम की गणना करता है। लेखन-समय एकत्रीकरण को कार्यान्वित करना अधिक कठिन है, लेकिन आप निम्न कारणों में से किसी एक के लिए पढ़ने-समय एकत्रीकरण के बजाय उनका उपयोग कर सकते हैं:
- आप वास्तविक समय के अपडेट के लिए एकत्रीकरण परिणाम सुनना चाहते हैं।
count()
,sum()
, औरaverage()
एकत्रीकरण क्वेरी वास्तविक समय अपडेट का समर्थन नहीं करती हैं। - आप एकत्रीकरण परिणाम को क्लाइंट-साइड कैश में संग्रहीत करना चाहते हैं।
count()
,sum()
, औरaverage()
एकत्रीकरण प्रश्न कैशिंग का समर्थन नहीं करते हैं। - आप अपने प्रत्येक उपयोगकर्ता के लिए हजारों दस्तावेज़ों से डेटा एकत्र कर रहे हैं और लागतों पर विचार कर रहे हैं। दस्तावेज़ों की कम संख्या होने पर, पढ़ने के समय एकत्रीकरण की लागत कम होती है। एक एकत्रीकरण में बड़ी संख्या में दस्तावेज़ों के लिए, लेखन-समय एकत्रीकरण की लागत कम हो सकती है।
- आप वास्तविक समय के अपडेट के लिए एकत्रीकरण परिणाम सुनना चाहते हैं।
आप क्लाइंट-साइड लेनदेन या क्लाउड फ़ंक्शंस का उपयोग करके राइट-टाइम एकत्रीकरण लागू कर सकते हैं। निम्नलिखित अनुभाग वर्णन करते हैं कि लेखन-समय एकत्रीकरण को कैसे कार्यान्वित किया जाए।
समाधान: क्लाइंट-साइड लेनदेन के साथ राइट-टाइम एकत्रीकरण
एक स्थानीय अनुशंसा ऐप पर विचार करें जो उपयोगकर्ताओं को बेहतरीन रेस्तरां ढूंढने में मदद करता है। निम्नलिखित क्वेरी किसी दिए गए रेस्तरां के लिए सभी रेटिंग पुनर्प्राप्त करती है:
वेब
db.collection("restaurants") .doc("arinell-pizza") .collection("ratings") .get();
तीव्र
db.collection("restaurants") .document("arinell-pizza") .collection("ratings") .getDocuments() { (querySnapshot, err) in // ... }
उद्देश्य सी
FIRQuery *query = [[[self.db collectionWithPath:@"restaurants"] documentWithPath:@"arinell-pizza"] collectionWithPath:@"ratings"]; [query getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot, NSError * _Nullable error) { // ... }];
Kotlin+KTX
db.collection("restaurants") .document("arinell-pizza") .collection("ratings") .get()
Java
db.collection("restaurants") .document("arinell-pizza") .collection("ratings") .get();
सभी रेटिंग प्राप्त करने और फिर समग्र जानकारी की गणना करने के बजाय, हम इस जानकारी को रेस्तरां दस्तावेज़ पर ही संग्रहीत कर सकते हैं:
वेब
var arinellDoc = { name: 'Arinell Pizza', avgRating: 4.65, numRatings: 683 };
तीव्र
struct Restaurant { let name: String let avgRating: Float let numRatings: Int init(name: String, avgRating: Float, numRatings: Int) { self.name = name self.avgRating = avgRating self.numRatings = numRatings } } let arinell = Restaurant(name: "Arinell Pizza", avgRating: 4.65, numRatings: 683)
उद्देश्य सी
@interface FIRRestaurant : NSObject @property (nonatomic, readonly) NSString *name; @property (nonatomic, readonly) float averageRating; @property (nonatomic, readonly) NSInteger ratingCount; - (instancetype)initWithName:(NSString *)name averageRating:(float)averageRating ratingCount:(NSInteger)ratingCount; @end @implementation FIRRestaurant - (instancetype)initWithName:(NSString *)name averageRating:(float)averageRating ratingCount:(NSInteger)ratingCount { self = [super init]; if (self != nil) { _name = name; _averageRating = averageRating; _ratingCount = ratingCount; } return self; } @end
Kotlin+KTX
data class Restaurant( // default values required for use with "toObject" internal var name: String = "", internal var avgRating: Double = 0.0, internal var numRatings: Int = 0, )
val arinell = Restaurant("Arinell Pizza", 4.65, 683)
Java
public class Restaurant { String name; double avgRating; int numRatings; public Restaurant(String name, double avgRating, int numRatings) { this.name = name; this.avgRating = avgRating; this.numRatings = numRatings; } }
Restaurant arinell = new Restaurant("Arinell Pizza", 4.65, 683);
इन एकत्रीकरणों को सुसंगत बनाए रखने के लिए, उपसंग्रह में हर बार नई रेटिंग जोड़े जाने पर उन्हें अद्यतन किया जाना चाहिए। स्थिरता प्राप्त करने का एक तरीका एक ही लेनदेन में ऐड और अपडेट करना है:
वेब
function addRating(restaurantRef, rating) { // Create a reference for a new rating, for use inside the transaction var ratingRef = restaurantRef.collection('ratings').doc(); // In a transaction, add the new rating and update the aggregate totals return db.runTransaction((transaction) => { return transaction.get(restaurantRef).then((res) => { if (!res.exists) { throw "Document does not exist!"; } // Compute new number of ratings var newNumRatings = res.data().numRatings + 1; // Compute new average rating var oldRatingTotal = res.data().avgRating * res.data().numRatings; var newAvgRating = (oldRatingTotal + rating) / newNumRatings; // Commit to Firestore transaction.update(restaurantRef, { numRatings: newNumRatings, avgRating: newAvgRating }); transaction.set(ratingRef, { rating: rating }); }); }); }
तीव्र
func addRatingTransaction(restaurantRef: DocumentReference, rating: Float) { let ratingRef: DocumentReference = restaurantRef.collection("ratings").document() db.runTransaction({ (transaction, errorPointer) -> Any? in do { let restaurantDocument = try transaction.getDocument(restaurantRef).data() guard var restaurantData = restaurantDocument else { return nil } // Compute new number of ratings let numRatings = restaurantData["numRatings"] as! Int let newNumRatings = numRatings + 1 // Compute new average rating let avgRating = restaurantData["avgRating"] as! Float let oldRatingTotal = avgRating * Float(numRatings) let newAvgRating = (oldRatingTotal + rating) / Float(newNumRatings) // Set new restaurant info restaurantData["numRatings"] = newNumRatings restaurantData["avgRating"] = newAvgRating // Commit to Firestore transaction.setData(restaurantData, forDocument: restaurantRef) transaction.setData(["rating": rating], forDocument: ratingRef) } catch { // Error getting restaurant data // ... } return nil }) { (object, err) in // ... } }
उद्देश्य सी
- (void)addRatingTransactionWithRestaurantReference:(FIRDocumentReference *)restaurant rating:(float)rating { FIRDocumentReference *ratingReference = [[restaurant collectionWithPath:@"ratings"] documentWithAutoID]; [self.db runTransactionWithBlock:^id (FIRTransaction *transaction, NSError **errorPointer) { FIRDocumentSnapshot *restaurantSnapshot = [transaction getDocument:restaurant error:errorPointer]; if (restaurantSnapshot == nil) { return nil; } NSMutableDictionary *restaurantData = [restaurantSnapshot.data mutableCopy]; if (restaurantData == nil) { return nil; } // Compute new number of ratings NSInteger ratingCount = [restaurantData[@"numRatings"] integerValue]; NSInteger newRatingCount = ratingCount + 1; // Compute new average rating float averageRating = [restaurantData[@"avgRating"] floatValue]; float newAverageRating = (averageRating * ratingCount + rating) / newRatingCount; // Set new restaurant info restaurantData[@"numRatings"] = @(newRatingCount); restaurantData[@"avgRating"] = @(newAverageRating); // Commit to Firestore [transaction setData:restaurantData forDocument:restaurant]; [transaction setData:@{@"rating": @(rating)} forDocument:ratingReference]; return nil; } completion:^(id _Nullable result, NSError * _Nullable error) { // ... }]; }
Kotlin+KTX
private fun addRating(restaurantRef: DocumentReference, rating: Float): Task<Void> { // Create reference for new rating, for use inside the transaction val ratingRef = restaurantRef.collection("ratings").document() // In a transaction, add the new rating and update the aggregate totals return db.runTransaction { transaction -> val restaurant = transaction.get(restaurantRef).toObject<Restaurant>()!! // Compute new number of ratings val newNumRatings = restaurant.numRatings + 1 // Compute new average rating val oldRatingTotal = restaurant.avgRating * restaurant.numRatings val newAvgRating = (oldRatingTotal + rating) / newNumRatings // Set new restaurant info restaurant.numRatings = newNumRatings restaurant.avgRating = newAvgRating // Update restaurant transaction.set(restaurantRef, restaurant) // Update rating val data = hashMapOf<String, Any>( "rating" to rating, ) transaction.set(ratingRef, data, SetOptions.merge()) null } }
Java
private Task<Void> addRating(final DocumentReference restaurantRef, final float rating) { // Create reference for new rating, for use inside the transaction final DocumentReference ratingRef = restaurantRef.collection("ratings").document(); // In a transaction, add the new rating and update the aggregate totals return db.runTransaction(new Transaction.Function<Void>() { @Override public Void apply(@NonNull Transaction transaction) throws FirebaseFirestoreException { Restaurant restaurant = transaction.get(restaurantRef).toObject(Restaurant.class); // Compute new number of ratings int newNumRatings = restaurant.numRatings + 1; // Compute new average rating double oldRatingTotal = restaurant.avgRating * restaurant.numRatings; double newAvgRating = (oldRatingTotal + rating) / newNumRatings; // Set new restaurant info restaurant.numRatings = newNumRatings; restaurant.avgRating = newAvgRating; // Update restaurant transaction.set(restaurantRef, restaurant); // Update rating Map<String, Object> data = new HashMap<>(); data.put("rating", rating); transaction.set(ratingRef, data, SetOptions.merge()); return null; } }); }
लेन-देन का उपयोग करने से आपका समग्र डेटा अंतर्निहित संग्रह के अनुरूप रहता है। क्लाउड फायरस्टोर में लेन-देन के बारे में अधिक पढ़ने के लिए, लेन-देन और बैचेड राइट्स देखें।
सीमाएँ
ऊपर दिखाया गया समाधान क्लाउड फायरस्टोर क्लाइंट लाइब्रेरी का उपयोग करके डेटा एकत्र करने को प्रदर्शित करता है, लेकिन आपको निम्नलिखित सीमाओं के बारे में पता होना चाहिए:
- सुरक्षा - क्लाइंट-साइड लेनदेन के लिए ग्राहकों को आपके डेटाबेस में समग्र डेटा को अपडेट करने की अनुमति देना आवश्यक है। हालाँकि आप उन्नत सुरक्षा नियम लिखकर इस दृष्टिकोण के जोखिमों को कम कर सकते हैं, लेकिन यह सभी स्थितियों में उचित नहीं हो सकता है।
- ऑफ़लाइन समर्थन - उपयोगकर्ता का डिवाइस ऑफ़लाइन होने पर क्लाइंट-साइड लेनदेन विफल हो जाएगा, जिसका अर्थ है कि आपको अपने ऐप में इस मामले को संभालने और उचित समय पर पुनः प्रयास करने की आवश्यकता है।
- प्रदर्शन - यदि आपके लेन-देन में एकाधिक पढ़ने, लिखने और अद्यतन संचालन शामिल हैं, तो इसके लिए क्लाउड फायरस्टोर बैकएंड के लिए एकाधिक अनुरोधों की आवश्यकता हो सकती है। मोबाइल डिवाइस पर, इसमें काफी समय लग सकता है।
- दरें लिखें - यह समाधान बार-बार अपडेट किए गए एकत्रीकरण के लिए काम नहीं कर सकता है क्योंकि क्लाउड फायरस्टोर दस्तावेज़ प्रति सेकंड अधिकतम एक बार ही अपडेट किए जा सकते हैं। इसके अतिरिक्त, यदि कोई लेन-देन किसी दस्तावेज़ को पढ़ता है जिसे लेन-देन के बाहर संशोधित किया गया था, तो यह सीमित संख्या में पुनः प्रयास करता है और फिर विफल हो जाता है। एकत्रीकरण के लिए प्रासंगिक समाधान के लिए वितरित काउंटरों की जाँच करें जिन्हें अधिक लगातार अपडेट की आवश्यकता होती है।
समाधान: क्लाउड फ़ंक्शंस के साथ राइट-टाइम एकत्रीकरण
यदि क्लाइंट-साइड लेन-देन आपके एप्लिकेशन के लिए उपयुक्त नहीं है, तो आप हर बार किसी रेस्तरां में नई रेटिंग जोड़ने पर समग्र जानकारी को अपडेट करने के लिए क्लाउड फ़ंक्शन का उपयोग कर सकते हैं:
नोड.जे.एस
exports.aggregateRatings = functions.firestore .document('restaurants/{restId}/ratings/{ratingId}') .onWrite(async (change, context) => { // Get value of the newly added rating const ratingVal = change.after.data().rating; // Get a reference to the restaurant const restRef = db.collection('restaurants').doc(context.params.restId); // Update aggregations in a transaction await db.runTransaction(async (transaction) => { const restDoc = await transaction.get(restRef); // Compute new number of ratings const newNumRatings = restDoc.data().numRatings + 1; // Compute new average rating const oldRatingTotal = restDoc.data().avgRating * restDoc.data().numRatings; const newAvgRating = (oldRatingTotal + ratingVal) / newNumRatings; // Update restaurant info transaction.update(restRef, { avgRating: newAvgRating, numRatings: newNumRatings }); }); });
यह समाधान क्लाइंट से होस्टेड फ़ंक्शन पर काम को ऑफलोड करता है, जिसका अर्थ है कि आपका मोबाइल ऐप लेनदेन पूरा होने की प्रतीक्षा किए बिना रेटिंग जोड़ सकता है। क्लाउड फ़ंक्शन में निष्पादित कोड सुरक्षा नियमों से बंधा नहीं है, जिसका अर्थ है कि अब आपको ग्राहकों को समग्र डेटा तक लिखने की पहुंच देने की आवश्यकता नहीं है।
सीमाएँ
एकत्रीकरण के लिए क्लाउड फ़ंक्शन का उपयोग करने से क्लाइंट-साइड लेनदेन के साथ कुछ समस्याओं से बचा जा सकता है, लेकिन यह सीमाओं के एक अलग सेट के साथ आता है:
- लागत - जोड़ी गई प्रत्येक रेटिंग क्लाउड फ़ंक्शन आमंत्रण का कारण बनेगी, जिससे आपकी लागत बढ़ सकती है। अधिक जानकारी के लिए, क्लाउड फ़ंक्शंस मूल्य निर्धारण पृष्ठ देखें।
- विलंबता - एकत्रीकरण कार्य को क्लाउड फ़ंक्शन पर लोड करने से, आपका ऐप अपडेटेड डेटा तब तक नहीं देख पाएगा जब तक कि क्लाउड फ़ंक्शन निष्पादित नहीं हो जाता और क्लाइंट को नए डेटा के बारे में सूचित नहीं कर दिया जाता। आपके क्लाउड फ़ंक्शन की गति के आधार पर, स्थानीय स्तर पर लेनदेन निष्पादित करने में अधिक समय लग सकता है।
- दरें लिखें - यह समाधान बार-बार अपडेट किए गए एकत्रीकरण के लिए काम नहीं कर सकता है क्योंकि क्लाउड फायरस्टोर दस्तावेज़ प्रति सेकंड अधिकतम एक बार ही अपडेट किए जा सकते हैं। इसके अतिरिक्त, यदि कोई लेन-देन किसी दस्तावेज़ को पढ़ता है जिसे लेन-देन के बाहर संशोधित किया गया था, तो यह सीमित संख्या में पुनः प्रयास करता है और फिर विफल हो जाता है। एकत्रीकरण के लिए प्रासंगिक समाधान के लिए वितरित काउंटरों की जाँच करें जिन्हें अधिक लगातार अपडेट की आवश्यकता होती है।