क्लाउड फायरस्टोर में डेटा जोड़ें

क्लाउड फायरस्टोर पर डेटा लिखने के कई तरीके हैं:

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

यह मार्गदर्शिका बताती है कि क्लाउड फायरस्टोर में सेट का उपयोग कैसे करें, व्यक्तिगत दस्तावेज़ कैसे जोड़ें या अपडेट करें। यदि आप बड़ी मात्रा में डेटा लिखना चाहते हैं, तो लेनदेन और बैचेड राइट्स देखें।

शुरू करने से पहले

क्लाउड फायरस्टोर डेटाबेस बनाने के लिए क्लाउड फायरस्टोर के साथ शुरुआत करें देखें।

क्लाउड फायरस्टोर प्रारंभ करें

क्लाउड फायरस्टोर का एक उदाहरण प्रारंभ करें:

Web modular API

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
    FIREBASE_CONFIGURATION
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = getFirestore(app);

FIREBASE_CONFIGURATION अपने वेब ऐप के firebaseConfig से बदलें।

जब डिवाइस अपना कनेक्शन खो देता है तो डेटा को बनाए रखने के लिए, ऑफ़लाइन डेटा सक्षम करें दस्तावेज़ देखें।

Web namespaced API

import firebase from "firebase/app";
import "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
    FIREBASE_CONFIGURATION
};

// Initialize Firebase
firebase.initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = firebase.firestore();

FIREBASE_CONFIGURATION अपने वेब ऐप के firebaseConfig से बदलें।

जब डिवाइस अपना कनेक्शन खो देता है तो डेटा को बनाए रखने के लिए, ऑफ़लाइन डेटा सक्षम करें दस्तावेज़ देखें।

तीव्र
नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()

let db = Firestore.firestore()
उद्देश्य सी
नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
@import FirebaseCore;
@import FirebaseFirestore;

// Use Firebase library to configure APIs
[FIRApp configure];
  
FIRFirestore *defaultFirestore = [FIRFirestore firestore];

Kotlin+KTX

// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore

Java

// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();

Dart

db = FirebaseFirestore.instance;
जावा
क्लाउड फायरस्टोर एसडीके को आपके परिवेश के आधार पर अलग-अलग तरीकों से आरंभ किया गया है। नीचे सबसे सामान्य तरीके दिए गए हैं. संपूर्ण संदर्भ के लिए, एडमिन एसडीके को प्रारंभ करें देखें।
  • Google क्लाउड
    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;
    
    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;
    
    // Use the application default credentials
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    FirebaseOptions options = new FirebaseOptions.Builder()
        .setCredentials(credentials)
        .setProjectId(projectId)
        .build();
    FirebaseApp.initializeApp(options);
    
    Firestore db = FirestoreClient.getFirestore();
    
    पर प्रारंभ करें
  • अपने सर्वर पर प्रारंभ करें

    अपने स्वयं के सर्वर पर फायरबेस एडमिन एसडीके का उपयोग करने के लिए, एक सेवा खाते का उपयोग करें।

    Google क्लाउड कंसोल में IAM और एडमिन > सेवा खाते पर जाएँ। एक नई निजी कुंजी बनाएं और JSON फ़ाइल सहेजें। फिर SDK को प्रारंभ करने के लिए फ़ाइल का उपयोग करें:

    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;
    
    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;
    
    // Use a service account
    InputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json");
    GoogleCredentials credentials = GoogleCredentials.fromStream(serviceAccount);
    FirebaseOptions options = new FirebaseOptions.Builder()
        .setCredentials(credentials)
        .build();
    FirebaseApp.initializeApp(options);
    
    Firestore db = FirestoreClient.getFirestore();
    
  • अजगर
    क्लाउड फायरस्टोर एसडीके को आपके परिवेश के आधार पर अलग-अलग तरीकों से आरंभ किया गया है। नीचे सबसे सामान्य तरीके दिए गए हैं. संपूर्ण संदर्भ के लिए, एडमिन एसडीके को प्रारंभ करें देखें।
  • Google क्लाउड
    import firebase_admin
    from firebase_admin import firestore
    
    # Application Default credentials are automatically created.
    app = firebase_admin.initialize_app()
    db = firestore.client()
    पर प्रारंभ करें

    एसडीके को आरंभ करने के लिए मौजूदा एप्लिकेशन डिफ़ॉल्ट क्रेडेंशियल का भी उपयोग किया जा सकता है।

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore
    
    # Use the application default credentials.
    cred = credentials.ApplicationDefault()
    
    firebase_admin.initialize_app(cred)
    db = firestore.client()
  • अपने सर्वर पर प्रारंभ करें

    अपने स्वयं के सर्वर पर फायरबेस एडमिन एसडीके का उपयोग करने के लिए, एक सेवा खाते का उपयोग करें।

    Google क्लाउड कंसोल में IAM और एडमिन > सेवा खाते पर जाएँ। एक नई निजी कुंजी बनाएं और JSON फ़ाइल सहेजें। फिर SDK को प्रारंभ करने के लिए फ़ाइल का उपयोग करें:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore
    
    # Use a service account.
    cred = credentials.Certificate('path/to/serviceAccount.json')
    
    app = firebase_admin.initialize_app(cred)
    
    db = firestore.client()
  • Python

    क्लाउड फायरस्टोर एसडीके को आपके परिवेश के आधार पर अलग-अलग तरीकों से आरंभ किया गया है। नीचे सबसे सामान्य तरीके दिए गए हैं. संपूर्ण संदर्भ के लिए, एडमिन एसडीके को प्रारंभ करें देखें।
  • Google क्लाउड
    import firebase_admin
    from firebase_admin import firestore_async
    
    # Application Default credentials are automatically created.
    app = firebase_admin.initialize_app()
    db = firestore_async.client()
    पर प्रारंभ करें

    एसडीके को आरंभ करने के लिए मौजूदा एप्लिकेशन डिफ़ॉल्ट क्रेडेंशियल का भी उपयोग किया जा सकता है।

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async
    
    # Use the application default credentials.
    cred = credentials.ApplicationDefault()
    
    firebase_admin.initialize_app(cred)
    db = firestore_async.client()
  • अपने सर्वर पर प्रारंभ करें

    अपने स्वयं के सर्वर पर फायरबेस एडमिन एसडीके का उपयोग करने के लिए, एक सेवा खाते का उपयोग करें।

    Google क्लाउड कंसोल में IAM और एडमिन > सेवा खाते पर जाएँ। एक नई निजी कुंजी बनाएं और JSON फ़ाइल सहेजें। फिर SDK को प्रारंभ करने के लिए फ़ाइल का उपयोग करें:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async
    
    # Use a service account.
    cred = credentials.Certificate('path/to/serviceAccount.json')
    
    app = firebase_admin.initialize_app(cred)
    
    db = firestore_async.client()
  • सी++
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
    App::Create();
    Firestore* db = Firestore::GetInstance();
    नोड.जे.एस
    क्लाउड फायरस्टोर एसडीके को आपके परिवेश के आधार पर अलग-अलग तरीकों से आरंभ किया गया है। नीचे सबसे सामान्य तरीके दिए गए हैं. संपूर्ण संदर्भ के लिए, एडमिन एसडीके को प्रारंभ करें देखें।
    • क्लाउड फ़ंक्शंस
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp();
      
      const db = getFirestore();
      
      पर प्रारंभ करें
    • Google क्लाउड पर आरंभ करें
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp({
        credential: applicationDefault()
      });
      
      const db = getFirestore();
    • अपने सर्वर पर प्रारंभ करें

      अपने स्वयं के सर्वर (या किसी अन्य Node.js वातावरण) पर फायरबेस एडमिन SDK का उपयोग करने के लिए, एक सेवा खाते का उपयोग करें। Google क्लाउड कंसोल में IAM और एडमिन > सेवा खाते पर जाएँ। एक नई निजी कुंजी बनाएं और JSON फ़ाइल सहेजें। फिर SDK को प्रारंभ करने के लिए फ़ाइल का उपयोग करें:

      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      const serviceAccount = require('./path/to/serviceAccountKey.json');
      
      initializeApp({
        credential: cert(serviceAccount)
      });
      
      const db = getFirestore();
      
    जाना
    क्लाउड फायरस्टोर एसडीके को आपके परिवेश के आधार पर अलग-अलग तरीकों से आरंभ किया गया है। नीचे सबसे सामान्य तरीके दिए गए हैं. संपूर्ण संदर्भ के लिए, एडमिन एसडीके को प्रारंभ करें देखें।
  • Google क्लाउड
    import (
      "log"
    
      firebase "firebase.google.com/go"
      "google.golang.org/api/option"
    )
    
    // Use the application default credentials
    ctx := context.Background()
    conf := &firebase.Config{ProjectID: projectID}
    app, err := firebase.NewApp(ctx, conf)
    if err != nil {
      log.Fatalln(err)
    }
    
    client, err := app.Firestore(ctx)
    if err != nil {
      log.Fatalln(err)
    }
    defer client.Close()
    
    पर प्रारंभ करें
  • अपने सर्वर पर प्रारंभ करें

    अपने स्वयं के सर्वर पर फायरबेस एडमिन एसडीके का उपयोग करने के लिए, एक सेवा खाते का उपयोग करें।

    Google क्लाउड कंसोल में IAM और एडमिन > सेवा खाते पर जाएँ। एक नई निजी कुंजी बनाएं और JSON फ़ाइल सहेजें। फिर SDK को प्रारंभ करने के लिए फ़ाइल का उपयोग करें:

    import (
      "log"
    
      firebase "firebase.google.com/go"
      "google.golang.org/api/option"
    )
    
    // Use a service account
    ctx := context.Background()
    sa := option.WithCredentialsFile("path/to/serviceAccount.json")
    app, err := firebase.NewApp(ctx, nil, sa)
    if err != nil {
      log.Fatalln(err)
    }
    
    client, err := app.Firestore(ctx)
    if err != nil {
      log.Fatalln(err)
    }
    defer client.Close()
    
  • पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    use Google\Cloud\Firestore\FirestoreClient;
    
    /**
     * Initialize Cloud Firestore with default project ID.
     */
    function setup_client_create(string $projectId = null)
    {
        // Create the Cloud Firestore client
        if (empty($projectId)) {
            // The `projectId` parameter is optional and represents which project the
            // client will act on behalf of. If not supplied, the client falls back to
            // the default project inferred from the environment.
            $db = new FirestoreClient();
            printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
        } else {
            $db = new FirestoreClient([
                'projectId' => $projectId,
            ]);
            printf('Created Cloud Firestore client with project ID: %s' . PHP_EOL, $projectId);
        }
    }
    एकता
    using Firebase.Firestore;
    using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    सी#

    सी#

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    माणिक
    require "google/cloud/firestore"
    
    # The `project_id` parameter is optional and represents which project the
    # client will act on behalf of. If not supplied, the client falls back to the
    # default project inferred from the environment.
    firestore = Google::Cloud::Firestore.new project_id: project_id
    
    puts "Created Cloud Firestore client with given project ID."

    एक दस्तावेज़ सेट करें

    किसी एकल दस्तावेज़ को बनाने या अधिलेखित करने के लिए, निम्नलिखित भाषा-विशिष्ट set() विधियों का उपयोग करें:

    Web modular API

    setDoc() विधि का उपयोग करें:

    import { doc, setDoc } from "firebase/firestore"; 
    
    // Add a new document in collection "cities"
    await setDoc(doc(db, "cities", "LA"), {
      name: "Los Angeles",
      state: "CA",
      country: "USA"
    });

    Web namespaced API

    set() विधि का उपयोग करें:

    // Add a new document in collection "cities"
    db.collection("cities").doc("LA").set({
        name: "Los Angeles",
        state: "CA",
        country: "USA"
    })
    .then(() => {
        console.log("Document successfully written!");
    })
    .catch((error) => {
        console.error("Error writing document: ", error);
    });
    तीव्र

    setData() विधि का उपयोग करें:

    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Add a new document in collection "cities"
    do {
      try await db.collection("cities").document("LA").setData([
        "name": "Los Angeles",
        "state": "CA",
        "country": "USA"
      ])
      print("Document successfully written!")
    } catch {
      print("Error writing document: \(error)")
    }
    उद्देश्य सी

    setData: विधि का उपयोग करें:

    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Add a new document in collection "cities"
    [[[self.db collectionWithPath:@"cities"] documentWithPath:@"LA"] setData:@{
      @"name": @"Los Angeles",
      @"state": @"CA",
      @"country": @"USA"
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error writing document: %@", error);
      } else {
        NSLog(@"Document successfully written!");
      }
    }];

    Kotlin+KTX

    set() विधि का उपयोग करें:

    val city = hashMapOf(
        "name" to "Los Angeles",
        "state" to "CA",
        "country" to "USA",
    )
    
    db.collection("cities").document("LA")
        .set(city)
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }

    Java

    set() विधि का उपयोग करें:

    Map<String, Object> city = new HashMap<>();
    city.put("name", "Los Angeles");
    city.put("state", "CA");
    city.put("country", "USA");
    
    db.collection("cities").document("LA")
            .set(city)
            .addOnSuccessListener(new OnSuccessListener<Void>() {
                @Override
                public void onSuccess(Void aVoid) {
                    Log.d(TAG, "DocumentSnapshot successfully written!");
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error writing document", e);
                }
            });
    

    Dart

    set() विधि का उपयोग करें:

    final city = <String, String>{
      "name": "Los Angeles",
      "state": "CA",
      "country": "USA"
    };
    
    db
        .collection("cities")
        .doc("LA")
        .set(city)
        .onError((e, _) => print("Error writing document: $e"));
    जावा

    set() विधि का उपयोग करें:

    // Create a Map to store the data we want to set
    Map<String, Object> docData = new HashMap<>();
    docData.put("name", "Los Angeles");
    docData.put("state", "CA");
    docData.put("country", "USA");
    docData.put("regions", Arrays.asList("west_coast", "socal"));
    // Add a new document (asynchronously) in collection "cities" with id "LA"
    ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(docData);
    // ...
    // future.get() blocks on response
    System.out.println("Update time : " + future.get().getUpdateTime());
    अजगर

    set() विधि का उपयोग करें:

    data = {"name": "Los Angeles", "state": "CA", "country": "USA"}
    
    # Add a new doc in collection 'cities' with ID 'LA'
    db.collection("cities").document("LA").set(data)

    Python

    set() विधि का उपयोग करें:

    data = {"name": "Los Angeles", "state": "CA", "country": "USA"}
    
    # Add a new doc in collection 'cities' with ID 'LA'
    await db.collection("cities").document("LA").set(data)
    सी++

    Set() विधि का उपयोग करें:

    // Add a new document in collection 'cities'
    db->Collection("cities")
        .Document("LA")
        .Set({{"name", FieldValue::String("Los Angeles")},
              {"state", FieldValue::String("CA")},
              {"country", FieldValue::String("USA")}})
        .OnCompletion([](const Future<void>& future) {
          if (future.error() == Error::kErrorOk) {
            std::cout << "DocumentSnapshot successfully written!" << std::endl;
          } else {
            std::cout << "Error writing document: " << future.error_message()
                      << std::endl;
          }
        });
    नोड.जे.एस

    set() विधि का उपयोग करें:

    const data = {
      name: 'Los Angeles',
      state: 'CA',
      country: 'USA'
    };
    
    // Add a new document in collection "cities" with ID 'LA'
    const res = await db.collection('cities').doc('LA').set(data);
    जाना

    Set() विधि का उपयोग करें:

    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func addDocAsMap(ctx context.Context, client *firestore.Client) error {
    	_, err := client.Collection("cities").Doc("LA").Set(ctx, map[string]interface{}{
    		"name":    "Los Angeles",
    		"state":   "CA",
    		"country": "USA",
    	})
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    set() विधि का उपयोग करें:

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $data = [
        'name' => 'Los Angeles',
        'state' => 'CA',
        'country' => 'USA'
    ];
    $db->collection('samples/php/cities')->document('LA')->set($data);
    एकता

    SetAsync() विधि का उपयोग करें:

    DocumentReference docRef = db.Collection("cities").Document("LA");
    Dictionary<string, object> city = new Dictionary<string, object>
    {
    	{ "Name", "Los Angeles" },
    	{ "State", "CA" },
    	{ "Country", "USA" }
    };
    docRef.SetAsync(city).ContinueWithOnMainThread(task => {
    	Debug.Log("Added data to the LA document in the cities collection.");
    });
    सी#

    SetAsync() विधि का उपयोग करें:

    DocumentReference docRef = db.Collection("cities").Document("LA");
    Dictionary<string, object> city = new Dictionary<string, object>
    {
        { "name", "Los Angeles" },
        { "state", "CA" },
        { "country", "USA" }
    };
    await docRef.SetAsync(city);
    माणिक

    set() विधि का उपयोग करें:

    city_ref = firestore.doc "#{collection_path}/LA"
    
    data = {
      name:    "Los Angeles",
      state:   "CA",
      country: "USA"
    }
    
    city_ref.set data

    यदि दस्तावेज़ मौजूद नहीं है, तो इसे बनाया जाएगा। यदि दस्तावेज़ मौजूद है, तो इसकी सामग्री को नए प्रदान किए गए डेटा के साथ अधिलेखित कर दिया जाएगा, जब तक कि आप निर्दिष्ट नहीं करते कि डेटा को मौजूदा दस्तावेज़ में विलय किया जाना चाहिए, निम्नानुसार:

    Web modular API

    import { doc, setDoc } from "firebase/firestore"; 
    
    const cityRef = doc(db, 'cities', 'BJ');
    setDoc(cityRef, { capital: true }, { merge: true });

    Web namespaced API

    var cityRef = db.collection('cities').doc('BJ');
    
    var setWithMerge = cityRef.set({
        capital: true
    }, { merge: true });
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Update one field, creating the document if it does not exist.
    db.collection("cities").document("BJ").setData([ "capital": true ], merge: true)
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Write to the document reference, merging data with existing
    // if the document already exists
    [[[self.db collectionWithPath:@"cities"] documentWithPath:@"BJ"]
         setData:@{ @"capital": @YES }
         merge:YES
         completion:^(NSError * _Nullable error) {
           // ...
         }];

    Kotlin+KTX

    // Update one field, creating the document if it does not already exist.
    val data = hashMapOf("capital" to true)
    
    db.collection("cities").document("BJ")
        .set(data, SetOptions.merge())
    

    Java

    // Update one field, creating the document if it does not already exist.
    Map<String, Object> data = new HashMap<>();
    data.put("capital", true);
    
    db.collection("cities").document("BJ")
            .set(data, SetOptions.merge());
    

    Dart

    // Update one field, creating the document if it does not already exist.
    final data = {"capital": true};
    
    db.collection("cities").doc("BJ").set(data, SetOptions(merge: true));
    जावा
    // asynchronously update doc, create the document if missing
    Map<String, Object> update = new HashMap<>();
    update.put("capital", true);
    
    ApiFuture<WriteResult> writeResult =
        db.collection("cities").document("BJ").set(update, SetOptions.merge());
    // ...
    System.out.println("Update time : " + writeResult.get().getUpdateTime());
    अजगर
    city_ref = db.collection("cities").document("BJ")
    
    city_ref.set({"capital": True}, merge=True)

    Python

    city_ref = db.collection("cities").document("BJ")
    
    await city_ref.set({"capital": True}, merge=True)
    सी++
    db->Collection("cities").Document("BJ").Set(
        {{"capital", FieldValue::Boolean(true)}}, SetOptions::Merge());
    नोड.जे.एस
    const cityRef = db.collection('cities').doc('BJ');
    
    const res = await cityRef.set({
      capital: true
    }, { merge: true });
    जाना
    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func updateDocCreateIfMissing(ctx context.Context, client *firestore.Client) error {
    	_, err := client.Collection("cities").Doc("BJ").Set(ctx, map[string]interface{}{
    		"capital": true,
    	}, firestore.MergeAll)
    
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $cityRef = $db->collection('samples/php/cities')->document('BJ');
    $cityRef->set([
        'capital' => true
    ], ['merge' => true]);
    एकता
    DocumentReference docRef = db.Collection("cities").Document("LA");
    Dictionary<string, object> update = new Dictionary<string, object>
    {
    	{ "capital", false }
    };
    docRef.SetAsync(update, SetOptions.MergeAll);
    सी#
    DocumentReference docRef = db.Collection("cities").Document("LA");
    Dictionary<string, object> update = new Dictionary<string, object>
    {
        { "capital", false }
    };
    await docRef.SetAsync(update, SetOptions.MergeAll);
    माणिक
    city_ref = firestore.doc "#{collection_path}/LA"
    city_ref.set({ capital: false }, merge: true)

    यदि आप निश्चित नहीं हैं कि दस्तावेज़ मौजूद है या नहीं, तो संपूर्ण दस्तावेज़ों को ओवरराइट करने से बचने के लिए किसी भी मौजूदा दस्तावेज़ के साथ नए डेटा को मर्ज करने का विकल्प पास करें। मानचित्रों वाले दस्तावेज़ों के लिए, ध्यान दें कि खाली मानचित्र वाले फ़ील्ड के साथ एक सेट निर्दिष्ट करने से लक्ष्य दस्तावेज़ का मानचित्र फ़ील्ड अधिलेखित हो जाएगा।

    डेटा के प्रकार

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

    Web modular API

    import { doc, setDoc, Timestamp } from "firebase/firestore"; 
    
    const docData = {
        stringExample: "Hello world!",
        booleanExample: true,
        numberExample: 3.14159265,
        dateExample: Timestamp.fromDate(new Date("December 10, 1815")),
        arrayExample: [5, true, "hello"],
        nullExample: null,
        objectExample: {
            a: 5,
            b: {
                nested: "foo"
            }
        }
    };
    await setDoc(doc(db, "data", "one"), docData);

    Web namespaced API

    var docData = {
        stringExample: "Hello world!",
        booleanExample: true,
        numberExample: 3.14159265,
        dateExample: firebase.firestore.Timestamp.fromDate(new Date("December 10, 1815")),
        arrayExample: [5, true, "hello"],
        nullExample: null,
        objectExample: {
            a: 5,
            b: {
                nested: "foo"
            }
        }
    };
    db.collection("data").doc("one").set(docData).then(() => {
        console.log("Document successfully written!");
    });
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    let docData: [String: Any] = [
      "stringExample": "Hello world!",
      "booleanExample": true,
      "numberExample": 3.14159265,
      "dateExample": Timestamp(date: Date()),
      "arrayExample": [5, true, "hello"],
      "nullExample": NSNull(),
      "objectExample": [
        "a": 5,
        "b": [
          "nested": "foo"
        ]
      ]
    ]
    do {
      try await db.collection("data").document("one").setData(docData)
      print("Document successfully written!")
    } catch {
      print("Error writing document: \(error)")
    }
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    NSDictionary *docData = @{
      @"stringExample": @"Hello world!",
      @"booleanExample": @YES,
      @"numberExample": @3.14,
      @"dateExample": [FIRTimestamp timestampWithDate:[NSDate date]],
      @"arrayExample": @[@5, @YES, @"hello"],
      @"nullExample": [NSNull null],
      @"objectExample": @{
        @"a": @5,
        @"b": @{
          @"nested": @"foo"
        }
      }
    };
    
    [[[self.db collectionWithPath:@"data"] documentWithPath:@"one"] setData:docData
        completion:^(NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error writing document: %@", error);
          } else {
            NSLog(@"Document successfully written!");
          }
        }];

    Kotlin+KTX

    val docData = hashMapOf(
        "stringExample" to "Hello world!",
        "booleanExample" to true,
        "numberExample" to 3.14159265,
        "dateExample" to Timestamp(Date()),
        "listExample" to arrayListOf(1, 2, 3),
        "nullExample" to null,
    )
    
    val nestedData = hashMapOf(
        "a" to 5,
        "b" to true,
    )
    
    docData["objectExample"] = nestedData
    
    db.collection("data").document("one")
        .set(docData)
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }
    

    Java

    Map<String, Object> docData = new HashMap<>();
    docData.put("stringExample", "Hello world!");
    docData.put("booleanExample", true);
    docData.put("numberExample", 3.14159265);
    docData.put("dateExample", new Timestamp(new Date()));
    docData.put("listExample", Arrays.asList(1, 2, 3));
    docData.put("nullExample", null);
    
    Map<String, Object> nestedData = new HashMap<>();
    nestedData.put("a", 5);
    nestedData.put("b", true);
    
    docData.put("objectExample", nestedData);
    
    db.collection("data").document("one")
            .set(docData)
            .addOnSuccessListener(new OnSuccessListener<Void>() {
                @Override
                public void onSuccess(Void aVoid) {
                    Log.d(TAG, "DocumentSnapshot successfully written!");
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error writing document", e);
                }
            });
    

    Dart

    final docData = {
      "stringExample": "Hello world!",
      "booleanExample": true,
      "numberExample": 3.14159265,
      "dateExample": Timestamp.now(),
      "listExample": [1, 2, 3],
      "nullExample": null
    };
    
    final nestedData = {
      "a": 5,
      "b": true,
    };
    
    docData["objectExample"] = nestedData;
    
    db
        .collection("data")
        .doc("one")
        .set(docData)
        .onError((e, _) => print("Error writing document: $e"));
    जावा
    Map<String, Object> docData = new HashMap<>();
    docData.put("stringExample", "Hello, World");
    docData.put("booleanExample", false);
    docData.put("numberExample", 3.14159265);
    docData.put("nullExample", null);
    
    ArrayList<Object> arrayExample = new ArrayList<>();
    Collections.addAll(arrayExample, 5L, true, "hello");
    docData.put("arrayExample", arrayExample);
    
    Map<String, Object> objectExample = new HashMap<>();
    objectExample.put("a", 5L);
    objectExample.put("b", true);
    
    docData.put("objectExample", objectExample);
    
    ApiFuture<WriteResult> future = db.collection("data").document("one").set(docData);
    System.out.println("Update time : " + future.get().getUpdateTime());
    अजगर
    data = {
        "stringExample": "Hello, World!",
        "booleanExample": True,
        "numberExample": 3.14159265,
        "dateExample": datetime.datetime.now(tz=datetime.timezone.utc),
        "arrayExample": [5, True, "hello"],
        "nullExample": None,
        "objectExample": {"a": 5, "b": True},
    }
    
    db.collection("data").document("one").set(data)

    Python

    data = {
        "stringExample": "Hello, World!",
        "booleanExample": True,
        "numberExample": 3.14159265,
        "dateExample": datetime.datetime.now(tz=datetime.timezone.utc),
        "arrayExample": [5, True, "hello"],
        "nullExample": None,
        "objectExample": {"a": 5, "b": True},
    }
    
    await db.collection("data").document("one").set(data)
    सी++
    MapFieldValue doc_data{
        {"stringExample", FieldValue::String("Hello world!")},
        {"booleanExample", FieldValue::Boolean(true)},
        {"numberExample", FieldValue::Double(3.14159265)},
        {"dateExample", FieldValue::Timestamp(Timestamp::Now())},
        {"arrayExample", FieldValue::Array({FieldValue::Integer(1),
                                            FieldValue::Integer(2),
                                            FieldValue::Integer(3)})},
        {"nullExample", FieldValue::Null()},
        {"objectExample",
         FieldValue::Map(
             {{"a", FieldValue::Integer(5)},
              {"b", FieldValue::Map(
                        {{"nested", FieldValue::String("foo")}})}})},
    };
    
    db->Collection("data").Document("one").Set(doc_data).OnCompletion(
        [](const Future<void>& future) {
          if (future.error() == Error::kErrorOk) {
            std::cout << "DocumentSnapshot successfully written!" << std::endl;
          } else {
            std::cout << "Error writing document: " << future.error_message()
                      << std::endl;
          }
        });
    नोड.जे.एस
    const data = {
      stringExample: 'Hello, World!',
      booleanExample: true,
      numberExample: 3.14159265,
      dateExample: Timestamp.fromDate(new Date('December 10, 1815')),
      arrayExample: [5, true, 'hello'],
      nullExample: null,
      objectExample: {
        a: 5,
        b: true
      }
    };
    
    const res = await db.collection('data').doc('one').set(data);
    जाना
    
    import (
    	"context"
    	"log"
    	"time"
    
    	"cloud.google.com/go/firestore"
    )
    
    func addDocDataTypes(ctx context.Context, client *firestore.Client) error {
    	doc := make(map[string]interface{})
    	doc["stringExample"] = "Hello world!"
    	doc["booleanExample"] = true
    	doc["numberExample"] = 3.14159265
    	doc["dateExample"] = time.Now()
    	doc["arrayExample"] = []interface{}{5, true, "hello"}
    	doc["nullExample"] = nil
    	doc["objectExample"] = map[string]interface{}{
    		"a": 5,
    		"b": true,
    	}
    
    	_, err := client.Collection("data").Doc("one").Set(ctx, doc)
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $data = [
        'stringExample' => 'Hello World',
        'booleanExample' => true,
        'numberExample' => 3.14159265,
        'dateExample' => new Timestamp(new DateTime()),
        'arrayExample' => array(5, true, 'hello'),
        'nullExample' => null,
        'objectExample' => ['a' => 5, 'b' => true],
        'documentReferenceExample' => $db->collection('samples/php/data')->document('two'),
    ];
    $db->collection('samples/php/data')->document('one')->set($data);
    printf('Set multiple data-type data for the one document in the data collection.' . PHP_EOL);
    एकता
    DocumentReference docRef = db.Collection("data").Document("one");
    Dictionary<string, object> docData = new Dictionary<string, object>
    {
    	{ "stringExample", "Hello World" },
    	{ "booleanExample", false },
    	{ "numberExample", 3.14159265 },
    	{ "nullExample", null },
    	{ "arrayExample", new List<object>() { 5, true, "Hello" } },
    	{ "objectExample", new Dictionary<string, object>
    		{
    			{ "a", 5 },
    			{ "b", true },
    		}
    	},
    };
    
    docRef.SetAsync(docData);
    सी#
    DocumentReference docRef = db.Collection("data").Document("one");
    Dictionary<string, object> docData = new Dictionary<string, object>
    {
        { "stringExample", "Hello World" },
        { "booleanExample", false },
        { "numberExample", 3.14159265 },
        { "nullExample", null },
    };
    
    ArrayList arrayExample = new ArrayList();
    arrayExample.Add(5);
    arrayExample.Add(true);
    arrayExample.Add("Hello");
    docData.Add("arrayExample", arrayExample);
    
    Dictionary<string, object> objectExample = new Dictionary<string, object>
    {
        { "a", 5 },
        { "b", true },
    };
    docData.Add("objectExample", objectExample);
    
    await docRef.SetAsync(docData);
    माणिक
    doc_ref = firestore.doc "#{collection_path}/one"
    
    data = {
      stringExample:  "Hello, World!",
      booleanExample: true,
      numberExample:  3.14159265,
      dateExample:    DateTime.now,
      arrayExample:   [5, true, "hello"],
      nullExample:    nil,
      objectExample:  {
        a: 5,
        b: true
      }
    }
    
    doc_ref.set data

    कस्टम ऑब्जेक्ट

    अपने दस्तावेज़ों को प्रस्तुत करने के लिए Map या Dictionary ऑब्जेक्ट का उपयोग करना अक्सर बहुत सुविधाजनक नहीं होता है, इसलिए क्लाउड फायरस्टोर कस्टम कक्षाओं के साथ दस्तावेज़ लिखने का समर्थन करता है। क्लाउड फायरस्टोर ऑब्जेक्ट को समर्थित डेटा प्रकारों में परिवर्तित करता है।

    कस्टम कक्षाओं का उपयोग करके, आप प्रारंभिक उदाहरण को फिर से लिख सकते हैं जैसा कि दिखाया गया है:

    Web modular API

    class City {
        constructor (name, state, country ) {
            this.name = name;
            this.state = state;
            this.country = country;
        }
        toString() {
            return this.name + ', ' + this.state + ', ' + this.country;
        }
    }
    
    // Firestore data converter
    const cityConverter = {
        toFirestore: (city) => {
            return {
                name: city.name,
                state: city.state,
                country: city.country
                };
        },
        fromFirestore: (snapshot, options) => {
            const data = snapshot.data(options);
            return new City(data.name, data.state, data.country);
        }
    };

    Web namespaced API

    class City {
        constructor (name, state, country ) {
            this.name = name;
            this.state = state;
            this.country = country;
        }
        toString() {
            return this.name + ', ' + this.state + ', ' + this.country;
        }
    }
    
    // Firestore data converter
    var cityConverter = {
        toFirestore: function(city) {
            return {
                name: city.name,
                state: city.state,
                country: city.country
                };
        },
        fromFirestore: function(snapshot, options){
            const data = snapshot.data(options);
            return new City(data.name, data.state, data.country);
        }
    };
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    public struct City: Codable {
    
      let name: String
      let state: String?
      let country: String?
      let isCapital: Bool?
      let population: Int64?
    
      enum CodingKeys: String, CodingKey {
        case name
        case state
        case country
        case isCapital = "capital"
        case population
      }
    
    }
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // This isn't supported in Objective-C.
      

    Kotlin+KTX

    data class City(
        val name: String? = null,
        val state: String? = null,
        val country: String? = null,
        @field:JvmField // use this annotation if your Boolean field is prefixed with 'is'
        val isCapital: Boolean? = null,
        val population: Long? = null,
        val regions: List<String>? = null,
    )
    

    Java

    प्रत्येक कस्टम क्लास में एक सार्वजनिक कंस्ट्रक्टर होना चाहिए जो कोई तर्क नहीं लेता है। इसके अलावा, वर्ग में प्रत्येक संपत्ति के लिए एक सार्वजनिक गेटर शामिल होना चाहिए।

    public class City {
    
    
        private String name;
        private String state;
        private String country;
        private boolean capital;
        private long population;
        private List<String> regions;
    
        public City() {}
    
        public City(String name, String state, String country, boolean capital, long population, List<String> regions) {
            // ...
        }
    
        public String getName() {
            return name;
        }
    
        public String getState() {
            return state;
        }
    
        public String getCountry() {
            return country;
        }
    
        public boolean isCapital() {
            return capital;
        }
    
        public long getPopulation() {
            return population;
        }
    
        public List<String> getRegions() {
            return regions;
        }
    
    }
    

    Dart

    class City {
      final String? name;
      final String? state;
      final String? country;
      final bool? capital;
      final int? population;
      final List<String>? regions;
    
      City({
        this.name,
        this.state,
        this.country,
        this.capital,
        this.population,
        this.regions,
      });
    
      factory City.fromFirestore(
        DocumentSnapshot<Map<String, dynamic>> snapshot,
        SnapshotOptions? options,
      ) {
        final data = snapshot.data();
        return City(
          name: data?['name'],
          state: data?['state'],
          country: data?['country'],
          capital: data?['capital'],
          population: data?['population'],
          regions:
              data?['regions'] is Iterable ? List.from(data?['regions']) : null,
        );
      }
    
      Map<String, dynamic> toFirestore() {
        return {
          if (name != null) "name": name,
          if (state != null) "state": state,
          if (country != null) "country": country,
          if (capital != null) "capital": capital,
          if (population != null) "population": population,
          if (regions != null) "regions": regions,
        };
      }
    }
    जावा
    public City() {
      // Must have a public no-argument constructor
    }
    
    // Initialize all fields of a city
    public City(
        String name,
        String state,
        String country,
        Boolean capital,
        Long population,
        List<String> regions) {
      this.name = name;
      this.state = state;
      this.country = country;
      this.capital = capital;
      this.population = population;
      this.regions = regions;
    }
    अजगर
    class City:
        def __init__(self, name, state, country, capital=False, population=0, regions=[]):
            self.name = name
            self.state = state
            self.country = country
            self.capital = capital
            self.population = population
            self.regions = regions
    
        @staticmethod
        def from_dict(source):
            # ...
    
        def to_dict(self):
            # ...
    
        def __repr__(self):
            return f"City(\
                    name={self.name}, \
                    country={self.country}, \
                    population={self.population}, \
                    capital={self.capital}, \
                    regions={self.regions}\
                )"
    
    

    Python

    class City:
        def __init__(self, name, state, country, capital=False, population=0, regions=[]):
            self.name = name
            self.state = state
            self.country = country
            self.capital = capital
            self.population = population
            self.regions = regions
    
        @staticmethod
        def from_dict(source):
            # ...
    
        def to_dict(self):
            # ...
    
        def __repr__(self):
            return f"City(\
                    name={self.name}, \
                    country={self.country}, \
                    population={self.population}, \
                    capital={self.capital}, \
                    regions={self.regions}\
                )"
    
    
    सी++
    // This is not yet supported.
    
    नोड.जे.एस
    // Node.js uses JavaScript objects
    
    जाना
    
    // City represents a city.
    type City struct {
    	Name       string   `firestore:"name,omitempty"`
    	State      string   `firestore:"state,omitempty"`
    	Country    string   `firestore:"country,omitempty"`
    	Capital    bool     `firestore:"capital,omitempty"`
    	Population int64    `firestore:"population,omitempty"`
    	Regions    []string `firestore:"regions,omitempty"`
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    class City
    {
        /** @var string */
        public $name;
        /** @var string */
        public $state;
        /** @var string */
        public $country;
        /** @var bool */
        public $capital;
        /** @var int */
        public $population;
        /** @var array<string> */
        public $regions;
    
        /**
         * @param array<string> $regions
         */
        public function __construct(
            string $name,
            string $state,
            string $country,
            bool $capital = false,
            int $population = 0,
            array $regions = []
        ) {
            $this->name = $name;
            $this->state = $state;
            $this->country = $country;
            $this->capital = $capital;
            $this->population = $population;
            $this->regions = $regions;
        }
    
        /**
         * @param array<mixed> $source
         */
        public static function fromArray(array $source): City
        {
            // implementation of fromArray is excluded for brevity
            # ...
        }
    
        /**
         * @return array<mixed>
         */
        public function toArray(): array
        {
            // implementation of toArray is excluded for brevity
            # ...
        }
    
        public function __toString()
        {
            // implementation of __toString is excluded for brevity
            # ...
        }
    }
    
    एकता
    [FirestoreData]
    public class City
    {
    	[FirestoreProperty]
    	public string Name { get; set; }
    
    	[FirestoreProperty]
    	public string State { get; set; }
    
    	[FirestoreProperty]
    	public string Country { get; set; }
    
    	[FirestoreProperty]
    	public bool Capital { get; set; }
    
    	[FirestoreProperty]
    	public long Population { get; set; }
    }
    सी#
    [FirestoreData]
    public class City
    {
        [FirestoreProperty]
        public string Name { get; set; }
    
        [FirestoreProperty]
        public string State { get; set; }
    
        [FirestoreProperty]
        public string Country { get; set; }
    
        [FirestoreProperty]
        public bool Capital { get; set; }
    
        [FirestoreProperty]
        public long Population { get; set; }
    }
    माणिक
    // This isn't supported in Ruby
    

    Web modular API

    import { doc, setDoc } from "firebase/firestore"; 
    
    // Set with cityConverter
    const ref = doc(db, "cities", "LA").withConverter(cityConverter);
    await setDoc(ref, new City("Los Angeles", "CA", "USA"));

    Web namespaced API

    // Set with cityConverter
    db.collection("cities").doc("LA")
      .withConverter(cityConverter)
      .set(new City("Los Angeles", "CA", "USA"));
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    let city = City(name: "Los Angeles",
                    state: "CA",
                    country: "USA",
                    isCapital: false,
                    population: 5000000)
    
    do {
      try db.collection("cities").document("LA").setData(from: city)
    } catch let error {
      print("Error writing city to Firestore: \(error)")
    }
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // This isn't supported in Objective-C.
      

    Kotlin+KTX

    val city = City(
        "Los Angeles",
        "CA",
        "USA",
        false,
        5000000L,
        listOf("west_coast", "socal"),
    )
    db.collection("cities").document("LA").set(city)
    

    Java

    City city = new City("Los Angeles", "CA", "USA",
            false, 5000000L, Arrays.asList("west_coast", "sorcal"));
    db.collection("cities").document("LA").set(city);
    

    Dart

    final city = City(
      name: "Los Angeles",
      state: "CA",
      country: "USA",
      capital: false,
      population: 5000000,
      regions: ["west_coast", "socal"],
    );
    final docRef = db
        .collection("cities")
        .withConverter(
          fromFirestore: City.fromFirestore,
          toFirestore: (City city, options) => city.toFirestore(),
        )
        .doc("LA");
    await docRef.set(city);
    जावा
    City city =
        new City("Los Angeles", "CA", "USA", false, 3900000L, Arrays.asList("west_coast", "socal"));
    ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(city);
    // block on response if required
    System.out.println("Update time : " + future.get().getUpdateTime());
    अजगर
    city = City(name="Los Angeles", state="CA", country="USA")
    db.collection("cities").document("LA").set(city.to_dict())

    Python

    city = City(name="Los Angeles", state="CA", country="USA")
    await db.collection("cities").document("LA").set(city.to_dict())
    सी++
    // This is not yet supported.
    
    नोड.जे.एस
    // Node.js uses JavaScript objects
    
    जाना
    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func addDocAsEntity(ctx context.Context, client *firestore.Client) error {
    	city := City{
    		Name:    "Los Angeles",
    		Country: "USA",
    	}
    	_, err := client.Collection("cities").Doc("LA").Set(ctx, city)
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी
    // This isn't supported in PHP.
    
    एकता
    DocumentReference docRef = db.Collection("cities").Document("LA");
    City city = new City
    {
    	Name = "Los Angeles",
    	State = "CA",
    	Country = "USA",
    	Capital = false,
    	Population = 3900000L
    };
    docRef.SetAsync(city);
    सी#
    DocumentReference docRef = db.Collection("cities").Document("LA");
    City city = new City
    {
        Name = "Los Angeles",
        State = "CA",
        Country = "USA",
        Capital = false,
        Population = 3900000L
    };
    await docRef.SetAsync(city);
    माणिक
    // This isn't supported in Ruby.
    

    एक दस्तावेज़ जोड़ें

    जब आप दस्तावेज़ बनाने के लिए set() का उपयोग करते हैं, तो आपको दस्तावेज़ बनाने के लिए एक आईडी निर्दिष्ट करनी होगी। उदाहरण के लिए:

    Web modular API

    import { doc, setDoc } from "firebase/firestore"; 
    
    await setDoc(doc(db, "cities", "new-city-id"), data);

    Web namespaced API

    db.collection("cities").doc("new-city-id").set(data);
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    db.collection("cities").document("new-city-id").setData(data)
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    [[[self.db collectionWithPath:@"cities"] documentWithPath:@"new-city-id"]
        setData:data];

    Kotlin+KTX

    db.collection("cities").document("new-city-id").set(data)
    

    Java

    db.collection("cities").document("new-city-id").set(data);
    

    Dart

    db.collection("cities").doc("new-city-id").set({"name": "Chicago"});
    जावा
    db.collection("cities").document("new-city-id").set(data);
    अजगर
    db.collection("cities").document("new-city-id").set(data)

    Python

    await db.collection("cities").document("new-city-id").set(data)
    सी++
    db->Collection("cities").Document("SF").Set({/*some data*/});
    नोड.जे.एस
    await db.collection('cities').doc('new-city-id').set(data);
    जाना
    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func addDocWithID(ctx context.Context, client *firestore.Client) error {
    	var data = make(map[string]interface{})
    
    	_, err := client.Collection("cities").Doc("new-city-id").Set(ctx, data)
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $db->collection('samples/php/cities')->document('new-city-id')->set($data);
    एकता
    db.Collection("cities").Document("new-city-id").SetAsync(city);
    सी#
    await db.Collection("cities").Document("new-city-id").SetAsync(city);
    माणिक
    city_ref = firestore.doc "#{collection_path}/new-city-id"
    city_ref.set data

    लेकिन कभी-कभी दस्तावेज़ के लिए कोई सार्थक आईडी नहीं होती है, और क्लाउड फायरस्टोर को आपके लिए एक आईडी स्वतः उत्पन्न करने देना अधिक सुविधाजनक होता है। आप निम्नलिखित भाषा-विशिष्ट add() विधियों को कॉल करके ऐसा कर सकते हैं:

    Web modular API

    addDoc() विधि का उपयोग करें:

    import { collection, addDoc } from "firebase/firestore"; 
    
    // Add a new document with a generated id.
    const docRef = await addDoc(collection(db, "cities"), {
      name: "Tokyo",
      country: "Japan"
    });
    console.log("Document written with ID: ", docRef.id);

    Web namespaced API

    add() विधि का उपयोग करें:

    // Add a new document with a generated id.
    db.collection("cities").add({
        name: "Tokyo",
        country: "Japan"
    })
    .then((docRef) => {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch((error) => {
        console.error("Error adding document: ", error);
    });
    तीव्र

    addDocument() विधि का उपयोग करें:

    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Add a new document with a generated id.
    do {
      let ref = try await db.collection("cities").addDocument(data: [
        "name": "Tokyo",
        "country": "Japan"
      ])
      print("Document added with ID: \(ref.documentID)")
    } catch {
      print("Error adding document: \(error)")
    }
    उद्देश्य सी

    addDocumentWithData: विधि का उपयोग करें:

    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Add a new document with a generated id.
    __block FIRDocumentReference *ref =
        [[self.db collectionWithPath:@"cities"] addDocumentWithData:@{
          @"name": @"Tokyo",
          @"country": @"Japan"
        } completion:^(NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error adding document: %@", error);
          } else {
            NSLog(@"Document added with ID: %@", ref.documentID);
          }
        }];

    Kotlin+KTX

    add() विधि का उपयोग करें:

    // Add a new document with a generated id.
    val data = hashMapOf(
        "name" to "Tokyo",
        "country" to "Japan",
    )
    
    db.collection("cities")
        .add(data)
        .addOnSuccessListener { documentReference ->
            Log.d(TAG, "DocumentSnapshot written with ID: ${documentReference.id}")
        }
        .addOnFailureListener { e ->
            Log.w(TAG, "Error adding document", e)
        }
    

    Java

    add() विधि का उपयोग करें:

    // Add a new document with a generated id.
    Map<String, Object> data = new HashMap<>();
    data.put("name", "Tokyo");
    data.put("country", "Japan");
    
    db.collection("cities")
            .add(data)
            .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
                @Override
                public void onSuccess(DocumentReference documentReference) {
                    Log.d(TAG, "DocumentSnapshot written with ID: " + documentReference.getId());
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error adding document", e);
                }
            });
    

    Dart

    add() विधि का उपयोग करें:

    // Add a new document with a generated id.
    final data = {"name": "Tokyo", "country": "Japan"};
    
    db.collection("cities").add(data).then((documentSnapshot) =>
        print("Added Data with ID: ${documentSnapshot.id}"));
    जावा

    add() विधि का उपयोग करें:

    // Add document data with auto-generated id.
    Map<String, Object> data = new HashMap<>();
    data.put("name", "Tokyo");
    data.put("country", "Japan");
    ApiFuture<DocumentReference> addedDocRef = db.collection("cities").add(data);
    System.out.println("Added document with ID: " + addedDocRef.get().getId());
    अजगर

    add() विधि का उपयोग करें:

    city = {"name": "Tokyo", "country": "Japan"}
    update_time, city_ref = db.collection("cities").add(city)
    print(f"Added document with id {city_ref.id}")

    Python

    add() विधि का उपयोग करें:

    city = City(name="Tokyo", state=None, country="Japan")
    await db.collection("cities").add(city.to_dict())
    सी++

    Add() विधि का उपयोग करें:

    db->Collection("cities").Add({/*some data*/});
    नोड.जे.एस

    add() विधि का उपयोग करें:

    // Add a new document with a generated id.
    const res = await db.collection('cities').add({
      name: 'Tokyo',
      country: 'Japan'
    });
    
    console.log('Added document with ID: ', res.id);
    जाना

    Add() विधि का उपयोग करें:

    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func addDocWithoutID(ctx context.Context, client *firestore.Client) error {
    	_, _, err := client.Collection("cities").Add(ctx, map[string]interface{}{
    		"name":    "Tokyo",
    		"country": "Japan",
    	})
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    add() विधि का उपयोग करें:

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $data = [
        'name' => 'Tokyo',
        'country' => 'Japan'
    ];
    $addedDocRef = $db->collection('samples/php/cities')->add($data);
    printf('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());
    एकता

    AddAsync() विधि का उपयोग करें:

    Dictionary<string, object> city = new Dictionary<string, object>
    {
    	{ "Name", "Tokyo" },
    	{ "Country", "Japan" }
    };
    db.Collection("cities").AddAsync(city).ContinueWithOnMainThread(task => {
    	DocumentReference addedDocRef = task.Result;
    	Debug.Log(String.Format("Added document with ID: {0}.", addedDocRef.Id));
    });
    सी#

    AddAsync() विधि का उपयोग करें:

    Dictionary<string, object> city = new Dictionary<string, object>
    {
        { "Name", "Tokyo" },
        { "Country", "Japan" }
    };
    DocumentReference addedDocRef = await db.Collection("cities").AddAsync(city);
    Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id);
    माणिक

    add() विधि का उपयोग करें:

    data = {
      name:    "Tokyo",
      country: "Japan"
    }
    
    cities_ref = firestore.col collection_path
    
    added_doc_ref = cities_ref.add data
    puts "Added document with ID: #{added_doc_ref.document_id}."

    कुछ मामलों में, ऑटो-जनरेटेड आईडी के साथ दस्तावेज़ संदर्भ बनाना उपयोगी हो सकता है, फिर बाद में संदर्भ का उपयोग करें। इस उपयोग के मामले के लिए, आप doc() कॉल कर सकते हैं:

    Web modular API

    import { collection, doc, setDoc } from "firebase/firestore"; 
    
    // Add a new document with a generated id
    const newCityRef = doc(collection(db, "cities"));
    
    // later...
    await setDoc(newCityRef, data);

    Web namespaced API

    // Add a new document with a generated id.
    var newCityRef = db.collection("cities").doc();
    
    // later...
    newCityRef.set(data);
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    let newCityRef = db.collection("cities").document()
    
    // later...
    newCityRef.setData([
      // ...
    ])
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    FIRDocumentReference *newCityRef = [[self.db collectionWithPath:@"cities"] documentWithAutoID];
    // later...
    [newCityRef setData:@{ /* ... */ }];

    Kotlin+KTX

    val data = HashMap<String, Any>()
    
    val newCityRef = db.collection("cities").document()
    
    // Later...
    newCityRef.set(data)
    

    Java

    Map<String, Object> data = new HashMap<>();
    
    DocumentReference newCityRef = db.collection("cities").document();
    
    // Later...
    newCityRef.set(data);
    

    Dart

    // Add a new document with a generated id.
    final data = <String, dynamic>{};
    
    final newCityRef = db.collection("cities").doc();
    
    // Later...
    newCityRef.set(data);
    
    जावा
    // Add document data after generating an id.
    DocumentReference addedDocRef = db.collection("cities").document();
    System.out.println("Added document with ID: " + addedDocRef.getId());
    
    // later...
    ApiFuture<WriteResult> writeResult = addedDocRef.set(data);
    अजगर
    new_city_ref = db.collection("cities").document()
    
    # later...
    new_city_ref.set(
        {
            # ...
        }
    )

    Python

    new_city_ref = db.collection("cities").document()
    
    # later...
    await new_city_ref.set(
        {
            # ...
        }
    )
    सी++
    DocumentReference new_city_ref = db->Collection("cities").Document();
    नोड.जे.एस
    const newCityRef = db.collection('cities').doc();
    
    // Later...
    const res = await newCityRef.set({
      // ...
    });
    जाना
    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func addDocAfterAutoGeneratedID(ctx context.Context, client *firestore.Client) error {
    	data := City{
    		Name:    "Sydney",
    		Country: "Australia",
    	}
    
    	ref := client.Collection("cities").NewDoc()
    
    	// later...
    	_, err := ref.Set(ctx, data)
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $addedDocRef = $db->collection('samples/php/cities')->newDocument();
    printf('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());
    $addedDocRef->set($data);
    एकता
    DocumentReference addedDocRef = db.Collection("cities").Document();
    Debug.Log(String.Format("Added document with ID: {0}.", addedDocRef.Id));
    addedDocRef.SetAsync(city).ContinueWithOnMainThread(task => {
    	Debug.Log(String.Format(
    		"Added data to the {0} document in the cities collection.", addedDocRef.Id));
    });
    सी#
    DocumentReference addedDocRef = db.Collection("cities").Document();
    Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id);
    await addedDocRef.SetAsync(city);
    माणिक
    cities_ref = firestore.col collection_path
    
    added_doc_ref = cities_ref.doc
    puts "Added document with ID: #{added_doc_ref.document_id}."
    
    added_doc_ref.set data

    पर्दे के पीछे, .add(...) और .doc().set(...) पूरी तरह से समकक्ष हैं, इसलिए आप जो भी अधिक सुविधाजनक हो उसका उपयोग कर सकते हैं।

    किसी दस्तावेज़ को अद्यतन करें

    किसी दस्तावेज़ के कुछ फ़ील्ड को पूरे दस्तावेज़ को ओवरराइट किए बिना अद्यतन करने के लिए, निम्नलिखित भाषा-विशिष्ट update() विधियों का उपयोग करें:

    Web modular API

    updateDoc() विधि का उपयोग करें:

    import { doc, updateDoc } from "firebase/firestore";
    
    const washingtonRef = doc(db, "cities", "DC");
    
    // Set the "capital" field of the city 'DC'
    await updateDoc(washingtonRef, {
      capital: true
    });

    Web namespaced API

    update() विधि का उपयोग करें:

    var washingtonRef = db.collection("cities").doc("DC");
    
    // Set the "capital" field of the city 'DC'
    return washingtonRef.update({
        capital: true
    })
    .then(() => {
        console.log("Document successfully updated!");
    })
    .catch((error) => {
        // The document probably doesn't exist.
        console.error("Error updating document: ", error);
    });
    तीव्र

    updateData() विधि का उपयोग करें:

    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    let washingtonRef = db.collection("cities").document("DC")
    
    // Set the "capital" field of the city 'DC'
    do {
      try await washingtonRef.updateData([
        "capital": true
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    उद्देश्य सी

    updateData: विधि का उपयोग करें:

    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    FIRDocumentReference *washingtonRef =
        [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"];
    // Set the "capital" field of the city
    [washingtonRef updateData:@{
      @"capital": @YES
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error updating document: %@", error);
      } else {
        NSLog(@"Document successfully updated");
      }
    }];

    Kotlin+KTX

    update() विधि का उपयोग करें:

    val washingtonRef = db.collection("cities").document("DC")
    
    // Set the "isCapital" field of the city 'DC'
    washingtonRef
        .update("capital", true)
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully updated!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error updating document", e) }
    

    Java

    update() विधि का उपयोग करें:

    DocumentReference washingtonRef = db.collection("cities").document("DC");
    
    // Set the "isCapital" field of the city 'DC'
    washingtonRef
            .update("capital", true)
            .addOnSuccessListener(new OnSuccessListener<Void>() {
                @Override
                public void onSuccess(Void aVoid) {
                    Log.d(TAG, "DocumentSnapshot successfully updated!");
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error updating document", e);
                }
            });
    

    Dart

    update() विधि का उपयोग करें:

    final washingtonRef = db.collection("cites").doc("DC");
    washingtonRef.update({"capital": true}).then(
        (value) => print("DocumentSnapshot successfully updated!"),
        onError: (e) => print("Error updating document $e"));
    जावा

    update() विधि का उपयोग करें:

    // Update an existing document
    DocumentReference docRef = db.collection("cities").document("DC");
    
    // (async) Update one field
    ApiFuture<WriteResult> future = docRef.update("capital", true);
    
    // ...
    WriteResult result = future.get();
    System.out.println("Write result: " + result);
    अजगर

    update() विधि का उपयोग करें:

    city_ref = db.collection("cities").document("DC")
    
    # Set the capital field
    city_ref.update({"capital": True})

    Python

    update() विधि का उपयोग करें:

    city_ref = db.collection("cities").document("DC")
    
    # Set the capital field
    await city_ref.update({"capital": True})
    सी++

    Update() विधि का उपयोग करें:

    DocumentReference washington_ref = db->Collection("cities").Document("DC");
    // Set the "capital" field of the city "DC".
    washington_ref.Update({{"capital", FieldValue::Boolean(true)}});
    नोड.जे.एस

    update() विधि का उपयोग करें:

    const cityRef = db.collection('cities').doc('DC');
    
    // Set the 'capital' field of the city
    const res = await cityRef.update({capital: true});
    जाना

    Update() विधि का उपयोग करें:

    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func updateDoc(ctx context.Context, client *firestore.Client) error {
    	// ...
    
    	_, err := client.Collection("cities").Doc("DC").Update(ctx, []firestore.Update{
    		{
    			Path:  "capital",
    			Value: true,
    		},
    	})
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    update() विधि का उपयोग करें:

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $cityRef = $db->collection('samples/php/cities')->document('DC');
    $cityRef->update([
        ['path' => 'capital', 'value' => true]
    ]);
    एकता

    UpdateAsync() विधि का उपयोग करें:

    DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
    Dictionary<string, object> updates = new Dictionary<string, object>
    {
    	{ "Capital", false }
    };
    
    cityRef.UpdateAsync(updates).ContinueWithOnMainThread(task => {
    	Debug.Log(
    		"Updated the Capital field of the new-city-id document in the cities collection.");
    });
    // You can also update a single field with: cityRef.UpdateAsync("Capital", false);
    सी#

    UpdateAsync() विधि का उपयोग करें:

    DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
    Dictionary<string, object> updates = new Dictionary<string, object>
    {
        { "Capital", false }
    };
    await cityRef.UpdateAsync(updates);
    
    // You can also update a single field with: await cityRef.UpdateAsync("Capital", false);
    माणिक

    update() विधि का उपयोग करें:

    city_ref = firestore.doc "#{collection_path}/DC"
    city_ref.update({ capital: true })

    सर्वर टाइमस्टैम्प

    आप अपने दस्तावेज़ में एक फ़ील्ड को सर्वर टाइमस्टैम्प पर सेट कर सकते हैं जो सर्वर को अपडेट प्राप्त होने पर ट्रैक करता है।

    Web modular API

    import { updateDoc, serverTimestamp } from "firebase/firestore";
    
    const docRef = doc(db, 'objects', 'some-id');
    
    // Update the timestamp field with the value from the server
    const updateTimestamp = await updateDoc(docRef, {
        timestamp: serverTimestamp()
    });

    Web namespaced API

    var docRef = db.collection('objects').doc('some-id');
    
    // Update the timestamp field with the value from the server
    var updateTimestamp = docRef.update({
        timestamp: firebase.firestore.FieldValue.serverTimestamp()
    });
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    do {
      try await db.collection("objects").document("some-id").updateData([
        "lastUpdated": FieldValue.serverTimestamp(),
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    [[[self.db collectionWithPath:@"objects"] documentWithPath:@"some-id"] updateData:@{
      @"lastUpdated": [FIRFieldValue fieldValueForServerTimestamp]
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error updating document: %@", error);
      } else {
        NSLog(@"Document successfully updated");
      }
    }];

    Kotlin+KTX

    // If you're using custom Kotlin objects in Android, add an @ServerTimestamp
    // annotation to a Date field for your custom object classes. This indicates
    // that the Date field should be treated as a server timestamp by the object mapper.
    val docRef = db.collection("objects").document("some-id")
    
    // Update the timestamp field with the value from the server
    val updates = hashMapOf<String, Any>(
        "timestamp" to FieldValue.serverTimestamp(),
    )
    
    docRef.update(updates).addOnCompleteListener { }
    

    Java

    // If you're using custom Java objects in Android, add an @ServerTimestamp
    // annotation to a Date field for your custom object classes. This indicates
    // that the Date field should be treated as a server timestamp by the object mapper.
    DocumentReference docRef = db.collection("objects").document("some-id");
    
    // Update the timestamp field with the value from the server
    Map<String,Object> updates = new HashMap<>();
    updates.put("timestamp", FieldValue.serverTimestamp());
    
    docRef.update(updates).addOnCompleteListener(new OnCompleteListener<Void>() {
        // ...
        // ...
    

    Dart

    final docRef = db.collection("objects").doc("some-id");
    final updates = <String, dynamic>{
      "timestamp": FieldValue.serverTimestamp(),
    };
    
    docRef.update(updates).then(
        (value) => print("DocumentSnapshot successfully updated!"),
        onError: (e) => print("Error updating document $e"));
    जावा
    DocumentReference docRef = db.collection("objects").document("some-id");
    // Update the timestamp field with the value from the server
    ApiFuture<WriteResult> writeResult = docRef.update("timestamp", FieldValue.serverTimestamp());
    System.out.println("Update time : " + writeResult.get());
    अजगर
    city_ref = db.collection("objects").document("some-id")
    city_ref.update({"timestamp": firestore.SERVER_TIMESTAMP})

    Python

    city_ref = db.collection("objects").document("some-id")
    await city_ref.update({"timestamp": firestore.SERVER_TIMESTAMP})
    सी++
    DocumentReference doc_ref = db->Collection("objects").Document("some-id");
    doc_ref.Update({{"timestamp", FieldValue::ServerTimestamp()}})
        .OnCompletion([](const Future<void>& future) {
          // ...
        });
    नोड.जे.एस
    // Create a document reference
    const docRef = db.collection('objects').doc('some-id');
    
    // Update the timestamp field with the value from the server
    const res = await docRef.update({
      timestamp: FieldValue.serverTimestamp()
    });
    जाना
    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func updateDocServerTimestamp(ctx context.Context, client *firestore.Client) error {
    	// ...
    
    	_, err := client.Collection("objects").Doc("some-id").Set(ctx, map[string]interface{}{
    		"timestamp": firestore.ServerTimestamp,
    	}, firestore.MergeAll)
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $docRef = $db->collection('samples/php/objects')->document('some-id');
    $docRef->update([
        ['path' => 'timestamp', 'value' => FieldValue::serverTimestamp()]
    ]);
    एकता
    DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
    cityRef.UpdateAsync("Timestamp", FieldValue.ServerTimestamp)
    	.ContinueWithOnMainThread(task => {
    		Debug.Log(
    			"Updated the Timestamp field of the new-city-id document in the cities "
    			+ "collection.");
    	});
    सी#
    DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
    await cityRef.UpdateAsync("Timestamp", Timestamp.GetCurrentTimestamp());
    माणिक
    city_ref = firestore.doc "#{collection_path}/new-city-id"
    city_ref.update({ timestamp: firestore.field_server_time })

    लेन-देन के अंदर एकाधिक टाइमस्टैम्प फ़ील्ड को अपडेट करते समय, प्रत्येक फ़ील्ड को समान सर्वर टाइमस्टैंप मान प्राप्त होता है।

    नेस्टेड ऑब्जेक्ट में फ़ील्ड अपडेट करें

    यदि आपके दस्तावेज़ में नेस्टेड ऑब्जेक्ट हैं, तो आप update() कॉल करने पर दस्तावेज़ के भीतर नेस्टेड फ़ील्ड को संदर्भित करने के लिए "डॉट नोटेशन" का उपयोग कर सकते हैं:

    Web modular API

    import { doc, setDoc, updateDoc } from "firebase/firestore"; 
    
    // Create an initial document to update.
    const frankDocRef = doc(db, "users", "frank");
    await setDoc(frankDocRef, {
        name: "Frank",
        favorites: { food: "Pizza", color: "Blue", subject: "recess" },
        age: 12
    });
    
    // To update age and favorite color:
    await updateDoc(frankDocRef, {
        "age": 13,
        "favorites.color": "Red"
    });

    Web namespaced API

    // Create an initial document to update.
    var frankDocRef = db.collection("users").doc("frank");
    frankDocRef.set({
        name: "Frank",
        favorites: { food: "Pizza", color: "Blue", subject: "recess" },
        age: 12
    });
    
    // To update age and favorite color:
    db.collection("users").doc("frank").update({
        "age": 13,
        "favorites.color": "Red"
    })
    .then(() => {
        console.log("Document successfully updated!");
    });
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Create an initial document to update.
    let frankDocRef = db.collection("users").document("frank")
    do {
      try await frankDocRef.setData([
        "name": "Frank",
        "favorites": [ "food": "Pizza", "color": "Blue", "subject": "recess" ],
        "age": 12
      ])
    
      // To update age and favorite color:
      try await frankDocRef.updateData([
        "age": 13,
        "favorites.color": "Red"
      ])
      print("Document successfully updated")
    } catch {
      print("Error updating document: \(error)")
    }
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    // Create an initial document to update.
    FIRDocumentReference *frankDocRef =
        [[self.db collectionWithPath:@"users"] documentWithPath:@"frank"];
    [frankDocRef setData:@{
      @"name": @"Frank",
      @"favorites": @{
        @"food": @"Pizza",
        @"color": @"Blue",
        @"subject": @"recess"
      },
      @"age": @12
    }];
    // To update age and favorite color:
    [frankDocRef updateData:@{
      @"age": @13,
      @"favorites.color": @"Red",
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error updating document: %@", error);
      } else {
        NSLog(@"Document successfully updated");
      }
    }];

    Kotlin+KTX

    // Assume the document contains:
    // {
    //   name: "Frank",
    //   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
    //   age: 12
    // }
    //
    // To update age and favorite color:
    db.collection("users").document("frank")
        .update(
            mapOf(
                "age" to 13,
                "favorites.color" to "Red",
            ),
        )
    

    Java

    // Assume the document contains:
    // {
    //   name: "Frank",
    //   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
    //   age: 12
    // }
    //
    // To update age and favorite color:
    db.collection("users").document("frank")
            .update(
                    "age", 13,
                    "favorites.color", "Red"
            );
    

    Dart

    // Assume the document contains:
    // {
    //   name: "Frank",
    //   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
    //   age: 12
    // }
    db
        .collection("users")
        .doc("frank")
        .update({"age": 13, "favorites.color": "Red"});
    जावा
    // Create an initial document to update
    DocumentReference frankDocRef = db.collection("users").document("frank");
    Map<String, Object> initialData = new HashMap<>();
    initialData.put("name", "Frank");
    initialData.put("age", 12);
    
    Map<String, Object> favorites = new HashMap<>();
    favorites.put("food", "Pizza");
    favorites.put("color", "Blue");
    favorites.put("subject", "Recess");
    initialData.put("favorites", favorites);
    
    ApiFuture<WriteResult> initialResult = frankDocRef.set(initialData);
    // Confirm that data has been successfully saved by blocking on the operation
    initialResult.get();
    
    // Update age and favorite color
    Map<String, Object> updates = new HashMap<>();
    updates.put("age", 13);
    updates.put("favorites.color", "Red");
    
    // Async update document
    ApiFuture<WriteResult> writeResult = frankDocRef.update(updates);
    // ...
    System.out.println("Update time : " + writeResult.get().getUpdateTime());
    अजगर
    # Create an initial document to update
    frank_ref = db.collection("users").document("frank")
    frank_ref.set(
        {
            "name": "Frank",
            "favorites": {"food": "Pizza", "color": "Blue", "subject": "Recess"},
            "age": 12,
        }
    )
    
    # Update age and favorite color
    frank_ref.update({"age": 13, "favorites.color": "Red"})

    Python

    # Create an initial document to update
    frank_ref = db.collection("users").document("frank")
    await frank_ref.set(
        {
            "name": "Frank",
            "favorites": {"food": "Pizza", "color": "Blue", "subject": "Recess"},
            "age": 12,
        }
    )
    
    # Update age and favorite color
    await frank_ref.update({"age": 13, "favorites.color": "Red"})
    सी++
    // Assume the document contains:
    // {
    //   name: "Frank",
    //   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
    //   age: 12
    // }
    //
    // To update age and favorite color:
    db->Collection("users").Document("frank").Update({
        {"age", FieldValue::Integer(13)},
        {"favorites.color", FieldValue::String("red")},
    });
    नोड.जे.एस
    const initialData = {
      name: 'Frank',
      age: 12,
      favorites: {
        food: 'Pizza',
        color: 'Blue',
        subject: 'recess'
      }
    };
    
    // ...
    const res = await db.collection('users').doc('Frank').update({
      age: 13,
      'favorites.color': 'Red'
    });
    जाना
    
    import (
    	"context"
    	"log"
    
    	"cloud.google.com/go/firestore"
    )
    
    func updateDocNested(ctx context.Context, client *firestore.Client) error {
    	initialData := map[string]interface{}{
    		"name": "Frank",
    		"age":  12,
    		"favorites": map[string]interface{}{
    			"food":    "Pizza",
    			"color":   "Blue",
    			"subject": "recess",
    		},
    	}
    
    	// ...
    
    	_, err := client.Collection("users").Doc("frank").Set(ctx, map[string]interface{}{
    		"age": 13,
    		"favorites": map[string]interface{}{
    			"color": "Red",
    		},
    	}, firestore.MergeAll)
    	if err != nil {
    		// Handle any errors in an appropriate way, such as returning them.
    		log.Printf("An error has occurred: %s", err)
    	}
    
    	return err
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    // Create an initial document to update
    $frankRef = $db->collection('samples/php/users')->document('frank');
    $frankRef->set([
        'first' => 'Frank',
        'last' => 'Franklin',
        'favorites' => ['food' => 'Pizza', 'color' => 'Blue', 'subject' => 'Recess'],
        'age' => 12
    ]);
    
    // Update age and favorite color
    $frankRef->update([
        ['path' => 'age', 'value' => 13],
        ['path' => 'favorites.color', 'value' => 'Red']
    ]);
    एकता
    DocumentReference frankDocRef = db.Collection("users").Document("frank");
    Dictionary<string, object> initialData = new Dictionary<string, object>
    {
    	{ "Name", "Frank" },
    	{ "Age", 12 }
    };
    
    Dictionary<string, object> favorites = new Dictionary<string, object>
    {
    	{ "Food", "Pizza" },
    	{ "Color", "Blue" },
    	{ "Subject", "Recess" },
    };
    initialData.Add("Favorites", favorites);
    frankDocRef.SetAsync(initialData).ContinueWithOnMainThread(task => {
    
    	// Update age and favorite color
    	Dictionary<string, object> updates = new Dictionary<string, object>
    	{
    		{ "Age", 13 },
    		{ "Favorites.Color", "Red" },
    	};
    
    	// Asynchronously update the document
    	return frankDocRef.UpdateAsync(updates);
    }).ContinueWithOnMainThread(task => {
    	Debug.Log(
    		"Updated the age and favorite color fields of the Frank document in "
    		+ "the users collection.");
    });
    सी#
    DocumentReference frankDocRef = db.Collection("users").Document("frank");
    Dictionary<string, object> initialData = new Dictionary<string, object>
    {
        { "Name", "Frank" },
        { "Age", 12 }
    };
    
    Dictionary<string, object> favorites = new Dictionary<string, object>
    {
        { "Food", "Pizza" },
        { "Color", "Blue" },
        { "Subject", "Recess" },
    };
    initialData.Add("Favorites", favorites);
    await frankDocRef.SetAsync(initialData);
    
    // Update age and favorite color
    Dictionary<string, object> updates = new Dictionary<string, object>
    {
        { "Age", 13 },
        { "Favorites.Color", "Red" },
    };
    
    // Asynchronously update the document
    await frankDocRef.UpdateAsync(updates);
    माणिक
    # Create an initial document to update
    frank_ref = firestore.doc "#{collection_path}/frank"
    frank_ref.set(
      {
        name:      "Frank",
        favorites: {
          food:    "Pizza",
          color:   "Blue",
          subject: "Recess"
        },
        age:       12
      }
    )
    
    # Update age and favorite color
    frank_ref.update({ age: 13, "favorites.color": "Red" })

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

    वेब
    
    // Create our initial doc
    db.collection("users").doc("frank").set({
      name: "Frank",
      favorites: {
        food: "Pizza",
        color: "Blue",
        subject: "Recess"
      },
      age: 12
    }).then(function() {
      console.log("Frank created");
    });
    
    // Update the doc without using dot notation.
    // Notice the map value for favorites.
    db.collection("users").doc("frank").update({
      favorites: {
        food: "Ice Cream"
      }
    }).then(function() {
      console.log("Frank food updated");
    });
    
    /*
    Ending State, favorite.color and favorite.subject are no longer present:
    /users
        /frank
            {
                name: "Frank",
                favorites: {
                    food: "Ice Cream",
                },
                age: 12
            }
     */
    

    किसी सरणी में तत्वों को अद्यतन करें

    यदि आपके दस्तावेज़ में एक सरणी फ़ील्ड है, तो आप तत्वों को जोड़ने और हटाने के लिए arrayUnion() और arrayRemove() का उपयोग कर सकते हैं। arrayUnion() किसी सरणी में तत्व जोड़ता है लेकिन केवल वे तत्व जो पहले से मौजूद नहीं हैं। arrayRemove() प्रत्येक दिए गए तत्व के सभी उदाहरण हटा देता है।

    Web modular API

    import { doc, updateDoc, arrayUnion, arrayRemove } from "firebase/firestore";
    
    const washingtonRef = doc(db, "cities", "DC");
    
    // Atomically add a new region to the "regions" array field.
    await updateDoc(washingtonRef, {
        regions: arrayUnion("greater_virginia")
    });
    
    // Atomically remove a region from the "regions" array field.
    await updateDoc(washingtonRef, {
        regions: arrayRemove("east_coast")
    });

    Web namespaced API

    var washingtonRef = db.collection("cities").doc("DC");
    
    // Atomically add a new region to the "regions" array field.
    washingtonRef.update({
        regions: firebase.firestore.FieldValue.arrayUnion("greater_virginia")
    });
    
    // Atomically remove a region from the "regions" array field.
    washingtonRef.update({
        regions: firebase.firestore.FieldValue.arrayRemove("east_coast")
    });
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    let washingtonRef = db.collection("cities").document("DC")
    
    // Atomically add a new region to the "regions" array field.
    washingtonRef.updateData([
      "regions": FieldValue.arrayUnion(["greater_virginia"])
    ])
    
    // Atomically remove a region from the "regions" array field.
    washingtonRef.updateData([
      "regions": FieldValue.arrayRemove(["east_coast"])
    ])
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    FIRDocumentReference *washingtonRef =
        [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"];
    
    // Atomically add a new region to the "regions" array field.
    [washingtonRef updateData:@{
      @"regions": [FIRFieldValue fieldValueForArrayUnion:@[@"greater_virginia"]]
    }];
    
    // Atomically remove a new region to the "regions" array field.
    [washingtonRef updateData:@{
      @"regions": [FIRFieldValue fieldValueForArrayRemove:@[@"east_coast"]]
    }];

    Kotlin+KTX

    val washingtonRef = db.collection("cities").document("DC")
    
    // Atomically add a new region to the "regions" array field.
    washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"))
    
    // Atomically remove a region from the "regions" array field.
    washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"))
    

    Java

    DocumentReference washingtonRef = db.collection("cities").document("DC");
    
    // Atomically add a new region to the "regions" array field.
    washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"));
    
    // Atomically remove a region from the "regions" array field.
    washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"));
    

    Dart

    final washingtonRef = db.collection("cities").doc("DC");
    
    // Atomically add a new region to the "regions" array field.
    washingtonRef.update({
      "regions": FieldValue.arrayUnion(["greater_virginia"]),
    });
    
    // Atomically remove a region from the "regions" array field.
    washingtonRef.update({
      "regions": FieldValue.arrayRemove(["east_coast"]),
    });
    जावा
    DocumentReference washingtonRef = db.collection("cities").document("DC");
    
    // Atomically add a new region to the "regions" array field.
    ApiFuture<WriteResult> arrayUnion =
        washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"));
    System.out.println("Update time : " + arrayUnion.get());
    
    // Atomically remove a region from the "regions" array field.
    ApiFuture<WriteResult> arrayRm =
        washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"));
    System.out.println("Update time : " + arrayRm.get());
    अजगर
    city_ref = db.collection("cities").document("DC")
    
    # Atomically add a new region to the 'regions' array field.
    city_ref.update({"regions": firestore.ArrayUnion(["greater_virginia"])})
    
    # // Atomically remove a region from the 'regions' array field.
    city_ref.update({"regions": firestore.ArrayRemove(["east_coast"])})

    Python

    city_ref = db.collection("cities").document("DC")
    
    # Atomically add a new region to the 'regions' array field.
    await city_ref.update({"regions": firestore.ArrayUnion(["greater_virginia"])})
    
    # // Atomically remove a region from the 'regions' array field.
    await city_ref.update({"regions": firestore.ArrayRemove(["east_coast"])})
    सी++
    // This is not yet supported.
    
    नोड.जे.एस
    // ...
    const washingtonRef = db.collection('cities').doc('DC');
    
    // Atomically add a new region to the "regions" array field.
    const unionRes = await washingtonRef.update({
      regions: FieldValue.arrayUnion('greater_virginia')
    });
    // Atomically remove a region from the "regions" array field.
    const removeRes = await washingtonRef.update({
      regions: FieldValue.arrayRemove('east_coast')
    });
    
    // To add or remove multiple items, pass multiple arguments to arrayUnion/arrayRemove
    const multipleUnionRes = await washingtonRef.update({
      regions: FieldValue.arrayUnion('south_carolina', 'texas')
      // Alternatively, you can use spread operator in ES6 syntax
      // const newRegions = ['south_carolina', 'texas']
      // regions: FieldValue.arrayUnion(...newRegions)
    });
    जाना
    // Not supported yet
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $cityRef = $db->collection('samples/php/cities')->document('DC');
    
    // Atomically add a new region to the "regions" array field.
    $cityRef->update([
        ['path' => 'regions', 'value' => FieldValue::arrayUnion(['greater_virginia'])]
    ]);
    
    // Atomically remove a region from the "regions" array field.
    $cityRef->update([
        ['path' => 'regions', 'value' => FieldValue::arrayRemove(['east_coast'])]
    ]);
    एकता
    // This is not yet supported in the Unity SDK
      
    सी#
    DocumentReference washingtonRef = db.Collection("cities").Document("DC");
    
    // Atomically add a new region to the "regions" array field.
    await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayUnion("greater_virginia"));
    
    // Atomically remove a region from the "regions" array field.
    await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayRemove("east_coast"));
    माणिक
    // Not supported yet
    

    एक संख्यात्मक मान बढ़ाएँ

    आप संख्यात्मक फ़ील्ड मान को बढ़ा या घटा सकते हैं जैसा कि निम्नलिखित उदाहरण में दिखाया गया है। एक वृद्धि ऑपरेशन किसी फ़ील्ड के वर्तमान मूल्य को दी गई राशि से बढ़ाता या घटाता है।

    Web modular API

    import { doc, updateDoc, increment } from "firebase/firestore";
    
    const washingtonRef = doc(db, "cities", "DC");
    
    // Atomically increment the population of the city by 50.
    await updateDoc(washingtonRef, {
        population: increment(50)
    });

    Web namespaced API

    var washingtonRef = db.collection('cities').doc('DC');
    
    // Atomically increment the population of the city by 50.
    washingtonRef.update({
        population: firebase.firestore.FieldValue.increment(50)
    });
    तीव्र
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    let washingtonRef = db.collection("cities").document("DC")
    
    // Atomically increment the population of the city by 50.
    // Note that increment() with no arguments increments by 1.
    washingtonRef.updateData([
      "population": FieldValue.increment(Int64(50))
    ])
    उद्देश्य सी
    नोट: यह उत्पाद वॉचओएस और ऐप क्लिप लक्ष्य पर उपलब्ध नहीं है।
    FIRDocumentReference *washingtonRef =
        [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"];
    
    // Atomically increment the population of the city by 50.
    // Note that increment() with no arguments increments by 1.
    [washingtonRef updateData:@{
      @"population": [FIRFieldValue fieldValueForIntegerIncrement:50]
    }];

    Kotlin+KTX

    val washingtonRef = db.collection("cities").document("DC")
    
    // Atomically increment the population of the city by 50.
    washingtonRef.update("population", FieldValue.increment(50))
    

    Java

    DocumentReference washingtonRef = db.collection("cities").document("DC");
    
    // Atomically increment the population of the city by 50.
    washingtonRef.update("population", FieldValue.increment(50));
    

    Dart

    var washingtonRef = db.collection('cities').doc('DC');
    
    // Atomically increment the population of the city by 50.
    washingtonRef.update(
      {"population": FieldValue.increment(50)},
    );
    जावा
    DocumentReference washingtonRef = db.collection("cities").document("DC");
    
    // Atomically increment the population of the city by 50.
    final ApiFuture<WriteResult> updateFuture =
        washingtonRef.update("population", FieldValue.increment(50));
    अजगर
    washington_ref = db.collection("cities").document("DC")
    
    washington_ref.update({"population": firestore.Increment(50)})

    Python

    washington_ref = db.collection("cities").document("DC")
    
    await washington_ref.update({"population": firestore.Increment(50)})
    सी++
    // This is not yet supported.
    
    नोड.जे.एस
    // ...
    const washingtonRef = db.collection('cities').doc('DC');
    
    // Atomically increment the population of the city by 50.
    const res = await washingtonRef.update({
      population: FieldValue.increment(50)
    });
    जाना
    import (
    	"context"
    	"fmt"
    
    	"cloud.google.com/go/firestore"
    )
    
    // updateDocumentIncrement increments the population of the city document in the
    // cities collection by 50.
    func updateDocumentIncrement(projectID, city string) error {
    	// projectID := "my-project"
    
    	ctx := context.Background()
    
    	client, err := firestore.NewClient(ctx, projectID)
    	if err != nil {
    		return fmt.Errorf("firestore.NewClient: %w", err)
    	}
    	defer client.Close()
    
    	dc := client.Collection("cities").Doc(city)
    	_, err = dc.Update(ctx, []firestore.Update{
    		{Path: "population", Value: firestore.Increment(50)},
    	})
    	if err != nil {
    		return fmt.Errorf("Update: %w", err)
    	}
    
    	return nil
    }
    
    पीएचपी

    पीएचपी

    क्लाउड फायरस्टोर क्लाइंट स्थापित करने और बनाने के बारे में अधिक जानकारी के लिए, क्लाउड फायरस्टोर क्लाइंट लाइब्रेरीज़ देखें।

    $cityRef = $db->collection('samples/php/cities')->document('DC');
    
    // Atomically increment the population of the city by 50.
    $cityRef->update([
        ['path' => 'regions', 'value' => FieldValue::increment(50)]
    ]);
    एकता
    // This is not yet supported in the Unity SDK.
      
    सी#
    DocumentReference washingtonRef = db.Collection("cities").Document("DC");
    
    // Atomically increment the population of the city by 50.
    await washingtonRef.UpdateAsync("Regions", FieldValue.Increment(50));
    माणिक
    city_ref = firestore.doc "#{collection_path}/DC"
    city_ref.update({ population: firestore.field_increment(50) })

    इंक्रीमेंट ऑपरेशंस काउंटरों को लागू करने के लिए उपयोगी हैं, लेकिन ध्यान रखें कि आप एक दस्तावेज़ को प्रति सेकंड केवल एक बार ही अपडेट कर सकते हैं। यदि आपको अपने काउंटर को इस दर से ऊपर अपडेट करने की आवश्यकता है, तो वितरित काउंटर पृष्ठ देखें।