Opérateurs de types de données JSON

Découvrez les opérateurs disponibles pour les types de données " json et " jsonb

Il existe des variantes parallèles des opérateurs pour les types " json et " jsonb Les opérateurs d'extraction de champ/élément/chemin renvoient le même type que leur entrée gauche (soit " json, soit " jsonb), à l'exception des opérateurs spécifiés comme renvoyant " text, qui convertissent la valeur en texte. Les opérateurs d'extraction champ/élément/chemin renvoient NULL, au lieu d'échouer, si la structure de l'entrée JSON ne correspond pas à la demande ; par exemple, si aucun élément de ce type n'existe. Les opérateurs d'extraction de champ/élément/chemin qui acceptent les indices de tableaux JSON entiers prennent tous en charge l'indice négatif à partir de la fin des tableaux.

Note : Les opérateurs " #> et " #>> utilisent des tableaux JSONB comme opérande de droite.

Opérateurs disponibles pour json et jsonb

->

Type d'opérande de droite : int

Obtenir un élément de tableau JSON (indexé à partir de zéro, les nombres entiers négatifs comptent à partir de la fin).

Exemples :

SELECT '["football", "volleyball", "soccer"]'::JSONB -> 0;
  ?COLUMN?  
------------
 "football"
(1 row)

SELECT '["football", "volleyball", "soccer"]'::JSONB -> -1;
 ?COLUMN? 
----------
 "soccer"
(1 row)

->

Type d'opérande de droite : texte

Obtention d'un objet JSON classé par clé.

Exemples :

SELECT '{"name": "Joe Smith", "age": 28}'::JSONB -> 'name';
  ?COLUMN?   
-------------
 "Joe Smith"
(1 row)

SELECT '{"name": "Joe Smith", "age": 28}'::JSONB -> 'age';
 ?COLUMN? 
----------
 28
(1 row)

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football", "volleyball", "soccer"]}'::JSONB -> 'sports' -> 0;
  ?COLUMN?  
------------
 "football"
(1 row)

->>

Type d'opérande de droite : int

Obtenir un élément de tableau JSON sous la forme 'nvarchar.

Exemples :

SELECT '["football", "volleyball", "soccer"]'::JSONB ->> 0;
 ?COLUMN? 
----------
 football
(1 row)

SELECT '["football", "volleyball", "soccer"]'::JSONB ->> -1;
 ?COLUMN? 
----------
 soccer
(1 row)

->>

Type d'opérande de droite : texte

Obtenir le champ de l'objet JSON sous la forme 'nvarchar.

Exemples :

SELECT '{"name": "Joe Smith", "age": 28}'::JSONB ->> 'name';
 ?COLUMN?  
-----------
 Joe Smith
(1 row)

SELECT '{"name": "Joe Smith", "age": 28}'::JSONB ->> 'age';
 ?COLUMN? 
----------
 28
(1 row)

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football", "volleyball", "soccer"]}'::JSONB -> 'sports' ->> 0;
 ?COLUMN? 
----------
 football
(1 row)

#>

Type d'opérande droit : Tableaux JSONB

Fonction : json_extract_path, jsonb_extract_path

Obtenir un objet JSON au chemin spécifié.

Exemples :

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football", "volleyball", "soccer"]}'::JSONB #> '["sports", 0]';
  ?COLUMN?  
------------
 "football"
(1 row)

#>>

Type d'opérande droit : Tableaux JSONB

Nom de la fonction : json_extract_path_text, jsonb_extract_path_text

Obtenir l'objet JSON au chemin spécifié en tant que 'nvarchar.

Exemples :

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football", "volleyball", "soccer"]}'::JSONB #>> '["sports", 0]';
 ?COLUMN? 
----------
 football
(1 row)

D'autres opérateurs n'existent également que pour le " jsonb, comme décrit dans la section suivante du présent document.

Opérateurs disponibles pour jsonb

Remarque : certains pilotes NPS ne prennent pas en charge les opérateurs contenant un point d'interrogation. Au lieu de cela, vous devez utiliser la fonction. De même, les opérateurs " ?| et " ?& utilisent des tableaux JSONB comme type d'opérande droit.

?

Type d'opérande de droite : texte

Nom de la fonction : jsonb_exists

La chaîne existe-t-elle en tant que clé de premier niveau dans la valeur JSON ?

Exemples :

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football"]}'::JSONB ? 'age';
 ?COLUMN? 
----------
 t
(1 row)

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football"]}'::JSONB ? 'address';
 ?COLUMN? 
----------
 f
(1 row)

SELECT '{"n":null,"a":1,"b":[1,2],"c":{"1":2},"d":{"1":[2,3]},"一":"二"}'::jsonb ? 'e';
 ?COLUMN? 
----------
 f
(1 row)

SELECT jsonb_exists('{"一":"null", "二":"qq"}', '三');
 JSONB_EXISTS 
--------------
 f
(1 row)

Astuce : Les points d'interrogation ( ?) sont utilisés comme paramètres dans les pilotes ODBC et OLEDB. Vous devez utiliser " jsonb_exists() pour vérifier l'existence d'une clé :

Exemples :

SELECT jsonb_exists('{"name": "Joe Smith", "age": 28, "sports": ["football"]}', 'age');
 JSONB_EXISTS 
--------------
 t
(1 row)

SELECT jsonb_exists('{"name": "Joe Smith", "age": 28, "sports": ["football"]}', 'address');
 JSONB_EXISTS 
--------------
 f
(1 row)

?|

Type d'opérande droit : Tableaux JSONB

Fonction : jsonb_exists_any

Voir également les fonctions de surcharge.

L'une de ces chaînes de tableau existe-t-elle en tant que clé de premier niveau ?

Exemples :

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football"]}'::JSONB ?| '["age", "address"]';
 ?COLUMN? 
----------
 t
(1 row)

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football"]}'::JSONB ?| '["mobile", "address"]';
 ?COLUMN? 
----------
 f
(1 row)

Astuce : Les points d'interrogation ( ?) sont utilisés comme paramètres dans les pilotes ODBC et OLEDB. Vous devez utiliser " jsonb_exists_any() pour vérifier l'existence d'une clé :

Exemples :

SELECT jsonb_exists_any('{"name": "Joe Smith", "age": 28, "sports": ["football"]}', '["age", "address"]');
 JSONB_EXISTS_ANY 
------------------
 t
(1 row)

SELECT jsonb_exists_any('{"name": "Joe Smith", "age": 28, "sports": ["football"]}', '["mobile", "address"]');
 JSONB_EXISTS_ANY 
------------------
 f
(1 row)

?&

Type d'opérande droit : Tableaux JSONB

Fonction : jsonb_exists_all

Voir également les fonctions de surcharge.

Toutes ces chaînes de tableaux existent-elles en tant que clés de premier niveau ?

Exemples :

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football"]}'::JSONB ?& '["age", "address"]';
 ?COLUMN? 
----------
 f
(1 row)

SELECT '{"name": "Joe Smith", "age": 28, "sports": ["football"]}'::JSONB ?& '["age", "sports"]';
 ?COLUMN? 
----------
 t
(1 row)

Astuce : Les points d'interrogation ( ?) sont utilisés comme paramètres dans les pilotes ODBC et OLEDB. Vous devez utiliser " jsonb_exists_all() pour vérifier l'existence d'une clé :

Exemples :

SELECT jsonb_exists_all('{"name": "Joe Smith", "age": 28, "sports": ["football"]}', '["age", "address"]');
 JSONB_EXISTS_ALL 
------------------
 f
(1 row)

SELECT jsonb_exists_all('{"name": "Joe Smith", "age": 28, "sports": ["football"]}', '["age", "sports"]');
 JSONB_EXISTS_ALL 
------------------
 t
(1 row)

@?

Type d'opérande droit : jsonpath

Fonction : jsonb_path_exists()

Retourne vrai si jsonpath renvoie au moins un élément pour la valeur jsonb spécifiée.

Exemples :

SELECT '2'                @? '$ > 1'::JSONPATH;
 ?COLUMN? 
----------
 t
(1 row)

select jsonb '{"a": 12}' @? '1';
 ?COLUMN? 
----------
 t
(1 row)

select jsonb '["1",2,0,3]' @? '-$[*]';
 ?COLUMN? 
----------
 t
(1 row)

@@

Type d'opérande droit : jsonpath

Fonction : jsonb_path_match

Renvoie le résultat de la vérification du prédicat de chemin JSON pour la valeur JSON spécifiée. Seul le premier élément du résultat est pris en compte. Si le résultat n'est pas booléen, il renvoie null

Exemples :

SELECT '2'::NCHAR(100)    @@ '$ > 1'::JSONPATH;
 ?COLUMN? 
----------
 t
(1 row)

SELECT '2'::JSONB @@ '$ > 1'::JSONPATH;
 ?COLUMN? 
----------
 t
(1 row)

SELECT '2'::JSONB @@ '1'::INT;
ERROR:  Cannot convert 'INT4' to 'JSONB'
SELECT '2'::JSONB @@ '1'::JSONB;
ERROR:  Unable to identify an operator '@@' for types 'JSONB' and 'JSONB'
	You will have to retype this query using an explicit cast
SELECT '2'::JSONB @@ 'true'::BOOL ;
ERROR:  Cannot convert 'BOOL' to 'JSONB'

Le " @ ? les opérateurs et @@ sont supprimés :

Erreur de champ d'objet ou d'élément de tableau manquant.
Type d'élément JSON inattendu et erreurs numériques.

Cela peut s'avérer utile si vous effectuez des recherches dans des collections de documents JSON dont la structure varie.

Confinement et existence

endiguement

Le confinement des tests est une capacité importante du type de données " jsonb Le type " json ne dispose pas d'un ensemble parallèle de telles facilités. Le confinement permet de vérifier si un document " jsonb contient un autre document.

L'objet contenu doit correspondre à l'objet contenant en ce qui concerne la structure et le contenu des données, éventuellement après avoir éliminé certains éléments de tableau ou paires clé/valeur d'objet ne correspondant pas à l'objet contenant. L'ordre des éléments du tableau n'a pas d'importance lorsqu'il s'agit d'effectuer une comparaison de confinement, et les éléments dupliqués du tableau ne sont effectivement pris en compte qu'une seule fois.

Exemples :

Les valeurs scalaires/primitives simples ne contiennent que la valeur identique :
```
SELECT '"foo"'::jsonb @> '"foo"'::jsonb;
?COLUMN? 
----------
 t
(1 row)
```

Le tableau de droite est contenu dans celui de gauche :

SELECT '[1, 2, 3]'::jsonb @> '[1, 3]'::jsonb;
?COLUMN? 
----------
 t
(1 row)

L'ordre des éléments d'un tableau n'est pas significatif, ce qui est également vrai :
```
SELECT '[1, 2, 3]'::jsonb @> '[3, 1]'::jsonb;
?COLUMN? 
----------
 t
(1 row)
```

Les éléments de tableau dupliqués n'ont pas d'importance non plus :

SELECT '[1, 2, 3]'::jsonb @> '[1, 2, 2]'::jsonb;
?COLUMN? 
----------
 t
(1 row)

L'objet avec une seule paire sur le côté droit est contenu dans l'objet sur le côté gauche :

SELECT '{"product": "PostgreSQL", "version": 9.4, "jsonb": true}'::jsonb @> '{"version": 9.4}'::jsonb;
?COLUMN? 
----------
 t
(1 row)

Le tableau de droite n'est pas considéré comme contenu dans le tableau de gauche, même si un tableau similaire y est imbriqué :

SELECT '[1, 2, [1, 3]]'::jsonb @> '[1, 3]'::jsonb;
?COLUMN? 
----------
 f
(1 row)

Mais avec une couche d'emboîtement, elle est contenue :

SELECT '[1, 2, [1, 3]]'::jsonb @> '[[1, 3]]'::jsonb;
?COLUMN? 
----------
 t
(1 row)

De même, le confinement n'est pas mentionné ici :

SELECT '{"foo": {"bar": "baz"}}'::jsonb @> '{"bar": "baz"}'::jsonb;
?COLUMN? 
----------
 f
(1 row)

Une clé de premier niveau et un objet vide sont contenus :

SELECT '{"foo": {"bar": "baz"}}'::jsonb @> '{"foo": {}}'::jsonb;
?COLUMN? 
----------
 t
(1 row)

Un tableau peut contenir une valeur primitive, ce qui constitue une exception au principe de correspondance des structures.

Exemple :

SELECT '["foo", "bar"]'::jsonb @> '"bar"'::jsonb;
?COLUMN? 
----------
 t
(1 row)

Cette exception n'est pas réciproque ; les cas de non-confinement sont signalés ici :

SELECT '"bar"'::jsonb @> '["bar"]'::jsonb;
?COLUMN? 
----------
 f
(1 row)

Existence

jsonb a également un opérateur d'existence. Il teste si une chaîne de caractères (donnée comme valeur " text ) apparaît comme une clé d'objet ou un élément de tableau au niveau supérieur de la valeur " jsonb. les objets JSON sont mieux adaptés que les tableaux pour tester le confinement ou l'existence lorsque de nombreuses clés ou de nombreux éléments sont concernés. Contrairement aux tableaux, ils sont optimisés en interne pour la recherche et n'ont pas besoin d'être parcourus linéairement.

Exemples :

La chaîne existe en tant qu'élément de tableau :

SELECT '["foo", "bar", "baz"]'::jsonb ? 'bar';
?COLUMN? 
----------
 t
(1 row)

La chaîne de caractères existe en tant que clé de l'objet :

SELECT '{"foo": "bar"}'::jsonb ? 'foo';
?COLUMN? 
----------
 t
(1 row)

Les valeurs des objets ne sont pas prises en compte :

SELECT '{"foo": "bar"}'::jsonb ? 'bar';
?COLUMN? 
----------
 f
(1 row)

Comme pour le confinement, l'existence doit correspondre au niveau supérieur :

SELECT '{"foo": {"bar": "baz"}}'::jsonb ? 'bar';
?COLUMN? 
----------
 f
(1 row)

Une chaîne est considérée comme existante si elle correspond à une chaîne JSON primitive :
```
SELECT '"foo"'::jsonb ? 'foo';
?COLUMN? 
----------
 t
(1 row)
```