MySQL में, JSON_SEARCH() फ़ंक्शन किसी JSON दस्तावेज़ में दिए गए स्ट्रिंग का पथ लौटाता है।
आप JSON दस्तावेज़ को फ़ंक्शन के तर्क के रूप में प्रदान करते हैं। आप तर्क भी प्रदान करते हैं जो खोज के लिए वास्तविक स्ट्रिंग (किसी भी एस्केप वर्ण सहित) को निर्धारित करता है, साथ ही यह इंगित करने के लिए एक कीवर्ड भी प्रदान करता है कि सभी उदाहरणों का पथ वापस करना है या सिर्फ एक।
सिंटैक्स
वाक्य रचना इस प्रकार है:
JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path] ...])
प्रत्येक तर्क की व्याख्या इस प्रकार है।
json_docखोजने के लिए JSON दस्तावेज़ हैone_or_allकीवर्ड हैoneयाall. अगर आपoneका इस्तेमाल करते हैं , पहली घटना मिलने पर खोज रोक दी जाती है। यही है, फ़ंक्शन केवल खोज स्ट्रिंग के पहले उदाहरण का पथ देता है। अगरallनिर्दिष्ट किया गया है, तो सभी घटनाओं के पथ लौटाए जाते हैं जैसे कि कोई डुप्लिकेट पथ शामिल नहीं हैं। यदि कई पथ हैं, तो वे एक सरणी के रूप में स्वतः लपेटे जाते हैं।search_strका पथ वापस करने के लिए वास्तविक स्ट्रिंग है।escape_charएस्केप कैरेक्टर के रूप में उपयोग करने के लिए एक वैकल्पिक चरित्र है। यह एक स्थिरांक होना चाहिए जो खाली हो या एक वर्ण हो। यदि आप इस तर्क को निर्दिष्ट नहीं करते हैं (या यदि यह NULL है), तो एस्केप वर्ण बैकस्लैश है (\)।pathयह निर्धारित करने के लिए एक वैकल्पिक तर्क है कि JSON दस्तावेज़ में "शीर्ष-स्तरीय" पथ कहाँ से शुरू होता है।
search_str . के अंदर तर्क, % और _ अक्षर वैसे ही काम करते हैं जैसे वे LIKE . के साथ प्रयोग करने पर करते हैं ऑपरेटर:% किसी भी संख्या में वर्णों से मेल खाता है (शून्य वर्णों सहित), और _ बिल्कुल एक वर्ण से मेल खाता है।
एक शाब्दिक % specify निर्दिष्ट करने के लिए या _ खोज स्ट्रिंग में वर्ण, उसके पहले एस्केप वर्ण से पहले करें।
उदाहरण 1 - मूल उपयोग
प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है।
SELECT
JSON_SEARCH('{"Name": "Bart", "Age": 10}', 'one', 'Bart') Result;
परिणाम:
+----------+ | Result | +----------+ | "$.Name" | +----------+
उदाहरण 2 - सरणी
यहां एक सरणी के भीतर एक स्ट्रिंग खोजने का एक उदाहरण दिया गया है।
SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Mischief') Result;
परिणाम:
+----------------+ | Result | +----------------+ | "$.Hobbies[1]" | +----------------+
सरणियाँ शून्य-आधारित क्रमांकन का उपयोग करती हैं, इसलिए यह परिणाम दूसरे तत्व को इंगित करता है।
उदाहरण 3 - गैर-मौजूद स्ट्रिंग
यदि आप एक स्ट्रिंग निर्दिष्ट करते हैं जो मौजूद नहीं है तो एक NULL मान वापस आ जाता है।
SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Homer') Result;
परिणाम:
+--------+ | Result | +--------+ | NULL | +--------+
यदि कोई json_doc . है तो आपको एक NULL मान भी मिलेगा , search_str , या path तर्क हैं NULL या यदि JSON ऑब्जेक्ट में कोई पथ मौजूद नहीं है।
उदाहरण 4 - एक स्ट्रिंग की एकाधिक बारंबारता
यदि JSON दस्तावेज़ में एक ही स्ट्रिंग की कई आवृत्तियाँ हैं, तो परिणाम इस पर निर्भर करेगा कि आप one निर्दिष्ट करते हैं या नहीं या all दूसरे तर्क के रूप में।
अगर आप one का इस्तेमाल करते हैं , केवल पहली घटना लौटा दी जाती है (यह मानते हुए कि कम से कम एक घटना है):
SET @doc = '{"Name": "Bart", "Friends": ["Bart", "Milhouse"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Bart') Result;
परिणाम:
+----------+ | Result | +----------+ | "$.Name" | +----------+
अगर आप all का इस्तेमाल करते हैं , सभी घटनाओं के पथ लौटाए जाते हैं। यदि एक से अधिक पथ हैं, तो वे एक सरणी के रूप में स्वतः लपेटे जाते हैं।
SET @doc = '{"Name": "Bart", "Friends": ["Bart", "Milhouse"]}';
SELECT JSON_SEARCH(@doc, 'all', 'Bart') Result;
परिणाम:
+----------------------------+ | Result | +----------------------------+ | ["$.Name", "$.Friends[0]"] | +----------------------------+
आप एक पथ भी निर्दिष्ट कर सकते हैं जो किसी निर्दिष्ट पथ से केवल वे परिणाम देता है। उस पर और नीचे (उदाहरण 8 के तहत - एक पथ निर्दिष्ट करें )।
उदाहरण 5 - वाइल्डकार्ड
आप ऊपर दिए गए सिंटैक्स में बताए अनुसार वाइल्डकार्ड वर्णों का उपयोग कर सकते हैं। उदाहरण के लिए, आप % . का उपयोग कर सकते हैं किसी भी वर्ण से मेल खाने के लिए।
SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Skate%') Result;
परिणाम:
+----------------+ | Result | +----------------+ | "$.Hobbies[0]" | +----------------+
और आप _ . का उपयोग कर सकते हैं केवल एक वर्ण से मेल खाने के लिए।
SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Bar_') Result;
परिणाम:
+----------+ | Result | +----------+ | "$.Name" | +----------+
अगर हमें _ . का उपयोग करना होता पिछले उदाहरण में, हमें एक NULL परिणाम मिलेगा।
SET @doc = '{"Name": "Bart", "Hobbies": ["Skateboarding", "Mischief"]}';
SELECT JSON_SEARCH(@doc, 'one', 'Skate_') Result;
परिणाम:
+--------+ | Result | +--------+ | NULL | +--------+
उदाहरण 6 - डिफ़ॉल्ट एस्केप कैरेक्टर
यदि आपको ऐसी स्ट्रिंग की खोज करने की आवश्यकता है जिसमें वास्तव में उपरोक्त वाइल्डकार्ड वर्णों में से कोई भी हो, तो आपको वर्ण से बचने की आवश्यकता होगी। यह MySQL को इसे एक स्ट्रिंग अक्षर के रूप में उपयोग करने के लिए कहता है (इसे वाइल्डकार्ड वर्ण के रूप में व्याख्या करने के बजाय)।
SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT JSON_SEARCH(@doc, 'one', 'pass\%word') Result;
परिणाम:
+---------+ | Result | +---------+ | "$.pwd" | +---------+
पहली नज़र में, आप सोच रहे होंगे कि बैकस्लैश अनावश्यक था, क्योंकि आखिरकार, अगर हम ऐसा करते हैं तो हमें वही परिणाम मिलेगा:
SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT JSON_SEARCH(@doc, 'one', 'pass%word') Result;
परिणाम:
+---------+ | Result | +---------+ | "$.pwd" | +---------+
लेकिन इस दृष्टिकोण के साथ समस्या यह है कि यदि हम ऐसा करते हैं तो हमें भी वही परिणाम मिलता है:
SET @doc = '{"userid": "bart_simpson", "pwd": "pass%BLAH-BLAH-BLAH-word"}';
SELECT JSON_SEARCH(@doc, 'one', 'pass%word') 'Result';
परिणाम:
+---------+ | Result | +---------+ | "$.pwd" | +---------+
तो बैकस्लैश MySQL को सूचित करता है कि हम केवल % . के एक उदाहरण की तलाश कर रहे हैं एक स्ट्रिंग अक्षर के रूप में, और नहीं अन्य वर्णों की संख्या के लिए।
अंडरस्कोर कैरेक्टर के लिए भी यही अवधारणा सही है।
अगर हम ऐसा करते हैं:
SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT
JSON_SEARCH(@doc, 'one', 'bart\_simpson') 'Escaped',
JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';
हमें यह मिलता है:
+------------+-------------+ | Escaped | Not Escaped | +------------+-------------+ | "$.userid" | "$.userid" | +------------+-------------+
दोनों दृष्टिकोण एक ही परिणाम लौटाते हैं।
लेकिन अगर हम ऐसा करते हैं (उपयोगकर्ता आईडी में _ को J से बदलें):
SET @doc = '{"userid": "bartJsimpson", "pwd": "pass%word"}';
SELECT
JSON_SEARCH(@doc, 'one', 'bart\_simpson') 'Escaped',
JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';
हमें यह मिलता है:
+---------+-------------+ | Escaped | Not Escaped | +---------+-------------+ | NULL | "$.userid" | +---------+-------------+
उदाहरण 7 - कस्टम एस्केप कैरेक्टर
यदि आवश्यक हो तो आप अपना खुद का एस्केप कैरेक्टर निर्दिष्ट कर सकते हैं। आप इसे वैकल्पिक चौथे तर्क के रूप में शामिल करके करते हैं।
एक अलग एस्केप कैरेक्टर का उपयोग करने के लिए यहां पिछले उदाहरण को फिर से लिखा गया है (उपयोगकर्ता आईडी में एक _ . शामिल है चरित्र)।
SET @doc = '{"userid": "bart_simpson", "pwd": "pass%word"}';
SELECT
JSON_SEARCH(@doc, 'one', 'bart$_simpson', '$') 'Escaped',
JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';
परिणाम:
+------------+-------------+ | Escaped | Not Escaped | +------------+-------------+ | "$.userid" | "$.userid" | +------------+-------------+
और अगर हम _ . को प्रतिस्थापित करते हैं J . के साथ उपयोगकर्ता आईडी में:
SET @doc = '{"userid": "bartJsimpson", "pwd": "pass%word"}';
SELECT
JSON_SEARCH(@doc, 'one', 'bart$_simpson', '$') 'Escaped',
JSON_SEARCH(@doc, 'one', 'bart_simpson') 'Not Escaped';
परिणाम:
+---------+-------------+ | Escaped | Not Escaped | +---------+-------------+ | NULL | "$.userid" | +---------+-------------+
उदाहरण 8 - एक पथ निर्दिष्ट करें
आप एक पथ भी निर्दिष्ट कर सकते हैं जिससे खोज शुरू करना है। यहाँ एक उदाहरण है।
SET @data = '{
"Person": {
"Name": "Bart",
"Age": 10,
"Friends": ["Bart", "Milhouse"]
}
}';
SELECT JSON_SEARCH(@data, 'all', 'Bart', NULL, '$.Person.Friends') AS 'Result';
परिणाम:
+-----------------------+ | Result | +-----------------------+ | "$.Person.Friends[0]" | +-----------------------+
यदि हमने कोई पथ निर्दिष्ट नहीं किया होता, तो हमें निम्न परिणाम प्राप्त होते।
SET @data = '{
"Person": {
"Name": "Bart",
"Age": 10,
"Friends": ["Bart", "Milhouse"]
}
}';
SELECT JSON_SEARCH(@data, 'all', 'Bart') AS 'Result';
परिणाम:
+------------------------------------------+ | Result | +------------------------------------------+ | ["$.Person.Name", "$.Person.Friends[0]"] | +------------------------------------------+
इसके अलावा, अगर हम oneनिर्दिष्ट करते हैं दूसरे तर्क के रूप में (साथ ही पथ तर्क को छोड़कर), हम निम्नलिखित के साथ समाप्त होंगे।
SET @data = '{
"Person": {
"Name": "Bart",
"Age": 10,
"Friends": ["Bart", "Milhouse"]
}
}';
SELECT JSON_SEARCH(@data, 'one', 'Bart') AS 'Result';
परिणाम:
+-----------------+ | Result | +-----------------+ | "$.Person.Name" | +-----------------+
उदाहरण 9 - खाली दस्तावेज़
यदि दस्तावेज़ में कोई पथ नहीं है, तो आपको एक NULL मान मिलेगा।
SELECT
JSON_SEARCH('{}', 'all', 'Bart') 'Result';
परिणाम:
+--------+ | Result | +--------+ | NULL | +--------+
