Firebase Firestore: ما هو، NoSQL وكيف يعمل

ما هو Firebase Firestore؟

Firebase Firestore هي قاعدة بيانات NoSQL مرنة وقابلة للتوسع أطلقتها Google في 2019 كتطور لـ Firebase Realtime Database. تخزن البيانات في مجموعات من المستندات، حيث يحتوي كل مستند على مجموعة من أزواج المفتاح-القيمة. على عكس قواعد البيانات العلائقية التقليدية، لا تتطلب Firestore مخططاً محدداً مسبقاً — يتم تشكيل هيكل البيانات ديناميكياً بناءً على المستندات التي يتم كتابتها.

الفرق الرئيسي بين Firestore وقواعد البيانات السحابية الكلاسيكية هو المزامنة المدمجة في الوقت الفعلي. عندما تتغير البيانات على الخادم، تتلقى جميع العملاء المتصلة التحديثات عبر اتصال WebSocket دائم. هذا يلغي الحاجة إلى الاستقصاء اليدوي للخادم ويسمح ببناء تطبيقات ذات تحديثات حية: الدردشات، خلاصات النشاط، المحررين التعاونيين وأنظمة المراقبة.

قاعدة البيانات متاحة على جميع المنصات الرئيسية: Android، iOS، الويب (JavaScript) ولغات الخادم عبر Admin SDK. توفر Firestore SDK لـ Swift وKotlin وJavaScript وPython وGo وJava وNode.js. وفقاً لـ Google، تعالج Firestore أكثر من 100 مليار طلب يومياً عبر نظام Firebase البيئي بأكمله، مما يؤكد موثوقيتها كأساس لتطبيقات الإنتاج.

المفاهيم الأساسية: المجموعات والمستندات

في 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", "تمت إضافة المستند بالمعرف: ${docRef.id}")
    }

كل مستند في مجموعة له معرف فريد، يمكن إنشاؤه تلقائياً أو تعيينه يدوياً. تقوم Firestore بفهرسة جميع حقول المستند تلقائياً، مما يتيح إجراء استعلامات معقدة مع تصفية وفرز وتحديد عدد النتائج دون تكوين فهارس يدوياً.

Firebase Firestore مقابل 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 دائم بين العميل والخادم لمزامنة البيانات في الوقت الفعلي. عندما يشترك تطبيق في تغييرات مستند أو مجموعة عبر snapshot listener، ينشئ SDK قناة اتصال يرسل من خلالها الخادم التحديثات كلما تغيرت البيانات. يتلقى العميل فقط المستندات التي تغيرت، وليس لقطة كاملة للمجموعة بأكملها في كل مرة.

آلية المزامنة تعتمد على تدفق الأحداث: added (ظهر مستند)، modified (تغير مستند) وremoved (تم حذف مستند). يمكن للمطور معالجة كل حدث على حدة، وتحديث عناصر واجهة المستخدم المقابلة فقط. هذا يضمن أداءً عالياً حتى مع آلاف المستندات، حيث يتم إعادة عرض المكونات التي تغيرت فقط.

الوصول دون اتصال والتخزين المؤقت

إحدى المزايا الرئيسية لـ 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 ميجابايت، ولكن يمكن زيادتها للتطبيقات ذات القراءة المكثفة للبيانات. يتوفر أيضاً وضع التخزين المؤقت على القرص الدائم الذي يبقى بعد إعادة تشغيل التطبيق. لإدارة توفر وضع عدم الاتصال، يتم استخدام طريقتي 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 من جانب الخادم.

مثال على استخدام Firebase Firestore في Android

لنلقِ نظرة على مثال لتكامل Firestore في تطبيق Android لإنشاء قائمة مهام (todo). سيقوم التطبيق بقراءة المهام في الوقت الفعلي، وإضافة مهام جديدة، ووضع علامة على المهام المكتملة. للعمل غير المتزامن، تُستخدم واجهات رد اتصال Firebase و coroutines في Kotlin.

إعداد Firebase وإضافة التبعيات

قبل البدء، تحتاج إلى ربط المشروع بـ Firebase عبر Firebase Console وإضافة ملف google-services.json إلى وحدة التطبيق. ثم، في build.gradle يتم إضافة التبعية firebase-firestore-ktx والمكون الإضافي google-services. يجب أن يتوافق إصدار المكتبة مع إصدار BoM الحالي لـ Firebase لتوافق جميع مكونات Firebase مع بعضها البعض.

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 بتسلسل data class تلقائياً إلى مستند، باستخدام أسماء الحقول كمفاتيح. لقراءة البيانات، يتم استخدام snapshot listener الذي يعيد Flow عبر الإضافة 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))
    }
}

تشترك ViewModel في Flow من المستودع وتمرر قائمة المهام إلى مستوى واجهة المستخدم. عند إضافة مهمة جديدة، يتم استدعاء دالة suspend للمستودع عبر نطاق coroutine. تقوم Firestore بمزامنة التغييرات تلقائياً بين جميع العملاء: إذا أضاف مستخدم مهمة، يراها الآخرون في الوقت الفعلي دون إعادة تحميل الشاشة.