Opérateur

Dans SQLite, le ->> L'opérateur extrait un sous-composant d'un document JSON et renvoie une représentation SQL de ce sous-composant.

Le ->> L'opérateur a été introduit pour la première fois dans la version 3.38.0 de SQLite (publiée le 22 février 2022).

Syntaxe

La syntaxe ressemble à ceci :

json ->> path

Où json est le document JSON et le path est le chemin vers le sous-composant que nous voulons en extraire.

Nous fournissons donc un document JSON à gauche de l'opérateur, et nous spécifions le chemin que nous voulons extraire à sa droite.

Le ->> L'opérateur renvoie toujours une représentation SQL du sous-composant spécifié. Pour renvoyer une représentation JSON, utilisez le -> opérateur à la place.

Exemples

Voici un exemple simple pour montrer comment le ->> l'opérateur fonctionne :

SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$';

Résultat :

{"name":"Wag","type":"Dog"}

Dans ce cas, j'ai spécifié un chemin de '$' qui renvoie le document entier.

Spécifiez un autre chemin :

SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$.type';

Résultat :

Dog

Nous pouvons également omettre le signe dollar et le point, comme ceci :

SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> 'type';

Résultat :

Dog

Le voici avec un document JSON plus volumineux :

SELECT '[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]' ->> '$[0]';

Résultat :

{"user":"Spike","age":30,"scores":[9,7,3]}

Dans SQLite, les tableaux sont basés sur zéro, et donc en spécifiant [0] renvoie le premier élément du tableau.

Si nous voulions uniquement obtenir les scores de cet utilisateur, nous pourrions procéder comme suit :

SELECT '[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]' ->> '$[0].scores';

Résultat :

[9,7,3]

Nous pouvons aller encore plus loin et extraire un score spécifique :

SELECT '[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]' ->> '$[0].scores[1]';

Résultat :

7

Chemin inexistant

Si le chemin n'existe pas dans le JSON, une valeur nulle est renvoyée :

SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$.age';

Résultat :

null

Notez que dans SQLite, vous pouvez utiliser .nullvalue pour spécifier une chaîne à afficher chaque fois qu'une valeur nulle est renvoyée. Dans mon cas, j'avais précédemment exécuté la commande suivante :

.nullvalue null

Cela précise que le texte null doit être affiché chaque fois qu'une valeur nulle est renvoyée. C'est pourquoi l'exemple ci-dessus affiche le texte null . Si je ne l'avais pas fait, le résultat aurait pu être vide.

JSON non valide

Si le premier argument n'est pas un JSON valide, une erreur est renvoyée :

SELECT '{ "name" }' ->> '$';

Résultat :

Runtime error: malformed JSON

Chemin invalide

Et si le deuxième argument n'est pas un chemin valide, une erreur est renvoyée :

SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> '$name';

Résultat :

Runtime error: JSON path error near 'name'

Dans ce cas, j'ai oublié d'inclure le point (. ) entre le signe dollar ($ ) et name .

Cependant, comme mentionné, il est possible d'omettre complètement le signe dollar et le point :

SELECT '{ "name" : "Wag", "type" : "Dog" }' ->> 'name';

Résultat :

Wag