Firebase Firestore: यह क्या है, NoSQL और यह कैसे काम करता है

Firebase Firestore क्या है?

Firebase Firestore एक लचीला, स्केलेबल NoSQL डेटाबेस है जिसे Google ने 2019 में Firebase Realtime Database के विकास के रूप में लॉन्च किया। यह डॉक्यूमेंट के कलेक्शन में डेटा संग्रहीत करता है, जहाँ प्रत्येक डॉक्यूमेंट में की-वैल्यू जोड़े का एक सेट होता है। पारंपरिक रिलेशनल डेटाबेस के विपरीत, Firestore को पूर्वनिर्धारित स्कीमा की आवश्यकता नहीं होती — डेटा संरचना लिखे जा रहे डॉक्यूमेंट के आधार पर गतिशील रूप से बनती है।

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

डेटाबेस सभी प्रमुख प्लेटफ़ॉर्म पर उपलब्ध है: Android, iOS, Web (JavaScript) और Admin SDK के माध्यम से सर्वर-साइड भाषाएँ। Firestore Swift, Kotlin, JavaScript, Python, Go, Java और Node.js के लिए SDK प्रदान करता है। Google के अनुसार, Firestore संपूर्ण Firebase इकोसिस्टम में प्रतिदिन 100 बिलियन से अधिक अनुरोधों को संसाधित करता है, जो प्रोडक्शन एप्लिकेशन के लिए एक आधार के रूप में इसकी विश्वसनीयता की पुष्टि करता है।

मूल अवधारणाएँ: कलेक्शन और डॉक्यूमेंट

Firestore में, डेटा एक पदानुक्रमित संरचना में व्यवस्थित होता है। कलेक्शन डॉक्यूमेंट का एक कंटेनर है, जो SQL में तालिका के समान है लेकिन बिना निश्चित स्कीमा के। डॉक्यूमेंट एक रिकॉर्ड है जिसमें विभिन्न प्रकार के फ़ील्ड होते हैं: स्ट्रिंग, संख्याएँ, बूलियन मान, ऐरे, नेस्टेड ऑब्जेक्ट और जियोपॉइंट। डॉक्यूमेंट में सबकलेक्शन हो सकते हैं, जो किसी भी गहराई के नेस्टेड डेटा संरचनाएँ बनाने की अनुमति देते हैं।

val db = FirebaseFirestore.getInstance()

val user = hashMapOf(
    "name" to "Anna Petrova",
    "email" to "anna@example.com",
    "age" to 28,
    "isActive" to true
)

db.collection("users")
    .add(user)
    .addOnSuccessListener { docRef ->
        Log.d("TAG", "दस्तावेज़ ID के साथ जोड़ा गया: ${docRef.id}")
    }

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

Firebase Firestore vs Realtime Database: तुलना

Firestore और Firebase Realtime Database Google के दो क्लाउड रीयल-टाइम डेटाबेस हैं। जबकि दोनों रीयल-टाइम सिंक्रोनाइज़ेशन प्रदान करते हैं, उनमें डेटा मॉडल, स्केलिंग और मूल्य निर्धारण में मूलभूत अंतर हैं। किसी विशिष्ट प्रोजेक्ट के लिए सही डेटाबेस चुनते समय इन अंतरों को समझना महत्वपूर्ण है।

मुख्य आर्किटेक्चरल अंतर डेटा मॉडल है। Realtime Database सब कुछ एक बड़े JSON ट्री में संग्रहीत करता है, जो गहरी नेस्टिंग वाली क्वेरी को जटिल बनाता है। Firestore कलेक्शन और डॉक्यूमेंट का उपयोग करता है, जो कई शर्तों के साथ जटिल क्वेरी सक्षम करता है। इसके अलावा, Firestore मजबूत डेटा संगति प्रदान करता है: सफल लेखन के बाद, सभी बाद की रीड नवीनतम डेटा लौटाने की गारंटी देती हैं।

स्केलेबिलिटी और डेटा संरचना

Firestore अपनी मल्टी-रीजन आर्किटेक्चर के कारण लाखों समवर्ती कनेक्शन तक स्वचालित रूप से स्केल होता है। Realtime Database एक क्षेत्र तक सीमित है और अधिकतम 200,000 समवर्ती कनेक्शन। वैश्विक दर्शकों को लक्षित करने वाले प्रोजेक्ट के लिए, Firestore बेहतर है क्योंकि डेटा स्वचालित रूप से कई Google डेटा केंद्रों में प्रतिकृति होता है।

Firestore में डेटा संरचना सबकलेक्शन के साथ जटिल पदानुक्रमित मॉडल बनाने की अनुमति देती है। उदाहरण के लिए, एक उपयोगकर्ता के पास «ऑर्डर» सबकलेक्शन हो सकता है, और प्रत्येक ऑर्डर के पास «आइटम» सबकलेक्शन। Realtime Database में, ऐसी गहरी नेस्टिंग क्वेरी के दौरान प्रदर्शन समस्याओं का कारण बनती है, क्योंकि रूट से आवश्यक नोड तक का पूरा पथ लोड होता है।

Firestore में डेटा सिंक्रोनाइज़ेशन कैसे काम करता है

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

सिंक्रोनाइज़ेशन तंत्र इवेंट स्ट्रीम पर आधारित है: added (डॉक्यूमेंट प्रकट हुआ), modified (डॉक्यूमेंट बदला) और removed (डॉक्यूमेंट हटाया गया)। डेवलपर प्रत्येक इवेंट को अलग-अलग संभाल सकता है, केवल संबंधित UI तत्वों को अपडेट करके। यह हजारों डॉक्यूमेंट के साथ भी उच्च प्रदर्शन सुनिश्चित करता है, क्योंकि केवल बदले हुए घटकों को फिर से रेंडर किया जाता है।

ऑफ़लाइन पहुंच और कैशिंग

Firestore के प्रमुख लाभों में से एक अंतर्निहित ऑफ़लाइन मोड समर्थन है। SDK स्वचालित रूप से सभी पढ़े गए डेटा को डिवाइस पर कैश करता है और नेटवर्क न होने पर काम करना जारी रखता है। जब एप्लिकेशन ऑफ़लाइन मोड में डेटा लिखता है, तो इसे स्थानीय कतार में रखा जाता है और कनेक्शन बहाल होने पर सर्वर को भेजा जाता है। विरोध समाधान के लिए last-write-wins रणनीति का उपयोग किया जाता है।

val docRef = db.collection("cities").document("SF")

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "सुनने में त्रुटि", error)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "वर्तमान डेटा: ${snapshot.data}")
    }
}

कैश आकार को FirestoreSettings के माध्यम से कॉन्फ़िगर किया जा सकता है। डिफ़ॉल्ट मान 100 MB है, लेकिन गहन डेटा रीडिंग वाले एप्लिकेशन के लिए इसे बढ़ाया जा सकता है। एक स्थायी डिस्क कैश मोड भी उपलब्ध है जो एप्लिकेशन रीस्टार्ट से बचता है। ऑफ़लाइन मोड की उपलब्धता प्रबंधित करने के लिए, enableNetwork और disableNetwork विधियों का उपयोग किया जाता है, जो अस्थायी रूप से नेटवर्क इंटरैक्शन को अक्षम करने की अनुमति देते हैं।

Firestore सुरक्षा और एक्सेस नियम

Firestore Security Rules सर्वर स्तर पर डेटा तक पहुंच को नियंत्रित करने के लिए एक घोषणात्मक मार्कअप भाषा है। नियम परिभाषित करते हैं कि कौन और किन शर्तों के तहत डॉक्यूमेंट पढ़ और लिख सकता है। वे क्वेरी निष्पादन से पहले काम करते हैं और प्राधिकरण के लिए अलग सर्वर लॉजिक की आवश्यकता नहीं होती। प्रत्येक डेटा रीड या राइट से पहले Firebase पक्ष पर नियमों की जाँच की जाती है।

एक्सेस नियम अनुमति (allow) सिद्धांत पर बनाए गए हैं। डिफ़ॉल्ट रूप से, सभी पहुंच निषिद्ध है। डेवलपर विशिष्ट शर्तों के तहत विशिष्ट संचालन (read, write, create, update, delete) के लिए क्रमिक रूप से पहुंच खोलता है। शर्तें request.auth के माध्यम से उपयोगकर्ता प्रमाणीकरण, request.resource के माध्यम से अनुरोध डेटा और resource के माध्यम से मौजूदा डेटा की जाँच कर सकती हैं।

// Firestore एक्सेस नियम
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // उपयोगकर्ता केवल अपना डेटा पढ़ता और लिखता है
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // कोई भी प्रमाणित उपयोगकर्ता पोस्ट पढ़ सकता है
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

नियमों के माध्यम से डेटा सत्यापन

एक्सेस नियंत्रण के अलावा, Security Rules लिखे गए डेटा की संरचना और प्रकारों को मान्य करने की अनुमति देती हैं। उदाहरण के लिए, यह जाँच की जा सकती है कि ईमेल फ़ील्ड एक नियमित अभिव्यक्ति से मेल खाता है, या उम्र 120 वर्ष से अधिक नहीं है। सत्यापन लेखन से पहले किया जाता है, जो सर्वर पर गलत डेटा सहेजने से रोकता है। फ़ील्ड सत्यापन के लिए, request.resource.data ऑब्जेक्ट का उपयोग किया जाता है जिसमें पूरा लिखा जा रहा डॉक्यूमेंट होता है।

Firestore उन कलेक्शन का भी समर्थन करता है जो क्लाइंट पहुंच के बिना, केवल Admin SDK के माध्यम से सर्वर-साइड लेखन के लिए सुलभ हैं। यह सेवा जानकारी, API कुंजियाँ और कॉन्फ़िगरेशन संग्रहीत करने के लिए सुविधाजनक है जो उपयोगकर्ताओं को दिखाई नहीं देनी चाहिए। इसके लिए, नियमों में संबंधित कलेक्शन पर सभी क्लाइंट संचालन को अस्वीकार करना पर्याप्त है, केवल सर्वर पक्ष से Admin SDK के माध्यम से पहुंच की अनुमति देता है।

Android में Firebase Firestore का उपयोग उदाहरण

आइए टू-डू सूची (todo) बनाने के लिए Android एप्लिकेशन में Firestore एकीकरण का एक उदाहरण देखें। एप्लिकेशन वास्तविक समय में कार्यों को पढ़ेगा, नए जोड़ेगा और पूर्ण किए गए कार्यों को चिह्नित करेगा। एसिंक्रोनस कार्य के लिए, Firebase कॉलबैक इंटरफ़ेस और Kotlin कोरूटीन का उपयोग किया जाता है।

Firebase सेटअप और निर्भरताएँ जोड़ना

शुरू करने से पहले, प्रोजेक्ट को Firebase Console के माध्यम से Firebase से कनेक्ट करना और एप्लिकेशन मॉड्यूल में google-services.json फ़ाइल जोड़ना आवश्यक है। फिर, build.gradle में firebase-firestore-ktx निर्भरता और google-services प्लगइन जोड़ा जाता है। लाइब्रेरी संस्करण सभी Firebase घटकों की एक दूसरे के साथ संगतता के लिए वर्तमान Firebase BoM संस्करण के अनुरूप होना चाहिए।

dependencies {
    // Firebase BoM — संस्करण प्रबंधन
    implementation platform("com.google.firebase:firebase-bom:33.0.0")
    implementation "com.google.firebase:firebase-firestore-ktx"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0"
}

सेटअप के बाद, एक Task डेटा मॉडल और Firestore के साथ काम करने के लिए एक रिपॉजिटरी बनाई जाती है। मॉडल में id, title, isCompleted और timestamp फ़ील्ड होते हैं। Firestore फ़ील्ड नामों को कुंजी के रूप में उपयोग करके स्वचालित रूप से डेटा क्लास को डॉक्यूमेंट में सीरियलाइज़ करता है। डेटा पढ़ने के लिए, एक स्नैपशॉट लिसनर का उपयोग किया जाता है जो snapshotFlow एक्सटेंशन के माध्यम से Flow लौटाता है।

data class Task(
    val id: String = "",
    val title: String = "",
    val isCompleted: Boolean = false,
    val createdAt: Timestamp? = null
)

class TaskRepository {
    private val tasksRef = FirebaseFirestore
        .getInstance()
        .collection("tasks")

    fun getTasks(): Flow<List<Task>> = tasksRef
        .orderBy("createdAt", Query.Direction.DESCENDING)
        .snapshotFlow()
        .map { snapshot ->
            snapshot?.toObjects(Task::class.java) ?: emptyList()
        }

    suspend fun addTask(title: String) {
        tasksRef.add(Task(title = title))
    }
}

ViewModel रिपॉजिटरी से Flow की सदस्यता लेता है और कार्य सूची को UI स्तर पर भेजता है। जब एक नया कार्य जोड़ा जाता है, तो कोरूटीन स्कोप के माध्यम से रिपॉजिटरी की suspend फ़ंक्शन कॉल की जाती है। Firestore स्वचालित रूप से सभी क्लाइंट के बीच परिवर्तनों को सिंक्रोनाइज़ करता है: यदि एक उपयोगकर्ता कार्य जोड़ता है, तो अन्य इसे स्क्रीन रीफ़्रेश किए बिना वास्तविक समय में देखते हैं।