Cách nhập tệp JSON vào bảng SQL Server

Nếu bạn có tài liệu JSON, có một số cách bạn có thể thực hiện để đưa nó vào SQL Server.

Nếu đó là một tài liệu nhỏ, bạn có thể sao chép và dán nội dung của nó. Nếu đó là tài liệu lớn hơn (hoặc thậm chí là tài liệu nhỏ), bạn có thể muốn nhập toàn bộ tệp.

Bài viết này trình bày một ví dụ về cách nhập tệp JSON vào cơ sở dữ liệu SQL Server.

Chọn nội dung của tệp JSON

T-SQL bao gồm OPENROWSET() , có thể đọc dữ liệu từ bất kỳ tệp nào trên ổ đĩa cục bộ hoặc mạng và trả về dưới dạng một tập hợp hàng. Để làm điều đó, hãy thực thi chức năng này với BULK lựa chọn.

Mặc dù bài viết này được viết riêng để nhập tệp JSON vào bảng, bạn cũng có thể sử dụng OPENROWSET() để đọc từ tệp dữ liệu mà không nhất thiết phải tải tệp đó vào bảng.

Điều này cho phép bạn kiểm tra dữ liệu trước, trước khi tải nó vào bảng.

Dưới đây là ví dụ về việc chọn nội dung của tệp JSON.

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

Kết quả:

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

Trong trường hợp này, hệ thống tệp là Linux và do đó, các quy ước về đường dẫn Linux được sử dụng khi chỉ định tệp nào sẽ tải lên.

Nếu bạn đang sử dụng Windows, đường dẫn tệp của bạn có thể trông giống như sau:

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

Dù sao, chúng ta có thể thấy nội dung của tệp JSON ở trên. Bây giờ chúng ta hãy tải nó vào một bảng.

Tải nó vào một bảng

Chúng tôi có thể sửa đổi câu lệnh trước đó để nội dung của tệp được nhập thẳng vào bảng.

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

Kết quả:

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

Làm điều đó sẽ tạo bảng và chèn JSON.

Lưu ý rằng khi sử dụng OPENROWSET() với BULK , bạn cũng phải cung cấp tên tương quan (còn được gọi là biến phạm vi hoặc bí danh) trong FROM mệnh đề.

Nếu bạn không cung cấp tên tương quan, bạn sẽ gặp lỗi.

Trong ví dụ của tôi, tôi đã sử dụng Json như tên tương quan, nhưng hãy tự do chọn của riêng bạn.

Phân tích cú pháp JSON thành Hàng và Cột

Đây là nơi mọi thứ trở nên thú vị. Chúng tôi không chỉ có thể tải lên nội dung của tệp và nhập vào cột trong bảng, chúng tôi còn có thể tách nội dung của tệp trên nhiều hàng và cột.

OPENJSON() là một hàm có giá trị bảng chuyển đổi các tài liệu JSON thành một định dạng bảng.

Do đó, chúng ta có thể sử dụng OPENJSON() để chuyển đổi nội dung của tệp JSON của chúng tôi sang định dạng bảng và chèn nội dung đó vào một bảng hoặc nhiều bảng nếu đó là mục tiêu.

Nhưng một lần nữa, chúng tôi có thể kiểm tra dữ liệu của mình trước khi chèn nó vào bất kỳ bảng nào.

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

Kết quả:

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

Đây chính xác là giao diện của nó khi được chèn vào hai bảng.

Để chèn nó vào các bảng, tất cả những gì chúng ta cần làm là thêm INTO TableName giữa SELECT một phần và FROM (trong đó TableName là tên của bảng mà chúng tôi muốn tạo).

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

Kết quả:

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

Các bảng này được tạo bằng cách sử dụng các định nghĩa cột mà chúng tôi đã cung cấp trong WITH mệnh đề.

Mỗi khóa JSON được ánh xạ tới một tên cột mà chúng tôi chọn.

Bạn cũng có thể đặt tên cột của mình dựa trên tên khóa trong tệp JSON. Nếu bạn làm điều đó, bạn không cần phải ánh xạ chúng với một đường dẫn, dưới dạng OPENJSON() sẽ tự động khớp chúng với các tên khóa JSON.

Ví dụ:thay vì sử dụng mệnh đề WITH sau:

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

Bạn có thể sử dụng cái này:

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

Tải JSON vào một biến

Một cách khác để làm điều đó là tải JSON đã tải lên vào một biến, sau đó chuyển biến đó vào OPENJSON() chức năng.

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

Kết quả:

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

Một lần nữa, để chèn cái này vào bảng, chúng ta sẽ thêm INTO TableName sau SELECT part (trong đó TableName là tên của bảng bạn muốn tạo).

Tải Toàn bộ Đối tượng Con vào một Cột

Nếu bạn muốn toàn bộ các đối tượng con nằm trong cột riêng của chúng, bạn có thể sử dụng AS JSON tùy chọn của WITH mệnh đề.

Ví dụ:thay vì có mỗi con mèo và con chó được phân phối trên ba cột, toàn bộ phân đoạn JSON của chúng có thể chiếm một cột. Mỗi con vẫn sẽ có hàng riêng của chúng.

Đây là một ví dụ về ý tôi muốn nói.

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]

Kết quả:

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