JSON_QUERY () SQL सर्वर में उदाहरण (T-SQL)

SQL सर्वर के साथ JSON का उपयोग करते समय, आप JSON_QUERY() . का उपयोग कर सकते हैं JSON स्ट्रिंग से किसी ऑब्जेक्ट या सरणी को निकालने के लिए कार्य करता है।

इस फ़ंक्शन का उपयोग करने के लिए, आप JSON व्यंजक को तर्क के रूप में प्रदान करते हैं। आप निकालने के लिए ऑब्जेक्ट या सरणी निर्दिष्ट करने के लिए दूसरा (वैकल्पिक) तर्क भी प्रदान कर सकते हैं।

सिंटैक्स

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

JSON_QUERY ( expression [ , path ] )  

जहां expression JSON स्ट्रिंग एक्सप्रेशन है, और path वह वस्तु या सरणी है जिसे आप उस अभिव्यक्ति से निकालना चाहते हैं। path तर्क वैकल्पिक है (यदि आप इसे प्रदान नहीं करते हैं, तो संपूर्ण JSON दस्तावेज़ वापस कर दिया जाता है)।

पथ तर्क (यदि आपूर्ति की जाती है) में एक वैकल्पिक पथ मोड . शामिल हो सकता है अवयव। यह वैकल्पिक पथ मोड या तो lax . का मान हो सकता है या strict . यह मान निर्धारित करता है कि आपूर्ति किया गया पथ अमान्य होने की स्थिति में क्या होता है। पथ मोड (यदि आपूर्ति की जाती है) डॉलर चिह्न से पहले आता है।

उदाहरण 1 - मूल उपयोग

JSON_QUERY() . के मूल उपयोग को प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है समारोह।

DECLARE @data NVARCHAR(4000)
SET @data=N'{
    "Cities": [
        {
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        },
        {
            "Name": "Qandahar",
            "CountryCode": "AFG",
            "District": "Qandahar",
            "Population": 237500
        }
    ]
}'
SELECT JSON_QUERY(@data, '$.Cities[0]') AS 'Result';

परिणाम:

+----------+
| Result   |
|----------|
| {
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        }          |
+----------+

इस उदाहरण में, मैं पहले @data . नामक एक वैरिएबल घोषित और सेट करता हूं . मैं फिर इस चर के लिए एक सरणी असाइन करता हूं। एक बार ऐसा करने के बाद, मैं उस सरणी के विरुद्ध एक क्वेरी चलाता हूं।

इस मामले में मैं Cities[0] . का उपयोग करता हूं सरणी में पहले आइटम को संदर्भित करने के लिए (JSON सरणियाँ शून्य-आधारित क्रमांकन का उपयोग करती हैं)।

मैं Cities[1] . का उपयोग करके दूसरे आइटम तक पहुंच सकता हूं . इस तरह:

DECLARE @data NVARCHAR(4000)
SET @data=N'{
    "Cities": [
        {
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        },
        {
            "Name": "Qandahar",
            "CountryCode": "AFG",
            "District": "Qandahar",
            "Population": 237500
        }
    ]
}'
SELECT JSON_QUERY(@data, '$.Cities[1]') AS 'Result';

परिणाम:

+----------+
| Result   |
|----------|
| {
            "Name": "Qandahar",
            "CountryCode": "AFG",
            "District": "Qandahar",
            "Population": 237500
        }          |
+----------+

उदाहरण 2 - संपूर्ण JSON एक्सप्रेशन लौटाएं

दूसरा तर्क वैकल्पिक है, इसलिए यदि आप इसे छोड़ देते हैं, तो संपूर्ण JSON दस्तावेज़ वापस आ जाता है। जब हम पिछले उदाहरणों के समान डेटा का उपयोग करके ऐसा करते हैं तो यहां क्या होता है:

DECLARE @data NVARCHAR(4000)
SET @data=N'{
    "Cities": [
        {
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        },
        {
            "Name": "Qandahar",
            "CountryCode": "AFG",
            "District": "Qandahar",
            "Population": 237500
        }
    ]
}'
SELECT JSON_QUERY(@data) AS 'Result';

परिणाम:

+----------+
| Result   |
|----------|
| {
    "Cities": [
        {
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        },
        {
            "Name": "Qandahar",
            "CountryCode": "AFG",
            "District": "Qandahar",
            "Population": 237500
        }
    ]
}          |
+----------+

उदाहरण 3 - एक डेटाबेस उदाहरण

यदि हम पिछले उदाहरण के डेटा को डेटाबेस में डालते हैं, तो हम क्वेरी को निम्नानुसार फिर से लिख सकते हैं:

SELECT 
  JSON_QUERY(Document,'$.Cities[0]') AS 'City 1'
FROM Json_Documents

परिणाम:

+----------+
| City 1   |
|----------|
| {
            "ID": 1,
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        }          |
+----------+

यह मानता है कि JSON दस्तावेज़ Document . नामक कॉलम में संग्रहीत है , जो Json_Documents . नामक तालिका में है ।

उदाहरण 4 - स्केलर मान

JSON_QUERY() फ़ंक्शन को स्केलर मान वापस करने के लिए डिज़ाइन नहीं किया गया है। यदि आप एक अदिश मान वापस करना चाहते हैं, तो JSON_VALUE() . का उपयोग करें इसके बजाय कार्य करें।

हालांकि, ग्रैन्युलैरिटी के विभिन्न स्तरों पर डेटा वापस करने के लिए एक क्वेरी के भीतर दोनों कार्यों को संयोजित करने से रोकने के लिए कुछ भी नहीं है।

यहां एक उदाहरण दिया गया है:

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_VALUE(@data,'$.Suspect.Name') AS 'Name',
   JSON_QUERY(@data,'$.Suspect.Hobbies') AS 'Hobbies',
   JSON_VALUE(@data,'$.Suspect.Hobbies[2]') AS 'Last Hobby';

परिणाम:

+---------------+----------------------------------------+--------------+
| Name          | Hobbies                                | Last Hobby   |
|---------------+----------------------------------------+--------------|
| Homer Simpson | ["Eating", "Sleeping", "Base Jumping"] | Base Jumping |
+---------------+----------------------------------------+--------------+

इस उदाहरण में मैंने JSON_VALUE() . का उपयोग किया है विभिन्न अदिश मान निकालने के लिए, लेकिन मैंने JSON_QUERY() . का भी उपयोग किया एक संपूर्ण सरणी वापस करने के लिए (जो JSON_VALUE() नहीं कर सकता)।

उदाहरण 5 - पथ मोड

जैसा कि बताया गया है, आपके पास पथ मोड निर्दिष्ट करने का विकल्प भी है। यह या तो lax हो सकता है या strict ।

पथ मोड का मान निर्धारित करता है कि पथ व्यंजक में त्रुटि होने पर क्या होता है। विशेष रूप से:

• ढीले . में मोड, यदि पथ अभिव्यक्ति में कोई त्रुटि है, तो फ़ंक्शन खाली मान देता है। उदाहरण के लिए, अगर आप मान $.name . का अनुरोध करते हैं , और JSON टेक्स्ट में कोई नाम . नहीं है कुंजी, फ़ंक्शन शून्य लौटाता है, लेकिन कोई त्रुटि उत्पन्न नहीं करता है।

• सख्त . में मोड, यदि पथ अभिव्यक्ति में कोई त्रुटि है, तो फ़ंक्शन एक त्रुटि उत्पन्न करता है।

डिफ़ॉल्ट मान lax है ।

इन दो मोड के बीच अंतर को प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है।

ढीला मोड में त्रुटि

यहां बताया गया है कि जब लैक्स मोड में पाथ एक्सप्रेशन में त्रुटि होती है तो क्या होता है।

SELECT JSON_QUERY('{"Name": "Bruce"}', 'lax $.Name') AS 'Result';

परिणाम:

+----------+
| Result   |
|----------|
| NULL     |
+----------+

इस उदाहरण में हम एक अदिश मान लौटाने का प्रयास कर रहे हैं, लेकिन JSON_QUERY() अदिश मान नहीं करता है। जैसा कि बताया गया है, यह केवल वस्तुओं और सरणी देता है। इस मामले में हमें एक शून्य मान मिलता है (क्योंकि हम लैक्स मोड का उपयोग कर रहे हैं)।

सख्त मोड में त्रुटि

जब हम समान कोड को स्ट्रिक्ट मोड में चलाते हैं तो यहां क्या होता है।

SELECT JSON_QUERY('{"Name": "Bruce"}', 'strict $.Name') AS 'Result';

परिणाम:

Msg 13624, Level 16, State 2, Line 1
Object or array cannot be found in the specified JSON path.

जैसा कि अपेक्षित था, सख्त मोड के परिणामस्वरूप त्रुटि की व्याख्या करने वाला एक त्रुटि संदेश आता है।