Pokud máte dokument JSON, existuje několik způsobů, jak jej dostat na SQL Server.
Pokud se jedná o malý dokument, můžete jeho obsah zkopírovat a vložit. Pokud se jedná o větší dokument (nebo dokonce malý), možná budete chtít importovat celý soubor.
Tento článek představuje příklad importu souboru JSON do databáze SQL Server.
Výběr obsahu souboru JSON
T-SQL obsahuje OPENROWSET() funkce, která dokáže číst data z libovolného souboru na místním disku nebo síti a vracet je jako sadu řádků. Chcete-li to provést, spusťte tuto funkci pomocí BULK volba.
I když byl tento článek napsán speciálně pro import souboru JSON do tabulky, můžete také použít OPENROWSET() číst z datového souboru, aniž by bylo nutné jej načítat do tabulky.
To vám umožní zkontrolovat data před jejich načtením do tabulky.
Zde je příklad výběru obsahu souboru JSON.
SELECT BulkColumn FROM OPENROWSET (
BULK '/var/opt/mssql/bak/pets.json',
SINGLE_CLOB
) AS [Json];Výsledek:
+--------------+
| 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" }
]
}
} |
+--------------+ V tomto případě je souborovým systémem Linux, a proto se při určování, který soubor se má nahrát, použijí konvence cest pro Linux.
Pokud používáte Windows, cesta k souboru může vypadat podobně jako tato:
SELECT BulkColumn FROM OPENROWSET (
BULK 'D:\data\pets.json',
SINGLE_CLOB
) AS [Json];Každopádně můžeme vidět obsah souboru JSON výše. Nyní to načteme do tabulky.
Načtěte jej do tabulky
Předchozí příkaz můžeme upravit tak, aby se obsah souboru importoval rovnou do tabulky.
-- 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;Výsledek:
+--------------+
| 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" }
]
}
} |
+--------------+ Tím se vytvoří tabulka a vloží se JSON.
Všimněte si, že při použití OPENROWSET() pomocí BULK musíte také zadat název korelace (známý také jako proměnná rozsahu nebo alias) v FROM doložka.
Pokud nezadáte název korelace, zobrazí se chyba.
V mém příkladu jsem použil Json jako název korelace, ale můžete si vybrat svůj vlastní.
Analyzujte JSON na řádky a sloupce
Tady jsou věci vzrušující. Nejen, že můžeme nahrát obsah souboru a importovat jej do sloupce tabulky, můžeme také rozdělit jeho obsah do více řádků a sloupců.
OPENJSON() je funkce s tabulkovou hodnotou, která převádí dokumenty JSON do tabulkového formátu.
Proto můžeme použít OPENJSON() převést obsah našeho souboru JSON do tabulkového formátu a vložit jej do tabulky nebo do více tabulek, pokud je to cílem.
Ale opět můžeme svá data zkontrolovat, než je vložíme do jakékoli tabulky.
-- 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]Výsledek:
+---------+-----------+--------+ | 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)
Přesně tak to bude vypadat po vložení do dvou tabulek.
K vložení do tabulek stačí přidat INTO TableName mezi SELECT část a FROM (kde TableName je název tabulky, kterou chceme vytvořit).
-- 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 ImportedDogsVýsledek:
+---------+-----------+--------+ | 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)
Tyto tabulky byly vytvořeny pomocí definic sloupců, které jsme dodali v WITH doložka.
Každý klíč JSON je namapován na název sloupce podle našeho výběru.
Názvy sloupců můžete také založit na názvech klíčů v souboru JSON. Pokud to uděláte, nemusíte je mapovat pomocí cesty, jako je OPENJSON() automaticky je spojí s názvy klíčů JSON.
Například namísto použití následující klauzule WITH:
WITH (
DogId int '$.id',
DogName varchar(60) '$.name',
Sex varchar(6) '$.sex'
) AS [Dogs]Můžete použít toto:
WITH (
id int,
name varchar(60),
sex varchar(6)
) AS [Dogs]Načtěte JSON do proměnné
Dalším způsobem, jak to udělat, by bylo načíst nahraný JSON do proměnné a poté tuto proměnnou předat do OPENJSON() funkce.
-- 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'
);Výsledek:
+---------+-----------+--------+ | 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)
Opět, abychom to vložili do tabulky, přidali bychom INTO TableName za SELECT část (kde TableName je název tabulky, kterou chcete vytvořit).
Načíst celý dílčí objekt do sloupce
Pokud chcete, aby se celé dílčí objekty nacházely ve vlastním sloupci, můžete použít AS JSON možnost WITH doložka.
Například místo toho, aby byla každá kočka a pes rozděleni do tří sloupců, celý jejich fragment JSON by mohl zabírat jeden sloupec. Každé zvíře bude mít stále svůj vlastní řádek.
Zde je příklad toho, co mám na mysli.
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]Výsledek:
+------------------------------------------------------+
| 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)