SQLite JSON_EXTRACT()

Dans SQLite, le json_extract() la fonction extrait et renvoie une ou plusieurs valeurs à partir d'un JSON bien formé.

Nous passons le JSON comme argument lorsque nous appelons la fonction, et il renvoie la ou les valeurs applicables.

Nous pouvons spécifier un ou plusieurs chemins à extraire du document JSON.

Syntaxe

La syntaxe ressemble à ceci :

json_extract(X,P1,P2,...)

Où X représente le document JSON, et P1,P2,... sont des chemins que nous pouvons utiliser pour extraire des parties spécifiques du document JSON.

Exemples

Voici un exemple de base pour illustrer :

SELECT json_extract('{ "a" : 1 }', '$');

Résultat :

{"a":1}

Ici, j'ai spécifié un chemin de $ , qui renvoie l'intégralité du document JSON.

Voici un exemple avec un document JSON plus volumineux :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$'
);

Résultat :

{"dogs":[{"name":"Wag","scores":[7,9]},{"name":"Bark","scores":[3,4,8,7]},{"name":"Woof","scores":[3,2,1]}]}

Modifions le chemin pour ne renvoyer que les dogs tableau :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs'
);

Résultat :

[{"name":"Wag","scores":[7,9]},{"name":"Bark","scores":[3,4,8,7]},{"name":"Woof","scores":[3,2,1]}]

Sélectionnons l'un des éléments du tableau :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[1]'
);

Résultat :

{"name":"Bark","scores":[3,4,8,7]}

Les tableaux sont basés sur zéro, et donc le décompte commence à 0 . Par conséquent, nous avons spécifié [1] pour obtenir le deuxième élément dans le dogs tableau, qui se trouve être un objet JSON.

Allons encore plus loin et renvoyons uniquement le nom du chien à cette position dans le tableau :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[1].name'
);

Résultat :

Bark

Spécifier plusieurs chemins

Le json_extract() permet de sélectionner plusieurs chemins :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.dogs[0].name',
'$.dogs[1].name',
'$.dogs[2].name'
);

Résultat :

["Wag","Bark","Woof"]

Dans ce cas, j'ai renvoyé les noms de tous les chiens dans le champ dogs tableau.

Tous les noms de chiens sont renvoyés dans un tableau.

Sélectionner un chemin inexistant

Si nous pointons vers un chemin qui n'existe pas, null est renvoyé.

Tout d'abord, définissons .nullvalue à NULL :

.nullvalue NULL

Le .nullvalue La commande point nous permet de fournir une chaîne qui sera utilisée pour remplacer les valeurs nulles. C'est l'une des nombreuses façons dont vous pouvez remplacer les valeurs nulles par une chaîne dans SQLite. Dans ce cas, je l'ai défini sur NULL . Désormais, toutes les valeurs nulles renverront NULL au lieu d'un résultat vide.

Appelons maintenant json_extract() , mais utilisez un deuxième argument qui pointe vers un chemin inexistant :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'$.cats'
);

Résultat :

NULL

Chemins non valides

Nous aurons une erreur si notre chemin n'est pas bien formé :

SELECT json_extract('{
    "dogs" : [
            { "name" : "Wag", "scores" : [ 7, 9 ] },
            { "name" : "Bark", "scores" : [ 3, 4, 8, 7 ] },
            { "name" : "Woof", "scores" : [ 3, 2, 1 ] }
    ]
}', 
'dogs'
);

Résultat :

Runtime error: JSON path error near 'dogs'

Dans ce cas, j'ai oublié d'inclure $. au début du chemin.

Documents JSON non valides

Nous aurons également une erreur, le JSON n'est pas bien formé :

SELECT json_extract('{ "Dogs" : }', 
'$'
);

Résultat :

Runtime error: malformed JSON

Cette fois, l'erreur nous indique que notre JSON est malformé.

Types de retour

La documentation SQLite indique ce qui suit :

Si un seul chemin P1 est fourni, alors le type de données SQL du résultat est NULL pour un JSON nul, INTEGER ou REAL pour une valeur numérique JSON, un INTEGER zéro pour une valeur JSON fausse, un INTEGER un pour une valeur JSON vraie, le texte entre guillemets pour une valeur de chaîne JSON et une représentation textuelle pour les valeurs d'objet et de tableau JSON. S'il existe plusieurs arguments de chemin (P1, P2, etc.), cette routine renvoie du texte SQLite qui est un tableau JSON bien formé contenant les différentes valeurs.

Compatibilité MySQL

La documentation SQLite nous avertit également d'une subtile incompatibilité entre les implémentations SQLite et MySQL du json_extract() fonction.

Plus précisément, il indique :

La version MySQL de json_extract() renvoie toujours JSON. La version SQLite de json_extract() ne renvoie JSON que s'il y a deux arguments PATH ou plus (car le résultat est alors un tableau JSON) ou si l'unique argument PATH référence un tableau ou un objet. Dans SQLite, si json_extract() n'a qu'un seul argument PATH et que PATH référence un null JSON ou une chaîne ou une valeur numérique, alors json_extract() renvoie la valeur SQL NULL, TEXT, INTEGER ou REAL correspondante.

Fondamentalement, cette différence ne devient apparente que lors de l'accès à des valeurs individuelles dans le JSON qui sont des chaînes ou des valeurs NULL.