Firebase Firestore: ce este, NoSQL și cum funcționează

Ce este Firebase Firestore?

Firebase Firestore este o bază de date NoSQL flexibilă și scalabilă, lansată de Google în 2019 ca evoluție a Firebase Realtime Database. Stochează datele sub formă de colecții de documente, unde fiecare document conține un set de perechi cheie-valoare. Spre deosebire de bazele de date relaționale tradiționale, Firestore nu necesită o schemă predefinită — structura datelor se formează dinamic pe baza documentelor scrise.

Diferența cheie a Firestore față de bazele de date cloud clasice este sincronizarea încorporată în timp real. Când datele se modifică pe server, toți clienții conectați primesc actualizări printr-o conexiune WebSocket permanentă. Aceasta elimină necesitatea interogării manuale a serverului și permite construirea de aplicații cu actualizări live: chat-uri, fluxuri de activitate, editoare colaborative și sisteme de monitorizare.

Baza de date este disponibilă pe toate platformele principale: Android, iOS, Web (JavaScript) și limbaje server prin Admin SDK. Firestore oferă SDK pentru Swift, Kotlin, JavaScript, Python, Go, Java și Node.js. Conform datelor Google, Firestore procesează peste 100 de miliarde de interogări pe zi în întregul ecosistem Firebase, ceea ce confirmă fiabilitatea sa ca bază pentru aplicații de producție.

Concepte de bază: colecții și documente

În Firestore, datele sunt organizate într-o structură ierarhică. O colecție este un container de documente, similar unui tabel în SQL, dar fără o schemă fixă. Un document este o înregistrare care conține câmpuri de diferite tipuri: șiruri de caractere, numere, valori booleene, array-uri, obiecte imbricate și puncte geografice. Documentele pot conține subcolecții, permițând construirea de structuri de date imbricate de orice adâncime.

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", "Document adăugat cu ID: ${docRef.id}")
    }

Fiecare document dintr-o colecție are un identificator unic care poate fi generat automat sau setat manual. Firestore indexează automat toate câmpurile documentului, permițând executarea de interogări complexe cu filtrare, sortare și limitare a numărului de rezultate fără configurarea prealabilă a indexurilor.

Firebase Firestore vs Realtime Database: comparație

Firestore și Firebase Realtime Database sunt două baze de date cloud în timp real de la Google. Deși ambele oferă sincronizare în timp real, au diferențe fundamentale în modelul de date, scalare și prețuri. Înțelegerea acestor diferențe este critică atunci când alegeți baza de date potrivită pentru un anumit proiect.

Diferența arhitecturală principală este modelul de date. Realtime Database stochează totul într-un singur arbore JSON mare, ceea ce complică interogările cu imbricare profundă. Firestore folosește colecții și documente, permițând executarea de interogări complexe cu mai multe condiții. În plus, Firestore asigură o consistență puternică a datelor: după o scriere reușită, toate citirile ulterioare returnează garantat date actualizate.

Scalabilitate și structura datelor

Firestore se scalează automat până la milioane de conexiuni simultane datorită arhitecturii multiregionale. Realtime Database este limitată la o singură regiune și maximum 200.000 de conexiuni simultane. Pentru proiectele care planifică o audiență globală, Firestore este de preferat, deoarece datele sunt replicate automat între mai multe centre de date Google.

Structura datelor în Firestore permite construirea de modele ierarhice complexe cu subcolecții. De exemplu, un utilizator poate avea o subcolecție „comenzi", iar fiecare comandă — o subcolecție „produse". În Realtime Database, o astfel de imbricare profundă duce la probleme de performanță la interogări, deoarece se încarcă întregul drum de la rădăcină până la nodul dorit.

Cum funcționează sincronizarea datelor în Firestore

Firestore folosește o conexiune WebSocket permanentă între client și server pentru sincronizarea datelor în timp real. Când aplicația se abonează la modificările unui document sau ale unei colecții prin snapshot listener, SDK stabilește un canal de comunicație prin care serverul trimite actualizări la fiecare modificare a datelor. Clientul primește doar documentele modificate, nu întreaga colecție de fiecare dată.

Mecanismul de sincronizare se bazează pe un flux de evenimente: added (documentul a apărut), modified (documentul s-a modificat) și removed (documentul a fost șters). Dezvoltatorul poate procesa fiecare eveniment separat, actualizând doar elementele UI corespunzătoare. Aceasta asigură o performanță ridicată chiar și cu mii de documente, deoarece doar componentele modificate sunt redeseneate.

Acces offline și cache

Unul dintre avantajele cheie ale Firestore este suportul încorporat pentru modul offline. SDK-ul stochează automat în cache toate datele citite pe dispozitiv și continuă să funcționeze în absența rețelei. Când aplicația scrie date în modul offline, acestea sunt plasate într-o coadă locală și trimise pe server la restabilirea conexiunii. Pentru rezolvarea conflictelor se utilizează strategia last-write-wins.

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

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

    if (snapshot != null && snapshot.exists()) {
        Log.d("TAG", "Date curente: ${snapshot.data}")
    }
}

Dimensiunea cache-ului poate fi configurată prin FirestoreSettings. Implicit se utilizează o valoare de 100 MB, dar pentru aplicațiile cu citire intensivă a datelor poate fi mărită. De asemenea, este disponibil modul persistent disk cache care supraviețuiește repornirii aplicației. Pentru gestionarea disponibilității modului offline se folosesc metodele enableNetwork și disableNetwork, permițând dezactivarea temporară a comunicării în rețea.

Securitatea și regulile de acces Firestore

Firestore Security Rules este un limbaj de marcare declarativ pentru controlul accesului la date la nivel de server. Regulile determină cine și în ce condiții poate citi și scrie documente. Acestea funcționează înainte de executarea interogării și nu necesită o logică server separată pentru autorizare. Regulile sunt verificate de partea Firebase înainte de fiecare citire sau scriere a datelor.

Regulile de acces se construiesc pe principiul accesului permis (allow). Implicit, tot accesul este interzis. Dezvoltatorul deschide succesiv accesul pentru operații specifice (read, write, create, update, delete) în anumite condiții. Condițiile pot verifica autentificarea utilizatorului prin request.auth, datele interogării prin request.resource și datele existente prin resource.

// Reguli de acces Firestore
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Utilizatorul citește și scrie doar propriile date
    match /users/{userId} {
      allow read, write: if
          request.auth != null &&
          request.auth.uid == userId;
    }

    // Orice utilizator autentificat poate citi postările
    match /posts/{postId} {
      allow read: if request.auth != null;
      allow create: if request.auth != null
          && request.resource.data.author == request.auth.uid;
    }
  }
}

Validarea datelor prin reguli

Pe lângă controlul accesului, Security Rules permit validarea structurii și tipurilor datelor scrise. De exemplu, se poate verifica dacă câmpul email corespunde unei expresii regulate sau dacă vârsta nu depășește 120 de ani. Validarea se efectuează înainte de scriere, prevenind stocarea datelor incorecte pe server. Pentru verificarea câmpurilor se folosește obiectul request.resource.data, care conține întregul document scris.

Firestore suportă, de asemenea, colecții accesibile doar pentru scriere server prin Admin SDK, fără acces din partea clienților. Acest lucru este convenabil pentru stocarea informațiilor de serviciu, cheilor API și configurațiilor care nu ar trebui să fie vizibile utilizatorilor. Pentru aceasta, în reguli este suficient să se interzică toate operațiunile client pe colecțiile respective, permițând accesul doar prin Admin SDK din partea serverului.

Exemplu de utilizare Firebase Firestore în Android

Să analizăm un exemplu de integrare a Firestore într-o aplicație Android pentru crearea unei liste de sarcini (todo). Aplicația va citi sarcinile în timp real, va adăuga altele noi și va marca pe cele finalizate. Pentru lucrul asincron se folosesc interfețe callback Firebase și corutine Kotlin.

Configurarea Firebase și adăugarea dependențelor

Înainte de a începe, este necesar să conectați proiectul la Firebase prin Firebase Console și să adăugați fișierul google-services.json în modulul aplicației. Apoi, în build.gradle se adaugă dependența firebase-firestore-ktx și pluginul google-services. Versiunea bibliotecii trebuie să corespundă versiunii curente BoM Firebase pentru compatibilitatea tuturor componentelor Firebase între ele.

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

După configurare, se creează modelul de date Task și repository-ul pentru lucrul cu Firestore. Modelul conține câmpurile id, title, isCompleted și timestamp. Firestore serializează automat data class într-un document, folosind numele câmpurilor ca chei. Pentru citirea datelor se folosește snapshot listener, care returnează un Flow prin extensia snapshotFlow.

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-ul se abonează la Flow din repository și transmite lista de sarcini la nivelul UI. La adăugarea unei noi sarcini, se apelează funcția suspend a repository-ului prin corutina scope. Firestore sincronizează automat modificările între toți clienții: dacă un utilizator adaugă o sarcină, ceilalți o văd în timp real fără a reîncărca ecranul.