Google डेटा प्रोटोकॉल में बैच प्रोसेसिंग

बैच प्रोसेसिंग की मदद से, हर कार्रवाई को अलग-अलग सबमिट करने के बजाय, एक ही अनुरोध में कई कार्रवाइयां की जा सकती हैं.

ध्यान दें: बैच ऑपरेशन करने के लिए, आपको अपनी Google Data API क्लाइंट लाइब्रेरी का नया वर्शन इस्तेमाल करना होगा. JavaScript क्लाइंट लाइब्रेरी में बैच ऑपरेशन काम नहीं करते.

दर्शक

यह दस्तावेज़ उन प्रोग्राम के लिए है जो बैच प्रोसेसिंग का इस्तेमाल करके, एक अनुरोध में कई कार्रवाइयां सबमिट करना चाहते हैं.

यह दस्तावेज़ मान लेता है कि आप GData Java क्लाइंट लाइब्रेरी का इस्तेमाल करने के बारे में जानते हैं. इस दस्तावेज़ में दिए गए उदाहरण, Java की क्लाइंट लाइब्रेरी का इस्तेमाल करके, बैच ऑपरेशन चलाने का तरीका बताते हैं.

इस दस्तावेज़ में दिए गए उदाहरण, Google के बेस डेटा एपीआई के हिसाब से हैं. हालांकि, अन्य सेवाएं भी बैच क्षमताएं दे सकती हैं.

ध्यान दें: अन्य क्लाइंट लाइब्रेरी के लिए, प्रोटोकॉल और सामान्य प्रक्रियाएं एक जैसी रहेंगी, लेकिन बैच अनुरोधों को करने के खास तरीके अलग-अलग हो सकते हैं. कृपया क्लाइंट लाइब्रेरी से जुड़े खास दस्तावेज़ देखें.

सुविधा के बारे में जानकारी

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

उदाहरण के लिए, इस फ़ीड में चार कार्रवाइयां शामिल हैं:

<feed>
  <entry>
    <batch:operation type="insert"/>
    ... what to insert ...
  </entry> 
  <entry>
    <batch:operation type="update"/>
    ... what to update ...
  </entry>
  <entry>
    <batch:operation type="delete"/>
    ... what to delete ...
  </entry>
  <entry>
    <batch:operation type="query"/>
    ... what to query ...
  </entry>
</feed>

यह सेवा अनुरोध किए गए ज़्यादा से ज़्यादा बदलाव करेगी. साथ ही, स्थिति की जानकारी भी देगी जिसे आप हर कार्रवाई की सफलता या असफलता का आकलन करने के लिए इस्तेमाल कर सकते हैं.

बैच में शामिल कुछ कार्रवाइयां पूरी न होने पर भी, सेवा हर बैच पर कार्रवाई करने की कोशिश करती है.

बैच में अनुरोध सबमिट करना

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

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

"बैच" लिंक संबंध, rel="http://schemas.google.com/g/2005#batch" वाला एक <link> एलिमेंट है. लिंक संबंध की href विशेषता उस यूआरएल को तय करती है जहां बैच कार्रवाइयों के लिए फ़ीड दस्तावेज़ पोस्ट किए जा सकते हैं.

उदाहरण के लिए, अगर आप GET http://www.google.com/base/feeds/items (Google Base की "आइटम" फ़ीड ) सामान्य फ़ीड{/1} को लागू करते हैं, तो आपको यह रिस्पॉन्स मिल सकता है:

<feed xmlns=...
  <id>http://www.google.com/base/feeds/items</id>
  <link rel="http://schemas.google.com/g/2005#feed"
    type="application/atom+xml"
    href="http://www.google.com/base/feeds/items"/>
  <link rel="http://schemas.google.com/g/2005#post"
    type="application/atom+xml"
    href="http://www.google.com/base/feeds/items"/>
  <link rel="http://schemas.google.com/g/2005#batch"
    type="application/atom+xml"
    href="http://www.google.com/base/feeds/items/batch"/>
  ...
</feed>

इस उदाहरण में, बैच यूआरएल http://www.google.com/base/feeds/items/batch है.

बैच ऑपरेशन फ़ीड लिखना

ऑपरेशन फ़ीड में शामिल करने, अपडेट करने, मिटाने या क्वेरी करने के लिए एंट्री की सूची होती है. हर कार्रवाई, <batch:operation type="insert|update|delete|query"/> एलिमेंट से तय होती है.

यह एलिमेंट, <feed> एलिमेंट का डायरेक्ट चाइल्ड, फ़ीड में मौजूद किसी भी एंट्री का डायरेक्ट चाइल्ड या दोनों हो सकता है. जब किसी एंट्री में शामिल किया जाता है, तो उस खास एंट्री के लिए एक्ज़ीक्यूट करने का तरीका बताया जाता है. अगर फ़ीड में शामिल है, तो यह एलिमेंट ऐसे किसी भी एंट्री को लागू करने के लिए डिफ़ॉल्ट कार्रवाई के बारे में बताता है जिसमें <batch:operation/> एलिमेंट नहीं होता.

जब न तो एंट्री और न ही फ़ीड से कोई कार्रवाई तय होती है, तब डिफ़ॉल्ट कार्रवाई insert होती है.

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

परफ़ॉर्मेंस को बेहतर बनाने के लिए, कार्रवाइयों को उनके ऑर्डर के क्रम में प्रोसेस नहीं किया जा सकता. हालांकि, आखिरी नतीजा हमेशा एक जैसा होता है. जैसे, एंट्री को प्रोसेस किया गया हो.

सर्वर को भेजे जाने वाले एक्सएमएल फ़ाइल की संख्या, 1 एमबी (10,48,576 बाइट) से ज़्यादा नहीं होनी चाहिए. आम तौर पर, कुल बाइट साइज़ 1 एमबी से ज़्यादा नहीं होने पर, अनुरोध करने की संख्या को तय नहीं किया जा सकता. हालांकि, कुछ सेवाओं पर अतिरिक्त पाबंदियां हो सकती हैं.

बैच कार्रवाइयों का इस्तेमाल करने के लिए, आपको <feed> एलिमेंट में विशेषता के रूप में बैच नेमस्पेस एलान जोड़ना होगा:

<feed 
  xmlns="http://www.w3.org/2005/Atom"
  xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
  ...
  xmlns:batch="http://schemas.google.com/gdata/batch">

कार्रवाइयां डालें

इंसर्ट करने की कार्रवाई को इस तरह से दिखाया जाता है:

<batch:operation type="insert">

सम्मिलित करें कार्रवाई, प्रविष्टि POST करने के बराबर है. जब कार्रवाई सफल हो जाती है, तो अपडेट किए गए दस्तावेज़ <id> एलिमेंट और <batch:status code="201"/> एलिमेंट के साथ, एंट्री का पूरा कॉन्टेंट दिखाया जाता है.

अनुरोध शामिल करने का एक उदाहरण यहां दिया गया है:

<entry>
  <title type="text">...</title>
  <content type="html">...</content>
  <batch:id>itemA</batch:id>
  <batch:operation type="insert"/>
  <g:item_type>recipes</g:item_type>
  ... 
</entry>

यहां एक सफल अनुरोध के जवाब का उदाहरण दिया गया है:

<entry>
  <batch:status code="201"/>
  <batch:id>itemA</batch:id>
  <batch:operation type="insert"/>
  <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
  <link rel="self" type="application/atom+xml"
    href="http://www.google.com/base/feeds/items/17437536661927313949"/>
  <title type="text">...</title>
  <content type="html">...</content>
  <g:item_type>recipes</g:item_type>
  ... 
</entry>

कार्रवाइयों को अपडेट करें

<batch:operation type="update">

अपडेट कार्रवाई, एंट्री के <id> एलिमेंट में बताए गए यूआरएल पर PUT लागू करने के बराबर होती है. कार्रवाई कामयाब होने पर, एंट्री का पूरा कॉन्टेंट <batch:status code="200"/> एलिमेंट के साथ दिखाया जाता है.

ध्यान दें: कुछ फ़ीड के साथ, आपको एंट्री के rel="edit" लिंक के साथ-साथ बैच अपडेट के अनुरोध भी बताने होंगे. इसमें, ऐसे फ़ीड शामिल हैं जो डेटा के एक साथ कई काम करने के लेवल वाले डेटा के साथ Google Data प्रोटोकॉल का इस्तेमाल करते हैं. साथ ही, इसमें वे फ़ीड भी शामिल हैं जिनके यूआरएल नहीं हैं.

यहां अपडेट के अनुरोध का एक उदाहरण दिया गया है:

<entry>
  <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
  <batch:operation type="update"/>
  ...
</entry>

सफल जवाब का एक उदाहरण:

<entry>
  <batch:status code="200"/>
  <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
  <batch:operation type="update"/>
  ... 
</entry>

ध्यान दें: कुछ फ़ीड में strong Eटैग का इस्तेमाल किया जाता है, ताकि आप अनजाने में किसी दूसरे व्यक्ति के बदलावों में बदलाव न कर पाएं. इनमें से किसी एक फ़ीड में एंट्री के लिए, बैच को अपडेट करने का अनुरोध करते समय, आपको एंट्री के gd:etag एट्रिब्यूट में ETag वैल्यू देनी होगी. उदाहरण के लिए, <entry gd:etag="'F08NQAxFdip7IWA6WhVR'">...<batch:operation type="update"/>...

पार्शियल अपडेट कार्रवाइयां

आंशिक अपडेट की सुविधा वाले फ़ीड के लिए, आप उनका इस्तेमाल बैच अनुरोधों में भी कर सकते हैं. कुछ हद तक अपडेट की कार्रवाई, एंट्री के <id> एलिमेंट में बताए गए यूआरएल पर PATCH लागू करने जैसी ही होती है. कार्रवाई कामयाब होने पर, एंट्री का पूरा कॉन्टेंट <batch:status code="200"/> एलिमेंट के साथ दिखाया जाता है.

ध्यान दें: कुछ फ़ीड के साथ, आपको एंट्री के rel="edit" लिंक के साथ-साथ बैच अपडेट के अनुरोध भी बताने होंगे. इसमें, ऐसे फ़ीड शामिल हैं जो डेटा के एक साथ कई काम करने के लेवल वाले डेटा के साथ Google Data प्रोटोकॉल का इस्तेमाल करते हैं. साथ ही, इसमें वे फ़ीड भी शामिल हैं जिनके यूआरएल नहीं हैं.

<batch:operation type="patch"/>

यहां कुछ हद तक अपडेट के अनुरोध का एक उदाहरण दिया गया है:

<entry gd:fields="content" gd:etag="FE8LQQJJeSp7IWA6WhVa">
  <id>http://www.google.com/calendar/feeds/jo@gmail.com/private/full/entryID</id>
  <batch:operation type="patch"/>
  <title>New title</title>
</entry>

यहां एक सफल जवाब का उदाहरण दिया गया है:

<entry gd:etag="FE8LQQJJeSp7IWA6WhVa">
  <batch:status code="200"/>
  <id>http://www.google.com/calendar/feeds/jo@gmail.com/private/full/entryID</id>
  <batch:operation type="patch"/>
  <title>New title</title>
  <content></content>
  ...rest of the entry...
</entry>

कार्रवाइयां मिटाना

<batch:operation type="delete">

मिटाया गया कार्रवाई यूआरएल के DELETE इस्तेमाल करने के बराबर है, जिसका ज़िक्र एंट्री के <id> एलिमेंट ने किया है. मिटाने की कार्रवाई करने के लिए, आपको एंट्री मिटाने के लिए सिर्फ़ <id> एलिमेंट को भेजना होगा. अगर आप ऐसे एलिमेंट में जानकारी देते हैं जो batch: नेमस्पेस में नहीं हैं, तो उन्हें अनदेखा कर दिया जाएगा. जब कार्रवाई सफल होती है, तब उसी आईडी वाली एंट्री को <batch:status code="200"/> एलिमेंट के साथ दिखाया जाएगा.

ध्यान दें: कुछ फ़ीड के साथ, आपको एंट्री के rel="edit" लिंक के साथ-साथ, बैच को मिटाने के अनुरोध के बारे में भी बताना होगा. इसमें, ऐसे फ़ीड शामिल हैं जो डेटा के एक साथ कई काम करने के लेवल वाले डेटा के साथ Google Data प्रोटोकॉल का इस्तेमाल करते हैं. साथ ही, इसमें वे फ़ीड भी शामिल हैं जिनके यूआरएल नहीं हैं.

डेटा मिटाने के अनुरोध का एक उदाहरण:

<entry>
  <batch:operation type="delete"/>
  <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
</entry>

सफल जवाब का एक उदाहरण:

<entry>
  <batch:operation type="delete"/>
  <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
  <batch:status code="200" reason="Success"/>
</entry>

ध्यान दें: कुछ फ़ीड में strong Eटैग का इस्तेमाल किया जाता है, ताकि आप अनजाने में किसी दूसरे व्यक्ति के बदलावों में बदलाव न कर पाएं. इनमें से किसी एक फ़ीड में एंट्री के लिए बैच मिटाने का अनुरोध करते समय, आपको एंट्री के gd:etag एट्रिब्यूट में ETag वैल्यू देनी होगी. उदाहरण के लिए, <entry gd:etag="'F08NQAxFdip7IWA6WhVR'">...<batch:operation type="delete"/>...

क्वेरी से जुड़ी कार्रवाइयां

<batch:operation type="query">

क्वेरी कार्रवाई, एंट्री के <id> एलिमेंट से जुड़े यूआरएल पर GET लागू करने के बराबर है. कार्रवाई सफल होने पर, एंट्री का पूरा कॉन्टेंट दिखाया जाता है.

ध्यान दें: कुछ फ़ीड के साथ, आपको एंट्री के rel="self" लिंक के साथ-साथ बैच क्वेरी के अनुरोध भी बताने होंगे. इसमें वे फ़ीड शामिल हैं जिनके आईडी नहीं हैं, जो यूआरएल हैं.

क्वेरी अनुरोध का एक उदाहरण:

<entry>
  <id>http://www.google.com/base/feeds/items/1743753666192313949</id>
  <batch:operation type="query"/>
</entry>

सफल जवाब का एक उदाहरण:

<entry>
  <id>http://www.google.com/base/feeds/items/1743753666192313949</id>
  <batch:operation type="query"/>
  <batch:status code="200" reason="Success"/>
   ...
</entry>

ट्रैकिंग कार्रवाइयां

ज़रूरी नहीं है कि GData एंट्री के नतीजे उसी क्रम में मिलें जिस क्रम में अनुरोध किए गए थे. किसी आइडेंटिफ़ायर को लाइफ़टाइम का इस्तेमाल करके, ट्रैक किया जा सकता है.

अपडेट, मिटाने, और क्वेरी की कार्रवाइयों के लिए, एंट्री का आईडी इस्तेमाल करके, कार्रवाई को ट्रैक किया जा सकता है.

कार्रवाइयां डालने के लिए, अब तक कोई आईडी मौजूद नहीं है. इसलिए, कोई कार्रवाई आइडेंटिफ़ायर पास किया जा सकता है. इस आइडेंटिफ़ायर का इस्तेमाल करके, नतीजों की एंट्री को अनुरोध की एंट्री से जोड़ा जा सकता है. ऑपरेशन आइडेंटिफ़ायर को <batch:id> एलिमेंट में पास किया जाता है.

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

हर कार्रवाई के आइडेंटिफ़ायर का इस्तेमाल करके, सिर्फ़ उन कार्रवाइयों के लिए फिर से कोशिश की जा सकती है जो प्रोसेस नहीं हो सकीं. आपको फिर से कोशिश करनी होगी.

<batch:id> का कॉन्टेंट, एक स्ट्रिंग वैल्यू है जो क्लाइंट ने तय की है. यह वैल्यू, जवाब के तौर पर एक ही एंट्री में दिखेगी.आपके पास ऐसी कोई भी वैल्यू तय करने का विकल्प होता है जिसकी मदद से क्लाइंट, मूल अनुरोध में दिए गए जवाब का जवाब दे सके. संबंधित एलिमेंट में यह एलिमेंट, जैसा है वैसा ही इको होगा, भले ही ऑपरेशन फ़ेल हो गया हो. GData कभी भी इस बैच आईडी के कॉन्टेंट को सेव नहीं करता है और न ही उसे समझता है.

नीचे दिए गए उदाहरण में, बैच ऑपरेशन फ़ीड को दिखाया गया है. ध्यान दें कि <batch:id> एलिमेंट इस कार्रवाई को itemB के तौर पर लेबल करता है.

<entry>
  <title type="text">...</title>
  <content type="html">...</content>
  <batch:id>itemB</batch:id>
  <batch:operation type="insert"/>
  <g:item_type>recipes</g:item_type>
</entry>

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

<entry>
  <id>http://www.google.com/base/feeds/items/2173859253842813008</id>
  <published>2006-07-11T14:51:43.560Z</published>
  <updated>2006-07-11T14:51: 43.560Z</updated>
  <title type="text">...</title>
  <content type="html">...</content>
  <link rel="self" 
    type="application/atom+xml" 
    href="http://www.google.com/base/feeds/items/2173859253842813008"/>
  <link rel="edit" 
    type="application/atom+xml" 
    href="http://www.google.com/base/feeds/items/2173859253842813008"/>
  <g:item_type>recipes</g:item_type>
  <batch:operation type="insert"/>
  <batch:id>itemB</batch:id>
  <batch:status code="201" reason="Created"/>
</entry>

हैंडलिंग स्टेटस कोड

स्टेटस कोड इस एलिमेंट के ज़रिए बताए जाते हैं:

<batch:status code="200|201|404|500|..." reason="reason" [content-type="type"]/>

जवाब फ़ीड की हर एंट्री में एक <batch:status> एलिमेंट होता है. इस एलिमेंट में बताया गया है कि कार्रवाई करते समय क्या हुआ. यह ऐसे एचटीटीपी रिस्पॉन्स की नकल करता है जिसे ऑपरेशन बैच बैच के हिस्से के बजाय अलग-अलग भेजा जाता.

जवाब में हर एंट्री के <batch:status> एलिमेंट को देखकर, यह पता लगाया जा सकता है कि उससे जुड़ी कार्रवाई सही तरीके से प्रोसेस हुई या नहीं. code="n" एट्रिब्यूट में एक GData स्टेटस कोड शामिल होता है.

स्थिति की जानकारी

<batch:status> एलिमेंट के reason="reason" एट्रिब्यूट में, कार्रवाई की स्थिति के बारे में ज़्यादा जानकारी दी गई है.

वीडियो का टाइप

<batch:status> एलिमेंट के content-type="type" एट्रिब्यूट में, MIME टाइप का डेटा मौजूद होता है. यह डेटा, <batch:status> एलिमेंट में शामिल होता है. यह स्थिति, एचटीटीपी स्टेटस रिस्पॉन्स के Content-Type हेडर से मेल खाती है. इस एट्रिब्यूट को सबमिट करना ज़रूरी नहीं है.

कॉन्टेंट टाइप सेट होने पर, <batch:status> एलिमेंट में मुख्य जानकारी होती है कि एंट्री को प्रोसेस करते समय क्या गड़बड़ी हुई.

प्रोसेस में रुकावट का पता लगाना

किसी रुकावट वाली कार्रवाई के जवाब में यह एलिमेंट शामिल होता है:

<batch:interrupted reason="reason" success="N" failures="N" parsed="N">

इस एलिमेंट का मतलब है कि बैच की प्रोसेसिंग में रुकावट आई और रुकावट की वजह को वापस पाने की सभी कोशिशों में नाकाम रहा. हो सकता है कि कुछ एंट्री को पहले ही प्रोसेस कर दिया गया हो. ऐसी सभी एंट्री जिन्हें इस मामले में शामिल होने से पहले रिपोर्ट नहीं किया गया था.

यह एलिमेंट बहुत असामान्य है और आम तौर पर यह बताता है कि अनुरोध के मुख्य हिस्से में भेजा गया फ़ीड सही एक्सएमएल फ़ॉर्मैट में नहीं था.

<batch:status> एलिमेंट की तरह ही, reason एट्रिब्यूट में स्टेटस का छोटा कोड देखा जा सकता है. नतीजे के तौर पर, जवाब के ज़्यादा नतीजे भी दिख सकते हैं.

बैच ऑपरेशन और स्टेटस फ़ीड के उदाहरण

यह एक बैच कार्रवाई फ़ीड है जिसे सर्वर को भेजा जा सकता है. यह फ़ीड, दो एंट्री मिटाने और दो नई एंट्री जोड़ने का अनुरोध करता है. ध्यान दें कि <feed> एलिमेंट में नेमस्पेस के लिए नेमस्पेस के साथ फ़र्क़ होना चाहिए, जैसा कि नीचे दिए गए उदाहरण में हाइलाइट किया गया है.

POST : http://www.google.com/base/feeds/items/batch
<?xml version="1.0" encoding="UTF-8"?>
<feed
  xmlns="http://www.w3.org/2005/Atom"
  xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
  xmlns:g="http://base.google.com/ns/1.0"
  xmlns:batch="http://schemas.google.com/gdata/batch">
  <title type="text">My Batch Feed</title>
  <entry>
    <id>http://www.google.com/base/feeds/items/13308004346459454600</id>
    <batch:operation type="delete"/>
  </entry>
  <entry>
    <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
    <batch:operation type="delete"/>
  </entry>
  <entry>
    <title type="text">...</title>
    <content type="html">...</content>
    <batch:id>itemA</batch:id>
    <batch:operation type="insert"/>
    <g:item_type>recipes</g:item_type>
  </entry>
  <entry>
    <title type="text">...</title>
    <content type="html">...</content>
    <batch:id>itemB</batch:id>
    <batch:operation type="insert"/>
    <g:item_type>recipes</g:item_type>
  </entry>
</feed>

मान लें कि दो प्रविष्टियों ने काम किया, लेकिन दो में से एक को हटाया नहीं जा सका. इस स्थिति में, बैच स्टेटस फ़ीड कुछ ऐसा दिख सकता है. ध्यान दें कि बैच ऑपरेशन फ़ीड की तुलना में, एंट्री का क्रम बदल दिया गया है.

<?xml version="1.0" encoding="UTF-8"?>
<feed
  xmlns="http://www.w3.org/2005/Atom"
  xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
  xmlns:g="http://base.google.com/ns/1.0"
  xmlns:batch="http://schemas.google.com/gdata/batch">
  <id>http://www.google.com/base/feeds/items</id>
  <updated>2006-07-11T14:51:42.894Z</updated>
  <title type="text">My Batch</title>
  <link rel="http://schemas.google.com/g/2005#feed"
    type="application/atom+xml"
    href="http://www.google.com/base/feeds/items"/>
  <link rel="http://schemas.google.com/g/2005#post"
    type="application/atom+xml"
    href="http://www.google.com/base/feeds/items"/>
  <link rel=" http://schemas.google.com/g/2005#batch"
    type="application/atom+xml"
    href="http://www.google.com/base/feeds/items/batch"/>
  <entry>
    <id>http://www.google.com/base/feeds/items/2173859253842813008</id>
    <published>2006-07-11T14:51:43.560Z</published>
    <updated>2006-07-11T14:51: 43.560Z</updated>
    <title type="text">...</title>
    <content type="html">...</content>
    <link rel="self"
      type="application/atom+xml"
      href="http://www.google.com/base/feeds/items/2173859253842813008"/>
    <link rel="edit"
      type="application/atom+xml"
      href="http://www.google.com/base/feeds/items/2173859253842813008"/>
    <g:item_type>recipes</g:item_type>
    <batch:operation type="insert"/>
    <batch:id>itemB</batch:id>
    <batch:status code="201" reason="Created"/>
  </entry>
  <entry>
    <id>http://www.google.com/base/feeds/items/11974645606383737963</id>
    <published>2006-07-11T14:51:43.247Z</published>
    <updated>2006-07-11T14:51: 43.247Z</updated>
    <title type="text">...</title>
    <content type="html">...</content>
    <link rel="self"
      type="application/atom+xml"
      href="http://www.google.com/base/feeds/items/11974645606383737963"/>
    <link rel="edit"
      type="application/atom+xml"
      href="http://www.google.com/base/feeds/items/11974645606383737963"/>
    <g:item_type>recipes</g:item_type>
    <batch:operation type="insert"/>
    <batch:id>itemA</batch:id>
    <batch:status code="201" reason="Created"/>
  </entry>
  <entry>
    <id>http://www.google.com/base/feeds/items/13308004346459454600</id>
    <updated>2006-07-11T14:51:42.894Z</updated>
    <title type="text">Error</title>
    <content type="text">Bad request</content>
    <batch:status code="404"
      reason="Bad request"
      content-type="application/xml">
      <errors>
        <error type="request" reason="Cannot find item"/>
      </errors>
    </batch:status>
  </entry>
  <entry>
    <id>http://www.google.com/base/feeds/items/17437536661927313949</id>
    <updated>2006-07-11T14:51:43.246Z</updated>
    <content type="text">Deleted</content>
    <batch:operation type="delete"/>
    <batch:status code="200" reason="Success"/>
  </entry>
</feed>

GData Java क्लाइंट लाइब्रेरी की बैच सुविधा का इस्तेमाल करना

यह सेक्शन, अनुरोधों के ग्रुप को सबमिट करने, अपडेट करने, और/या मिटाने के लिए, GData Java क्लाइंट लाइब्रेरी के बैच फ़ंक्शन को इस्तेमाल करने का तरीका बताता है.

इस सेक्शन में दिए गए उदाहरण, Google Base API का इस्तेमाल करते हैं.

सबसे पहले, वे कक्षाएं इंपोर्ट करें जिनकी आपको ज़रूरत है, जैसे कि GData और Google Base की मानक क्लास के साथ

import com.google.gdata.data.batch.*;
import com.google.api.gbase.client.*;

बैच में अनुरोध सबमिट करने के लिए, आपको किसी फ़ीड से बैच यूआरएल लेना होगा. feed को GoogleBaseFeed ऑब्जेक्ट के तौर पर फ़ीड में जोड़े जाने की जानकारी देने के लिए, यहां दिए गए कोड स्निपेट में उसे करने का तरीका बताया गया है.

Link batchLink = feed.getLink(Link.Rel.FEED_BATCH, Link.Type.ATOM);
if (batchLink != null) {
  URL batchUrl = new URL(batchLink.getHref());
  ... // batch handling
} else {
  // batching is not supported for this feed
}

नीचे दिया गया कोड स्निपेट एक फ़ीड तैयार करता है जो एक कार्रवाई में दो एंट्री डालेगा:

GoogleBaseEntry entry1 = new GoogleBaseEntry();
...   // initialize entry 1 content
BatchUtils.setBatchId(entry1, "A"); // A is the local batch ID for this entry
feed.addEntry(entry1);
GoogleBaseEntry entry2 = new GoogleBaseEntry();
... // initialize entry 2 content
BatchUtils.setBatchId(entry2, "B"); // B is the local batch ID for this entry
feed.addEntry(entry2);

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

बैच फ़ीड भेजने और नतीजे पाने के लिए, Service.batch वाले तरीके को कॉल करें.

Service.insert की तरह, Service.batch, डाली गई एंट्री को नए <atom:id> वैल्यू के साथ दिखाता है. दिखाई गई एंट्री GoogleBaseFeed ऑब्जेक्ट में होती हैं.

अगर अन्य दोनों एंट्री डालने के साथ-साथ आप तीसरी एंट्री (जिसे आपने पहले ही फ़ेच और entry3 में स्टोर कर लिया है) को मिटाना चाहते हैं, तो आप इस कोड का इस्तेमाल कर सकते हैं:

GoogleBaseEntry toDelete = new GoogleBaseEntry();


toDelete.setId(entry3.getId());
BatchUtils.setBatchOperationType(toDelete, BatchOperationType.DELETE);

feed.addEntry(toDelete);


GoogleBaseFeed result = service.batch(batchUrl, feed);

यहां service, com.google.gdata.client.Service का एक उदाहरण है.

अगर आपको कोई एंट्री अपडेट करनी है, तो OperationType.UPDATE के बारे में बताएं. साथ ही, एंट्री को ज़्यादातर खाली छोड़ने के बजाय, उसमें मनचाहे बदलाव करें.

इन उदाहरणों में, Google Base डेटा एपीआई का इस्तेमाल किया गया है. अगर आप service.batch का इस्तेमाल किसी दूसरी तरह की GData सेवा के साथ कर रहे हैं, तो GoogleBaseFeed, GoogleBaseEntry, और GoogleBaseService क्लास को सही फ़ीड, एंट्री, और सेवा क्लास से बदलें.

यह ज़रूरी नहीं है कि बैच कार्रवाई के नतीजे उसी क्रम में दिखें जिस क्रम में उनका अनुरोध किया गया था. ऊपर दिए गए उदाहरण में, नतीजे के फ़ीड में entry2 के बाद entry1 हो सकता है. आपको यह कभी नहीं मानना चाहिए कि एंट्री किसी खास क्रम में दी जाती है.

आपकी बैच ऑपरेशन फ़ीड को हर इंसर्ट करने के लिए एक खास बैच आईडी असाइन करना चाहिए, जैसा कि ट्रैकिंग कार्रवाइयों में बताया गया है. ऊपर दिए गए उदाहरणों में, बैच आईडी A और B हैं. इसलिए, अनुरोध की गई कार्रवाइयों की स्थिति जानने के लिए, आपको लौटाए गए बैच फ़ीड में एंट्री को दोहराना होगा और उनके बैच आईडी या एंट्री आईडी की तुलना इस तरह करनी होगी:

for (GoogleBaseEntry entry : result.getEntries()) {
  String batchId = BatchUtils.getBatchId(entry);      
  if (BatchUtils.isSuccess(entry)) {     
    if ("A".equals(batchId)) {       
      entry1 = entry;     } 
    else if ("B".equals(batchId)) {       
      entry2 = entry;     } 
    else if (BatchUtils.getBatchOperationType(entry) 
      == BatchOperationType.DELETE) {       
      System.out.println("Entry " + entry.getId() +
      " has been deleted successfully.");     
    }      
  } else {     
    BatchStatus status = BatchUtils.getBatchStatus(entry);     
    System.err.println(batchId + " failed (" +                
      status.getReason() + ") " +  status.getContent());      
    }    
  }

फ़ीड में दिखने वाली हर एंट्री में, उससे जुड़ा BatchStatus ऑब्जेक्ट होगा. BatchStatus ऑब्जेक्ट में एक एचटीटीपी रिटर्न कोड और एक जवाब है जो बताता है कि एंट्री प्रोसेस करते समय क्या गड़बड़ी हुई थी. आपको हर एंट्री के एचटीटीपी रिटर्न कोड की जांच करके यह बताना होगा कि कार्रवाई सही हुई या नहीं.

ऊपर दिए गए उदाहरण में, सुविधा के तरीके की जांच की गई है. BatchUtils.isSuccess इस मामले में, यह BatchUtils.getBatchStatus(entry) < 300 के बराबर होता है:

स्थिति कोड और जवाबों के बारे में स्थिति कोड मैनेज करना में ज़्यादा समझाया गया है.

वापस सबसे ऊपर जाएं