मिटाएं

delete() , डेटा में बदलाव करने वाली कंप्यूटर प्रोग्राम की भाषा (डीएमएल) का एक चरण है. इसकी मदद से, क्वेरी के नतीजों के आधार पर दस्तावेज़ों को हटाया जा सकता है. इस चरण को क्वेरी के आखिर में जोड़ा जा सकता है. इससे, पिछले चरण में मौजूद __name__ फ़ील्ड में रेफ़रंस वाले सभी दस्तावेज़ मिट जाएंगे.

उदाहरण

उदाहरण के लिए, यहां दी गई क्वेरी से 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();
Go
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)

व्यवहार

जवाब

delete() चरण हमेशा एक दस्तावेज़ दिखाता है. जैसे, { documents_modified: 28L }. इससे पता चलता है कि कितने दस्तावेज़ मिटाए गए हैं.

पूरे कलेक्शन को मिटाना

किसी कलेक्शन के सभी दस्तावेज़ मिटाने के लिए, इनपुट स्टेज में delete() जोड़ा जा सकता है. जैसे:

Node.js

const results = await db.pipeline()
  .collection("/users")
  .delete()
  .execute();

यह पक्का करें कि आखिरी delete() से पहले मौजूद where(...) चरण, दस्तावेज़ों को सिर्फ़ उन दस्तावेज़ों तक सीमित करे जिन्हें अपडेट करना है. यह पुष्टि करने के लिए कि सिर्फ़ ज़रूरी दस्तावेज़ हटाए गए हैं, यह सबसे अच्छा तरीका है कि क्वेरी को आखिरी delete() चरण के बिना चलाया जाए.

आखिरी चरण

delete() चरण, पाइपलाइन के आखिर में होना चाहिए. इसके बाद कोई और चरण नहीं जोड़ा जा सकता.

सभी हटाएं

डिफ़ॉल्ट रूप से, delete() चरण, पिछले चरण में रेफ़रंस वाले सभी दस्तावेज़ हटा देगा. अगर आपको वर्कलोड का साइज़ सीमित करना है या आपको पता है कि फ़िल्टर की शर्तें सिर्फ़ एक दस्तावेज़ से मैच करती हैं, तो कुल काम को सीमित करने के लिए, आखिरी delete() से पहले limit(1) जोड़ा जा सकता है.

कलेक्शन में बदलाव करना

आखिरी delete() चरण, __name__ में रेफ़रंस वाले किसी भी दस्तावेज़ पर बदलाव लागू करेगा. हालांकि, इसके लिए ज़रूरी सभी पुष्टि की जानकारी उपलब्ध होनी चाहिए. इसमें, एक ही अनुरोध के तहत, अलग-अलग कलेक्शन या कलेक्शन ग्रुप से दस्तावेज़ मिटाना शामिल है.

__name__ ज़रूरी है

delete() चरण के लिए, ज़रूरी है कि पिछला चरण, __name__ फ़ील्ड उपलब्ध कराए. इसमें, हटाने के लिए दस्तावेज़ का रेफ़रंस होना चाहिए. ऐसा न करने पर, रनटाइम में गड़बड़ी होगी. साथ ही, लेन-देन के बाहर क्वेरी चलाने पर, हो सकता है कि कुछ दस्तावेज़ ही मिटें.

ज़्यादातर इनपुट स्टेज में, जैसे कि collection(...), collection_group(...), database(...) और documents(...), डिफ़ॉल्ट रूप से __name__ फ़ील्ड शामिल होता है. इसलिए, यह सिर्फ़ तब काम का है, जब प्रोजेक्शन (जैसे, select(...)) का इस्तेमाल किया जा रहा हो या दस्तावेज़ों पर बदलाव किया जा रहा हो (जैसे, aggregate(...)).

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

{documents_modified: 3L}

सीमाएं

  • डीएमएल स्टेज, Cloud Firestore Security Rules के साथ काम नहीं करती हैं. डीएमएल ऑपरेशन करने की कोशिशों को Cloud Firestore Security Rules के ज़रिए अस्वीकार कर दिया जाता है.

  • इस सुविधा की झलक के दौरान, लेन-देन में डीएमएल स्टेज नहीं चलाई जा सकतीं. संगति के व्यवहार के बारे में ज़्यादा जानने के लिए, संगति देखें.

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