Jak zaimportować plik JSON do tabeli serwera SQL?

Jeśli masz dokument JSON, istnieje kilka sposobów na wprowadzenie go do SQL Server.

Jeśli jest to mały dokument, możesz skopiować i wkleić jego zawartość. Jeśli jest to większy dokument (lub nawet mały), możesz chcieć zaimportować cały plik.

W tym artykule przedstawiono przykład importowania pliku JSON do bazy danych SQL Server.

Wybieranie zawartości pliku JSON

T-SQL zawiera OPENROWSET() funkcja, która może odczytywać dane z dowolnego pliku na dysku lokalnym lub w sieci i zwracać je jako zestaw wierszy. Aby to zrobić, wykonaj tę funkcję za pomocą BULK opcja.

Chociaż ten artykuł został napisany specjalnie w celu importowania pliku JSON do tabeli, możesz również użyć OPENROWSET() czytać z pliku danych bez konieczności ładowania go do tabeli.

Pozwala to najpierw sprawdzić dane przed załadowaniem ich do tabeli.

Oto przykład wyboru zawartości pliku JSON.

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

Wynik:

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

W tym przypadku systemem plików jest Linux, dlatego przy określaniu pliku do przesłania używane są konwencje ścieżek linuksowych.

Jeśli korzystasz z systemu Windows, ścieżka pliku może wyglądać bardziej jak ta:

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

W każdym razie możemy zobaczyć zawartość pliku JSON powyżej. Załadujmy go teraz do tabeli.

Załaduj do tabeli

Możemy zmodyfikować poprzednią instrukcję, aby zawartość pliku była importowana bezpośrednio do tabeli.

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

Wynik:

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

Spowoduje to utworzenie tabeli i wstawienie JSON.

Zwróć uwagę, że podczas korzystania z OPENROWSET() z BULK opcja, musisz również podać nazwę korelacji (znaną również jako zmienna zakresu lub alias) w FROM klauzula.

Jeśli nie podasz nazwy korelacji, pojawi się błąd.

W moim przykładzie użyłem Json jako nazwę korelacji, ale możesz wybrać własną.

Przetwarzaj JSON na wiersze i kolumny

To tutaj robi się ekscytująco. Możemy nie tylko przesłać zawartość pliku i zaimportować go do kolumny tabeli, ale także podzielić jego zawartość na wiele wierszy i kolumn.

OPENJSON() to funkcja zwracająca tabelę, która konwertuje dokumenty JSON na format tabelaryczny.

Dlatego możemy użyć OPENJSON() przekonwertować zawartość naszego pliku JSON na format tabelaryczny i wstawić go do tabeli lub wielu tabel, jeśli taki jest cel.

Ale znowu, możemy sprawdzić nasze dane przed wstawieniem ich do jakichkolwiek tabel.

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

Wynik:

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

Dokładnie tak będzie wyglądać po wstawieniu do dwóch tabel.

Aby wstawić go do tabel, wystarczy dodać INTO TableName między SELECT część i FROM (gdzie TableName to nazwa tabeli, którą chcemy utworzyć).

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

Wynik:

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

Te tabele zostały utworzone przy użyciu definicji kolumn, które podaliśmy w WITH klauzula.

Każdy klucz JSON jest mapowany na wybraną przez nas nazwę kolumny.

Możesz również oprzeć nazwy kolumn na nazwach kluczy w pliku JSON. Jeśli to zrobisz, nie musisz mapować ich ścieżką, jak OPENJSON() automatycznie dopasuje je do nazw kluczy JSON.

Na przykład, zamiast używać następującej klauzuli WITH:

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

Możesz użyć tego:

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

Załaduj JSON do zmiennej

Innym sposobem na zrobienie tego byłoby załadowanie przesłanego JSON do zmiennej, a następnie przekazanie tej zmiennej do OPENJSON() funkcja.

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

Wynik:

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

Ponownie, aby wstawić to do tabeli, dodamy INTO TableName po SELECT część (gdzie TableName to nazwa tabeli, którą chcesz utworzyć).

Załaduj cały podobiekt do kolumny

Jeśli chcesz, aby całe podobiekty znajdowały się we własnej kolumnie, możesz użyć AS JSON opcja WITH klauzula.

Na przykład zamiast umieszczania każdego kota i psa w trzech kolumnach, cały ich fragment JSON może zająć jedną kolumnę. Każde zwierzę nadal będzie miało swój własny rząd.

Oto przykład tego, co mam na myśli.

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]

Wynik:

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