Sqlserver
 sql >> Teknologi Basis Data >  >> RDS >> Sqlserver

Cara Memasukkan JSON ke dalam Tabel di SQL Server

Jika Anda memiliki dokumen JSON yang perlu Anda sisipkan ke dalam tabel di database SQL Server, OPENJSON() fungsi bisa menjadi apa yang Anda butuhkan.

OPENJSON() adalah fungsi bernilai tabel yang mengembalikan JSON dalam format tabel. Artinya, ini mengubah JSON Anda menjadi kumpulan hasil tabel yang terdiri dari baris dan kolom. Oleh karena itu, ini memungkinkan Anda untuk memasukkannya ke dalam tabel.

Contoh 1 – PILIH KE

Dalam contoh ini, kami menggunakan SELECT * INTO untuk membuat tabel baru dan memasukkan konten dokumen JSON ke dalamnya.

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

Saya pertama kali mendeklarasikan variabel dan memasukkan JSON ke dalamnya. Kemudian saya menggunakan SELECT * INTO pernyataan untuk menyisipkan isinya.

Namun, Anda akan melihat bahwa saya menggunakan klausa WITH untuk mendefinisikan skema. Pada dasarnya yang saya lakukan di sini adalah membuat nama kolom saya sendiri dan tipe datanya masing-masing, lalu memetakan setiap kunci JSON dengan sebuah kolom.

Pada baris terakhir, saya menggunakan AS JSON untuk menentukan bahwa konten kolom tersebut adalah objek atau larik JSON.

Ini akan menjadi jelas ketika saya memilih isi tabel.

Ayo lakukan itu.

SELECT * FROM JsonCats1;

Hasil:

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

Jadi kita bisa melihat bahwa tiga kolom pertama masing-masing berisi nilai yang berbeda dari dokumen JSON, dan kolom terakhir berisi JSON sebenarnya untuk setiap elemen array.

Kita juga dapat menggunakan sys.column tampilan katalog sistem memeriksa nama dan jenis kolom tabel.

SELECT
    name AS [Column],
    TYPE_NAME(system_type_id) AS [Type],
    max_length
FROM sys.columns 
WHERE OBJECT_ID('JsonCats2') = object_id;

Hasil:

+----------+----------+--------------+
| Column   | Type     | max_length   |
|----------+----------+--------------|
| Cat Id   | int      | 4            |
| Cat Name | varchar  | 60           |
| Sex      | varchar  | 6            |
| Cats     | nvarchar | -1           |
+----------+----------+--------------+

Sekali lagi, persis seperti yang kami tentukan.

Perhatikan bahwa sys.columns selalu mengembalikan max_length dari -1 ketika tipe data kolom adalah varchar(max) , nvarchar(maks) , varbinary(maks) , atau xml . Kami menentukan nvarchar(max) jadi nilai -1 persis seperti yang diharapkan.

Perhatikan juga bahwa, ketika Anda menggunakan AS JSON (seperti yang kita lakukan pada kolom keempat), Anda harus membuat kolom itu menjadi nvarchar(max) .

Contoh 2 – INSERT INTO

Ini contoh yang sama, kecuali kali ini kita memasukkan JSON ke tabel yang sudah ada.

Oleh karena itu, hal pertama yang perlu kita lakukan adalah membuat tabel:

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

Sekarang setelah kita membuatnya, kita dapat melanjutkan dan memasukkan konten dokumen JSON kita ke dalam tabel itu.

Seperti ini:

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

Satu-satunya perbedaan antara ini dan contoh sebelumnya adalah saya mengganti bit berikut:

SELECT * INTO JsonCats1

Dengan ini:

INSERT INTO JsonCats2
SELECT *

Jadi, memilih isi tabel akan menghasilkan hasil yang sama seperti contoh sebelumnya.

SELECT * FROM JsonCats2;

Hasil:

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

Contoh 3 – Menggunakan Skema Default

Dalam contoh sebelumnya saya mendefinisikan skema saya sendiri. Artinya, saya menentukan nama kolom untuk tabel, dan saya menentukan tipe data sebenarnya dari kolom tersebut.

Jika saya tidak melakukannya, OPENJSON() akan menggunakan skema default. Skema default terdiri dari tiga kolom; kunci , nilai , dan ketik .

Berikut adalah contoh penggunaan skema default saat memasukkan JSON ke dalam tabel.

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

Jadi satu-satunya perbedaan antara ini dan contoh pertama, adalah saya menghapus seluruh WITH ayat. Itulah bagian yang mendefinisikan skema dalam dua contoh sebelumnya.

Sekarang mari kita periksa isi tabelnya.

SELECT * FROM JsonCats3;

Hasil:

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

Tabel ini berisi tiga kolom seperti yang disebutkan. Kolom nilai berisi setiap elemen larik.

Contoh 4 – Gunakan Kunci JSON sebagai Header Kolom

Contoh ini sedikit persilangan antara dua contoh sebelumnya.

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

Kami masih mendefinisikan skema kami sendiri, karena kami menggunakan WITH ayat. Tetapi Anda akan melihat bahwa saya tidak memetakan nama kolom ke jalur JSON mana pun. Ini karena saya menggunakan nama sebenarnya dari kunci JSON.

Saat Anda melakukannya, OPENJSON() cukup pintar untuk mencocokkan nama kolom Anda dengan kunci JSON.

Mari kita lihat apa yang ada di tabel.

SELECT * FROM JsonCats4;

Hasil:

+------+-----------+--------+
| id   | name      | sex    |
|------+-----------+--------|
| 1    | Fluffy    | Female |
| 2    | Long Tail | Female |
| 3    | Scratch   | Male   |
+------+-----------+--------+

Jadi data telah dimasukkan ke dalam tabel, seperti pada dua contoh pertama, tetapi kali ini nama kolom diambil dari dokumen JSON.

Contoh 5 – Tentukan Lebih Sedikit Kolom

Anda tidak perlu menyertakan semua nilai dari dokumen JSON jika Anda tidak membutuhkan semuanya. Anda dapat menentukan hanya yang Anda butuhkan.

Anda dapat melakukannya dengan menentukan kolom di SELECT daftar.

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;

Hasil:

+------+-----------+
| id   | name      |
|------+-----------|
| 1    | Fluffy    |
| 2    | Long Tail |
| 3    | Scratch   |
+------+-----------+

Cara lain untuk melakukannya adalah dengan menghapus kolom yang relevan dari WITH klausa.

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;

Hasil:

+------+-----------+
| id   | name      |
|------+-----------|
| 1    | Fluffy    |
| 2    | Long Tail |
| 3    | Scratch   |
+------+-----------+

Meskipun, mungkin lebih baik melakukan keduanya.

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;

Hasil:

+------+-----------+
| id   | name      |
|------+-----------|
| 1    | Fluffy    |
| 2    | Long Tail |
| 3    | Scratch   |
+------+-----------+

Contoh 6 – Tentukan Lebih Sedikit Baris

Anda juga dapat menggunakan sintaks T-SQL normal untuk memfilter baris, sehingga hanya beberapa catatan yang dimasukkan ke dalam tabel. 

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;

Hasil:

+------+-----------+
| id   | name      |
|------+-----------|
| 1    | Fluffy    |
| 2    | Long Tail |
+------+-----------+

Dalam hal ini saya menggunakan WHERE klausa untuk menyisipkan hanya baris yang saya minati.

Impor JSON dari File

Anda dapat menggunakan OPENJSON() dalam hubungannya dengan OPENROWSET() berfungsi untuk mengimpor file JSON ke dalam tabel.

Ini memungkinkan Anda untuk mengunggah data dari file JSON di drive lokal atau drive jaringan. Ini menyelamatkan Anda dari keharusan menyalin dan menempelkan konten dokumen ke dalam kode SQL Anda. Ini bisa sangat bermanfaat saat bekerja dengan dokumen JSON berukuran besar.


  1. Database
    2.   
  2. Mysql
    3.   
  3. Oracle
    4.   
  4. Sqlserver
    5.   
  5. PostgreSQL
    6.   
  6. Access
    7.   
  7. SQLite
    8.   
  8. MariaDB

  1. Bagaimana cara menentukan literal tanggal saat menulis kueri SQL dari SQL Server yang ditautkan ke Oracle?

  2. Cara Menghapus Spasi Leading dan Trailing di SQL Server – TRIM()

  3. Beberapa pernyataan INSERT vs. INSERT tunggal dengan beberapa NILAI

  4. Cara Mengembalikan Stempel Waktu Unix di SQL Server (T-SQL)

  5. SQL - Bagaimana cara menyimpan dan menavigasi hierarki?