Hoe een JSON-bestand in een SQL Server-tabel te importeren

Als u een JSON-document hebt, zijn er verschillende manieren om het in SQL Server te krijgen.

Als het een klein document is, kunt u de inhoud kopiëren en plakken. Als het een groter document is (of zelfs een klein document), wilt u misschien het hele bestand importeren.

Dit artikel geeft een voorbeeld van het importeren van een JSON-bestand in een SQL Server-database.

De inhoud van het JSON-bestand selecteren

T-SQL bevat de OPENROWSET() functie, die gegevens van elk bestand op de lokale schijf of het netwerk kan lezen en deze als een rijset kan retourneren. Om dat te doen, voert u deze functie uit met de BULK optie.

Hoewel dit artikel speciaal is geschreven voor het importeren van het JSON-bestand in een tabel, kunt u ook OPENROWSET() gebruiken om uit een gegevensbestand te lezen zonder het noodzakelijkerwijs in een tabel te laden.

Hierdoor kunt u eerst de gegevens controleren voordat u deze in de tabel laadt.

Hier is een voorbeeld van het selecteren van de inhoud van een JSON-bestand.

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

Resultaat:

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

In dit geval is het bestandssysteem Linux, en dus worden de Linux-padconventies gebruikt bij het specificeren welk bestand moet worden geüpload.

Als u Windows gebruikt, kan uw bestandspad er meer zo uitzien:

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

Hoe dan ook, we kunnen de inhoud van het JSON-bestand hierboven zien. Laten we het nu in een tabel laden.

Laad het in een tabel

We kunnen de vorige verklaring wijzigen, zodat de inhoud van het bestand rechtstreeks in een tabel wordt geïmporteerd.

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

Resultaat:

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

Als u dat doet, wordt de tabel gemaakt en wordt de JSON ingevoegd.

Merk op dat bij gebruik van OPENROWSET() met de BULK optie, moet u ook een correlatienaam (ook bekend als een bereikvariabele of alias) opgeven in de FROM clausule.

Als u geen correlatienaam opgeeft, krijgt u een foutmelding.

In mijn voorbeeld gebruikte ik Json als de correlatienaam, maar kies gerust uw eigen naam.

De JSON ontleden in rijen en kolommen

Dit is waar dingen spannend worden. We kunnen niet alleen de inhoud van een bestand uploaden en importeren in een tabelkolom, we kunnen de inhoud ook scheiden over meerdere rijen en kolommen.

OPENJSON() is een functie met tabelwaarde die JSON-documenten omzet in een tabelformaat.

Daarom kunnen we OPENJSON() . gebruiken om de inhoud van ons JSON-bestand om te zetten in tabelformaat en dat in een tabel in te voegen, of meerdere tabellen als dat het doel is.

Maar nogmaals, we kunnen onze gegevens controleren voordat ze in tabellen worden ingevoegd.

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

Resultaat:

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

Dit is precies hoe het eruit zal zien als het eenmaal in twee tabellen is ingevoegd.

Om het in de tabellen in te voegen, hoeven we alleen maar INTO TableName toe te voegen tussen de SELECT deel en FROM (waar TableName is de naam van de tabel die we willen maken).

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

Resultaat:

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

Deze tabellen zijn gemaakt met behulp van de kolomdefinities die we hebben geleverd in de WITH clausule.

Elke JSON-sleutel is toegewezen aan een kolomnaam naar keuze.

U kunt uw kolomnamen ook baseren op de sleutelnamen in het JSON-bestand. Als je dat doet, hoef je ze niet toe te wijzen met een pad, zoals OPENJSON() zal ze automatisch matchen met de JSON-sleutelnamen.

Bijvoorbeeld, in plaats van de volgende WITH-component te gebruiken:

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

Je zou dit kunnen gebruiken:

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

Laad de JSON in een variabele

Een andere manier om dit te doen, is door de geüploade JSON in een variabele te laden en die variabele vervolgens door te geven aan de OPENJSON() functie.

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

Resultaat:

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

Nogmaals, om dit in een tabel in te voegen, zouden we INTO TableName . toevoegen na de SELECT deel (waar TableName is de naam van de tabel die u wilt maken).

Een heel subobject in een kolom laden

Als u wilt dat hele subobjecten in hun eigen kolom staan, kunt u de AS JSON gebruiken optie van de WITH clausule.

In plaats van bijvoorbeeld elke kat en hond over drie kolommen te verdelen, zou hun hele JSON-fragment één kolom kunnen beslaan. Elk dier heeft nog steeds zijn eigen rij.

Hier is een voorbeeld van wat ik bedoel.

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]

Resultaat:

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