मारियाडीबी JSON_REPLACE () समझाया गया

मारियाडीबी में, JSON_REPLACE() एक अंतर्निहित फ़ंक्शन है जो JSON दस्तावेज़ में मौजूदा मानों को बदल देता है और परिणाम देता है।

सिंटैक्स

वाक्य रचना इस प्रकार है:

JSON_REPLACE(json_doc, path, val[, path, val] ...)

उदाहरण

प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है।

SET @json = '{ "name" : "Wag", "type" : "Cat" }';

SELECT JSON_REPLACE(@json, '$.type', 'Dog');

परिणाम:

+--------------------------------------+
| JSON_REPLACE(@json, '$.type', 'Dog') |
+--------------------------------------+
| {"name": "Wag", "type": "Dog"}       |
+--------------------------------------+

इस मामले में मैंने Cat . मान को बदल दिया है Dog . के साथ ।

सरणी तत्व

किसी सरणी तत्व को बदलने के लिए, तत्व की अनुक्रमणिका निर्दिष्ट करें:

SET @json = '{ "name" : "Wag", "scores" : [8, 0, 9] }';

SELECT JSON_REPLACE(@json, '$.scores[1]', 7);

परिणाम:

+---------------------------------------+
| JSON_REPLACE(@json, '$.scores[1]', 7) |
+---------------------------------------+
| {"name": "Wag", "scores": [8, 7, 9]}  |
+---------------------------------------+

इस मामले में, दूसरे सरणी तत्व को नए मान से बदल दिया गया था। सरणी शून्य आधारित हैं, और इसलिए $.scores[1] सरणी में दूसरे तत्व को संदर्भित करता है।

एकाधिक पथ

सिंटैक्स एक ही कॉल के साथ कई पथों पर मानों को JSON_REPLACE() . पर बदलने की अनुमति देता है ।

एकाधिक पथ प्रदान करते समय, उनका मूल्यांकन बाएं से दाएं किया जाता है। इसका मतलब यह है कि पहले के मूल्यांकन के परिणाम का उपयोग अगले के लिए मूल्य के रूप में किया जाता है।

सबसे पहले, यहां एक उदाहरण दिया गया है जो एक दस्तावेज़ में कई मानों को उनकी कुंजी के आधार पर बदल देता है:

SET @json = '
    { 
        "name" : "Flutter", 
        "type" : "Bird",
        "weight" : 10
    }
';

SELECT JSON_REPLACE(@json, '$.type', 'Bat', '$.weight', 20);

परिणाम:

+------------------------------------------------------+
| JSON_REPLACE(@json, '$.type', 'Bat', '$.weight', 20) |
+------------------------------------------------------+
| {"name": "Flutter", "type": "Bat", "weight": 20}     |
+------------------------------------------------------+

प्रत्येक मान को अपेक्षानुसार बदल दिया गया था।

अगले उदाहरण में हम एक सरणी में कई तत्वों को प्रतिस्थापित करते हैं:

SET @json = '{ "scores" : [ 0, 1, 2, 3, 4, 5 ] }';

SELECT 
    JSON_REPLACE(
        @json, 
        '$.scores[2]', "a", 
        '$.scores[4]', "b"
    ) AS Result;

परिणाम:

+------------------------------------+
| Result                             |
+------------------------------------+
| {"scores": [0, 1, "a", 3, "b", 5]} |
+------------------------------------+

अशक्त तर्क

अगर json_doc या कोई path तर्क null है , परिणाम NULL . है . लेकिन अगर value तर्क null है , फिर मान को null . में बदल दिया जाता है ।

SELECT 
    JSON_REPLACE(null, '$.a', 1) AS a,
    JSON_REPLACE('{"a":1}', null, 1) AS b,
    JSON_REPLACE('{"a":1}', '$.a', null) AS c;

परिणाम:

+------+------+-------------+
| a    | b    | c           |
+------+------+-------------+
| NULL | NULL | {"a": null} |
+------+------+-------------+

निम्न उदाहरण में, JSON_REPLACE() के लिए प्रत्येक कॉल से पथ तर्कों में से एक अनुपलब्ध है . इसका परिणाम NULL होता है दोनों कॉलों के लिए लौटाया जा रहा है:

SET @json = '{ "name" : "Wag", "type" : "Cat" }';

SELECT 
    JSON_REPLACE(@json, null, 'Bark', '$.type', 'Dog') AS a,
    JSON_REPLACE(@json, '$.name', 'Bark', null, 'Dog') AS b;

परिणाम:

+------+------+
| a    | b    |
+------+------+
| NULL | NULL |
+------+------+

गलत पैरामीटर गणना

कॉलिंग JSON_REPLACE() बिना तर्क के त्रुटि उत्पन्न होती है:

SELECT JSON_REPLACE();

परिणाम:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'JSON_REPLACE'

जब पर्याप्त तर्क पारित नहीं होते हैं तो ऐसा ही होता है:

SELECT JSON_REPLACE('{"a":1}');

परिणाम:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'JSON_REPLACE'

समान कार्य

JSON_INSERT() फ़ंक्शन नया डेटा सम्मिलित कर सकता है।

JSON_SET() फ़ंक्शन नया डेटा सम्मिलित कर सकता है और मौजूदा डेटा को अपडेट कर सकता है। तो JSON_SET() JSON_INSERT() जैसा है और JSON_REPLACE() एक समारोह में।