So importieren Sie eine JSON-Datei in eine SQL Server-Tabelle

Wenn Sie ein JSON-Dokument haben, gibt es mehrere Möglichkeiten, wie Sie es in SQL Server übertragen können.

Wenn es sich um ein kleines Dokument handelt, können Sie seinen Inhalt kopieren und einfügen. Wenn es sich um ein größeres Dokument (oder sogar ein kleines) handelt, möchten Sie möglicherweise die gesamte Datei importieren.

Dieser Artikel enthält ein Beispiel für den Import einer JSON-Datei in eine SQL Server-Datenbank.

Auswählen des Inhalts der JSON-Datei

T-SQL enthält das OPENROWSET() Funktion, die Daten aus jeder Datei auf dem lokalen Laufwerk oder Netzwerk lesen und als Rowset zurückgeben kann. Führen Sie dazu diese Funktion mit dem BULK aus Möglichkeit.

Obwohl dieser Artikel speziell für den Import der JSON-Datei in eine Tabelle geschrieben wurde, können Sie auch OPENROWSET() verwenden aus einer Datendatei zu lesen, ohne sie notwendigerweise in eine Tabelle zu laden.

Dadurch können Sie die Daten zuerst prüfen, bevor Sie sie in die Tabelle laden.

Hier ist ein Beispiel für die Auswahl des Inhalts einer JSON-Datei.

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

Ergebnis:

+--------------+| BulkColumn ||----------------------|| { „Haustiere“ :{ „Katzen“ :[ { „ID“ :1, „Name“ :„Fluffy“, „Geschlecht“ :„Weiblich“ }, { „ID“ :2, „Name“ :„Long Tail“ , "Geschlecht" :"Weiblich" }, { "ID":3, "Name" :"Scratch", "Geschlecht" :"Männlich" } ], "Hunde" :[ { "ID" :1, "Name" :„Fetch“, „sex“ :„Male“ }, { „id“ :2, „name“ :„Fluffy“, „sex“ :„Male“ }, { „id“ :3, „name“ :„ Wag", "Geschlecht" :"Weiblich" } ] }} |+--------------+

In diesem Fall ist das Dateisystem Linux, und daher werden die Linux-Pfadkonventionen verwendet, wenn angegeben wird, welche Datei hochgeladen werden soll.

Unter Windows sieht Ihr Dateipfad möglicherweise eher so aus:

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

Wie auch immer, wir können den Inhalt der JSON-Datei oben sehen. Lassen Sie es uns jetzt in eine Tabelle laden.

In eine Tabelle laden

Wir können die vorherige Anweisung ändern, sodass der Inhalt der Datei direkt in eine Tabelle importiert wird.

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

Ergebnis:

+--------------+| BulkColumn ||----------------------|| { „Haustiere“ :{ „Katzen“ :[ { „ID“ :1, „Name“ :„Fluffy“, „Geschlecht“ :„Weiblich“ }, { „ID“ :2, „Name“ :„Long Tail“ , "Geschlecht" :"Weiblich" }, { "ID":3, "Name" :"Scratch", "Geschlecht" :"Männlich" } ], "Hunde" :[ { "ID" :1, "Name" :„Fetch“, „sex“ :„Male“ }, { „id“ :2, „name“ :„Fluffy“, „sex“ :„Male“ }, { „id“ :3, „name“ :„ Wag", "Geschlecht" :"Weiblich" } ] }} |+--------------+

Dadurch wird die Tabelle erstellt und die JSON eingefügt.

Beachten Sie dies bei der Verwendung von OPENROWSET() mit dem BULK müssen Sie auch einen Korrelationsnamen (auch bekannt als Bereichsvariable oder Alias) in FROM angeben Klausel.

Wenn Sie keinen Korrelationsnamen angeben, erhalten Sie eine Fehlermeldung.

In meinem Beispiel habe ich Json verwendet als Korrelationsnamen, aber Sie können gerne Ihren eigenen wählen.

Parse den JSON in Zeilen und Spalten

Hier wird es spannend. Wir können nicht nur den Inhalt einer Datei hochladen und in eine Tabellenspalte importieren, wir können ihren Inhalt auch auf mehrere Zeilen und Spalten verteilen.

OPENJSON() ist eine Tabellenwertfunktion, die JSON-Dokumente in ein Tabellenformat konvertiert.

Daher können wir OPENJSON() verwenden um den Inhalt unserer JSON-Datei in ein tabellarisches Format umzuwandeln und das in eine Tabelle oder mehrere Tabellen einzufügen, wenn dies das Ziel ist.

Aber auch hier können wir unsere Daten überprüfen, bevor wir sie in Tabellen einfügen.

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

Ergebnis:

+---------+-----------+--------+| CatID | Katzenname | Geschlecht ||---------+-----------+--------|| 1 | Flauschig | Weiblich || 2 | Langer Schwanz | Weiblich || 3 | Kratzer | Männlich |+---------+-----------+--------+(3 Reihen betroffen)+---------+ -----------+--------+| Hunde-ID | Hundename | Geschlecht ||---------+-----------+--------|| 1 | Holen | Männlich || 2 | Flauschig | Männlich || 3 | Wackeln | Weiblich |+---------+-----------+--------+(3 Reihen betroffen)

Genau so wird es aussehen, wenn es in zwei Tabellen eingefügt wird.

Um es in die Tabellen einzufügen, müssen wir nur INTO TableName hinzufügen zwischen SELECT Teil und FROM (wobei TableName ist der Name der Tabelle, die wir erstellen möchten).

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

Ergebnis:

+---------+-----------+--------+| CatID | Katzenname | Geschlecht ||---------+-----------+--------|| 1 | Flauschig | Weiblich || 2 | Langer Schwanz | Weiblich || 3 | Kratzer | Männlich |+---------+-----------+--------+(3 Reihen betroffen)+---------+ -----------+--------+| Hunde-ID | Hundename | Geschlecht ||---------+-----------+--------|| 1 | Holen | Männlich || 2 | Flauschig | Männlich || 3 | Wackeln | Weiblich |+---------+-----------+--------+(3 Reihen betroffen)

Diese Tabellen wurden unter Verwendung der Spaltendefinitionen erstellt, die wir in WITH bereitgestellt haben Klausel.

Jeder JSON-Schlüssel wird einem Spaltennamen unserer Wahl zugeordnet.

Sie können Ihre Spaltennamen auch auf den Schlüsselnamen in der JSON-Datei basieren. Wenn Sie das tun, müssen Sie sie nicht mit einem Pfad zuordnen, wie OPENJSON() gleicht sie automatisch mit den JSON-Schlüsselnamen ab.

Anstatt beispielsweise die folgende WITH-Klausel zu verwenden:

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

Sie könnten dies verwenden:

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

JSON in eine Variable laden

Eine andere Möglichkeit wäre, den hochgeladenen JSON in eine Variable zu laden und diese Variable dann an OPENJSON() zu übergeben Funktion.

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

Ergebnis:

+---------+-----------+--------+| CatID | Katzenname | Geschlecht ||---------+-----------+--------|| 1 | Flauschig | Weiblich || 2 | Langer Schwanz | Weiblich || 3 | Kratzer | Männlich |+---------+-----------+--------+(3 Reihen betroffen)+---------+ -----------+--------+| Hunde-ID | Hundename | Geschlecht ||---------+-----------+--------|| 1 | Holen | Männlich || 2 | Flauschig | Männlich || 3 | Wackeln | Weiblich |+---------+-----------+--------+(3 Reihen betroffen)

Um dies wiederum in eine Tabelle einzufügen, würden wir INTO TableName hinzufügen nach dem SELECT Teil (wobei TableName ist der Name der Tabelle, die Sie erstellen möchten).

Lade ein ganzes Unterobjekt in eine Spalte

Wenn Sie möchten, dass sich ganze Unterobjekte in einer eigenen Spalte befinden, können Sie den AS JSON verwenden Option des WITH Klausel.

Anstatt beispielsweise jede Katze und jeden Hund auf drei Spalten zu verteilen, könnte ihr gesamtes JSON-Fragment eine Spalte einnehmen. Jedes Tier hat immer noch seine eigene Reihe.

Hier ist ein Beispiel dafür, was ich meine.

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] 

Ergebnis: