Firestore पाइपलाइन ऑपरेशन की मदद से डेटा में बदलाव करना

डेटा पाइपलाइन बनाने के लिए, update(...) और delete(...) डेटा में बदलाव करने वाली कंप्यूटर प्रोग्राम की भाषा (डीएमएल) के चरणों का इस्तेमाल करें. ये पाइपलाइन, दस्तावेज़ों के लिए क्वेरी कर सकती हैं. इसके बाद, डेटा को मिटा सकती हैं या उसमें बदलाव कर सकती हैं.

वर्शन के लिए ज़रूरी शर्तें

इस पेज पर बताई गई कार्रवाइयों के लिए, Firestore Enterprise एडिशन की ज़रूरत होती है.

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

आपको यह पता होना चाहिए कि पाइपलाइन ऑपरेशन की मदद से डेटाबेस को कैसे क्वेरी किया जाता है.

दस्तावेज़ अपडेट करना

डेटा पाइपलाइन बनाने के लिए, update(...) डीएमएल स्टेज का इस्तेमाल करें. इससे दस्तावेज़ों के लिए क्वेरी की जा सकती है. इसके बाद, डेटा जोड़ा या बदला जा सकता है.

सभी डीएमएल स्टेज, पाइपलाइन के आखिर में होने चाहिए. इस चरण में आने वाले दस्तावेज़ों में, __name__ फ़ील्ड शामिल होना चाहिए, ताकि यह पता चल सके कि किन दस्तावेज़ों को अपडेट करना है. अगर अपडेट किए जाने वाले दस्तावेज़ों में से कोई भी मौजूद नहीं है, तो ऑपरेशन पूरा नहीं होगा.

उदाहरण के लिए, यहां दिया गया ऑपरेशन, डेटा मॉडल में हुए बदलाव को किसी कलेक्शन ग्रुप के सभी दस्तावेज़ों में फिर से भरता है. पाइपलाइन, users कलेक्शन ग्रुप के उन सभी दस्तावेज़ों में preferences.color फ़ील्ड जोड़ती है जिनमें यह फ़ील्ड मौजूद नहीं है.

Node.js
const snapshot = await db.pipeline()
   .collectionGroup("users")
   .where(not(exists(field("preferences.color"))))
   .addFields(constant(null).as("preferences.color"))
   .removeFields("color")
   .update()
   .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Constant, Field, Not

snapshot = (
    client.pipeline()
    .collection_group("users")
    .where(Not(Field.of("preferences.color").exists()))
    .add_fields(Constant.of(None).as_("preferences.color"))
    .remove_fields("color")
    .update()
    .execute()
)
Java
Pipeline.Snapshot snapshot = firestore.pipeline()
   .collectionGroup("users")
   .where(not(exists(field("preferences.color"))))
   .addFields(constant((String) null).as("preferences.color"))
   .removeFields("color")
   .update()
   .execute().get();
जाएं
snapshot := client.Pipeline().
	CollectionGroup("users").
	Where(firestore.Not(firestore.FieldExists(firestore.FieldOf("preferences.color")))).
	AddFields(firestore.Selectables(
		firestore.ConstantOfNull().As("preferences.color"),
	)).
	RemoveFields(firestore.Fields("color")).
	Update().
	Execute(ctx)

दस्तावेज़ मिटाना

डेटा पाइपलाइन बनाने के लिए, delete(...) स्टेज DML स्टेज का इस्तेमाल करें. इससे दस्तावेज़ों के लिए क्वेरी की जा सकती है और फिर डेटा मिटाया जा सकता है. एक साथ कई पाइपलाइन के गलती से मिटने से रोकने के लिए, delete(...) पर खत्म होने वाली पाइपलाइन में कम से कम एक where(...) स्टेज शामिल होना चाहिए. सभी डीएमएल स्टेज, पाइपलाइन के आखिर में होने चाहिए.

उदाहरण के लिए, यहां दी गई पाइपलाइन, users के उन सभी दस्तावेज़ों को मिटा देती है जिनमें address.users को USA पर सेट किया गया है और __create_time__ की वैल्यू 10 दिनों से कम है:

Node.js
const pipeline = db.pipeline()
  .collectionGroup("users")
  .where(field("address.country").equal("USA"))
  .where(field("__create_time__").timestampAdd("day", 10).lessThan(currentTimestamp()))
  .delete();
await pipeline.execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import CurrentTimestamp, Field

snapshot = (
    client.pipeline()
    .collection_group("users")
    .where(Field.of("address.country").equal("USA"))
    .where(
        Field.of("__create_time__")
        .timestamp_add("day", 10)
        .less_than(CurrentTimestamp())
    )
    .delete()
    .execute()
)
Java
Pipeline.Snapshot deleteResults = firestore.pipeline()
  .collectionGroup("users")
  .where(field("address.country").equal("USA"))
  .where(field("__create_time__").add(constant(10)).lessThan(currentTimestamp()))
  .delete()
  .execute().get();
जाएं
snapshot := client.Pipeline().
	CollectionGroup("users").
	Where(firestore.FieldOf("address.country").Equal("USA")).
	Where(firestore.FieldOf("__create_time__").Add(firestore.ConstantOf(10)).LessThan(firestore.CurrentTimestamp())).
	Delete().
	Execute(ctx)

लगातार वीडियो अपलोड करते रहना

किसी लेन-देन में, update(...) और delete() चरणों वाली पाइपलाइन कार्रवाइयों का इस्तेमाल नहीं किया जा सकता. डीएमएल स्टेज, ट्रांज़ैक्शन के बाहर काम करती हैं. इनका व्यवहार इस तरह होता है:

  • हर दस्तावेज़ को अलग से अपडेट किया जाता है. इसका मतलब है कि दस्तावेज़ों में एक साथ कई कार्रवाइयां नहीं की जा सकतीं. पहली गड़बड़ी होने पर कार्रवाई पूरी नहीं होती. हालांकि, कुछ मामलों में कार्रवाई पूरी हो सकती है.
  • इन चरणों के लिए, यह सुविधा उपलब्ध है:
    • collection(...)
    • collection_group(...)
    • where(...)
    • select(...)
    • add_fields(...)
    • remove_fields(...)
    • let(...)
    • sort(...)
    • limit(...)
    • offset(...)
  • इन चरणों के लिए, यह सुविधा उपलब्ध नहीं है:
    • aggregate(...)
    • distinct(...)
    • unnest(...)
    • find_nearest(...)
    • डीएमएल स्टेज से पहले, एक से ज़्यादा क्वेरी वाले स्टेज (जैसे कि union(...), जॉइन, और सब-क्वेरी) की अनुमति नहीं है.

सीमाएं

डीएमएल चरणों के लिए, इन सीमाओं का ध्यान रखें:

  • .execute() को कॉल करने से पहले, DML स्टेज को पाइपलाइन की परिभाषा में आखिरी स्टेज होना चाहिए.
  • किसी लेन-देन में, update(...) और delete() चरणों वाली पाइपलाइन कार्रवाइयों का इस्तेमाल नहीं किया जा सकता.
  • अगर डीएमएल स्टेज से पहले की स्टेज में, एक ही __name__ वाले कई दस्तावेज़ जनरेट होते हैं, तो हर इंस्टेंस को प्रोसेस किया जाता है. update(...) के लिए, इसका मतलब है कि एक ही टारगेट दस्तावेज़ में कई बार बदलाव किया जा सकता है. delete(...) के लिए, पहली कोशिश के बाद की जाने वाली कोशिशें काम नहीं करेंगी.