SQL सर्वर तालिका में JSON फ़ाइल कैसे आयात करें

यदि आपके पास JSON दस्तावेज़ है, तो इसे SQL सर्वर में लाने के कई तरीके हैं।

यदि यह एक छोटा दस्तावेज़ है, तो आप इसकी सामग्री को कॉपी और पेस्ट कर सकते हैं। यदि यह एक बड़ा दस्तावेज़ है (या एक छोटा भी है), तो आप पूरी फ़ाइल को आयात करना चाह सकते हैं।

यह आलेख एक JSON फ़ाइल को SQL सर्वर डेटाबेस में आयात करने का एक उदाहरण प्रस्तुत करता है।

JSON फ़ाइल की सामग्री का चयन करना

T-SQL में OPENROWSET() . शामिल है फ़ंक्शन, जो स्थानीय ड्राइव या नेटवर्क पर किसी भी फ़ाइल से डेटा पढ़ सकता है, और इसे एक पंक्ति सेट के रूप में वापस कर सकता है। ऐसा करने के लिए, इस फ़ंक्शन को BULK . के साथ निष्पादित करें विकल्प।

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

इससे आप डेटा को तालिका में लोड करने से पहले पहले उसकी जांच कर सकते हैं।

यहां JSON फ़ाइल की सामग्री चुनने का एक उदाहरण दिया गया है।

SELECT BulkColumn FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB
    ) AS [Json];

परिणाम:

+--------------+
| BulkColumn   |
|--------------|
| { 
    "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 BulkColumn FROM OPENROWSET (
    BULK 'D:\data\pets.json', 
    SINGLE_CLOB
    ) AS [Json];

वैसे भी, हम ऊपर JSON फ़ाइल की सामग्री देख सकते हैं। आइए अब इसे एक टेबल में लोड करें।

इसे तालिका में लोड करें

हम पिछले कथन को संशोधित कर सकते हैं, ताकि फ़ाइल की सामग्री सीधे एक तालिका में आयात की जा सके।

-- Import it directly into the table
SELECT BulkColumn INTO ImportedJson FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB
    ) AS [Json];

-- Select the contents of the table
SELECT * FROM ImportedJson;

परिणाम:

+--------------+
| BulkColumn   |
|--------------|
| { 
    "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" }
        ]
    }
}              |
+--------------+

ऐसा करने से तालिका बनती है और JSON सम्मिलित होता है।

ध्यान दें कि OPENROWSET() . का उपयोग करते समय BULK . के साथ विकल्प, आपको FROM में एक सहसंबंध नाम (जिसे श्रेणी चर या उपनाम के रूप में भी जाना जाता है) प्रदान करना होगा खंड।

यदि आप एक सहसंबंध नाम प्रदान नहीं करते हैं, तो आपको एक त्रुटि मिलेगी।

मेरे उदाहरण में, मैंने Json . का उपयोग किया है सहसंबंध नाम के रूप में, लेकिन बेझिझक अपना नाम चुनें।

JSON को पंक्तियों और स्तंभों में पार्स करें

यहीं से चीजें रोमांचक हो जाती हैं। हम न केवल किसी फ़ाइल की सामग्री को अपलोड कर सकते हैं और उसे एक तालिका कॉलम में आयात कर सकते हैं, हम उसकी सामग्री को कई पंक्तियों और स्तंभों में अलग भी कर सकते हैं।

OPENJSON() एक तालिका-मूल्यवान फ़ंक्शन है जो JSON दस्तावेज़ों को एक सारणीबद्ध प्रारूप में परिवर्तित करता है।

इसलिए, हम OPENJSON() . का उपयोग कर सकते हैं हमारी JSON फ़ाइल की सामग्री को सारणीबद्ध प्रारूप में बदलने के लिए, और यदि लक्ष्य है तो उसे एक तालिका, या एकाधिक तालिकाओं में सम्मिलित करें।

लेकिन फिर से, हम अपने डेटा को किसी भी टेबल में डालने से पहले उसकी जांच कर सकते हैं।

-- Select the cats
SELECT Cats.* FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB) AS [Json]
    CROSS APPLY OPENJSON ( BulkColumn, '$.pets.cats' )
    WITH  (
            CatId     int             '$.id',  
            CatName   varchar(60)     '$.name', 
            Sex       varchar(6)      '$.sex'  
        ) AS [Cats]

-- Select the dogs
SELECT Dogs.* FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB) AS [Json]    
    CROSS APPLY OPENJSON ( BulkColumn, '$.pets.dogs' )
    WITH  (
            DogId     int             '$.id',  
            DogName   varchar(60)     '$.name', 
            Sex       varchar(6)      '$.sex'  
        ) AS [Dogs]

परिणाम:

+---------+-----------+--------+
| CatId   | CatName   | Sex    |
|---------+-----------+--------|
| 1       | Fluffy    | Female |
| 2       | Long Tail | Female |
| 3       | Scratch   | Male   |
+---------+-----------+--------+
(3 rows affected)
+---------+-----------+--------+
| DogId   | DogName   | Sex    |
|---------+-----------+--------|
| 1       | Fetch     | Male   |
| 2       | Fluffy    | Male   |
| 3       | Wag       | Female |
+---------+-----------+--------+
(3 rows affected)

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

इसे टेबल में डालने के लिए, हमें केवल INTO TableName . जोड़ना होगा SELECT . के बीच भाग और FROM (जहां TableName उस तालिका का नाम है जिसे हम बनाना चाहते हैं)।

-- Insert cats into a table
SELECT Cats.* INTO ImportedCats
FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB) AS [Json]
    CROSS APPLY OPENJSON ( BulkColumn, '$.pets.cats' )
    WITH  (
            CatId     int             '$.id',  
            CatName   varchar(60)     '$.name', 
            Sex       varchar(6)      '$.sex'  
        ) AS [Cats]

-- Insert dogs into a table
SELECT Dogs.* INTO ImportedDogs
FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB) AS [Json]    
    CROSS APPLY OPENJSON ( BulkColumn, '$.pets.dogs' )
    WITH  (
            DogId     int             '$.id',  
            DogName   varchar(60)     '$.name', 
            Sex       varchar(6)      '$.sex'  
        ) AS [Dogs]

-- Select the results from both tables
SELECT * FROM ImportedCats
SELECT * FROM ImportedDogs

परिणाम:

+---------+-----------+--------+
| CatId   | CatName   | Sex    |
|---------+-----------+--------|
| 1       | Fluffy    | Female |
| 2       | Long Tail | Female |
| 3       | Scratch   | Male   |
+---------+-----------+--------+
(3 rows affected)
+---------+-----------+--------+
| DogId   | DogName   | Sex    |
|---------+-----------+--------|
| 1       | Fetch     | Male   |
| 2       | Fluffy    | Male   |
| 3       | Wag       | Female |
+---------+-----------+--------+
(3 rows affected)

इन तालिकाओं को हमारे द्वारा WITH . में प्रदान की गई कॉलम परिभाषाओं का उपयोग करके बनाया गया था खंड।

प्रत्येक JSON कुंजी को हमारी पसंद के कॉलम नाम से मैप किया जाता है।

आप JSON फ़ाइल में प्रमुख नामों से अपने कॉलम नामों को भी आधार बना सकते हैं। यदि आप ऐसा करते हैं, तो आपको उन्हें OPENJSON() के रूप में पथ के साथ मैप करने की आवश्यकता नहीं है JSON कुंजी नामों के साथ स्वचालित रूप से उनका मिलान करेगा।

उदाहरण के लिए, क्लॉज के साथ निम्नलिखित का उपयोग करने के बजाय:

WITH  (
            DogId     int             '$.id',  
            DogName   varchar(60)     '$.name', 
            Sex       varchar(6)      '$.sex'  
        ) AS [Dogs]

आप इसका इस्तेमाल कर सकते हैं:

WITH  (
        id     int,  
        name   varchar(60), 
        sex    varchar(6)  
    ) AS [Dogs]

JSON को वेरिएबल में लोड करें

इसे करने का दूसरा तरीका यह होगा कि अपलोड किए गए JSON को एक वेरिएबल में लोड किया जाए, फिर उस वेरिएबल को OPENJSON() में पास किया जाए। समारोह।

-- Declare variable
DECLARE @json nvarchar(max);

-- Upload JSON data into that variable
SELECT @json = BulkColumn FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB
    ) AS [Json];

-- Select the cats from that variable
SELECT * FROM OPENJSON(@json, '$.pets.cats')
WITH  (
        CatId     int             '$.id',  
        CatName   varchar(60)     '$.name', 
        Sex       varchar(6)      '$.sex'   
    );

-- Select the dogs from that variable
SELECT * FROM OPENJSON(@json, '$.pets.dogs')
WITH  (
        DogId     int             '$.id',  
        DogName   varchar(60)     '$.name', 
        Sex       varchar(6)      '$.sex'  
    );

परिणाम:

+---------+-----------+--------+
| CatId   | CatName   | Sex    |
|---------+-----------+--------|
| 1       | Fluffy    | Female |
| 2       | Long Tail | Female |
| 3       | Scratch   | Male   |
+---------+-----------+--------+
(3 rows affected)
+---------+-----------+--------+
| DogId   | DogName   | Sex    |
|---------+-----------+--------|
| 1       | Fetch     | Male   |
| 2       | Fluffy    | Male   |
| 3       | Wag       | Female |
+---------+-----------+--------+
(3 rows affected)

दोबारा, इसे एक टेबल में डालने के लिए, हम INTO TableName . जोड़ेंगे SELECT . के बाद भाग (जहां TableName उस तालिका का नाम है जिसे आप बनाना चाहते हैं)।

पूरे उप-ऑब्जेक्ट को कॉलम में लोड करें

यदि आप चाहते हैं कि संपूर्ण उप-वस्तुएं अपने स्वयं के कॉलम में रहें, तो आप AS JSON का उपयोग कर सकते हैं WITH . का विकल्प खंड।

उदाहरण के लिए, प्रत्येक बिल्ली और कुत्ते को तीन स्तंभों में वितरित करने के बजाय, उनका संपूर्ण JSON खंड एक स्तंभ ले सकता है। प्रत्येक जानवर की अभी भी अपनी पंक्ति होगी।

मेरे कहने का एक उदाहरण यहां दिया गया है।

SELECT Cats.* FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB) AS [Json]
    CROSS APPLY OPENJSON ( BulkColumn, '$.pets.cats' )
    WITH  (
            Cats nvarchar(max) '$' AS JSON   
        ) AS [Cats]

SELECT Dogs.* FROM OPENROWSET (
    BULK '/var/opt/mssql/bak/pets.json', 
    SINGLE_CLOB) AS [Json]    
    CROSS APPLY OPENJSON ( BulkColumn, '$.pets.dogs' )
    WITH  (
            Dogs nvarchar(max) '$' AS JSON   
        ) AS [Dogs]

परिणाम:

+------------------------------------------------------+
| Cats                                                 |
|------------------------------------------------------|
| { "id" : 1, "name" : "Fluffy", "sex" : "Female" }    |
| { "id" : 2, "name" : "Long Tail", "sex" : "Female" } |
| { "id" : 3, "name" : "Scratch", "sex" : "Male" }     |
+------------------------------------------------------+
(3 rows affected)
+-------------------------------------------------+
| Dogs                                            |
|-------------------------------------------------|
| { "id" : 1, "name" : "Fetch", "sex" : "Male" }  |
| { "id" : 2, "name" : "Fluffy", "sex" : "Male" } |
| { "id" : 3, "name" : "Wag", "sex" : "Female" }  |
+-------------------------------------------------+
(3 rows affected)