Cara Mengimpor File JSON ke Tabel SQL Server

Jika Anda memiliki dokumen JSON, ada beberapa cara untuk memasukkannya ke SQL Server.

Jika itu adalah dokumen kecil, Anda dapat menyalin dan menempelkan isinya. Jika itu adalah dokumen yang lebih besar (atau bahkan yang kecil), Anda mungkin ingin mengimpor seluruh file.

Artikel ini menyajikan contoh mengimpor file JSON ke database SQL Server.

Memilih Isi File JSON

T-SQL menyertakan OPENROWSET() fungsi, yang dapat membaca data dari file apa pun di drive atau jaringan lokal, dan mengembalikannya sebagai kumpulan baris. Untuk melakukannya, jalankan fungsi ini dengan BULK pilihan.

Meskipun artikel ini ditulis khusus untuk mengimpor file JSON ke dalam tabel, Anda juga dapat menggunakan OPENROWSET() untuk membaca dari file data tanpa harus memuatnya ke dalam tabel.

Ini memungkinkan Anda untuk memeriksa data terlebih dahulu, sebelum memuatnya ke dalam tabel.

Berikut ini contoh pemilihan konten file JSON.

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

Hasil:

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

Dalam hal ini, sistem filenya adalah Linux, sehingga konvensi jalur Linux digunakan saat menentukan file mana yang akan diunggah.

Jika Anda menggunakan Windows, jalur file Anda mungkin terlihat seperti ini:

SELECT BulkColumn FROM OPENROWSET (
    BULK 'D:\data\pets.json', 
    SINGLE_CLOB
    ) AS [Json];

Oya, kita bisa melihat isi dari file JSON diatas. Sekarang mari kita muat ke dalam tabel.

Muat ke dalam Tabel

Kita dapat mengubah pernyataan sebelumnya, sehingga isi file diimpor langsung ke dalam tabel.

-- 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;

Hasil:

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

Melakukannya akan membuat tabel dan menyisipkan JSON.

Perhatikan bahwa saat menggunakan OPENROWSET() dengan BULK pilihan, Anda juga harus memberikan nama korelasi (juga dikenal sebagai variabel rentang atau alias) di FROM ayat.

Jika Anda tidak memberikan nama korelasi, Anda akan mendapatkan kesalahan.

Dalam contoh saya, saya menggunakan Json sebagai nama korelasi, tetapi silakan pilih sendiri.

Parsing JSON menjadi Baris dan Kolom

Di sinilah hal-hal menjadi menarik. Kami tidak hanya dapat mengunggah konten file dan mengimpornya ke dalam kolom tabel, kami juga dapat memisahkan kontennya di beberapa baris dan kolom.

OPENJSON() adalah fungsi bernilai tabel yang mengubah dokumen JSON menjadi format tabel.

Oleh karena itu, kita dapat menggunakan OPENJSON() untuk mengonversi konten file JSON kami ke dalam format tabel, dan menyisipkannya ke dalam tabel, atau beberapa tabel jika itu tujuannya.

Tetapi sekali lagi, kita dapat memeriksa data kita sebelum memasukkannya ke dalam tabel apa pun.

-- 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]

Hasil:

+---------+-----------+--------+
| 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)

Seperti inilah tampilannya setelah dimasukkan ke dalam dua tabel.

Untuk memasukkannya ke dalam tabel, yang perlu kita lakukan adalah menambahkan INTO TableName antara SELECT bagian dan FROM (di mana TableName adalah nama tabel yang ingin kita buat).

-- 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

Hasil:

+---------+-----------+--------+
| 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)

Tabel ini dibuat menggunakan definisi kolom yang kami sediakan di WITH klausa.

Setiap kunci JSON dipetakan ke nama kolom yang kita pilih.

Anda juga dapat mendasarkan nama kolom Anda dari nama kunci dalam file JSON. Jika Anda melakukannya, Anda tidak perlu memetakannya dengan jalur, karena OPENJSON() akan secara otomatis mencocokkannya dengan nama kunci JSON.

Misalnya, alih-alih menggunakan klausa WITH berikut:

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

Anda dapat menggunakan ini:

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

Muat JSON ke dalam Variabel

Cara lain untuk melakukannya adalah dengan memuat JSON yang diunggah ke dalam variabel, lalu meneruskan variabel itu ke OPENJSON() fungsi.

-- 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'  
    );

Hasil:

+---------+-----------+--------+
| 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)

Sekali lagi, untuk memasukkan ini ke dalam tabel, kita akan menambahkan INTO TableName setelah SELECT bagian (di mana TableName adalah nama tabel yang ingin Anda buat).

Muat Seluruh Sub-Objek ke dalam Kolom

Jika Anda ingin seluruh sub-objek berada di kolomnya sendiri, Anda dapat menggunakan AS JSON opsi WITH klausa.

Misalnya, alih-alih masing-masing kucing dan anjing didistribusikan di tiga kolom, seluruh fragmen JSON mereka dapat mengambil satu kolom. Setiap hewan akan tetap memiliki barisannya sendiri.

Ini contoh yang saya maksud.

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]

Hasil:

+------------------------------------------------------+
| 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)