OPENJSON के साथ SQL सर्वर में नेस्टेड JSON का चयन कैसे करें?

अगर आप OPENJSON() . का इस्तेमाल कर रहे हैं , लेकिन आप यह याद रखने की कोशिश कर रहे हैं कि JSON दस्तावेज़ से एक आंतरिक खंड का चयन कैसे करें, पढ़ें।

OPENJSON() सिंटैक्स आपको JSON दस्तावेज़ों को एक सारणीबद्ध दृश्य में बदलने की अनुमति देता है। यह आपको JSON दस्तावेज़ से नेस्टेड JSON खंड का चयन करने की भी अनुमति देता है।

ऐसा करने का तरीका पथ . के साथ है ।

पथ

पथ में निम्न शामिल हैं:

• एक डॉलर का चिह्न ($ ), जो संदर्भ वस्तु का प्रतिनिधित्व करता है।
• पथ चरणों का एक सेट। पथ चरणों में निम्नलिखित तत्व और ऑपरेटर शामिल हो सकते हैं:
  • मुख्य नाम। उदाहरण के लिए, $.pets और $.pets.dogs . यदि कुंजी नाम डॉलर के चिह्न से शुरू होता है या इसमें रिक्त स्थान जैसे विशेष वर्ण होते हैं, तो इसे उद्धरणों से घिरा होना चाहिए (उदाहरण के लिए $."my pets" )।
  • सरणी तत्व। उदाहरण के लिए, $.pets.dogs[1] . सरणी अनुक्रमणिका शून्य-आधारित हैं, इसलिए यह उदाहरण सरणी में दूसरे तत्व का चयन करता है।
  • डॉट ऑपरेटर (. ) किसी वस्तु के सदस्य को इंगित करता है। उदाहरण के लिए, $.pets.dogs . में , dogs pets . का सदस्य है .

मूल उदाहरण

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

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets.dogs')
WITH  (
        [id]    int,  
        [name]  varchar(60), 
        [sex]   varchar(6)
    );

परिणाम:

+------+--------+--------+
| id   | name   | sex    |
|------+--------+--------|
| 1    | Fetch  | Male   |
| 2    | Fluffy | Male   |
| 3    | Wag    | Female |
+------+--------+--------+

इस मामले में, दूसरा तर्क OPENJSON() '$.pets.dogs' . है , जिसका अर्थ है कि हम dogs . के मान का चयन कर रहे हैं key, जो स्वयं pets . का बच्चा है ।

डॉलर का चिह्न ($ ) संदर्भ आइटम का प्रतिनिधित्व करता है।

ध्यान दें कि इस उदाहरण में, मैं WITH . का भी उपयोग करता हूं स्कीमा को परिभाषित करने के लिए खंड। अगर मैंने इसे शामिल नहीं किया, तो इसके बजाय डिफ़ॉल्ट स्कीमा का उपयोग किया जाएगा।

यहां बताया गया है कि यह डिफ़ॉल्ट स्कीमा का उपयोग करके कैसा दिखता है।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets.dogs');

परिणाम:

+-------+-------------------------------------------------+--------+
| key   | value                                           | type   |
|-------+-------------------------------------------------+--------|
| 0     | { "id" : 1, "name" : "Fetch", "sex" : "Male" }  | 5      |
| 1     | { "id" : 2, "name" : "Fluffy", "sex" : "Male" } | 5      |
| 2     | { "id" : 3, "name" : "Wag", "sex" : "Female" }  | 5      |
+-------+-------------------------------------------------+--------+

इसलिए हम अभी भी उसी नेस्टेड JSON का चयन कर रहे हैं, बस हम एक अलग स्कीमा का उपयोग कर रहे हैं।

डिफ़ॉल्ट स्कीमा हमेशा तीन कॉलम देता है; कुंजी , मान , और टाइप करें ।

सरणी तत्वों का चयन करना

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

यहाँ एक उदाहरण है।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets.dogs[0]')
WITH  (
        [id]    int,  
        [name]  varchar(60), 
        [sex]   varchar(6)
    );

परिणाम:

+------+--------+-------+
| id   | name   | sex   |
|------+--------+-------|
| 1    | Fetch  | Male  |
+------+--------+-------+

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

डिफ़ॉल्ट स्कीमा का उपयोग करते समय यह उदाहरण कैसा दिखता है (अर्थात WITH के बिना) खंड)।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets.dogs[0]');

परिणाम:

+-------+---------+--------+
| key   | value   | type   |
|-------+---------+--------|
| id    | 1       | 2      |
| name  | Fetch   | 1      |
| sex   | Male    | 1      |
+-------+---------+--------+

पथ मोड

पथ का उपयोग करते समय, आपके पास पथ मोड घोषित करने का विकल्प होता है।

पथ मोड निर्धारित करता है कि क्या होता है जब पथ व्यंजक में कोई त्रुटि होती है।

पथ मोड या तो lax हो सकता है या strict ।

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

डिफ़ॉल्ट पथ मोड lax है , इसलिए यदि आप इसे घोषित नहीं करते हैं, तो lax प्रयोग किया जाता है।

उदाहरण

यह प्रदर्शित करने के लिए एक उदाहरण दिया गया है कि प्रत्येक पथ मोड कैसे गुम पथों को संभालता है।

लैक्स मोड

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, 'lax $.pets.cows');

परिणाम:

(0 rows affected)

इसलिए लैक्स मोड ने कोई त्रुटि नहीं की। इसका परिणाम यह हुआ कि शून्य पंक्तियाँ प्रभावित हुईं।

यदि हम अपना स्वयं का स्कीमा निर्दिष्ट करते हैं, और हमने सही उप-वस्तु का चयन किया है, लेकिन हमने किसी स्तंभ नाम को मैप करने के लिए अनुपलब्ध पथ का उपयोग किया है, तो यह NULL लौटाएगा। उस कॉलम में।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}'

SELECT *
FROM OPENJSON(@json, 'lax $.pets.dogs')
WITH  (
        [id]    int         'lax $.id',  
        [name]  varchar(60) 'lax $.name', 
        [color]   varchar(6)  'lax $.color'
    );

परिणाम:

+------+--------+---------+
| id   | name   | color   |
|------+--------+---------|
| 1    | Fetch  | NULL    |
| 2    | Fluffy | NULL    |
| 3    | Wag    | NULL    |
+------+--------+---------+

सख्त मोड

यहां बताया गया है कि जब हम सख्त मोड का उपयोग करते हैं तो क्या होता है।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, 'strict $.pets.cows');

परिणाम:

Msg 13608, Level 16, State 3, Line 16
Property cannot be found on the specified JSON path.

जैसी कि उम्मीद थी, इसके परिणामस्वरूप एक त्रुटि हुई।

वही त्रुटि तब होती है जब हम सही JSON कुंजी का चयन करते हैं, लेकिन एक कॉलम को एक गैर-मौजूद कुंजी पर मैप करते हैं।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, 'strict $.pets.dogs')
WITH  (
        [id]    int         'strict $.id',  
        [name]  varchar(60) 'strict $.name', 
        [color]   varchar(6)  'strict $.color'
    );

परिणाम:

Msg 13608, Level 16, State 6, Line 16
Property cannot be found on the specified JSON path.

डुप्लिकेट पथ

यदि आपके JSON दस्तावेज़ में समान नेस्टिंग स्तर पर डुप्लिकेट पथ हैं, OPENJSON() उन सभी को वापस कर सकते हैं।

यह JSON_VALUE() . के विपरीत है और JSON_QUERY() , दोनों ही पथ से मेल खाने वाले पहले मान को लौटाते हैं।

यहां OPENJSON() का उपयोग करने का एक उदाहरण दिया गया है डुप्लिकेट पथ वापस करने के लिए।

DECLARE @json NVARCHAR(4000) = N'{
    "dog": {
            "names": {
                "name": "Fetch", 
                "name": "Good Dog"
            }
        }
    }';
SELECT * FROM OPENJSON(@json, '$.dog.names');

परिणाम:

+-------+----------+--------+
| key   | value    | type   |
|-------+----------+--------|
| name  | Fetch    | 1      |
| name  | Good Dog | 1      |
+-------+----------+--------+

नेस्टेड सब-ऑब्जेक्ट्स

अपने स्वयं के स्कीमा को परिभाषित करते समय, आप AS JSON . का उपयोग कर सकते हैं एक संपूर्ण उप-वस्तु को अपने स्वयं के JSON दस्तावेज़ के रूप में वापस करने का विकल्प।

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets')
WITH  (
        [dogs]  nvarchar(max) '$.dogs' AS JSON
    );

परिणाम:

+--------+
| dogs   |
|--------|
| [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]        |
+--------+

अगर हमने AS JSON . का इस्तेमाल नहीं किया होता विकल्प, हमें एक त्रुटि या NULL प्राप्त होता, इस पर निर्भर करता है कि हमने निर्दिष्ट किया है या नहीं lax या strict मोड।

यहाँ यह प्रत्येक मोड में है जब AS JSON . को छोड़ दिया जाता है विकल्प।

लैक्स मोड

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets')
WITH  (
        [dogs]  nvarchar(max) 'lax $.dogs'
    );

परिणाम:

+--------+
| dogs   |
|--------|
| NULL   |
+--------+

सख्त मोड

DECLARE @json NVARCHAR(4000) = N'{ 
    "pets" : {
            "cats" : [
            { "id" : 1, "name" : "Fluffy", "sex" : "Female" },
            { "id" : 2, "name" : "Long Tail", "sex" : "Female" },
            { "id" : 3, "name" : "Scratch", "sex" : "Male" }
        ],
            "dogs" : [
            { "id" : 1, "name" : "Fetch", "sex" : "Male" },
            { "id" : 2, "name" : "Fluffy", "sex" : "Male" },
            { "id" : 3, "name" : "Wag", "sex" : "Female" }
        ]
    }
}';

SELECT *
FROM OPENJSON(@json, '$.pets')
WITH  (
        [dogs]  nvarchar(max) 'strict $.dogs'
    );

परिणाम:

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