Cloud Firestore डेटा मॉडल

Cloud Firestore एक NoSQL, दस्तावेज़-उन्मुख डेटाबेस है. SQL डेटाबेस के उलट, इसमें कोई टेबल या लाइनें नहीं होती हैं. इसके बजाय, डेटा को दस्तावेज़ों में सेव किया जाता है. इन दस्तावेज़ों को कलेक्शन में व्यवस्थित किया जाता है.

हर दस्तावेज़ में, की-वैल्यू पेयर का एक सेट होता है. Cloud Firestore को छोटे दस्तावेज़ों के बड़े कलेक्शन को सेव करने के लिए ऑप्टिमाइज़ किया गया है.

सभी दस्तावेज़, कलेक्शन में सेव होने चाहिए. दस्तावेज़ों में सब-कलेक्शन और नेस्ट किए गए ऑब्जेक्ट शामिल हो सकते हैं. इन दोनों में प्रिमिटिव फ़ील्ड शामिल हो सकते हैं, जैसे कि स्ट्रिंग या जटिल ऑब्जेक्ट, जैसे कि सूचियां.

Cloud Firestore में कलेक्शन और दस्तावेज़ अपने-आप बन जाते हैं. किसी कलेक्शन में मौजूद दस्तावेज़ को डेटा असाइन करें. अगर कलेक्शन या दस्तावेज़ मौजूद नहीं है, तो Cloud Firestore उसे बनाता है.

दस्तावेज़

Cloud Firestore में, स्टोरेज की यूनिट दस्तावेज़ होती है. दस्तावेज़ एक हल्का रिकॉर्ड होता है. इसमें ऐसे फ़ील्ड होते हैं जो वैल्यू के साथ मैप होते हैं. हर दस्तावेज़ को एक नाम से पहचाना जाता है.

उपयोगकर्ता alovelace को दिखाने वाला दस्तावेज़ कुछ ऐसा दिख सकता है:

• class alovelace

  first : "Ada"
last : "Lovelace"
born : 1815
  

किसी दस्तावेज़ में मौजूद मुश्किल और नेस्ट किए गए ऑब्जेक्ट को मैप कहा जाता है. उदाहरण के लिए, ऊपर दिए गए उदाहरण में उपयोगकर्ता के नाम को मैप की मदद से इस तरह स्ट्रक्चर किया जा सकता है:

• class alovelace

  name :
    first : "Ada"
    last : "Lovelace"
born : 1815
  

आपको दिख सकता है कि दस्तावेज़, JSON की तरह दिखते हैं. असल में, वे एक ही हैं. इनमें कुछ अंतर हैं. उदाहरण के लिए, दस्तावेज़ अतिरिक्त डेटा टाइप के साथ काम करते हैं और दस्तावेज़ के साइज़ की सीमा तक सीमित होते हैं. हालांकि, सामान्य तौर पर दस्तावेज़ों को हल्के JSON रिकॉर्ड के तौर पर इस्तेमाल किया जा सकता है.

संग्रह

दस्तावेज़, कलेक्शन में सेव किए जाते हैं. कलेक्शन, दस्तावेज़ों के कंटेनर होते हैं. उदाहरण के लिए, आपके पास users कलेक्शन हो सकता है, जिसमें आपके अलग-अलग उपयोगकर्ता शामिल हों. हर उपयोगकर्ता को एक दस्तावेज़ के तौर पर दिखाया जाता है:

• collections_bookmark उपयोगकर्ता

  • class alovelace

    first : "Ada"
last : "Lovelace"
born : 1815
    

  • class aturing

    first : "Alan"
last : "Turing"
born : 1912
    

Cloud Firestore में स्कीमा नहीं होता. इसलिए, आपके पास यह तय करने की पूरी आज़ादी होती है कि आपको हर दस्तावेज़ में कौनसे फ़ील्ड रखने हैं और उन फ़ील्ड में किस तरह का डेटा सेव करना है. एक ही कलेक्शन में मौजूद सभी दस्तावेज़ों में अलग-अलग फ़ील्ड हो सकते हैं. साथ ही, उन फ़ील्ड में अलग-अलग तरह का डेटा सेव किया जा सकता है. हालांकि, हमारा सुझाव है कि एक से ज़्यादा दस्तावेज़ों में एक ही फ़ील्ड और डेटा टाइप का इस्तेमाल करें. इससे आपको दस्तावेज़ों को क्वेरी करने में आसानी होगी.

कलेक्शन में सिर्फ़ दस्तावेज़ होते हैं. इसमें सीधे तौर पर वैल्यू वाले रॉ फ़ील्ड शामिल नहीं किए जा सकते. साथ ही, इसमें अन्य कलेक्शन भी शामिल नहीं किए जा सकते. (Cloud Firestore में ज़्यादा जटिल डेटा को स्ट्रक्चर करने के तरीके के बारे में जानने के लिए, हायरार्किकल डेटा देखें.)

किसी कलेक्शन में मौजूद दस्तावेज़ों के नाम अलग-अलग होते हैं. आपके पास अपने यूज़र आईडी जैसे कुंजियां देने का विकल्प होता है. इसके अलावा, Cloud Firestore को आपके लिए अपने-आप रैंडम आईडी जनरेट करने की अनुमति भी दी जा सकती है.

आपको कलेक्शन "बनाने" या "मिटाने" की ज़रूरत नहीं है. किसी कलेक्शन में पहला दस्तावेज़ बनाने के बाद, कलेक्शन मौजूद रहता है. किसी कलेक्शन में मौजूद सभी दस्तावेज़ मिटाने पर, वह कलेक्शन मौजूद नहीं रहता.

रेफ़रंस

Cloud Firestore में मौजूद हर दस्तावेज़ की पहचान, डेटाबेस में उसकी जगह के हिसाब से की जाती है. पिछले उदाहरण में, कलेक्शन users में मौजूद दस्तावेज़ alovelace दिखाया गया था. अपने कोड में इस जगह की जानकारी का इस्तेमाल करने के लिए, इसका रेफ़रंस बनाया जा सकता है.

import { doc } from "firebase/firestore";

const alovelaceDocumentRef = doc(db, 'users', 'alovelace');
doc_reference.js

var alovelaceDocumentRef = db.collection('users').doc('alovelace');
test.firestore.js

let alovelaceDocumentRef = db.collection("users").document("alovelace")
ViewController.swift

FIRDocumentReference *alovelaceDocumentRef =
    [[self.db collectionWithPath:@"users"] documentWithPath:@"alovelace"];
ViewController.m

val alovelaceDocumentRef = db.collection("users").document("alovelace")
DocSnippets.kt

DocumentReference alovelaceDocumentRef = db.collection("users").document("alovelace");
DocSnippets.java

final alovelaceDocumentRef = db.collection("users").doc("alovelace");
firestore.dart

// Reference to a document with id "alovelace" in the collection "users"
DocumentReference document = db.collection("users").document("alovelace");
References.java

a_lovelace_ref = db.collection("users").document("alovelace")
snippets.py

a_lovelace_ref = db.collection("users").document("alovelace")
snippets.py

DocumentReference alovelace_document_reference =
    db->Collection("users").Document("alovelace");
snippets.cpp

const alovelaceDocumentRef = db.collection('users').doc('alovelace');
index.js

import (
	"cloud.google.com/go/firestore"
)

func createDocReference(client *firestore.Client) {

	alovelaceRef := client.Collection("users").Doc("alovelace")

	_ = alovelaceRef
}
retrieve_data_reference_document.go

$document = $db->collection('samples/php/users')->document('alovelace');
data_reference_document.php

DocumentReference documentRef = db.Collection("users").Document("alovelace");

DocumentReference documentRef = db.Collection("users").Document("alovelace");
Program.cs

document_ref = firestore.col("users").doc("alovelace")
data_model.rb

रेफ़रंस एक छोटा ऑब्जेक्ट होता है. यह सिर्फ़ आपके डेटाबेस में किसी जगह की ओर इशारा करता है. डेटा मौजूद है या नहीं, इसके आधार पर रेफ़रंस बनाया जा सकता है. साथ ही, रेफ़रंस बनाने से कोई नेटवर्क ऑपरेशन नहीं होता.

कलेक्शन के रेफ़रंस भी बनाए जा सकते हैं:

import { collection } from "firebase/firestore";

const usersCollectionRef = collection(db, 'users');
collection_reference.js

var usersCollectionRef = db.collection('users');
test.firestore.js

let usersCollectionRef = db.collection("users")
ViewController.swift

FIRCollectionReference *usersCollectionRef = [self.db collectionWithPath:@"users"];
ViewController.m

val usersCollectionRef = db.collection("users")
DocSnippets.kt

CollectionReference usersCollectionRef = db.collection("users");
DocSnippets.java

final usersCollectionRef = db.collection("users");
firestore.dart

// Reference to the collection "users"
CollectionReference collection = db.collection("users");
References.java

users_ref = db.collection("users")
snippets.py

users_ref = db.collection("users")
snippets.py

CollectionReference users_collection_reference = db->Collection("users");
snippets.cpp

const usersCollectionRef = db.collection('users');
index.js

import (
	"cloud.google.com/go/firestore"
)

func createCollectionReference(client *firestore.Client) {
	usersRef := client.Collection("users")

	_ = usersRef
}
retrieve_data_reference_collection.go

$collection = $db->collection('samples/php/users');
data_reference_collection.php

CollectionReference collectionRef = db.Collection("users");

CollectionReference collectionRef = db.Collection("users");
Program.cs

collection_ref = firestore.col "users"
data_model.rb

आसानी के लिए, किसी दस्तावेज़ या कलेक्शन के पाथ को स्ट्रिंग के तौर पर तय करके भी रेफ़रंस बनाए जा सकते हैं. इसमें पाथ के कॉम्पोनेंट को फ़ॉरवर्ड स्लैश (/) से अलग किया जाता है. उदाहरण के लिए, alovelace दस्तावेज़ का रेफ़रंस बनाने के लिए:

import { doc } from "firebase/firestore"; 

const alovelaceDocumentRef = doc(db, 'users/alovelace');
doc_reference_alternative.js

var alovelaceDocumentRef = db.doc('users/alovelace');
test.firestore.js

let aLovelaceDocumentReference = db.document("users/alovelace")
ViewController.swift

FIRDocumentReference *aLovelaceDocumentReference =
    [self.db documentWithPath:@"users/alovelace"];
ViewController.m

val alovelaceDocumentRef = db.document("users/alovelace")
DocSnippets.kt

DocumentReference alovelaceDocumentRef = db.document("users/alovelace");
DocSnippets.java

final aLovelaceDocRef = db.doc("users/alovelace");
firestore.dart

// Reference to a document with id "alovelace" in the collection "users"
DocumentReference document = db.document("users/alovelace");
References.java

a_lovelace_ref = db.document("users/alovelace")
snippets.py

a_lovelace_ref = db.document("users/alovelace")
snippets.py

DocumentReference alovelace_document = db->Document("users/alovelace");
snippets.cpp

const alovelaceDocumentRef = db.doc('users/alovelace');
index.js

import (
	"cloud.google.com/go/firestore"
)

func createDocReferenceFromString(client *firestore.Client) {
	// Reference to a document with id "alovelace" in the collection "users"
	alovelaceRef := client.Doc("users/alovelace")

	_ = alovelaceRef
}
retrieve_data_reference_document_path.go

$document = $db->document('users/alovelace');
data_reference_document_path.php

DocumentReference documentRef = db.Document("users/alovelace");

DocumentReference documentRef = db.Document("users/alovelace");
Program.cs

document_path_ref = firestore.doc "users/alovelace"
data_model.rb

क्रम के हिसाब से व्यवस्थित डेटा

Cloud Firestore में, क्रम के हिसाब से व्यवस्थित डेटा स्ट्रक्चर के काम करने का तरीका समझने के लिए, मैसेज और चैट रूम वाले चैट ऐप्लिकेशन का उदाहरण देखें.

अलग-अलग चैट रूम को सेव करने के लिए, rooms नाम का कलेक्शन बनाया जा सकता है:

• collections_bookmark कमरे

  • class roomA

    name : "my chat room"
    

  • class roomB

    ...
    

अब आपके पास चैट रूम हैं. इसलिए, तय करें कि आपको अपने मैसेज कैसे सेव करने हैं. ऐसा हो सकता है कि आपको उन्हें चैट रूम के दस्तावेज़ में सेव न करना हो. Cloud Firestore में मौजूद दस्तावेज़ों का साइज़ कम होना चाहिए. साथ ही, किसी चैट रूम में बड़ी संख्या में मैसेज हो सकते हैं. हालांकि, चैट रूम के दस्तावेज़ में सब-कलेक्शन के तौर पर, अन्य कलेक्शन बनाए जा सकते हैं.

सब-कलेक्शन

इस स्थिति में, मैसेज को सेव करने का सबसे अच्छा तरीका सब-कलेक्शन का इस्तेमाल करना है. सबकलेक्शन, किसी खास दस्तावेज़ से जुड़ा कलेक्शन होता है.

अपने rooms कलेक्शन में मौजूद हर रूम दस्तावेज़ के लिए, messages नाम का एक सबकलेक्शन बनाया जा सकता है:

• collections_bookmark कमरे

  • class roomA

    name : "my chat room"
    

    • collections_bookmark मैसेज

      • class message1

        from : "alex"
msg : "Hello World!"
        

      • class message2

        ...
        

  • class roomB

    ...
    

इस उदाहरण में, आपको सब-कलेक्शन में मौजूद किसी मैसेज का रेफ़रंस बनाना होगा. इसके लिए, आपको यह कोड इस्तेमाल करना होगा:

import { doc } from "firebase/firestore"; 

const messageRef = doc(db, "rooms", "roomA", "messages", "message1");
subcollection_reference.js

var messageRef = db.collection('rooms').doc('roomA')
                .collection('messages').doc('message1');
test.firestore.js

let messageRef = db
  .collection("rooms").document("roomA")
  .collection("messages").document("message1")
ViewController.swift

FIRDocumentReference *messageRef =
    [[[[self.db collectionWithPath:@"rooms"] documentWithPath:@"roomA"]
    collectionWithPath:@"messages"] documentWithPath:@"message1"];
ViewController.m

val messageRef = db
    .collection("rooms").document("roomA")
    .collection("messages").document("message1")
DocSnippets.kt

DocumentReference messageRef = db
        .collection("rooms").document("roomA")
        .collection("messages").document("message1");
DocSnippets.java

final messageRef = db
    .collection("rooms")
    .doc("roomA")
    .collection("messages")
    .doc("message1");
firestore.dart

// Reference to a document in subcollection "messages"
DocumentReference document =
    db.collection("rooms").document("roomA").collection("messages").document("message1");
References.java

room_a_ref = db.collection("rooms").document("roomA")
message_ref = room_a_ref.collection("messages").document("message1")
snippets.py

room_a_ref = db.collection("rooms").document("roomA")
message_ref = room_a_ref.collection("messages").document("message1")
snippets.py

DocumentReference message_reference = db->Collection("rooms")
    .Document("roomA")
    .Collection("messages")
    .Document("message1");
snippets.cpp

const messageRef = db.collection('rooms').doc('roomA')
  .collection('messages').doc('message1');
index.js

import (
	"cloud.google.com/go/firestore"
)

func createSubcollectionReference(client *firestore.Client) {
	messageRef := client.Collection("rooms").Doc("roomA").
		Collection("messages").Doc("message1")

	_ = messageRef
}
retrieve_data_reference_subcollection.go

$document = $db
    ->collection('rooms')
    ->document('roomA')
    ->collection('messages')
    ->document('message1');
data_reference_subcollection.php

DocumentReference documentRef = db
	.Collection("Rooms").Document("RoomA")
	.Collection("Messages").Document("Message1");

DocumentReference documentRef = db
    .Collection("Rooms").Document("RoomA")
    .Collection("Messages").Document("Message1");
Program.cs

message_ref = firestore.col("rooms").doc("roomA").col("messages").doc("message1")
data_model.rb

कलेक्शन और दस्तावेज़ों के पैटर्न पर ध्यान दें. आपके कलेक्शन और दस्तावेज़ों में हमेशा इस पैटर्न का पालन किया जाना चाहिए. किसी कलेक्शन या दस्तावेज़ में, किसी दूसरे कलेक्शन या दस्तावेज़ का रेफ़रंस नहीं दिया जा सकता.

सबकलेक्शन की मदद से, डेटा को क्रम के हिसाब से व्यवस्थित किया जा सकता है. इससे डेटा को आसानी से ऐक्सेस किया जा सकता है. roomA में मौजूद सभी मैसेज पाने के लिए, messages सब-कलेक्शन का कलेक्शन रेफ़रंस बनाया जा सकता है. इसके बाद, इस रेफ़रंस के साथ उसी तरह इंटरैक्ट किया जा सकता है जिस तरह किसी अन्य कलेक्शन रेफ़रंस के साथ किया जाता है.

सब-कलेक्शन में मौजूद दस्तावेज़ों में भी सब-कलेक्शन हो सकते हैं. इससे आपको डेटा को और ज़्यादा नेस्ट करने की सुविधा मिलती है. डेटा को ज़्यादा से ज़्यादा 100 लेवल तक नेस्ट किया जा सकता है.