Comment importer un fichier JSON dans une table SQL Server

Si vous avez un document JSON, vous pouvez procéder de plusieurs manières pour l'intégrer à SQL Server.

S'il s'agit d'un petit document, vous pouvez copier et coller son contenu. S'il s'agit d'un document plus volumineux (ou même petit), vous voudrez peut-être importer le fichier entier.

Cet article présente un exemple d'importation d'un fichier JSON dans une base de données SQL Server.

Sélectionner le contenu du fichier JSON

T-SQL inclut le OPENROWSET() fonction, qui peut lire les données de n'importe quel fichier sur le lecteur local ou le réseau, et les renvoyer sous forme d'ensemble de lignes. Pour cela, exécutez cette fonction avec le BULK option.

Bien que cet article ait été écrit spécifiquement pour importer le fichier JSON dans une table, vous pouvez également utiliser OPENROWSET() pour lire un fichier de données sans nécessairement le charger dans une table.

Cela vous permet de vérifier d'abord les données, avant de les charger dans la table.

Voici un exemple de sélection du contenu d'un fichier JSON.

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

Résultat :

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

Dans ce cas, le système de fichiers est Linux, et donc les conventions de chemin Linux sont utilisées lors de la spécification du fichier à télécharger.

Si vous êtes sous Windows, votre chemin de fichier pourrait ressembler davantage à celui-ci :

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

Quoi qu'il en soit, nous pouvons voir le contenu du fichier JSON ci-dessus. Chargeons-le maintenant dans une table.

Chargez-le dans un tableau

Nous pouvons modifier la déclaration précédente, afin que le contenu du fichier soit importé directement dans une table.

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

Résultat :

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

Cela crée la table et insère le JSON.

Notez que lors de l'utilisation de OPENROWSET() avec le BULK option, vous devez également fournir un nom de corrélation (également appelé variable de plage ou alias) dans le champ FROM clause.

Si vous ne fournissez pas de nom de corrélation, vous obtiendrez une erreur.

Dans mon exemple, j'ai utilisé Json comme nom de corrélation, mais n'hésitez pas à choisir le vôtre.

Analyser le JSON en lignes et colonnes

C'est là que les choses deviennent passionnantes. Non seulement pouvons-nous télécharger le contenu d'un fichier et l'importer dans une colonne de tableau, mais nous pouvons également séparer son contenu sur plusieurs lignes et colonnes.

OPENJSON() est une fonction table qui convertit les documents JSON dans un format tabulaire.

Par conséquent, nous pouvons utiliser OPENJSON() pour convertir le contenu de notre fichier JSON au format tabulaire et l'insérer dans un tableau, ou plusieurs tableaux si tel est l'objectif.

Mais encore une fois, nous pouvons vérifier nos données avant de les insérer dans des tables.

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

Résultat :

+---------+-----------+--------+
| 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'est exactement ce à quoi il ressemblera une fois inséré dans deux tableaux.

Pour l'insérer dans les tables, il suffit d'ajouter INTO TableName entre le SELECT partie et FROM (où TableName est le nom de la table que nous voulons créer).

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

Résultat :

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

Ces tables ont été créées à l'aide des définitions de colonne que nous avons fournies dans le WITH clause.

Chaque clé JSON est mappée à un nom de colonne de notre choix.

Vous pouvez également baser vos noms de colonne sur les noms de clé du fichier JSON. Si vous faites cela, vous n'avez pas besoin de les mapper avec un chemin, comme OPENJSON() les associera automatiquement aux noms de clés JSON.

Par exemple, au lieu d'utiliser la clause WITH suivante :

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

Vous pouvez utiliser ceci :

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

Charger le JSON dans une variable

Une autre façon de procéder serait de charger le JSON téléchargé dans une variable, puis de transmettre cette variable au OPENJSON() fonction.

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

Résultat :

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

Encore une fois, pour insérer ceci dans une table, nous ajouterions INTO TableName après le SELECT partie (où TableName est le nom de la table que vous voulez créer).

Charger un sous-objet entier dans une colonne

Si vous vouliez que des sous-objets entiers résident dans leur propre colonne, vous pouvez utiliser le AS JSON option du WITH clause.

Par exemple, au lieu d'avoir chaque chat et chaque chien répartis sur trois colonnes, leur fragment JSON entier pourrait occuper une colonne. Chaque animal aura toujours sa propre ligne.

Voici un exemple de ce que je veux dire.

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]

Résultat :

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