RethinkDB 2.3 - update

ReQL कमांड: अपडेट




rethinkdb

ReQL कमांड: अपडेट

कमांड सिंटैक्स

table.update(object | function) → object
selection.update(object | function) → object
singleSelection.update(object | function) → object

विवरण

एक तालिका में JSON दस्तावेज़ अपडेट करें। एक JSON दस्तावेज़, एक ReQL अभिव्यक्ति या दो के संयोजन को स्वीकार करता है।

आप optArg का उपयोग करके निम्नलिखित विकल्प पास कर सकते हैं:

  • durability : संभव मूल्य hard और soft । यह विकल्प तालिका या क्वेरी की स्थायित्व सेटिंग ( run में सेट) को ओवरराइड करेगा। सॉफ्ट ड्यूरेबिलिटी मोड में RethinkDB इसे प्राप्त करने के तुरंत बाद लिखने को स्वीकार कर लेगा, लेकिन इससे पहले कि लिखने के लिए डिस्क को प्रतिबद्ध किया गया है।
  • return_changes :
    • true : पुराने changes शामिल करते changes एक changes सरणी old_val / किए गए परिवर्तनों का वर्णन करने वाली old_val / new_val वस्तुएं, केवल वास्तव में अपडेट किए गए दस्तावेजों सहित।
    • false : changes सरणी (डिफ़ॉल्ट) वापस न करें।
    • "always" : true रूप में व्यवहार करें, लेकिन सभी दस्तावेज़ों को शामिल करें, जिन्हें कमांड ने अपडेट करने की कोशिश की है कि अपडेट सफल था या नहीं। (यह true पूर्व 2.0 का व्यवहार था।)
  • non_atomic : यदि true सेट किया गया true , तो अपडेट को निष्पादित करता है और गैर-परमाणु फैशन में प्रतिकृतियों को परिणाम वितरित करता है। इस ध्वज को गैर-नियतात्मक अद्यतन करने की आवश्यकता होती है, जैसे कि किसी अन्य तालिका से डेटा पढ़ने की आवश्यकता होती है।

अद्यतन एक वस्तु देता है जिसमें निम्नलिखित गुण होते हैं:

  • replaced : अद्यतन किए गए दस्तावेज़ों की संख्या।
  • unchanged : नए मूल्य को छोड़कर संशोधित किए गए दस्तावेज़ों की संख्या पुराने मूल्य के समान थी।
  • skipped : दस्तावेज़ की संख्या मौजूद नहीं थी क्योंकि दस्तावेज़ मौजूद नहीं था।
  • errors : अद्यतन करते समय त्रुटियों की संख्या का सामना करना पड़ा।
  • first_error : यदि त्रुटियों का सामना किया गया था, तो पहली त्रुटि का पाठ शामिल है।
  • deleted और inserted : 0 एक अपडेट ऑपरेशन के लिए।
  • changes : अगर return_changes को true सेट किया जाता true , तो यह ऑब्जेक्ट का एक सरणी होगा, जो update ऑपरेशन से प्रभावित प्रत्येक ऑब्जेक्ट के लिए एक होगा। प्रत्येक वस्तु की दो कुंजियाँ { new_val : <new value> , old_val : <old value> } : { new_val : <new value> , old_val : <old value> }

RethinkDB लेखन कार्रवाई केवल अपवादों को फेंक देगी यदि त्रुटियां किसी भी लिखने से पहले होती हैं। अन्य त्रुटियों को first_error में सूचीबद्ध किया first_error , और errors को एक शून्य-शून्य पर सेट किया जाएगा। इस शब्द के साथ त्रुटियों को ठीक से संभालने के लिए, कोड को अपवादों को संभालना होगा और errors वापसी मूल्य की जांच करनी चाहिए!

उदाहरण: published लिए 1 id के साथ पोस्ट की स्थिति को अपडेट करें।

r.table("posts").get(1).update(r.hashMap("status", "published")).run(conn);

उदाहरण: published किए गए सभी पदों की स्थिति अपडेट करें।

r.table("posts").update(r.hashMap("status", "published")).run(conn);

उदाहरण: विलियम द्वारा लिखित सभी पदों की स्थिति का अद्यतन करें।

r.table("posts").filter(
    r.hashMap("author", "William")).update(r.hashMap("status", "published")
).run(conn);

ध्यान दें कि filter , getAll और इसी तरह के ऑपरेशन update साथ परमाणु फैशन में निष्पादित नहीं होते हैं । अधिक विवरण के लिए संगतता गारंटी पढ़ें। इसके अलावा, एक update खंड में branch का उपयोग कर समाधान के लिए नीचे दिए गए सशर्त अपडेट के लिए उदाहरण देखें।

उदाहरण: 1 id के साथ पोस्ट का फ़ील्ड view बढ़ाना। यदि फ़ील्ड views मौजूद नहीं है, तो यह क्वेरी एक त्रुटि फेंक देगी।

r.table("posts").get(1).update(
    post -> r.hashMap("views", post.g("views").add(1))
).run(conn);

उदाहरण: 1 id के साथ पोस्ट का फ़ील्ड view बढ़ाना। यदि फ़ील्ड views मौजूद नहीं है, तो इसे 0 सेट किया जाएगा।

r.table("posts").get(1).update(
    post -> r.hashMap("views", post.g("views").add(1).default_(0))
).run(conn);

उदाहरण: एक सशर्त अद्यतन करें।
यदि पोस्ट में 100 से अधिक दृश्य हैं, तो पोस्ट के type को hot सेट करें, अन्यथा इसे normal सेट करें।

r.table("posts").get(1).update(
    post -> r.branch(post.g("views").gt(100),
                     r.hashMap("type", "hot"),
                     r.hashMap("type", "normal")
    )
).run(conn);

उदाहरण: उप-क्वेरी के परिणाम के साथ फ़ील्ड numComments को अपडेट करें। क्योंकि यह अद्यतन परमाणु नहीं है, तो आपको non_atomic ध्वज को पास करना होगा।

r.table("posts").get(1).update(
    r.hashMap("numComments", r.table("comments")
     .filter(r.hashMap("id_post", 1)).count())
).optArg("non_atomic", true).run(conn);

यदि आप non_atomic ध्वज निर्दिष्ट करना भूल जाते हैं, तो आपको एक ReqlRuntimeError :

ReqlRuntimeError: Could not prove function deterministic.  Maybe you want to use the non_atomic flag? 

उदाहरण: 0 और 100 के बीच यादृच्छिक मान के साथ फ़ील्ड numComments को अपडेट करें। यह अद्यतन r.js (और वास्तव में नहीं है) के कारण निर्धारक सिद्ध नहीं किया जा सकता है, इसलिए आपको nonAtomic ध्वज को पास करना होगा।

r.table("posts").get(1).update(
    r.hashMap("numComments", r.js("Math.floor(Math.random()*100)"))
).optArg("non_atomic", true).run(conn);

उदाहरण: नरम स्थायित्व का उपयोग करके 1 id के साथ पोस्ट की स्थिति को अपडेट करें।

r.table("posts").get(1).update(
    r.hashMap(status, "published")
).optArg("durability", "soft").run(conn);

उदाहरण: क्षेत्र के views वृद्धि और अद्यतन कार्रवाई से पहले और बाद में दस्तावेज़ के मूल्यों को वापस लौटाएं।

r.table("posts").get(1).update(
    post -> r.hashMap("views", post.g("views").add(1))
).optArg("return_changes", true).run(conn);

परिणाम में अब एक changes क्षेत्र शामिल होगा:

{
    "deleted": 1,
    "errors": 0,
    "inserted": 0,
    "changes": [
        {
            "new_val": {
                "id": 1,
                "author": "Julius_Caesar",
                "title": "Commentarii de Bello Gallico",
                "content": "Aleas jacta est",
                "views": 207
            },
            "old_val": {
                "id": 1,
                "author": "Julius_Caesar",
                "title": "Commentarii de Bello Gallico",
                "content": "Aleas jacta est",
                "views": 206
            }
        }
    ],
    "replaced": 0,
    "skipped": 0,
    "unchanged": 0
}

नेस्टेड फ़ील्ड अद्यतन करना

update आदेश उपनिर्देशिका को अद्यतन करने के लिए RethinkDB के नेस्टेड फ़ील्ड सिंटैक्स का समर्थन करता है। इस प्रारूप में संपर्क जानकारी के साथ एक उपयोगकर्ता तालिका पर विचार करें:

{
	"id": 10001,
	"name": "Bob Smith",
	"contact": {
		"phone": {
			"work": "408-555-1212",
			"home": "408-555-1213",
			"cell": "408-555-1214"
		},
		"email": {
			"work": "[email protected]",
			"home": "[email protected]",
			"other": "[email protected]"
		},
		"im": {
			"skype": "Bob Smith",
			"aim": "bobmoose",
			"icq": "nobodyremembersicqnumbers"
		}
	},
	"notes": [
		{
			"date": r.time(2014,1,1,'Z'),
			"from": "John Doe",
			"subject": "My name is even more boring than Bob's"
		},
		{
			"date": r.time(2014,2,2,'Z'),
			"from": "Bob Smith Sr",
			"subject": "Happy Second of February"
		}
	]
}

उदाहरण: बॉब स्मिथ के सेल फोन नंबर को अपडेट करें।

r.table("users").get(10001).update(
    r.hashMap("contact",
        r.hashMap("phone",
            r.hashMap("cell", "408-555-4242")))
).run(conn);

उदाहरण: बॉब स्मिथ के रिकॉर्ड में एक और नोट जोड़ें।

import com.rethinkdb.model.MapObject;

MapObject newNote = r.hashMap("date", r.now())
                     .with("from", "Admin")
                     .with("subject", "You killed my father");

r.table("users").get(10001).update(
    row -> r.hashMap("notes", row.g("notes").append(newNote))
).run(conn);

यह विफल हो जाएगा यदि दस्तावेज़ में notes फ़ील्ड मौजूद नहीं है। इसे "अपटाउन" (अपडेट या इंसर्ट) के रूप में करने के लिए, फ़ील्ड को खाली सूची के रूप में आरम्भ करने के लिए default_ कमांड का उपयोग करें।

r.table("users").get(10001).update(
    row -> r.hashMap(notes, row.g("notes").default_(r.array()).append(newNote))
).run(conn);

उदाहरण: ICQ नंबर वाले प्रत्येक उपयोगकर्ता को एक नोट भेजें।

import com.rethinkdb.model.MapObject;

MapObject icqNote = r.hashMap("date", r.now())
                     .with("from", "Admin")
                     .with("subject", "Welcome to the future");

r.table("users").filter(
    row -> row.hasFields(r.hashMap("contact", r.hashMap("im", "icq")))
).update(r.hashMap("notes", row.g("notes").append(icqNote))).run(conn);

उदाहरण: बॉब के सभी आईएम रिकॉर्ड को बदलें। आम तौर पर, update नेस्टेड दस्तावेजों को एक साथ मिला देगा; पूरे "im" दस्तावेज़ को बदलने के लिए, literal कमांड का उपयोग करें।

r.table("users").get(10001).update(
    r.hashMap("contact",
        r.hashMap("im",
            r.literal(r.hashMap("aim", "themoosemeister"))))
).run(conn);

संबंधित आदेश

अधिक सहायता प्राप्त करें

आप जो खोज रहे थे, वह नहीं मिला?