JSON_MODIFY() Eksempler i SQL Server (T-SQL)

I SQL Server kan du bruge T-SQL JSON_MODIFY() funktion til at ændre værdien af en egenskab i en JSON-streng. Funktionen returnerer den opdaterede JSON-streng.

Syntaks

Syntaksen ser sådan ud:

JSON_MODIFY ( expression , path , newValue )

Hvor expression er JSON-strengudtrykket, path er stien til den egenskab, du vil opdatere, og newValue er den nye værdi, der skal gælde for den pågældende ejendom.

Eksempel 1 – Grundlæggende brug

Her er et eksempel til at demonstrere.

SELECT JSON_MODIFY('{"Name": "Homer"}', '$.Name', 'Bart') AS 'Result';

Resultat:

+------------------+
| Result           |
|------------------|
| {"Name": "Bart"} |
+------------------+

I dette eksempel:

{"Name": "Homer"} er den originale JSON-streng
$.Name er stien (dette begynder med $. efterfulgt af stien til den ejendom, vi ønsker at opdatere).
Bart er den nye værdi, vi vil tildele Name (dvs. at erstatte den aktuelle værdi)

Eksempel 2 – Returner den originale og ændrede JSON

Bemærk, at JSON_MODIFY() ændrer ikke den originale JSON. Det tager en kopi, ændrer derefter og returnerer kopien.

Her er et eksempel til at demonstrere dette:

DECLARE @suspect NVARCHAR(4000)
SET @suspect= '{"Name": "Homer"}'
SELECT 
  @suspect AS 'Original String',
  JSON_MODIFY(@suspect, '$.Name', 'Bart') AS 'Modified String',
  @suspect AS 'Original String';

Resultat:

+-------------------+-------------------+-------------------+
| Original String   | Modified String   | Original String   |
|-------------------+-------------------+-------------------|
| {"Name": "Homer"} | {"Name": "Bart"}  | {"Name": "Homer"} |
+-------------------+-------------------+-------------------+

Eksempel 3 – Indlejrede egenskaber

Stien kan bruge priknotation til at henvise til indlejrede egenskaber. Her er et eksempel.

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'$.Suspect.Address.City', 'Timaru') AS 'Modified Array';

Resultat:

+------------------+
| Modified Array   |
|------------------|
| {  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Timaru",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }                  |
+------------------+

Så vi kan se, at byen er blevet ændret fra Dunedin til Timaru .

Eksempel 4 – Opdater værdier i et array

Du kan også opdatere værdier i et array. I dette eksempel opdaterer vi en værdi i Hobbies array.

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'$.Suspect.Hobbies[2]', 'Brain Surgery') AS 'Updated Hobbies';

Resultat:

+-------------------+
| Updated Hobbies   |
|-------------------|
| {  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Brain Surgery"]  
    }
 }                   |
+-------------------+

Da arrays bruger nul-baseret nummerering, opdaterer vi det tredje element ved at henvise til Hobbies[2] .

Eksempel 5 – Tilføj en værdi til et array

I dette eksempel tilføjer vi en værdi til Hobbies array. Det gør vi ved at tilføje append i starten af sti-argumentet.

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'append $.Suspect.Hobbies', 'Brain Surgery') AS 'Updated Hobbies';

Resultat:

+-------------------+
| Updated Hobbies   |
|-------------------|
| {  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping","Brain Surgery"]  
    }
 }                   |
+-------------------+

Eksempel 6 – Opdater et helt array

I dette eksempel opdaterer jeg hele arrayet.

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'$.Suspect.Hobbies', JSON_QUERY('["Chess", "Brain Surgery"]')) AS 'Updated Hobbies';

Resultat:

+-------------------+
| Updated Hobbies   |
|-------------------|
| {  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Chess", "Brain Surgery"]  
    }
 }                   |
+-------------------+

Bemærk, at i dette eksempel sendes det tredje argument til JSON_QUERY() fungere. Hvis jeg ikke havde gjort dette, ville SQL Server have undsluppet de dobbelte anførselstegn og firkantede parenteser ved hjælp af omvendt skråstreg (\ ) karakter (og derfor ødelægger arrayet). Det ville have gjort dette, fordi det ikke ville have vidst, om den opdaterede værdi var et faktisk array eller en streng-literal.

Så for at komme uden om dette, kan vi bruge JSON_QUERY() . Denne funktion returnerer gyldig JSON, og SQL Server vil så antage, at den nye værdi er et array.

Her er, hvad der ville være sket, hvis vi ikke var brugte JSON_QUERY() :

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'$.Suspect.Hobbies', '["Chess", "Brain Surgery"]') AS 'Updated Hobbies';

Resultat:

+-------------------+
| Updated Hobbies   |
|-------------------|
| {  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Dunedin",  
         "Region": "Otago",  
         "Country": "New Zealand"  
       },  
       "Hobbies": "[\"Chess\", \"Brain Surgery\"]"  
    }
 }                   |
+-------------------+

Så SQL Server er undsluppet de firkantede parenteser og dobbelte anførselstegn.

Eksempel 7 – Opdater et helt objekt

Her er et eksempel på opdatering af et helt objekt.

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'$.Suspect', JSON_QUERY('{"Name": "Peter Griffin", "Hobbies": "None"}')) AS 'Updated Object';

Resultat:

+------------------+
| Updated Object   |
|------------------|
| {  
    "Suspect": {"Name": "Peter Griffin", "Hobbies": "None"}
 }                  |
+------------------+

Igen, hvis vi ikke havde brugt JSON_QUERY() , ville vi have modtaget en escaped streng:

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_MODIFY(@data,'$.Suspect', '{"Name": "Peter Griffin", "Hobbies": "None"}') AS 'Updated Object';

Resultat:

+------------------+
| Updated Object   |
|------------------|
| {  
    "Suspect": "{\"Name\": \"Peter Griffin\", \"Hobbies\": \"None\"}"
 }                  |
+------------------+

Eksempel 8 – Omdøb en nøgle

Du er ikke kun begrænset til at opdatere en ejendoms værdi, du kan også omdøbe dens nøgle. Her er et eksempel.

DECLARE @data NVARCHAR(50)='{"Name":"Homer"}'
PRINT @data

-- Rename the key
SET @data=
 JSON_MODIFY(
  JSON_MODIFY(@data,'$.Handle', JSON_VALUE(@data,'$.Name')),
  '$.Name',
  NULL
 )
PRINT @data

Resultat:

{"Name":"Homer"}
{"Handle":"Homer"}

Her tager vi værdien fra den eksisterende ejendom og tildeler den til et nyt nøgle/værdi-par. Vi sætter derefter værdien af den originale nøgle til NULL (hvilket automatisk sletter det).

For flere eksempler på omdøbning af en nøgle, se Sådan omdøbes en JSON-nøgle i SQL Server.