Sqlserver
 sql >> Base de données >  >> RDS >> Sqlserver

JSON_MODIFY() Exemples dans SQL Server (T-SQL)

Dans SQL Server, vous pouvez utiliser T-SQL JSON_MODIFY() fonction pour modifier la valeur d'une propriété dans une chaîne JSON. La fonction renvoie la chaîne JSON mise à jour.

Syntaxe

La syntaxe ressemble à ceci :

JSON_MODIFY ( expression , path , newValue )

Où expression est l'expression de chaîne JSON, path est le chemin d'accès à la propriété que vous souhaitez mettre à jour, et newValue est la nouvelle valeur à appliquer à cette propriété.

Exemple 1 - Utilisation de base

Voici un exemple pour illustrer.

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

Résultat :

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

Dans cet exemple :

  • {"Name": "Homer"} est la chaîne JSON d'origine
  • $.Name est le chemin (il commence par $. suivi du chemin d'accès à la propriété que nous voulons mettre à jour).
  • Bart est la nouvelle valeur que nous voulons attribuer à Name (c'est-à-dire pour remplacer la valeur actuelle)

Exemple 2 - Renvoyer le JSON d'origine et modifié

Notez que JSON_MODIFY() ne modifie pas le JSON d'origine. Il prend une copie, puis modifie et renvoie la copie.

Voici un exemple pour illustrer cela :

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

Résultat :

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

Exemple 3 - Propriétés imbriquées

Le chemin peut utiliser la notation par points pour référencer les propriétés imbriquées. Voici un exemple.

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

Résultat :

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

Nous pouvons donc voir que la ville a été modifiée de Dunedin à Timaru .

Exemple 4 - Mettre à jour des valeurs dans un tableau

Vous pouvez également mettre à jour des valeurs dans un tableau. Dans cet exemple, nous mettons à jour une valeur dans le Hobbies tableau.

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

Résultat :

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

Étant donné que les tableaux utilisent une numérotation à base zéro, nous mettons à jour le troisième élément en faisant référence à Hobbies[2] .

Exemple 5 - Ajouter une valeur à un tableau

Dans cet exemple, nous ajoutons une valeur au Hobbies déployer. Nous faisons cela en ajoutant append au début de l'argument du chemin.

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

Résultat :

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

Exemple 6 - Mettre à jour un tableau entier

Dans cet exemple, je mets à jour tout le tableau.

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

Résultat :

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

Notez que dans cet exemple, le troisième argument est passé au JSON_QUERY() une fonction. Si je ne l'avais pas fait, SQL Server aurait échappé aux guillemets doubles et aux crochets en utilisant la barre oblique inverse (\ ) caractère (et donc gâcher le tableau). Il aurait fait cela car il n'aurait pas su si la valeur mise à jour était un tableau réel ou un littéral de chaîne.

Donc, pour contourner cela, nous pouvons utiliser JSON_QUERY() . Cette fonction renvoie un JSON valide, et SQL Server supposera alors que la nouvelle valeur est un tableau.

Voici ce qui se serait passé si nous ne l'avions pas fait utilisé 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';

Résultat :

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

SQL Server a donc échappé aux crochets et aux guillemets doubles.

Exemple 7 - Mettre à jour un objet entier

Voici un exemple de mise à jour d'un objet entier.

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

Résultat :

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

Encore une fois, si nous n'avions pas utilisé JSON_QUERY() , nous aurions reçu une chaîne échappée :

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

Résultat :

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

Exemple 8 - Renommer une clé

Vous n'êtes pas limité à la mise à jour de la valeur d'une propriété, vous pouvez également renommer sa clé. Voici un exemple.

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

Résultat :

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

Ici, nous prenons la valeur de la propriété existante et l'attribuons à une nouvelle paire clé/valeur. Nous définissons ensuite la valeur de la clé d'origine sur NULL (ce qui le supprime automatiquement).

Pour plus d'exemples de renommage d'une clé, consultez Comment renommer une clé JSON dans SQL Server.