Sqlserver
 sql >> Datenbank >  >> RDS >> Sqlserver

JSON_MODIFY()-Beispiele in SQL Server (T-SQL)

In SQL Server können Sie T-SQL JSON_MODIFY() verwenden Funktion, um den Wert einer Eigenschaft in einer JSON-Zeichenfolge zu ändern. Die Funktion gibt die aktualisierte JSON-Zeichenfolge zurück.

Syntax

Die Syntax lautet wie folgt:

JSON_MODIFY ( expression , path , newValue )

Wobei expression ist der JSON-String-Ausdruck, path ist der Pfad zu der Eigenschaft, die Sie aktualisieren möchten, und newValue ist der neue Wert, der auf diese Eigenschaft angewendet werden soll.

Beispiel 1 – Grundlegende Verwendung

Hier ist ein Beispiel zur Veranschaulichung.

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

Ergebnis:

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

In diesem Beispiel:

  • {"Name": "Homer"} ist der ursprüngliche JSON-String
  • $.Name ist der Pfad (dieser beginnt mit $. gefolgt vom Pfad zu der Eigenschaft, die wir aktualisieren möchten).
  • Bart ist der neue Wert, den wir Name zuweisen möchten (d.h. um den aktuellen Wert zu ersetzen)

Beispiel 2 – Zurückgeben des ursprünglichen und modifizierten JSON

Beachten Sie, dass JSON_MODIFY() ändert das ursprüngliche JSON nicht. Es nimmt eine Kopie, modifiziert sie und gibt die Kopie zurück.

Hier ist ein Beispiel, um dies zu demonstrieren:

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

Ergebnis:

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

Beispiel 3 – Verschachtelte Eigenschaften

Der Pfad kann die Punktnotation verwenden, um auf verschachtelte Eigenschaften zu verweisen. Hier ist ein Beispiel.

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

Ergebnis:

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

Wir können also sehen, dass die Stadt von Dunedin geändert wurde zu Timaru .

Beispiel 4 – Werte in einem Array aktualisieren

Sie können auch Werte innerhalb eines Arrays aktualisieren. In diesem Beispiel aktualisieren wir einen Wert in 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';

Ergebnis:

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

Da Arrays eine nullbasierte Nummerierung verwenden, aktualisieren wir das dritte Element, indem wir auf Hobbies[2] verweisen .

Beispiel 5 – Einen Wert an ein Array anhängen

In diesem Beispiel hängen wir einen Wert an Hobbies an Reihe. Wir tun dies, indem wir append hinzufügen am Anfang des Pfadarguments.

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

Ergebnis:

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

Beispiel 6 – Aktualisieren eines ganzen Arrays

In diesem Beispiel aktualisiere ich das gesamte 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', JSON_QUERY('["Chess", "Brain Surgery"]')) AS 'Updated Hobbies';

Ergebnis:

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

Beachten Sie, dass in diesem Beispiel das dritte Argument an JSON_QUERY() übergeben wird Funktion. Wenn ich das nicht getan hätte, hätte SQL Server die doppelten Anführungszeichen und eckigen Klammern mit dem umgekehrten Schrägstrich (\ ) Zeichen (und damit das Array durcheinander bringt). Dies hätte es getan, weil es nicht gewusst hätte, ob der aktualisierte Wert ein tatsächliches Array oder ein Zeichenfolgenliteral war.

Um dies zu umgehen, können wir also JSON_QUERY() verwenden . Diese Funktion gibt gültiges JSON zurück und SQL Server geht dann davon aus, dass der neue Wert ein Array ist.

Folgendes wäre passiert, wenn wir es nicht getan hätten verwendet 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';

Ergebnis:

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

Daher hat SQL Server die eckigen Klammern und doppelten Anführungszeichen maskiert.

Beispiel 7 – Aktualisieren eines ganzen Objekts

Hier ist ein Beispiel für die Aktualisierung eines ganzen Objekts.

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

Ergebnis:

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

Nochmal, wenn wir nicht JSON_QUERY() verwendet hätten , hätten wir einen Escape-String erhalten:

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

Ergebnis:

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

Beispiel 8 – Schlüssel umbenennen

Sie sind nicht nur darauf beschränkt, den Wert einer Eigenschaft zu aktualisieren, Sie können auch ihren Schlüssel umbenennen. Hier ist ein Beispiel.

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

Ergebnis:

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

Hier nehmen wir den Wert aus der vorhandenen Eigenschaft und weisen ihn einem neuen Schlüssel/Wert-Paar zu. Wir setzen dann den Wert des ursprünglichen Schlüssels auf NULL (was es automatisch löscht).

Weitere Beispiele zum Umbenennen eines Schlüssels finden Sie unter Umbenennen eines JSON-Schlüssels in SQL Server.