Exemplos de JSON_MODIFY() no SQL Server (T-SQL)

No SQL Server, você pode usar o T-SQL JSON_MODIFY() função para modificar o valor de uma propriedade em uma string JSON. A função retorna a string JSON atualizada.

Sintaxe

A sintaxe fica assim:

JSON_MODIFY ( expression , path , newValue )

Onde expression é a expressão de string JSON, path é o caminho para a propriedade que você deseja atualizar e newValue é o novo valor a ser aplicado a essa propriedade.

Exemplo 1 – Uso básico

Aqui está um exemplo para demonstrar.

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

Resultado:

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

Neste exemplo:

{"Name": "Homer"} é a string JSON original
$.Name é o caminho (começa com $. seguido pelo caminho para a propriedade que queremos atualizar).
Bart é o novo valor que queremos atribuir a Name (ou seja, para substituir o valor atual)

Exemplo 2 – Retornar o JSON original e modificado

Observe que JSON_MODIFY() não modifica o JSON original. Ele faz uma cópia, depois modifica e retorna a cópia.

Aqui está um exemplo para demonstrar isso:

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

Resultado:

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

Exemplo 3 – Propriedades aninhadas

O caminho pode usar notação de ponto para fazer referência a propriedades aninhadas. Aqui está um exemplo.

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

Resultado:

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

Assim, podemos ver que a cidade foi alterada de Dunedin para Timaru .

Exemplo 4 – Atualizar valores em uma matriz

Você também pode atualizar valores em uma matriz. Neste exemplo, atualizamos um valor no arquivo Hobbies variedade.

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

Resultado:

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

Visto que os arrays usam numeração baseada em zero, atualizamos o terceiro item referenciando Hobbies[2] .

Exemplo 5 – Anexar um valor a uma matriz

Neste exemplo, anexamos um valor ao campo Hobbies variedade. Fazemos isso adicionando append no início do argumento de caminho.

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

Resultado:

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

Exemplo 6 – Atualizar uma matriz inteira

Neste exemplo, atualizo todo o 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';

Resultado:

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

Observe que neste exemplo, o terceiro argumento é passado para o JSON_QUERY() função. Se eu não tivesse feito isso, o SQL Server teria escapado das aspas duplas e colchetes usando a barra invertida (\ ) (e, portanto, bagunçando o array). Ele teria feito isso porque não saberia se o valor atualizado era um array real ou um literal de string.

Então, para contornar isso, podemos usar JSON_QUERY() . Essa função retorna um JSON válido e o SQL Server assumirá que o novo valor é uma matriz.

Veja o que teria acontecido se não tivéssemos usou 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';

Resultado:

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

Portanto, o SQL Server escapou dos colchetes e aspas duplas.

Exemplo 7 – Atualizar um objeto inteiro

Aqui está um exemplo de atualização de um objeto inteiro.

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

Resultado:

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

Novamente, se não tivéssemos usado JSON_QUERY() , teríamos recebido uma string de escape:

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

Resultado:

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

Exemplo 8 – Renomear uma chave

Você não está limitado apenas a atualizar o valor de uma propriedade, você também pode renomear sua chave. Aqui está um exemplo.

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

Resultado:

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

Aqui, pegamos o valor da propriedade existente e o atribuímos a um novo par chave/valor. Em seguida, definimos o valor da chave original para NULL (que o exclui automaticamente).

Para obter mais exemplos de renomeação de uma chave, consulte Como renomear uma chave JSON no SQL Server.