1. Vue d'ensemble2. Compilation de l'extension JSON13. Aperçu de l'interface3.1. Arguments JSON3.2. Arguments PATH3.3. Arguments VALUE3.4. Compatibilité4. Détails des fonctions4.1. La fonction json()4.2. La fonction json_array()4.3. La fonction json_array_length() 4.4. La fonction json_extract()4.5. Les fonctions json_insert(), json_replace et json_set() 4.6. La fonction json_object()4.7. La fonction json_patch()4.8. La fonction json_remove() 4.9. La fonction json_type() 4.10. La fonction json_valid()4.11. La fonction json_quote()4.12. Les fonctions SQL d'agrégation json_group_array() et json_group_object()4.13. Les fonctions de valeurs de table json_each() et json_tree() 4.13.1. Exemples d'utilisation de json_each() et json_tree().

Le site json1 est une extension chargeable qui implémente quinze fonctions SQL définies par l'application et deux fonctions à valeur de table qui sont utiles pour la gestion des JSON contenu stocké dans une base de données SQLite. Il y a treize fonctions scalaires :

  1. json(json)
  2. json_array(valeur1,valeur2,...)
  3. json_array_length(json)
    json_array_length(json,chemin)
  4. json_extract(json,chemin,...)
  5. json_insert(json,chemin,valeur,...)
  6. json_objet(étiquette1,valeur1,...)
  7. json_patch(json 1,json2)
  8. json_remove(json,chemin,...)
  9. json_replace(json,chemin,valeur,...)
  10. json_set(json,chemin,valeur,...)
  11. json_type(json)
    json_type(json,chemin)
  12. json_valid(json)
  13. json_quote(valeur)

Il existe deux fonctions SQL d'agrégation :

  1. json_group_array(valeur)
  2. json_group_object(nom,valeur)

Les deux fonctions à valeur de table sont :

  1. json_each(json)
    json_each(json,chemin)
  2. json_tree(json)
    json_tree(json,chemin)

La documentation sur les extensions chargeables décrit comment compiler les extensions chargeables en tant que bibliothèques partagées. Les techniques qui y sont décrites fonctionnent bien pour le module json1.

Le code source de json1 est inclus avec l'amalgame SQLite, bien qu'il soit désactivé par défaut. Ajoutez l'option de compilation -DSQLITE_ENABLE_JSON1 pour activer l'extension json1 qui est intégrée à l'amalgame. Les makefiles standard incluent -DSQLITE_ENABLE_JSON1 lors de la construction du shell en ligne de commande et de certains utilitaires de test, de sorte que cette extension est normalement disponible dans le shell en ligne de commande.

L'extension json1 (actuellement) stocke JSON comme du texte ordinaire.

Les contraintes de rétrocompatibilité signifient que SQLite est seulement capable de stocker des valeurs qui sont NULL, des entiers, des nombres à virgule flottante, du texte et des BLOBs. Il n'est pas possible d'ajouter un sixième type "JSON".

L'extension json1 ne supporte pas (actuellement) un encodage binaire de JSON. Les expériences n'ont pas permis de trouver un encodage binaire qui soit significativement plus petit ou plus rapide qu'un encodage en texte brut. (L'implémentation actuelle analyse le texte JSON à plus de 1 Go/s.) Toutes les fonctions json1 jettent actuellement une erreur si l'un de leurs arguments est un BLOB, car les BLOB sont réservés à une amélioration future dans laquelle les BLOB stockeront l'encodage binaire pour JSON.

Le "1" à la fin du nom de l'extension json1 est délibéré. Les concepteurs prévoient qu'il y aura de futures extensions JSON incompatibles s'appuyant sur les leçons tirées de json1. Une fois qu'une expérience suffisante aura été acquise, une sorte d'extension JSON pourrait être intégrée au noyau de SQLite. Pour l'instant, le support JSON reste une extension.

3.1. Arguments JSON

Pour les fonctions qui acceptent JSON comme premier argument, cet argument peut être un objet JSON, un tableau, un nombre, une chaîne de caractères ou null. Les valeurs numériques SQLite et les valeurs NULL sont interprétées comme des nombres et des nuls JSON, respectivement. Les valeurs textuelles SQLite peuvent être interprétées comme des objets JSON, des tableaux ou des chaînes de caractères. Si une valeur texte SQLite qui n'est pas un objet, un tableau ou une chaîne JSON bien formé est transmise à la fonction json1, cette fonction lèvera généralement une erreur. (Les exceptions à cette règle sont json_valid() et json_quote().)

Afin de déterminer la validité, les espaces blancs de tête et de queue sur les entrées JSON sont ignorés. Les espaces blancs intérieurs sont également ignorés, conformément à la spécification JSON. Ces routines acceptent exactement le syntaxe rfc-7159 JSON - ni plus ni moins.

3.2. arguments PATH

Pour les fonctions qui acceptent des arguments PATH, ce PATH doit être bien formé, sinon la fonction lancera une erreur. Un PATH bien formé est une valeur textuelle qui commence par exactement un caractère '$' suivi de zéro ou plusieurs occurrences de ".objectlabel" ou "[arrayindex]".

Le site arrayindex est généralement un nombre entier non négatif N. Dans ce cas, l'élément du tableau sélectionné est l'élément N-du tableau, en commençant par zéro à gauche. Le site arrayindex peut également être de la forme "#-N", auquel cas l'élément sélectionné est le N-en partant de la droite. Le dernier élément du tableau est "#-1". Considérez les caractères "#" comme le "nombre d'éléments du tableau". Alors l'expression "#-1" évalue est le nombre entier qui correspond à la dernière entrée du tableau.

3.3. arguments VALUE

Pour les fonctions qui acceptent les "valeur", les arguments (également indiqués comme "valeur1" et "valeur2"), ces arguments sont généralement compris comme des chaînes littérales qui sont citées et deviennent des valeurs de chaîne JSON dans le résultat. Même si l'entrée valeur ressemblent à du JSON bien formé, elles sont toujours interprétées comme des chaînes littérales dans le résultat.

Cependant, si une chaîne valeur argument proviennent directement du résultat d'une autre fonction json1, alors l'argument est compris comme étant du JSON réel et le JSON complet est inséré plutôt qu'une chaîne entre guillemets.

Par exemple, dans l'appel suivant à la fonction json_object(), l'argument valeur ressemble à un tableau JSON bien formé. Cependant, parce que c'est juste du texte SQL ordinaire, il est interprété comme une chaîne littérale et ajouté au résultat comme une chaîne entre guillemets :

  • json_object('ex','[52,3.14159]')→ '{"ex" :"[52,3.14159]"}'

Mais si le valeur argument dans l'appel extérieur json_object() est le résultat d'une autre fonction json1 comme json() ou json_array(), alors la valeur est comprise comme étant du JSON réel et est insérée comme telle :

  • json_object('ex',json('[52,3.14159]'))→ '{"ex" :[52,3.14159]}'
  • json_object('ex',json_array(52,3.14159))→ '{"ex" :[52,3.14159]}'

Pour être clair : "json" sont toujours interprétés comme JSON, quelle que soit la provenance de la valeur de cet argument. Mais "valeur" ne sont interprétés comme JSON que si ces arguments proviennent directement d'une autre fonction json1.

3.4. Compatibilité

L'extension json1 utilise les interfaces sqlite3_value_subtype() et sqlite3_result_subtype() qui ont été introduites avec SQLite version 3.9.0 (2015-10-14) L'extension json1 ne fonctionnera pas dans les versions antérieures de SQLite.

L'implémentation actuelle de cette bibliothèque JSON utilise un analyseur syntaxique à descente récursive. Afin d'éviter d'utiliser un excès d'espace de pile, toute entrée JSON qui a plus de 2000 niveaux d'imbrication est considérée comme invalide. Des limites sur la profondeur d'imbrication sont autorisées pour les implémentations compatibles de JSON par . RFC-7159 section 9.

Les sections suivantes fournissent des détails supplémentaires sur le fonctionnement des diverses fonctions qui font partie de l'extension json1.

4.1. La fonction json()

La fonction json(X) vérifie que son argument X est une chaîne JSON valide et renvoie une version minifiée de cette chaîne JSON (avec tous les espaces blancs inutiles supprimés). Si X n'est pas une chaîne JSON bien formée, alors cette routine lance une erreur.

Si l'argument X de json(X) contient des objets JSON avec des étiquettes en double, alors il n'est pas défini si les doublons sont préservés ou non. L'implémentation actuelle préserve les doublons. Cependant, les améliorations futures de cette routine peuvent choisir de supprimer silencieusement les doublons.

Exemple :

  • json(' {"this" : "is", "a" : [ "test" ] } ')→ '{"ceci" : "est", "a" :["test"]}'

4.2. La fonction json_array()

La fonction SQL json_array() accepte zéro ou plusieurs arguments et renvoie un tableau JSON bien formé qui est composé à partir de ces arguments. Si l'un des arguments de json_array() est un BLOB, alors une erreur est lancée.

Un argument avec le type SQL TEXT est normalement converti en une chaîne JSON entre guillemets. Cependant, si l'argument est la sortie d'une autre fonction json1, alors il est stocké en JSON. Cela permet d'imbriquer les appels à json_array() et json_object(). La fonction json() peut également être utilisée pour forcer les chaînes de caractères à être reconnues comme JSON.

Exemples :

  • json_array(1,2, '3',4)→ '[1,2,"3",4]'
  • json_array('[1,2]')→ '["[1,2]"]'
  • json_array(json_array(1,2))→ '[[1,2]]'
  • json_array(1,null, '3','[4,5]','{"six":7.7}')→ "[1,null, "3","[4,5]","{"six":7.7}"]
  • json_array(1,null, '3',json('[4,5]'),json('{"six":7.7}')→ "[1,null, "3",[4,5],{"six":7.7}]''

4.3. La fonction json_array_length()

La fonction json_array_length(X) renvoie le nombre d'éléments dans le tableau JSON X, ou 0 si X est une sorte de valeur JSON autre qu'un tableau. La fonction json_array_length(X,P) localise le tableau au chemin P dans X et renvoie la longueur de ce tableau, ou 0 si le chemin P localise un élément ou X autre qu'un tableau JSON, et NULL si le chemin P ne localise aucun élément de X. Des erreurs sont lancées si soit X n'est pas JSON bien formé, soit si P n'est pas un chemin bien formé.

Exemples :

  • json_array_length('[1,2,3,4]')→ 4
  • json_array_length('[1,2,3,4]', '$')→ 4
  • json_array_length('[1,2,3,4]', '$[2]')→ 0
  • json_array_length('{"un" :[1,2,3]}')→ 0
  • json_array_length('{"un" :[1,2,3]}', '$.one')→ 3
  • json_array_length('{"un" :[1,2,3]}', '$.two')→ NULL

4.4. La fonction json_extract()

La fonction json_extract(X,P1,P2,...) extrait et renvoie une ou plusieurs valeurs du JSON bien formé à X. Si un seul chemin P1 est fourni, alors le type de données SQL du résultat est NULL pour un null JSON, INTEGER ou REAL pour une valeur numérique JSON, un INTEGER zéro pour une valeur false JSON, un INTEGER un pour une valeur true JSON, le texte déquoilé pour une valeur de chaîne JSON, et une représentation textuelle pour les valeurs d'objet et de tableau JSON. S'il y a plusieurs arguments de chemin (P1, P2, et ainsi de suite), alors cette routine renvoie le texte SQLite qui est un tableau JSON bien formé contenant les différentes valeurs.

Exemples :

  • json_extract('{"a":2, "c" :[4,5,{"f":7}]}', '$')→ '{"a":2, "c" :[4,5,{"f":7}]}'
  • json_extract('{"a":2, "c" :[4,5,{"f":7}]}', '$.c')→ '[4,5,{"f":7}]'
  • json_extract('{"a":2, "c" :[4,5,{"f":7}]}', '$.c[2]')→ '{"f":7}'
  • json_extract('{"a":2, "c" :[4,5,{"f":7}]}', '$.c[2].f')→ 7
  • json_extract('{"a":2, "c" :[4,5], "f":7}','$.c','$.a')→ '[[4,5],2]'
  • json_extract('{"a":2, "c" :[4,5], "f":7}','$.c[#-1]')→ 5
  • json_extract('{"a":2, "c" :[4,5,{"f":7}]}', '$.x')→ NULL
  • json_extract('{"a":2, "c" :[4,5,{"f":7}]}', '$.x', '$.a')→ '[null,2]'

4.5. Les fonctions json_insert(), json_replace et json_set().

Les fonctions json_insert(), json_replace, et json_set() prennent toutes une seule valeur JSON comme premier argument, suivie de zéro ou plusieurs paires d'arguments chemin et valeur, et renvoient une nouvelle chaîne JSON formée par la mise à jour du JSON d'entrée par les paires chemin/valeur. Les fonctions ne diffèrent que par la façon dont elles traitent la création de nouvelles valeurs et l'écrasement des valeurs préexistantes.

Fonction Écraser si existe déjà ? Créer si n'existe pas ?
json_insert() Non Oui
json_replace() Oui Non
json_set() Oui Oui

Les fonctions json_insert(), json_replace() et json_set() prennent toujours un nombre impair d'arguments. Le premier argument est toujours le JSON original à éditer. Les arguments suivants se présentent par paires, le premier élément de chaque paire étant un chemin et le second élément étant la valeur à insérer ou à remplacer ou à définir sur ce chemin.

Les éditions se produisent séquentiellement de gauche à droite. Les changements causés par des éditions antérieures peuvent affecter la recherche de chemin pour les éditions suivantes.

Si la valeur d'une paire chemin/valeur est une valeur TEXTE SQLite, alors elle est normalement insérée comme une chaîne JSON citée, même si la chaîne ressemble à du JSON valide. Cependant, si la valeur est le résultat d'une autre fonction json1 (comme json() ou json_array() ou json_object()), alors elle est interprétée comme JSON et est insérée comme JSON en conservant toute sa sous-structure.

Ces routines lancent une erreur si le premier argument JSON n'est pas bien formé ou si tout argument PATH n'est pas bien formé ou si tout argument est un BLOB.

Pour ajouter un élément à la fin d'un tableau, en utilisant json_insert() avec un index de tableau de "#". Exemples :

  • json_insert('[1,2,3,4]','$[#]',99)→ '[1,2,3,4,99]'
  • json_insert('[1,[2,3],4]','$[1][#]',99)→ '[1,[2,3,99],4]'

Autres exemples :

  • json_insert('{"a":2, "c":4}', '$.a', 99)→ "{"a":2, "c":4}
  • json_insert('{"a":2, "c":4}', '$.e', 99)→ '{"a":2, "c":4, "e":99}'
  • json_replace('{"a":2, "c":4}', '$.a', 99)→ '{"a":99, "c":4}'
  • json_replace('{"a":2, "c":4}', '$.e', 99)→ '{"a":2, "c":4}'
  • json_set('{"a":2, "c":4}', '$.a', 99)→ '{"a":99, "c":4}'
  • json_set('{"a":2, "c":4}', '$.e', 99)→ '{"a":2, "c":4, "e":99}'
  • json_set('{"a":2, "c":4}', '$.c', '[97,96]')→ '{"a":2, "c" :"[97,96]"}'
  • json_set('{"a":2, "c":4}', '$.c', json('[97,96]'))→ '{"a":2, "c" :[97,96]}'
  • json_set('{"a":2, "c":4}', '$.c', json_array(97,96))→ '{"a":2, "c" :[97,96]}'

4.6. La fonction json_object()

La fonction SQL json_object() accepte zéro ou plusieurs paires d'arguments et renvoie un objet JSON bien formé qui est composé à partir de ces arguments. Le premier argument de chaque paire est le label et le second argument de chaque paire est la valeur. Si l'un des arguments de json_object() est un BLOB alors une erreur est lancée.

La fonction json_object() permet actuellement les étiquettes dupliquées sans plainte, bien que cela puisse changer dans une future amélioration.

Un argument avec le type SQL TEXT il est normalement converti en une chaîne JSON entre guillemets même si le texte d'entrée est JSON bien formé. Cependant, si l'argument est le résultat direct d'une autre fonction json1, alors il est traité comme JSON et toutes ses informations de type JSON et sa sous-structure sont préservées. Cela permet d'imbriquer les appels à json_object() et à json_array(). La fonction json() peut également être utilisée pour forcer les chaînes de caractères à être reconnues comme JSON.

Exemples :

  • json_object('a',2, 'c',4)→ "{"a":2, "c":4}
  • json_object('a',2,'c', '{e:5}')→ '{"a":2, "c" :"{e:5}"}'
  • json_objet('a',2,'c',json_objet('e',5))→ '{"a":2, "c":{"e":5}}'

4.7. La fonction json_patch()

La fonction SQL json_patch(T,P) exécute la fonction RFC-7396 algorithme MergePatch pour appliquer le patch P contre l'entrée T. La copie patchée de T est retournée.

MergePatch peut ajouter, modifier ou supprimer des éléments d'un objet JSON, et donc pour les objets JSON, la routine json_patch() est un remplacement généralisé de json_set() et json_remove(). Cependant, MergePatch traite les objets JSON Array comme des objets atomiques. MergePatch ne peut pas ajouter à un tableau ni modifier les éléments individuels d'un tableau. Il ne peut qu'insérer, remplacer ou supprimer l'ensemble du tableau comme une seule unité. Par conséquent, json_patch() n'est pas aussi utile lorsque vous traitez avec JSON qui comprend des Arrays, en particulier des Arrays avec beaucoup de sous-structure.

Exemples :

  • json_patch('{"a":1,"b":2}','{"c":3,"d":4}')→ "{"a":1, "b":2, "c":3, "d":4}
  • json_patch('{"a" :[1,2], "b":2}', '{"a":9}')→ "{"a":9, "b":2}
  • json_patch('{"a" :[1,2],"b":2}','{"a":null}')→ '{"b":2}'
  • json_patch('{"a":1,"b":2}','{"a":9,"b":null,"c":8}')→ '{"a":9, "c":8}'
  • json_patch('{"a":{"x":1,"y":2},"b":3}','{"a":{"y":9},"c":8}')→ '{"a":{"x":1,"y":9},"b":3,"c":8}'

4.8. La fonction json_remove()

La fonction json_remove(X,P,...) prend une seule valeur JSON comme premier argument, suivie de zéro ou plusieurs arguments de chemin. La fonction json_remove(X,P,...) renvoie une copie du paramètre X avec tous les éléments identifiés par les arguments de chemin supprimés. Les chemins qui sélectionnent des éléments non trouvés dans X sont silencieusement ignorés.

Les suppressions se produisent séquentiellement de gauche à droite. Les changements causés par les suppressions antérieures peuvent affecter la recherche de chemin pour les arguments suivants.

Si la fonction json_remove(X) est appelée sans arguments de chemin, alors elle renvoie l'entrée X reformatée, avec l'espace blanc excédentaire supprimé.

La fonction json_remove() jette une erreur si le premier argument n'est pas un JSON bien formé ou si tout argument ultérieur n'est pas un chemin bien formé, ou si tout argument est un BLOB.

Exemples :

  • json_remove('[0,1,2,3,4]','$[2]')→ '[0,1,3,4]'
  • json_remove('[0,1,2,3,4]','$[2]','$[0]')→ '[1,3,4]'
  • json_remove('[0,1,2,3,4]','$[0]','$[2]')→ '[1,2,4]'
  • json_remove('[0,1,2,3,4]','$[#-1]','$[0]')→ '[1,2,3]'
  • json_remove('{"x":25,"y":42}')→ '{"x":25, "y":42}'
  • json_remove('{"x":25,"y":42}','$.z')→ '{"x":25, "y":42}'
  • json_remove('{"x":25,"y":42}','$.y')→ '{"x":25}'
  • json_remove('{"x":25,"y":42}','$')→ NULL

4.9. La fonction json_type()

La fonction json_type(X) renvoie le "type" de l'élément le plus externe de X. La fonction json_type(X,P) renvoie le "type" de l'élément de X qui est sélectionné par le chemin P. Le "type" renvoyé par json_type() est l'une des valeurs textuelles an SQL suivantes : 'null', 'true', 'false', 'integer', 'real', 'text', 'array' ou 'object'. Si le chemin P dans json_type(X,P) sélectionne un élément qui n'existe pas dans X, alors cette fonction renvoie NULL.

La fonction json_type() jette une erreur si l'un de ses arguments n'est pas bien formé ou est un BLOB.

Exemples :

  • json_type('{"a" :[2,3.5,true,false,null,"x"]}')→ "objet
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$')→ objet
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a')→ 'array' (tableau)
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[0]')→ 'integer' (entier)
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[1]')→ "réel
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[2]')→ 'true'
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[3]')→ 'false'
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[4]')→ 'null'
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[5]')→ "texte
  • json_type('{"a" :[2,3.5,true,false,null,"x"]}','$.a[6]')→ NULL

4.10. La fonction json_valid()

La fonction json_valid(X) renvoie 1 si l'argument X est un JSON bien formé et renvoie 0 si l'argument X n'est pas un JSON bien formé.

Exemples :

  • json_valid('{"x":35}')→ 1
  • json_valid('{"x":35}')→ 0

4.11. La fonction json_quote()

La fonction json_quote(X) convertit la valeur SQL X (un nombre ou une chaîne) en sa représentation JSON correspondante.

Exemples :

  • json_quote(3.14159)→ 3.14159
  • json_quote('verdoyant')→ "verdoyant"

4.12. Les fonctions SQL d'agrégation json_group_array() et json_group_object().

La fonction json_group_array(X) est une fonction SQL d'agrégation qui renvoie un tableau JSON composé de toutes les valeurs X de l'agrégation. De même, la fonction json_group_object(NAME,VALUE) renvoie un objet JSON composé de toutes les paires NAME/VALUE dans l'agrégation.

4.13. Les fonctions à valeur de table json_each() et json_tree().

Les fonctions json_each(X) et json_tree(X) table-valued parcourent la valeur JSON fournie comme premier argument et renvoient une ligne pour chaque élément. La fonction json_each(X) parcourt uniquement les enfants immédiats du tableau ou de l'objet de niveau supérieur ou seulement l'élément de niveau supérieur lui-même si l'élément de niveau supérieur est une valeur primitive. La fonction json_tree(X) parcourt récursivement la sous-structure JSON en commençant par l'élément de premier niveau.

Les fonctions json_each(X,P) et json_tree(X,P) fonctionnent comme leurs homologues à un argument, sauf qu'elles traitent l'élément identifié par le chemin P comme l'élément de niveau supérieur.

Le schéma de la table retournée par json_each() et json_tree() est le suivant :

CREATETABLE json_tree(keyANY,-- key for current element relative to its parentvalueANY,-- value for the current elementtypeTEXT,-- 'object','array','string','integer', etc.
    atom ANY,-- value for primitive types, null for array & object
    id INTEGER,-- integer ID for this element
    parent INTEGER,-- integer ID for the parent of this element
    fullkey TEXT,-- full path describing the current element
    path TEXT,-- path to the container of the current row
    json JSON HIDDEN,-- 1st input parameter: the raw JSON
    root TEXT HIDDEN     -- 2nd input parameter: the PATH at which to start);

La colonne "key" est l'indice de tableau entier pour les éléments d'un tableau JSON et l'étiquette de texte pour les éléments d'un objet JSON. La colonne "key" est NULL dans tous les autres cas.

La colonne "atom" est la valeur SQL correspondant aux éléments primitifs - éléments autres que les tableaux et les objets JSON. La colonne "atom" est NULL pour un tableau ou un objet JSON. La colonne "value" est la même que la colonne "atom" pour les éléments primitifs JSON mais prend la valeur JSON textuelle pour les tableaux et les objets.

La colonne "type" est une valeur textuelle SQL prise parmi ('null', 'true', 'false', 'integer', 'real', 'text', 'array', 'object') en fonction du type de l'élément JSON courant.

La colonne "id" est un nombre entier qui identifie un élément JSON spécifique dans la chaîne JSON complète. L'entier "id" est un numéro interne de gestion, dont le calcul pourrait changer dans les prochaines versions. La seule garantie est que la colonne "id" sera différente pour chaque ligne.

La colonne "parent" est toujours NULL pour json_each(). Pour json_tree(), la colonne "parent" est l'entier "id" pour le parent de l'élément actuel, ou NULL pour l'élément JSON de niveau supérieur ou l'élément identifié par le chemin racine dans le deuxième argument.

La colonne "fullkey" est un chemin de texte qui identifie de manière unique l'élément de la ligne actuelle dans la chaîne JSON originale. La clé complète du véritable élément de premier niveau est renvoyée même si un autre point de départ est fourni par l'argument "root".

La colonne "path" est le chemin d'accès au tableau ou au conteneur d'objets qui contient la ligne actuelle, ou le chemin d'accès à la ligne actuelle dans le cas où l'itération commence sur un type primitif et ne fournit donc qu'une seule ligne de sortie.

4.13.1. Exemples utilisant json_each() et json_tree().

Supposons que la table "CREATE TABLE user(name,phone)" stocke zéro ou plusieurs numéros de téléphone sous la forme d'un objet tableau JSON dans le champ user.phone. Pour trouver tous les utilisateurs qui ont un numéro de téléphone quelconque avec un code régional 704 :

SELECTDISTINCTusername
  FROMuser, json_each(userphone)WHERE json_eachvalueLIKE'704-%';

Supposons maintenant que le champ user.phone contienne du texte brut si l'utilisateur n'a qu'un seul numéro de téléphone et un tableau JSON si l'utilisateur a plusieurs numéros de téléphone. La même question est posée : "Quels utilisateurs ont un numéro de téléphone dans l'indicatif régional 704 ?" Mais maintenant, la fonction json_each() ne peut être appelée que pour les utilisateurs qui ont deux numéros de téléphone ou plus, car json_each() nécessite du JSON bien formé comme premier argument :

SELECT name FROMuserWHERE phone LIKE'704-%'UNIONSELECTusername
  FROMuser, json_each(userphone)WHERE json_valid(userphone)AND json_eachvalueLIKE'704-%';

Considérons une autre base de données avec "CREATE TABLE big(json JSON)". Pour voir une décomposition complète ligne par ligne des données :

SELECT bigrowid, fullkey,valueFROM big, json_tree(bigjson)WHERE json_treetypeNOTIN('object','array');

Dans la précédente, le terme "type NOT IN ('object', 'array')" de la clause WHERE supprime les conteneurs et ne laisse passer que les éléments feuilles. Le même effet pourrait être obtenu de cette manière :

SELECT bigrowid, fullkey, atom
  FROM big, json_tree(bigjson)WHERE atom ISNOTNULL;

Supposons que chaque entrée de la table BIG est un objet JSON avec un champ '$.id' qui est un identifiant unique et un champ '$.partlist' qui peut être un objet profondément imbriqué. Vous voulez trouver l'id de chaque entrée qui contient une ou plusieurs références à l'uuid '6fa5181e-5721-11e5-a04e-57f3d7b32808' n'importe où dans son '$.partlist'.

SELECTDISTINCT json_extract(bigjson,'$.id')FROM big, json_tree(bigjson,'$.partlist')WHERE json_treekey='uuid'AND json_treevalue='6fa5181e-5721-11e5-a04e-57f3d7b32808';