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

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

Lorsque vous utilisez JSON avec SQL Server, vous pouvez utiliser le JSON_VALUE() fonction pour renvoyer une valeur scalaire à partir d'une chaîne JSON.

Pour utiliser cette fonction, vous fournissez deux arguments ; l'expression JSON et la propriété à extraire.

Syntaxe

La syntaxe ressemble à ceci :

JSON_VALUE ( expression , path )

Où expression est l'expression de chaîne JSON et path est la propriété que vous souhaitez extraire de cette expression.

L'argument chemin peut inclure un mode chemin facultatif composant. Ce mode de chemin optionnel peut être une valeur soit lax ou strict . Cette valeur, le cas échéant, vient avant le signe dollar.

Exemple 1 - Utilisation de base

Voici un exemple pour démontrer l'utilisation de base de JSON_VALUE() fonction.

SELECT JSON_VALUE('{"Name": "Bruce"}', '$.Name') AS 'Result';

Résultat :

+----------+
| Result   |
|----------|
| Bruce    |
+----------+

Dans cet exemple :

  • Le {"Name": "Bruce"} argument est l'expression JSON (une petite, mais toujours une expression JSON valide). Les expressions JSON consistent en une paire clé/valeur. Dans ce cas, Name est la clé, Bruce est sa valeur.
  • Le $.Name l'argument est le chemin. Ce chemin référence la valeur du Name clé de l'expression JSON. Nous pouvons donc extraire la valeur en référençant le nom de la paire.

Exemple 2 – Tableaux

Pour extraire une valeur d'un tableau, référencez son index entre crochets, suivi de la clé appropriée. Voici un exemple :

/* 
CREATE THE ARRAY (and put into a variable called @data)
*/
DECLARE @data NVARCHAR(4000)
SET @data=N'{
    "Cities": [
        {
            "Name": "Kabul",
            "CountryCode": "AFG",
            "District": "Kabol",
            "Population": 1780000
        },
        {
            "Name": "Qandahar",
            "CountryCode": "AFG",
            "District": "Qandahar",
            "Population": 237500
        }
    ]
}'

/* 
QUERY THE ARRAY
*/
SELECT 
  JSON_VALUE(@data,'$.Cities[0].Name') AS 'Name',
  JSON_VALUE(@data,'$.Cities[0].CountryCode') AS 'Country Code',
  JSON_VALUE(@data,'$.Cities[0].District') AS 'District',
  JSON_VALUE(@data,'$.Cities[0].Population') AS 'Population'

UNION ALL

SELECT 
  JSON_VALUE(@data,'$.Cities[1].Name') AS 'Name',
  JSON_VALUE(@data,'$.Cities[1].CountryCode') AS 'Country Code',
  JSON_VALUE(@data,'$.Cities[1].District') AS 'District',
  JSON_VALUE(@data,'$.Cities[1].Population') AS 'Population';

Résultat :

+----------+----------------+------------+--------------+
| Name     | Country Code   | District   | Population   |
|----------+----------------+------------+--------------|
| Kabul    | AFG            | Kabol      | 1780000      |
| Qandahar | AFG            | Qandahar   | 237500       |
+----------+----------------+------------+--------------+

Donc, dans cet exemple, nous créons un tableau JSON et le plaçons dans une variable appelée @data . Nous exécutons ensuite une requête en utilisant @data comme premier argument de JSON_VALUE() fonction (c'est parce que @data contient l'expression JSON).

Les tableaux utilisent une numérotation de base zéro, donc pour extraire le premier élément, nous devons utiliser Cities[0] , le second Cities[1] , et ainsi de suite.

Exemple 3 - Un exemple de base de données

Si nous devions mettre les données de l'exemple précédent dans une base de données, nous pourrions réécrire la requête comme suit :

SELECT 
  JSON_VALUE(Document,'$.Cities[0].Name') AS 'Name',
  JSON_VALUE(Document,'$.Cities[0].CountryCode') AS 'Country Code',
  JSON_VALUE(Document,'$.Cities[0].District') AS 'District',
  JSON_VALUE(Document,'$.Cities[0].Population') AS 'Population'
FROM Json_Documents

UNION ALL

SELECT 
  JSON_VALUE(Document,'$.Cities[1].Name') AS 'Name',
  JSON_VALUE(Document,'$.Cities[1].CountryCode') AS 'Country Code',
  JSON_VALUE(Document,'$.Cities[1].District') AS 'District',
  JSON_VALUE(Document,'$.Cities[1].Population') AS 'Population'
FROM Json_Documents

Résultat :

+----------+----------------+------------+--------------+
| Name     | Country Code   | District   | Population   |
|----------+----------------+------------+--------------|
| Kabul    | AFG            | Kabol      | 1780000      |
| Qandahar | AFG            | Qandahar   | 237500       |
+----------+----------------+------------+--------------+

Cela suppose que le document JSON est stocké dans une colonne appelée Document , qui se trouve dans une table appelée Json_Documents .

Exemple 4 - Mode Chemin

Comme mentionné, vous avez également la possibilité de spécifier le mode de chemin. Cela peut être soit lax ou strict .

La valeur du mode de chemin détermine ce qui se passe lorsque l'expression de chemin contient une erreur. Plus précisément :

  • En relâchement mode, la fonction renvoie des valeurs vides si l'expression de chemin contient une erreur. Par exemple, si vous demandez la valeur $.name , et le texte JSON ne contient pas de nom key, la fonction renvoie null, mais ne génère pas d'erreur.

  • En strict mode, la fonction génère une erreur si l'expression du chemin contient une erreur.

La valeur par défaut est lax .

Voici un exemple pour illustrer la différence entre ces deux modes.

Erreur en mode laxiste

Voici ce qui se passe lorsque l'expression de chemin contient une erreur en mode laxiste.

SELECT JSON_VALUE('{"Name": "Bruce"}', 'lax $.Hobbies') AS 'Result';

Résultat :

+----------+
| Result   |
|----------|
| NULL     |
+----------+

Dans cet exemple, nous essayons de faire référence à Hobbies , mais cette clé n'existe pas dans le document JSON. Dans ce cas, nous obtenons une valeur nulle (car nous utilisons le mode laxiste).

Erreur en mode strict

Voici ce qui se passe lorsque nous exécutons le même code en mode strict.

SELECT JSON_VALUE('{"Name": "Bruce"}', 'strict $.Hobbies') AS 'Result';

Résultat :

Msg 13608, Level 16, State 1, Line 1
Property cannot be found on the specified JSON path.

Comme prévu, le mode strict entraîne l'affichage d'un message d'erreur.

Exemple 5 – Retour d'objets et de tableaux

Le JSON_VALUE() La fonction ne renvoie pas d'objets et de tableaux. Si vous voulez retourner un objet ou un tableau, utilisez le JSON_QUERY() fonction à la place. Voici un exemple où j'utilise les deux fonctions dans une requête.

DECLARE @data NVARCHAR(4000)
SET @data=N'{  
    "Suspect": {    
       "Name": "Homer Simpson",  
       "Address": {    
         "City": "Mae Sai",  
         "Province": "Chiang Rai",  
         "Country": "Thailand"  
       },  
       "Hobbies": ["Eating", "Sleeping", "Base Jumping"]  
    }
 }'
 SELECT 
   JSON_VALUE(@data,'$.Suspect.Name') AS 'Name',
   JSON_VALUE(@data,'$.Suspect.Address.Country') AS 'Country',
   JSON_QUERY(@data,'$.Suspect.Hobbies') AS 'Hobbies',
   JSON_VALUE(@data,'$.Suspect.Hobbies[2]') AS 'Last Hobby';

Résultat :

+---------------+-----------+----------------------------------------+--------------+
| Name          | Country   | Hobbies                                | Last Hobby   |
|---------------+-----------+----------------------------------------+--------------|
| Homer Simpson | Thailand  | ["Eating", "Sleeping", "Base Jumping"] | Base Jumping |
+---------------+-----------+----------------------------------------+--------------+

Dans ce cas, j'utilise JSON_VALUE() pour renvoyer diverses valeurs scalaires, et JSON_QUERY() pour retourner un tableau.

Donc, si vous devez renvoyer un objet ou un tableau (y compris l'ensemble du document JSON), consultez JSON_QUERY() Exemples dans SQL Server.