यदि आपके पास एक JSON दस्तावेज़ है जिसे आपको SQL सर्वर डेटाबेस में किसी तालिका में सम्मिलित करने की आवश्यकता है, तो OPENJSON() फ़ंक्शन वही हो सकता है जिसकी आपको आवश्यकता है।
OPENJSON() एक तालिका-मूल्यवान फ़ंक्शन है जो JSON को सारणीबद्ध प्रारूप में लौटाता है। यही है, यह आपके JSON को पंक्तियों और स्तंभों से युक्त एक सारणीबद्ध परिणाम सेट में परिवर्तित करता है। इसलिए, यह आपको इसे एक तालिका में सम्मिलित करने में सक्षम बनाता है।
उदाहरण 1 - इसमें चुनें
इस उदाहरण में, हम SELECT * INTO . का उपयोग करते हैं एक नई तालिका बनाने और उसमें 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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT * INTO JsonCats1
FROM OPENJSON(@json, '$.pets.cats')
WITH (
CatId int '$.id',
CatName varchar(60) '$.name',
Sex varchar(6) '$.sex',
Cats nvarchar(max) '$' AS JSON
);
मैंने पहले एक वैरिएबल घोषित किया और उसमें JSON डाल दिया। फिर मैंने एक SELECT * INTO . का इस्तेमाल किया इसकी सामग्री डालने के लिए बयान।
हालाँकि, आप देखेंगे कि मैंने स्कीमा को परिभाषित करने के लिए WITH क्लॉज का उपयोग किया है। मूल रूप से मैं यहां जो कर रहा हूं वह मेरे अपने कॉलम नाम और उनके संबंधित डेटा प्रकार बना रहा है, फिर प्रत्येक JSON कुंजी को कॉलम के साथ मैप कर रहा है।
अंतिम पंक्ति में, मैं AS JSON का उपयोग करता हूं यह निर्दिष्ट करने के लिए कि उस कॉलम की सामग्री एक JSON ऑब्जेक्ट या सरणी है।
यह तब स्पष्ट हो जाएगा जब मैं तालिका की सामग्री का चयन करूंगा।
चलो ऐसा करते हैं।
SELECT * FROM JsonCats1;परिणाम:
+---------+-----------+--------+------------------------------------------------------+
| CatId | CatName | Sex | Cats |
|---------+-----------+--------+------------------------------------------------------|
| 1 | Fluffy | Female | { "id" : 1, "name" : "Fluffy", "sex" : "Female" } |
| 2 | Long Tail | Female | { "id" : 2, "name" : "Long Tail", "sex" : "Female" } |
| 3 | Scratch | Male | { "id" : 3, "name" : "Scratch", "sex" : "Male" } |
+---------+-----------+--------+------------------------------------------------------+ तो हम देख सकते हैं कि पहले तीन कॉलम में प्रत्येक में JSON दस्तावेज़ से एक अलग मान होता है, और अंतिम कॉलम में प्रत्येक सरणी तत्व के लिए वास्तविक JSON होता है।
हम sys.column . का भी उपयोग कर सकते हैं सिस्टम कैटलॉग व्यू तालिका के कॉलम नामों और प्रकारों की जांच करता है।
SELECT
name AS [Column],
TYPE_NAME(system_type_id) AS [Type],
max_length
FROM sys.columns
WHERE OBJECT_ID('JsonCats2') = object_id;परिणाम:
+----------+----------+--------------+ | Column | Type | max_length | |----------+----------+--------------| | Cat Id | int | 4 | | Cat Name | varchar | 60 | | Sex | varchar | 6 | | Cats | nvarchar | -1 | +----------+----------+--------------+
फिर से, हमने इसे कैसे निर्दिष्ट किया है।
ध्यान दें कि sys.columns हमेशा एक max_length देता है का -1 जब कॉलम डेटा प्रकार varchar(max) . हो , nvarchar(अधिकतम) , varbinary(अधिकतम) , या xml . हमने nvarchar(max) . निर्दिष्ट किया है और इसलिए -1 . का मान बिल्कुल अपेक्षित है।
यह भी ध्यान दें कि, जब आप AS JSON . का उपयोग करते हैं (जैसा कि हमने चौथे कॉलम में किया था), आपको उस कॉलम को एक nvarchar(max) . बनाना होगा ।
उदाहरण 2 - इसमें डालें
यहाँ वही उदाहरण है, इस समय को छोड़कर हम पहले से मौजूद तालिका में JSON सम्मिलित करते हैं।
इसलिए, पहली चीज़ जो हमें करने की ज़रूरत है वह है तालिका बनाना:
CREATE TABLE [dbo].[JsonCats2](
[CatId] [int] NULL,
[CatName] [varchar](60) NULL,
[Sex] [varchar](6) NULL,
[Cats] [nvarchar](max) NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GOअब जब हमने इसे बना लिया है, तो हम आगे बढ़ सकते हैं और अपने 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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
INSERT INTO JsonCats2
SELECT *
FROM OPENJSON(@json, '$.pets.cats')
WITH (
CatId int '$.id',
CatName varchar(60) '$.name',
Sex varchar(6) '$.sex',
Cats nvarchar(max) '$' AS JSON
);इस और पिछले उदाहरण के बीच एकमात्र अंतर यह है कि मैंने निम्नलिखित बिट को बदल दिया है:
SELECT * INTO JsonCats1इसके साथ:
INSERT INTO JsonCats2
SELECT * इसलिए, तालिका की सामग्री का चयन पिछले उदाहरण के समान परिणाम देगा।
SELECT * FROM JsonCats2;परिणाम:
+---------+-----------+--------+------------------------------------------------------+
| CatId | CatName | Sex | Cats |
|---------+-----------+--------+------------------------------------------------------|
| 1 | Fluffy | Female | { "id" : 1, "name" : "Fluffy", "sex" : "Female" } |
| 2 | Long Tail | Female | { "id" : 2, "name" : "Long Tail", "sex" : "Female" } |
| 3 | Scratch | Male | { "id" : 3, "name" : "Scratch", "sex" : "Male" } |
+---------+-----------+--------+------------------------------------------------------+ उदाहरण 3 - डिफ़ॉल्ट स्कीमा का उपयोग करना
पिछले उदाहरणों में मैंने अपनी खुद की स्कीमा परिभाषित की थी। अर्थात्, मैंने तालिकाओं के लिए स्तंभों के नाम निर्दिष्ट किए हैं, और मैंने उन स्तंभों के वास्तविक डेटा प्रकार निर्दिष्ट किए हैं।
अगर मैंने ऐसा नहीं किया होता, तो OPENJSON() डिफ़ॉल्ट स्कीमा का उपयोग किया होगा। डिफ़ॉल्ट स्कीमा में तीन कॉलम होते हैं; कुंजी , मान , और टाइप करें ।
तालिका में 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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT * INTO JsonCats3
FROM OPENJSON(@json, '$.pets.cats');
तो इस और पहले उदाहरण के बीच एकमात्र अंतर यह है कि मैंने पूरा WITH हटा दिया है खंड। यही वह बिट है जिसने पिछले दो उदाहरणों में स्कीमा को परिभाषित किया है।
आइए अब तालिका की सामग्री की जाँच करें।
SELECT * FROM JsonCats3;परिणाम:
+-------+------------------------------------------------------+--------+
| key | value | type |
|-------+------------------------------------------------------+--------|
| 0 | { "id" : 1, "name" : "Fluffy", "sex" : "Female" } | 5 |
| 1 | { "id" : 2, "name" : "Long Tail", "sex" : "Female" } | 5 |
| 2 | { "id" : 3, "name" : "Scratch", "sex" : "Male" } | 5 |
+-------+------------------------------------------------------+--------+ इस तालिका में उल्लिखित तीन कॉलम हैं। मान कॉलम में प्रत्येक सरणी तत्व होता है।
उदाहरण 4 - 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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT * INTO JsonCats4
FROM OPENJSON(@json, '$.pets.cats')
WITH (
id int,
name varchar(60),
sex varchar(6)
);
हम अभी भी अपने स्वयं के स्कीमा को परिभाषित कर रहे हैं, क्योंकि हम WITH . का उपयोग कर रहे हैं खंड। लेकिन आप देखेंगे कि मैं कॉलम नामों को किसी JSON पथ पर मैप नहीं कर रहा हूं। ऐसा इसलिए है क्योंकि मैं JSON कुंजियों के वास्तविक नामों का उपयोग कर रहा हूं।
जब आप ऐसा करते हैं, OPENJSON() आपके कॉलम नामों को JSON कुंजियों से मिलाने के लिए पर्याप्त स्मार्ट है।
आइए देखें कि तालिका में क्या है।
SELECT * FROM JsonCats4;परिणाम:
+------+-----------+--------+ | id | name | sex | |------+-----------+--------| | 1 | Fluffy | Female | | 2 | Long Tail | Female | | 3 | Scratch | Male | +------+-----------+--------+
इसलिए डेटा को पहले दो उदाहरणों की तरह ही तालिका में डाला गया है, लेकिन इस बार कॉलम के नाम JSON दस्तावेज़ से लिए गए हैं।
उदाहरण 5 - कम कॉलम निर्दिष्ट करें
यदि आपको उन सभी की आवश्यकता नहीं है, तो आपको JSON दस्तावेज़ से सभी मान शामिल करने की आवश्यकता नहीं है। आप केवल वही निर्दिष्ट कर सकते हैं जिनकी आपको आवश्यकता है।
आप SELECT . में कॉलम निर्दिष्ट करके ऐसा कर सकते हैं सूची।
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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT
id,
name
INTO JsonCats5a
FROM OPENJSON(@json, '$.pets.cats')
WITH (
id int,
name varchar(60),
sex varchar(6)
);
SELECT * FROM JsonCats5a;परिणाम:
+------+-----------+ | id | name | |------+-----------| | 1 | Fluffy | | 2 | Long Tail | | 3 | Scratch | +------+-----------+
इसे करने का एक अन्य तरीका प्रासंगिक कॉलम को 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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT * INTO JsonCats5b
FROM OPENJSON(@json, '$.pets.cats')
WITH (
id int,
name varchar(60)
);
SELECT * FROM JsonCats5b;परिणाम:
+------+-----------+ | id | name | |------+-----------| | 1 | Fluffy | | 2 | Long Tail | | 3 | Scratch | +------+-----------+
हालांकि, दोनों करना शायद बेहतर है।
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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT
id,
name
INTO JsonCats5c
FROM OPENJSON(@json, '$.pets.cats')
WITH (
id int,
name varchar(60)
);
SELECT * FROM JsonCats5c;परिणाम:
+------+-----------+ | id | name | |------+-----------| | 1 | Fluffy | | 2 | Long Tail | | 3 | Scratch | +------+-----------+
उदाहरण 6 - कम पंक्तियाँ निर्दिष्ट करें
आप पंक्तियों को फ़िल्टर करने के लिए सामान्य T-SQL सिंटैक्स का भी उपयोग कर सकते हैं, ताकि तालिका में केवल कुछ रिकॉर्ड डाले जा सकें।
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" : [
{ "name" : "Fetch", "sex" : "Male" },
{ "name" : "Fluffy", "sex" : "Male" },
{ "name" : "Wag", "sex" : "Female" }
]
}
}';
SELECT
id,
name
INTO JsonCats6
FROM OPENJSON(@json, '$.pets.cats')
WITH (
id int,
name varchar(60)
)
WHERE id IN (1,2);
SELECT * FROM JsonCats6;परिणाम:
+------+-----------+ | id | name | |------+-----------| | 1 | Fluffy | | 2 | Long Tail | +------+-----------+
इस मामले में मैंने WHERE . का उपयोग किया है केवल उन पंक्तियों को सम्मिलित करने के लिए क्लॉज जिनमें मेरी रुचि है।
एक फ़ाइल से JSON आयात करें
आप OPENJSON() . का उपयोग कर सकते हैं OPENROWSET() . के संयोजन में तालिका में JSON फ़ाइल आयात करने के लिए कार्य करता है।
यह आपको स्थानीय ड्राइव या नेटवर्क ड्राइव पर JSON फ़ाइल से डेटा अपलोड करने में सक्षम बनाता है। यह आपको दस्तावेज़ की सामग्री को अपने SQL कोड में कॉपी और पेस्ट करने से बचाता है। बड़े JSON दस्तावेज़ों के साथ काम करते समय यह विशेष रूप से फायदेमंद हो सकता है।
