Firebase Firestore: bu nima, NoSQL va qanday ishlaydi

Firebase Firestore nima?

Firebase Firestore — 2019-yilda Google tomonidan Firebase Realtime Database evolyutsiyasi sifatida ishga tushirilgan moslashuvchan, masshtablanadigan NoSQL ma'lumotlar bazasi. U ma'lumotlarni hujjat kolleksiyalari shaklida saqlaydi, bunda har bir hujjat kalit-qiymat juftliklari to'plamini o'z ichiga oladi. An'anaviy relyatsion bazalardan farqli o'laroq, Firestore oldindan belgilangan sxemani talab qilmaydi — ma'lumotlar strukturasi yozilayotgan hujjatlar asosida dinamik shakllanadi.

Firestore ning klassik bulutli bazalardan asosiy farqi — o'rnatilgan real vaqt sinxronizatsiyasi. Ma'lumotlar serverda o'zgarganda, barcha ulangan mijozlar doimiy WebSocket ulanishi orqali yangilanishlarni oladi. Bu serverni qo'lda so'roq qilish zaruratini bartaraf etadi va jonli yangilanishlar bilan ilovalar qurish imkonini beradi: chatlar, faoliyat lentalari, hamkorlikdagi muharrirlar va monitoring tizimlari.

Ma'lumotlar bazasi barcha asosiy platformalarda mavjud: Android, iOS, Web (JavaScript) va Admin SDK orqali server tillarida. Firestore SDK ni taqdim etadi Swift, Kotlin, JavaScript, Python, Go, Java va Node.js uchun. Google ma'lumotlariga ko'ra, Firestore Firebase ekotizimida kuniga 100 milliarddan ortiq so'rovni qayta ishlaydi, bu uning ishlab chiqarish ilovalari uchun asos sifatida ishonchliligini tasdiqlaydi.

Asosiy tushunchalar: kolleksiyalar va hujjatlar

Firestore da ma'lumotlar iyerarxik tuzilmada tashkil etiladi. Kolleksiya — bu SQL'dagi jadvalga o'xshash, ammo qat'iy sxemasiz hujjatlar konteyneri. Hujjat — bu turli xil turdagi maydonlarni o'z ichiga olgan yozuv: satrlar, raqamlar, mantiqiy qiymatlar, massivlar, ichma-ich obyektlar va geo-nuqtalar. Hujjatlar pastki kolleksiyalarni o'z ichiga olishi mumkin, bu istalgan chuqurlikdagi ichma-ich ma'lumotlar tuzilmalarini qurish imkonini beradi.

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", "Hujjat ID bilan qo'shildi: ${docRef.id}")
    }

Kolleksiyadagi har bir hujjat noyob identifikatorga ega bo'lib, u avtomatik yaratilishi yoki qo'lda o'rnatilishi mumkin. Firestore barcha hujjat maydonlarini avtomatik indekslaydi, bu esa indekslarni oldindan sozlashsiz filtrlash, saralash va natijalar sonini cheklash bilan murakkab so'rovlarni bajarish imkonini beradi.

Firebase Firestore vs Realtime Database: taqqoslash

Firestore va Firebase Realtime Database Google'dan ikkita bulutli real vaqt ma'lumotlar bazasidir. Ikkalasi ham real vaqt sinxronizatsiyasini ta'minlasa-da, ular ma'lumotlar modeli, masshtablash va narxlashda tub farqlarga ega. Bu farqlarni tushunish muayyan loyiha uchun mos bazani tanlashda muhim ahamiyatga ega.

Asosiy arxitektura farqi — ma'lumotlar modeli. Realtime Database hamma narsani bitta katta JSON daraxtida saqlaydi, bu chuqur ichma-ich so'rovlarni qiyinlashtiradi. Firestore kolleksiyalar va hujjatlardan foydalanadi, bu bir nechta shartlar bilan murakkab so'rovlarni bajarish imkonini beradi. Bundan tashqari, Firestore kuchli ma'lumotlar izchilligini ta'minlaydi: muvaffaqiyatli yozishdan keyin barcha keyingi o'qishlar kafolatlangan holda joriy ma'lumotlarni qaytaradi.

Masshtablash va ma'lumotlar tuzilmasi

Firestore ko'p mintaqali arxitektura tufayli millionlab bir vaqtda ulanishlargacha avtomatik masshtablanadi. Realtime Database bitta mintaqa va maksimum 200 000 bir vaqtda ulanish bilan cheklangan. Global auditoriyani rejalashtirgan loyihalar uchun Firestore afzalroq, chunki ma'lumotlar avtomatik ravishda Google-ning bir nechta ma'lumot markazlari o'rtasida replikatsiyalanadi.

Firestore da ma'lumotlar tuzilmasi pastki kolleksiyalar bilan murakkab iyerarxik modellar qurish imkonini beradi. Masalan, foydalanuvchining „buyurtmalar" pastki kolleksiyasi, har bir buyurtmaning esa „mahsulotlar" pastki kolleksiyasi bo'lishi mumkin. Realtime Database'da bunday chuqur ichma-ichlik so'rovlarda ishlash muammolariga olib keladi, chunki ildizdan kerakli tugungacha butun yo'l yuklanadi.

Firestore'da ma'lumot sinxronizatsiyasi qanday ishlaydi

Firestore real vaqt ma'lumot sinxronizatsiyasi uchun mijoz va server o'rtasida doimiy WebSocket ulanishidan foydalanadi. Ilova snapshot listener orqali hujjat yoki kolleksiya o'zgarishlariga obuna bo'lganda, SDK aloqa kanalini o'rnatadi, server har bir ma'lumot o'zgarishida yangilanishlarni yuboradi. Mijoz har safar butun kolleksiyaning to'liq nusxasini emas, faqat o'zgartirilgan hujjatlarni oladi.

Sinxronizatsiya mexanizmi hodisalar oqimiga asoslangan: added (hujjat paydo bo'ldi), modified (hujjat o'zgartirildi) va removed (hujjat o'chirildi). Dasturchi har bir hodisani alohida qayta ishlashi mumkin, faqat tegishli UI elementlarini yangilab. Bu minglab hujjatlar bo'lsa ham yuqori samaradorlikni ta'minlaydi, chunki faqat o'zgartirilgan komponentlar qayta chiziladi.

Oflayn kirish va keshlash

Firestore ning asosiy afzalliklaridan biri — o'rnatilgan oflayn rejimni qo'llab-quvvatlash. SDK avtomatik ravishda barcha o'qilgan ma'lumotlarni qurilmada keshlaydi va tarmoq bo'lmaganda ishlashni davom ettiradi. Ilova oflayn rejimda ma'lumot yozganda, ular mahalliy navbatga joylashtiriladi va ulanish tiklanganda serverga yuboriladi. Mojarolarni hal qilish uchun last-write-wins strategiyasidan foydalaniladi.

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

docRef.addSnapshotListener { snapshot, error ->
    if (error != null) {
        Log.w("TAG", "Tinglash xatosi", error)
        return@addSnapshotListener
    }

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Joriy ma'lumotlar: ${snapshot.data}")
    }
}

Kesh hajmini FirestoreSettings orqali sozlash mumkin. Standart sifatida 100 MB qiymati ishlatiladi, ammo ma'lumotlarni intensiv o'qiydigan ilovalar uchun uni oshirish mumkin. Shuningdek, ilovani qayta ishga tushirishdan keyin saqlanib qoladigan persistent disk cache rejimi mavjud. Oflayn rejim mavjudligini boshqarish uchun enableNetwork va disableNetwork metodlari ishlatiladi, tarmoq aloqasini vaqtincha o'chirish imkonini beradi.

Firestore xavfsizligi va kirish qoidalari

Firestore Security Rules — server darajasida ma'lumotlarga kirishni boshqarish uchun deklarativ belgilash tili. Qoidalar kim va qanday shartlar ostida hujjatlarni o'qishi va yozishi mumkinligini aniqlaydi. Ular so'rov bajarilishidan oldin ishlaydi va avtorizatsiya uchun alohida server mantig'ini talab qilmaydi. Qoidalar har bir ma'lumotni o'qish yoki yozishdan oldin Firebase tomonidan tekshiriladi.

Kirish qoidalari ruxsat etilgan kirish (allow) printsipi asosida quriladi. Standart sifatida barcha kirish taqiqlangan. Dasturchi ma'lum shartlar ostida muayyan operatsiyalar (read, write, create, update, delete) uchun ketma-ket kirishni ochadi. Shartlar request.auth orqali foydalanuvchi autentifikatsiyasini, request.resource orqali so'rov ma'lumotlarini va resource orqali mavjud ma'lumotlarni tekshirishi mumkin.

// Firestore kirish qoidalari
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Foydalanuvchi faqat o'z ma'lumotlarini o'qiydi va yozadi
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Har qanday autentifikatsiyalangan foydalanuvchi postlarni o'qiy oladi
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Qoidalar orqali ma'lumotlarni validatsiya qilish

Kirish nazoratidan tashqari, Security Rules yozilayotgan ma'lumotlarning tuzilishi va turlarini tekshirish imkonini beradi. Masalan, email maydonining muntazam ifodaga mos kelishini yoki yoshning 120 yildan oshmaganligini tekshirish mumkin. Validatsiya yozishdan oldin amalga oshiriladi, bu serverda noto'g'ri ma'lumotlarning saqlanishini oldini oladi. Maydonlarni tekshirish uchun butun yozilayotgan hujjatni o'z ichiga olgan request.resource.data obyekti ishlatiladi.

Firestore shuningdek mijozlar tomonidan kirishsiz faqat Admin SDK orqali server yozuvi uchun mavjud kolleksiyalarni qo'llab-quvvatlaydi. Bu foydalanuvchilarga ko'rinmasligi kerak bo'lgan xizmat ma'lumotlari, API kalitlari va konfiguratsiyalarni saqlash uchun qulay. Buning uchun qoidalarda tegishli kolleksiyalardagi barcha mijoz operatsiyalarini taqiqlash, faqat server tomonida Admin SDK orqali kirishga ruxsat berish kifoya.

Android'da Firebase Firestore'dan foydalanish misoli

Firestore ning Android ilovasida topshiriqlar ro'yxatini (todo) yaratish uchun integratsiya misolini ko'rib chiqamiz. Ilova topshiriqlarni real vaqtda o'qiydi, yangilarini qo'shadi va bajarilganlarini belgilaydi. Asinxron ish uchun Firebase callback interfeyslari va Kotlin korutinlaridan foydalaniladi.

Firebase sozlash va bog'liqliklarni qo'shish

Ishni boshlashdan oldin loyihani Firebase Console orqali Firebase'ga ulash va google-services.json faylini ilova moduliga qo'shish kerak. Keyin build.gradle'ga firebase-firestore-ktx bog'liqligi va google-services plagini qo'shiladi. Kutubxona versiyasi barcha Firebase komponentlarining o'zaro muvofiqligi uchun joriy Firebase BoM versiyasiga mos kelishi kerak.

dependencies {
    // Firebase BoM — versiyalarni boshqarish
    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"
}

Sozlashdan so'ng Task ma'lumotlar modeli va Firestore bilan ishlash uchun repository yaratiladi. Model id, title, isCompleted va timestamp maydonlarini o'z ichiga oladi. Firestore avtomatik ravishda data class-ni hujjatga seriyalashtiradi, maydon nomlaridan kalit sifatida foydalanadi. Ma'lumotlarni o'qish uchun snapshotFlow kengaytmasi orqali Flow qaytaradigan snapshot listener ishlatiladi.

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))
    }
}

View-model repository'dan Flow'ga obuna bo'ladi va topshiriqlar ro'yxatini UI darajasiga uzatadi. Yangi topshiriq qo'shilganda repository'ning suspend-funksiyasi korutin scope orqali chaqiriladi. Firestore o'zgarishlarni barcha mijozlar o'rtasida avtomatik sinxronlashtiradi: agar topshiriqni bir foydalanuvchi qo'shsa, boshqalar uni ekranni qayta yuklamasdan real vaqtda ko'radi.