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

मारियाडीबी में, JSON_SEARCH() एक अंतर्निहित फ़ंक्शन है जो आपको JSON दस्तावेज़ में दिए गए मान के लिए पथ प्राप्त करने की अनुमति देता है।

यह JSON दस्तावेज़ और एक स्ट्रिंग को तर्क के रूप में स्वीकार करता है, और दस्तावेज़ के भीतर दिए गए स्ट्रिंग का पथ लौटाता है।

सिंटैक्स

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

JSON_SEARCH(
    json_doc, 
    return_arg, 
    search_str[, escape_char[, path] ...]
    )

कहां:

• json_doc JSON दस्तावेज़ है और search_str स्ट्रिंग है।
• return_arg कीवर्ड है one या all . अगर आप one का इस्तेमाल करते हैं , केवल पहला पथ लौटाया जाता है। अन्य किसी भी घटना को नजर अंदाज कर दिया जाता है। किस पथ को "पहला" माना जाता है, यह अपरिभाषित है (मारियाडीबी दस्तावेज़ीकरण के अनुसार)। अगर all निर्दिष्ट है, सभी घटनाओं के पथ लौटाए जाते हैं। यदि कई पथ हैं, तो वे एक सरणी के रूप में स्वतः लपेटे जाते हैं।
• द escape_char तर्क एस्केप वर्ण के रूप में उपयोग करने के लिए एक वैकल्पिक वर्ण है।
• द path तर्क यह निर्धारित करने के लिए एक वैकल्पिक तर्क है कि JSON दस्तावेज़ में "शीर्ष-स्तर" पथ कहाँ से शुरू होता है।

उदाहरण

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

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

SELECT JSON_SEARCH(@json, 'one', 'Wag');

परिणाम:

+----------------------------------+
| JSON_SEARCH(@json, 'one', 'Wag') |
+----------------------------------+
| "$.name"                         |
+----------------------------------+

किसी सरणी में किसी तत्व के लिए पथ लौटाने का एक उदाहरण यहां दिया गया है:

SET @json = '
    { 
        "product" : "Left Handed Screwdriver", 
        "sizes" : [ "Small", "Medium", "Large" ],
    }';

SELECT JSON_SEARCH(@json, 'one', 'Medium');

परिणाम:

+-------------------------------------+
| JSON_SEARCH(@json, 'one', "Medium") |
+-------------------------------------+
| "$.sizes[1]"                        |
+-------------------------------------+

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

एकाधिक घटनाएं

यदि आप उन सभी पथों को वापस करना चाहते हैं जिनमें स्ट्रिंग है, तो all . का उपयोग करें one . के बजाय दूसरे तर्क के लिए।

SET @json = '[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]';

SELECT JSON_SEARCH(@json, 'all', 'Dog');

परिणाम:

+----------------------------------+
| JSON_SEARCH(@json, 'all', "Dog") |
+----------------------------------+
| ["$[0].type", "$[1].type"]       |
+----------------------------------+

अगर हम all बदलते हैं करने के लिए one , यहाँ क्या होता है:

SET @json = '[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]';

SELECT JSON_SEARCH(@json, 'one', 'Dog');

परिणाम:

+----------------------------------+
| JSON_SEARCH(@json, 'one', "Dog") |
+----------------------------------+
| "$[0].type"                      |
+----------------------------------+

केवल एक पथ लौटाया जाता है।

पथ निर्दिष्ट करें

यहां एक उदाहरण दिया गया है जो उस पथ को निर्दिष्ट करता है जिसके लिए दस्तावेज़ में खोजना है:

SET @json = '
    { 
        "_id" : 1, 
        "name" : "Wag", 
        "details" : {
            "type" : "Dog", 
            "weight" : 20,
            "awards" : { 
                "NZ Dog Award" : "Top Dog", 
                "New York Marathon" : "Fastest Animal", 
                "Sumo 2021" : "Biggest Dog"
            }
        }
    }
';
SELECT JSON_SEARCH(
    @json, 
    'all',
    '%dog%',
    NULL,
    '$.details.awards'
    ) AS Result;

परिणाम:

+-----------------------------------------------------------------+
| Result                                                          |
+-----------------------------------------------------------------+
| ["$.details.awards.NZ Dog Award", "$.details.awards.Sumo 2021"] |
+-----------------------------------------------------------------+

इस मामले में, स्ट्रिंग dog वास्तव में दस्तावेज़ के भीतर तीन बार होता है, लेकिन निर्दिष्ट पथ के नीचे केवल दो बार होता है।

साथ ही, हमने NULL . का उपयोग किया है एस्केप कैरेक्टर तर्क के लिए, जिसके परिणामस्वरूप डिफॉल्ट एस्केप कैरेक्टर का उपयोग किया जा रहा है, जो बैकस्लैश है (\ )

डिफ़ॉल्ट एस्केप कैरेक्टर

डिफ़ॉल्ट रूप से, एस्केप कैरेक्टर एक बैकस्लैश होता है (\ )

उदाहरण:

SET @json = '[
    { "uid": "Wag", "pwd": "my%pwd" },
    { "uid": "Bark", "pwd": "my%%%pwd" },
    { "uid": "Bark", "pwd": "myBIGpwd" }
]';

SELECT 
    JSON_SEARCH(@json, 'all', 'my%pwd') AS "Not Escaped",
    JSON_SEARCH(@json, 'all', 'my\%pwd') AS "Escaped";

परिणाम:

+--------------------------------------+------------+
| Not Escaped                          | Escaped    |
+--------------------------------------+------------+
| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |
+--------------------------------------+------------+

प्रतिशत चिह्न (% ) एक वाइल्डकार्ड वर्ण है जो किसी भी वर्ण से मेल खाता है। इसलिए, यदि हम इससे नहीं बचते हैं, तो यह किसी भी संख्या में वर्णों से मेल खाएगा, जिसमें ऐसे वर्ण भी शामिल हैं जो प्रतिशत चिह्न नहीं हैं।

लेकिन जब हम एस्केप कैरेक्टर के साथ प्रतिशत चिह्न से बचते हैं, तो यह केवल तभी मेल खाएगा जब उस स्थान पर ठीक एक प्रतिशत चिह्न हो।

उपरोक्त परिणाम इसे दर्शाते हैं।

कस्टम एस्केप कैरेक्टर निर्दिष्ट करें

यदि आवश्यक हो तो आप एक कस्टम एस्केप वर्ण निर्दिष्ट कर सकते हैं। ऐसा करने के लिए, इसे चौथे तर्क के रूप में प्रदान करें।

उदाहरण:

SET @json = '[
    { "uid": "Wag", "pwd": "my%pwd" },
    { "uid": "Bark", "pwd": "my%%%pwd" },
    { "uid": "Bark", "pwd": "myBIGpwd" }
]';

SELECT 
    JSON_SEARCH(@json, 'all', 'my%pwd', '!') AS "Not Escaped",
    JSON_SEARCH(@json, 'all', 'my!%pwd', '!') AS "Escaped";

परिणाम:

+--------------------------------------+------------+
| Not Escaped                          | Escaped    |
+--------------------------------------+------------+
| ["$[0].pwd", "$[1].pwd", "$[2].pwd"] | "$[0].pwd" |
+--------------------------------------+------------+

तो हम पिछले उदाहरण के समान ही परिणाम प्राप्त करते हैं। फर्क सिर्फ इतना है कि हमने एक अलग एस्केप कैरेक्टर निर्दिष्ट किया है। इस मामले में, हमने निर्दिष्ट किया है कि विस्मयादिबोधक चिह्न (! ) एस्केप कैरेक्टर है।

अशक्त तर्क

यदि कोई खोज स्ट्रिंग, खोज स्ट्रिंग, या पथ तर्क NULL . हैं , परिणाम NULL . है :

SELECT 
    JSON_SEARCH(null, 'all', 's', '', '$') AS a,
    JSON_SEARCH('{"a":1}', 'all', null, '', '$') AS b,
    JSON_SEARCH('{"a":1}', 'all', 's', '', null) AS c;

परिणाम:

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

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

तर्क न देने से त्रुटि होती है:

SELECT JSON_SEARCH();

परिणाम:

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

जब आप बहुत कम तर्क देते हैं तो ऐसा ही होता है:

SELECT JSON_SEARCH('{"a":1}', 'all');

परिणाम:

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