Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Mise en route avec JSON
MemoryDB prend en charge le format natif JSON ( JavaScript Object Notation), un moyen simple et sans schéma d'encoder des ensembles de données complexes dans des clusters Valkey ou Redis OSS. Vous pouvez stocker et accéder aux données de manière native à l'aide du format JSON ( JavaScript Object Notation) dans les clusters et mettre à jour les données JSON stockées dans ces clusters, sans avoir à gérer de code personnalisé pour les sérialiser et les désérialiser.
En plus de tirer parti de Valkey ou Redis OSS APIs pour les applications fonctionnant sur JSON, vous pouvez désormais récupérer et mettre à jour efficacement des parties spécifiques d'un document JSON sans avoir à manipuler l'objet dans son intégralité, ce qui peut améliorer les performances et réduire les coûts. Vous pouvez également rechercher le contenu de votre document JSON à l'aide de la requête `JSONPath` de [style Goessner](https://goessner.net/articles/JsonPath/).
Après avoir créé un cluster avec une version de moteur prise en charge, le type de données JSON et les commandes associées sont automatiquement disponibles. Ceci est compatible avec l'API et compatible RDB avec la version 2 du module RedisJSON, ce qui vous permet de migrer facilement les applications Valkey ou Redis OSS basées sur JSON existantes vers MemoryDB. Pour plus d'informations sur les commandes prises en charge, consultez[Commandes prises en charge](json-list-commands.md).
Une métrique liée au JSON `JsonBasedCmds` est intégrée CloudWatch pour surveiller l'utilisation de ce type de données. Pour plus d'informations, consultez [Metrics for MemoryDB](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html).
**Note**
Pour utiliser JSON, vous devez exécuter Valkey 7.2 ou version ultérieure, ou le moteur Redis OSS version 6.2.6 ou ultérieure.
**Topics**
+ [Présentation du type de données JSON](json-document-overview.md)
+ [Commandes prises en charge](json-list-commands.md)
# Présentation du type de données JSON
MemoryDB prend en charge un certain nombre de commandes Valkey et Redis OSS pour travailler avec le type de données JSON. Vous trouverez ci-dessous un aperçu du type de données JSON et une liste détaillée des commandes prises en charge.
## Terminologie
****
| Terme | Description |
| --- | --- |
| Document JSON | fait référence à la valeur d'une clé JSON |
| Valeur JSON | fait référence à un sous-ensemble d'un document JSON, y compris la racine qui représente l'intégralité du document. Une valeur peut être un conteneur ou une entrée dans un conteneur |
| Élément JSON | équivalent à une valeur JSON |
## Norme JSON prise en charge
Le format JSON est conforme à la norme d'échange de données JSON [RFC 7159](https://www.ietf.org/rfc/rfc7159.txt) et [ECMA-404](https://www.ietf.org/rfc/rfc7159.txt). L'[Unicode](https://www.unicode.org/standard/WhatIsUnicode.html) UTF-8 dans le texte JSON est pris en charge.
## Élément racine
L'élément racine peut être de n'importe quel type de données JSON. Notez que dans la précédente RFC 4627, seuls les objets ou les tableaux étaient autorisés comme valeurs racine. Depuis la mise à jour vers la RFC 7159, la racine d'un document JSON peut être de n'importe quel type de données JSON.
## Limite de taille du document
Les documents JSON sont stockés en interne dans un format optimisé pour un accès et une modification rapides. Ce format consomme généralement un peu plus de mémoire que la représentation sérialisée équivalente du même document. La consommation de mémoire par un seul document JSON est limitée à 64 Mo, ce qui correspond à la taille de la structure de données en mémoire, et non à la chaîne JSON. La quantité de mémoire consommée par un document JSON peut être inspectée à l'aide de la `JSON.DEBUG MEMORY` commande.
## JSON ACLs
+ Le type de données JSON est entièrement intégré à la fonctionnalité des [listes de contrôle d'accès (](https://valkey.io/topics/acl/)ACL) Valkey et Redis OSS. À l'instar des catégories existantes par type de données (@string, @hash, etc.), une nouvelle catégorie @json est ajoutée pour simplifier la gestion de l'accès aux commandes et aux données JSON. Aucune autre commande Valkey ou Redis OSS existante n'appartient à la catégorie @json. Toutes les commandes JSON appliquent les restrictions et autorisations des keyspaces ou des commandes.
+ Cinq catégories d'ACL existantes sont mises à jour pour inclure les nouvelles commandes JSON : @read, @write, @fast, @slow et @admin. Le tableau ci-dessous indique le mappage des commandes JSON vers les catégories appropriées.
**ACL**
| Commande JSON | @read | @write | @fast | @slow | @admin |
| --- | --- | --- | --- | --- | --- |
| JSON.ARRAPPEND | | y | y | | |
| JSON.ARRINDEX | y | | y | | |
| JSON.ARRINSERT | | y | y | | |
| JSON.ARRLEN | y | | y | | |
| JSON.ARRPOP | | y | y | | |
| JSON.ARRTRIM | | y | y | | |
| JSON.CLEAR | | y | y | | |
| JSON.DEBUG | y | | | y | y |
| JSON.DEL | | y | y | | |
| JSON.FORGET | | y | y | | |
| JSON.GET | y | | y | | |
| JSON.MGET | y | | y | | |
| JSON.NUMINCRBY | | y | y | | |
| JSON.NUMMULTBY | | y | y | | |
| JSON.OBJKEYS | y | | y | | |
| JSON.OBJLEN | y | | y | | |
| JSON.RESP | y | | y | | |
| JSON.SET | | y | | y | |
| JSON.STRAPPEND | | y | y | | |
| JSON.STRLEN | y | | y | | |
| JSON.STRLEN | y | | y | | |
| JSON.TOGGLE | | y | y | | |
| JSON.TYPE | y | | y | | |
| JSON.NUMINCRBY | | y | y | | |
## Limite de profondeur d'imbrication
Lorsqu'un objet ou un tableau JSON possède un élément qui est lui-même un autre objet ou tableau JSON, cet objet ou tableau intérieur est dit « imbriqué » dans l'objet ou le tableau extérieur. La limite maximale de la profondeur d'imbrication est de 128. Toute tentative de création d'un document contenant une profondeur d'imbrication supérieure à 128 sera rejetée avec une erreur.
## Syntaxe de commande
La plupart des commandes nécessitent un nom de clé Valkey ou Redis OSS comme premier argument. Certaines commandes ont également un argument path. L'argument path prend par défaut la racine s'il est facultatif et non fourni.
Notation :
+ Les arguments obligatoires sont placés entre crochets, par exemple
+ Les arguments facultatifs sont placés entre crochets, par exemple [path]
+ Les arguments facultatifs supplémentaires sont indiqués par..., par exemple [json...]
## Syntaxe de chemin
JSON pour Valkey et Redis OSS prend en charge deux types de syntaxes de chemin :
+ **Syntaxe améliorée** — Suit la JSONPath syntaxe décrite par [Goessner](https://goessner.net/articles/JsonPath/), comme indiqué dans le tableau ci-dessous. Nous avons réorganisé et modifié les descriptions dans le tableau pour plus de clarté.
+ **Syntaxe restreinte** : possède des capacités de requête limitées.
**Note**
Les résultats de certaines commandes dépendent du type de syntaxe de chemin utilisé.
Si un chemin de requête commence par « \$1 », il utilise la syntaxe améliorée. Sinon, la syntaxe restreinte est utilisée.
**Syntaxe améliorée**
****
| Symbole/Expression | Description |
| --- | --- |
| \$1 | l'élément racine |
| . ou [] | enfant opérateur |
| .. | descente récursive |
| \$1 | joker. Tous les éléments d'un objet ou d'un tableau. |
| [] | opérateur d'indice de tableau. L'index est basé sur 0. |
| [,] | opérateur syndical |
| [start:end:step] | opérateur de tranche de tableau |
| ?() | applique une expression de filtre (script) au tableau ou à l'objet en cours |
| () | expression du filtre |
| @ | utilisé dans les expressions de filtre faisant référence au nœud en cours de traitement |
| == | égal à, utilisé dans les expressions de filtre. |
| \$1= | différent de, utilisé dans les expressions de filtre. |
| > | supérieur à, utilisé dans les expressions de filtre. |
| >= | supérieur ou égal à, utilisé dans les expressions de filtre. |
| < | inférieur à, utilisé dans les expressions de filtre. |
| <= | inférieur ou égal à, utilisé dans les expressions de filtre. |
| && | ET logique, utilisé pour combiner plusieurs expressions de filtre. |
| \$1\$1 | OR logique, utilisé pour combiner plusieurs expressions de filtre. |
**Exemples**
Les exemples ci-dessous sont basés sur les exemples de données XML [de Goessner](https://goessner.net/articles/JsonPath/), que nous avons modifiés en ajoutant des champs supplémentaires.
```
{ "store": {
"book": [
{ "category": "reference",
"author": "Nigel Rees",
"title": "Sayings of the Century",
"price": 8.95,
"in-stock": true,
"sold": true
},
{ "category": "fiction",
"author": "Evelyn Waugh",
"title": "Sword of Honour",
"price": 12.99,
"in-stock": false,
"sold": true
},
{ "category": "fiction",
"author": "Herman Melville",
"title": "Moby Dick",
"isbn": "0-553-21311-3",
"price": 8.99,
"in-stock": true,
"sold": false
},
{ "category": "fiction",
"author": "J. R. R. Tolkien",
"title": "The Lord of the Rings",
"isbn": "0-395-19395-8",
"price": 22.99,
"in-stock": false,
"sold": false
}
],
"bicycle": {
"color": "red",
"price": 19.95,
"in-stock": true,
"sold": false
}
}
}
```
****
| Chemin | Description |
| --- | --- |
| \$1.store.book[\$1].author | les auteurs de tous les livres de la boutique |
| \$1..author | tous les auteurs |
| \$1.store.\$1 | tous les membres de la boutique |
| \$1["store"].\$1 | tous les membres de la boutique |
| \$1.store..price | le prix de tout ce qui se trouve dans le magasin |
| \$1..\$1 | tous les membres récursifs de la structure JSON |
| \$1..book[\$1] | tous les livres |
| \$1..book[0] | le premier livre |
| \$1..book[-1] | le dernier livre |
| \$1..book[0:2] | les deux premiers livres |
| \$1..book[0,1] | les deux premiers livres |
| \$1..book[0:4] | livres de l'index 0 à 3 (l'index final n'est pas inclus) |
| \$1..book[0:4:2] | livres aux index 0, 2 |
| \$1..book[?(@.isbn)] | tous les livres avec numéro ISBN |
| \$1..book[?(@.price<10)] | tous les livres à moins de 10\$1 |
| '\$1..book[?(@.price < 10)]' | tous les livres moins chers que 10\$1. (Le chemin doit être entre guillemets s'il contient des espaces) |
| '\$1..book[?(@["price"] < 10)]' | tous les livres à moins de 10\$1 |
| '\$1..book[?(@.["price"] < 10)]' | tous les livres à moins de 10\$1 |
| \$1.. book [? (@.prix>=10&&@.prix<=100)] | tous les livres dans la fourchette de prix de 10\$1 à 100\$1, inclus |
| '\$1..book[?(@.price>=10 && @.price<=100)]' | tous les livres dont le prix varie de 10\$1 à 100\$1, inclus. (Le chemin doit être entre guillemets s'il contient des espaces) |
| \$1..book[?(@.sold==true\$1\$1@.in-stock==false)] | tous les livres sont vendus ou en rupture de stock |
| '\$1..book[?(@.sold == true \$1\$1 @.in-stock == false)]' | tous les livres sont vendus ou sont en rupture de stock. (Le chemin doit être entre guillemets s'il contient des espaces) |
| '\$1.store.book[?(@.["category"] == "fiction")]' | tous les livres de la catégorie fiction |
| '\$1.store.book[?(@.["category"] \$1= "fiction")]' | tous les livres dans les catégories non-fictionnelles |
Autres exemples d'expressions de filtre :
```
127.0.0.1:6379> JSON.SET k1 . '{"books": [{"price":5,"sold":true,"in-stock":true,"title":"foo"}, {"price":15,"sold":false,"title":"abc"}]}'
OK
127.0.0.1:6379> JSON.GET k1 $.books[?(@.price>1&&@.price<20&&@.in-stock)]
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.price>1 && @.price<20 && @.in-stock)]'
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?((@.price>1 && @.price<20) && (@.sold==false))]'
"[{\"price\":15,\"sold\":false,\"title\":\"abc\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.title == "abc")]'
[{"price":15,"sold":false,"title":"abc"}]
127.0.0.1:6379> JSON.SET k2 . '[1,2,3,4,5]'
127.0.0.1:6379> JSON.GET k2 $.*.[?(@>2)]
"[3,4,5]"
127.0.0.1:6379> JSON.GET k2 '$.*.[?(@ > 2)]'
"[3,4,5]"
127.0.0.1:6379> JSON.SET k3 . '[true,false,true,false,null,1,2,3,4]'
OK
127.0.0.1:6379> JSON.GET k3 $.*.[?(@==true)]
"[true,true]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ == true)]'
"[true,true]"
127.0.0.1:6379> JSON.GET k3 $.*.[?(@>1)]
"[2,3,4]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ > 1)]'
"[2,3,4]"
```
**Syntaxe restreinte**
****
| Symbole/Expression | Description |
| --- | --- |
| . ou [] | enfant opérateur |
| [] | opérateur d'indice de tableau. L'index est basé sur 0. |
**Exemples**
****
| Chemin | Description |
| --- | --- |
| .store.book[0].author | l'auteur du premier livre |
| .store.book[-1].author | l'auteur du dernier livre |
| .address.city | nom de la ville |
| ["store"]["book"][0]["title"] | le titre du premier livre |
| ["store"]["book"][-1]["title"] | le titre du dernier livre |
**Note**
Tout le contenu de [Goessner](https://goessner.net/articles/JsonPath/) cité dans cette documentation est soumis à la [licence Creative Commons](https://creativecommons.org/licenses/by/2.5/).
## Préfixes d'erreur courantes
Chaque message d'erreur possède un préfixe. Voici une liste des préfixes d'erreur courants :
****
| Préfixe | Description |
| --- | --- |
| ERR | une erreur générale |
| LIMIT | erreur de dépassement de la limite de taille. Par exemple, la limite de taille du document ou la limite de profondeur d'imbrication ont été dépassées |
| NONEXISTENT | une clé ou un chemin n'existe pas |
| OUTOFBOUNDARIES | index de tableau hors limites |
| SYNTAXERR | erreur de syntaxe |
| WRONGTYPE | type de valeur incorrect |
## Métriques liées au JSON
Les métriques d'informations JSON suivantes sont fournies :
****
| Info (Infos) | Description |
| --- | --- |
| json\$1total\$1memory\$1bytes | mémoire totale allouée aux objets JSON |
| json\$1num\$1documents | nombre total de documents dans le moteur Valkey ou Redis OSS |
Pour interroger les métriques de base, exécutez la commande suivante :
```
info json_core_metrics
```
## Comment MemoryDB interagit avec JSON
Ce qui suit illustre comment MemoryDB interagit avec le type de données JSON.
### Priorité des opérateurs
Lors de l'évaluation d'expressions conditionnelles pour le filtrage, les && sont prioritaires, puis les \$1\$1 sont évalués, comme c'est le cas dans la plupart des langages. Les opérations entre parenthèses seront exécutées en premier.
### Comportement de la limite maximale d'imbrication des chemins
La limite maximale d'imbrication de chemins de MemoryDB est de 128. Ainsi, une valeur comme `$.a.b.c.d...` ne peut atteindre que 128 niveaux.
### Traitement des valeurs numériques
Le JSON ne dispose pas de types de données distincts pour les nombres entiers et les nombres à virgule flottante. Ils sont tous appelés des nombres.
Lorsqu'un numéro JSON est reçu, il est stocké dans l'un des deux formats suivants. Si le nombre correspond à un entier signé de 64 bits, il est converti dans ce format ; dans le cas contraire, il est stocké sous forme de chaîne. Les opérations arithmétiques sur deux nombres JSON (par exemple JSON.NUMINCRBY et JSON.NUMMULTBY) tentent de préserver le plus de précision possible. Si les deux opérandes et la valeur résultante correspondent à un entier signé de 64 bits, l'arithmétique des entiers est effectuée. Sinon, les opérandes d'entrée sont convertis en nombres à virgule flottante IEEE à double précision 64 bits, l'opération arithmétique est effectuée et le résultat est reconverti en chaîne.
Commandes arithmétiques `NUMINCRBY` et `NUMMULTBY` :
+ Si les deux nombres sont des entiers et que le résultat est hors de la plage de int64, il deviendra automatiquement un nombre à virgule flottante à double précision.
+ Si au moins l'un des nombres est un nombre à virgule flottante, le résultat sera un nombre à virgule flottante à double précision.
+ Si le résultat dépasse la plage de deux, la commande renvoie une `OVERFLOW` erreur.
**Note**
Avant la version 6.2.6.R2 du moteur Redis OSS, lorsqu'un numéro JSON était reçu en entrée, il était converti en l'une des deux représentations binaires internes : un entier signé de 64 bits ou un nombre à virgule flottante IEEE à double précision de 64 bits. La chaîne de caractères d'origine et toute sa mise en forme ne sont pas retenues. Ainsi, lorsqu'un nombre est généré en sortie dans le cadre d'une réponse JSON, il est converti de la représentation binaire interne en une chaîne imprimable qui utilise des règles de formatage génériques. Ces règles peuvent entraîner la génération d'une chaîne différente de celle qui a été reçue.
Si les deux nombres sont des entiers et que le résultat est hors de la plage de `int64`, il devient automatiquement un nombre à virgule flottante IEEE à double précision de 64 bits.
Si au moins un des nombres est un nombre à virgule flottante, le résultat est un nombre à virgule flottante IEEE à double précision de 64 bits.
Si le résultat dépasse la plage du double IEEE de 64 bits, la commande renvoie une erreur `OVERFLOW`.
Pour une liste détaillée des commandes disponibles, consultez [Commandes prises en charge](json-list-commands.md).
### Évaluation stricte de la syntaxe
MemoryDB n'autorise pas les chemins JSON dont la syntaxe est invalide, même si un sous-ensemble du chemin contient un chemin valide. Ceci afin de maintenir un comportement correct pour nos clients.
# Commandes prises en charge
Les commandes JSON suivantes sont prises en charge :
**Topics**
+ [JSON.ARRAPPEND](json-arrappend.md)
+ [JSON.ARRINDEX](json-arrindex.md)
+ [JSON.ARRINSERT](json-arrinsert.md)
+ [JSON.ARRLEN](json-arrlen.md)
+ [JSON.ARRPOP](json-arrpop.md)
+ [JSON.ARRTRIM](json-arrtrim.md)
+ [JSON.CLEAR](json-clear.md)
+ [JSON.DEBUG](json-debug.md)
+ [JSON.DEL](json-del.md)
+ [JSON.FORGET](json-forget.md)
+ [JSON.GET](json-get.md)
+ [JSON.MGET](json-mget.md)
+ [JSON.NUMINCRBY](json-numincrby.md)
+ [JSON.NUMMULTBY](json-nummultby.md)
+ [JSON.OBJLEN](json-objlen.md)
+ [JSON.OBJKEYS](json-objkeys.md)
+ [JSON.RESP](json-resp.md)
+ [JSON.SET](json-set.md)
+ [JSON.STRAPPEND](json-strappend.md)
+ [JSON.STRLEN](json-strlen.md)
+ [JSON.TOGGLE](json-toggle.md)
+ [JSON.TYPE](json-type.md)
# JSON.ARRAPPEND
Ajoutez une ou plusieurs valeurs aux valeurs du tableau sur le chemin.
Syntaxe
```
JSON.ARRAPPEND [json ...]
```
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — un chemin JSON
+ json (obligatoire) — Valeur JSON à ajouter au tableau
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la nouvelle longueur du tableau à chaque chemin.
+ Si une valeur n'est pas un tableau, sa valeur de retour correspondante est nulle.
+ Erreur `SYNTAXERR` si l'un des arguments d'entrée json n'est pas une chaîne JSON valide.
+ Erreur `NONEXISTENT` si le chemin n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Entier, la nouvelle longueur du tableau.
+ Si plusieurs valeurs de tableau sont sélectionnées, la commande renvoie la nouvelle longueur du dernier tableau mis à jour.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un tableau.
+ Erreur `SYNTAXERR` si l'un des arguments d'entrée json n'est pas une chaîne JSON valide.
+ Erreur `NONEXISTENT` si le chemin n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRAPPEND k1 $[*] '"c"'
1) (integer) 1
2) (integer) 2
3) (integer) 3
127.0.0.1:6379> JSON.GET k1
"[[\"c\"],[\"a\",\"c\"],[\"a\",\"b\",\"c\"]]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRAPPEND k1 [-1] '"c"'
(integer) 3
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"],[\"a\",\"b\",\"c\"]]"
```
# JSON.ARRINDEX
Recherchez la première occurrence d'une valeur JSON scalaire dans les tableaux situés sur le chemin.
+ Les erreurs hors limites sont traitées en arrondissant l'index au début et à la fin du tableau.
+ Si start > end, retourner -1 (non trouvé).
Syntaxe
```
JSON.ARRINDEX [start [end]]
```
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — un chemin JSON
+ json-scalar (obligatoire) : valeur scalaire à rechercher ; le scalaire JSON fait référence à des valeurs qui ne sont pas des objets ou des tableaux. C'est-à-dire que String, number, boolean et null sont des valeurs scalaires.
+ start (facultatif) — index de départ inclus. La valeur par défaut est 0 si elle n'est pas fournie.
+ end (facultatif) — index de fin, exclusif. La valeur par défaut est 0 s'il n'est pas fourni, ce qui signifie que le dernier élément est inclus. 0 ou -1 signifie que le dernier élément est inclus.
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers. Chaque valeur est l'index de l'élément correspondant dans le tableau au niveau du chemin. La valeur est -1 si elle n'est pas trouvée.
+ Si une valeur n'est pas un tableau, sa valeur de retour correspondante est nulle.
Si le chemin est une syntaxe restreinte :
+ Entier, l'index de l'élément correspondant, ou -1 si non trouvé.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un tableau.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRINDEX k1 $[*] '"b"'
1) (integer) -1
2) (integer) -1
3) (integer) 1
4) (integer) 1
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.ARRINDEX k1 .children '"Tom"'
(integer) 2
```
# JSON.ARRINSERT
Insérez une ou plusieurs valeurs dans les valeurs du tableau au niveau du chemin avant l'index.
Syntaxe
```
JSON.ARRINSERT [json ...]
```
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — un chemin JSON
+ index (obligatoire) — index du tableau avant lequel les valeurs sont insérées.
+ json (obligatoire) — Valeur JSON à ajouter au tableau
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la nouvelle longueur du tableau à chaque chemin.
+ Si une valeur est un tableau vide, sa valeur de retour correspondante est nulle.
+ Si une valeur n'est pas un tableau, sa valeur de retour correspondante est nulle.
+ Erreur `OUTOFBOUNDARIES` si l'argument index est hors limites.
Si le chemin est une syntaxe restreinte :
+ Entier, la nouvelle longueur du tableau.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un tableau.
+ Erreur `OUTOFBOUNDARIES` si l'argument index est hors limites.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRINSERT k1 $[*] 0 '"c"'
1) (integer) 1
2) (integer) 2
3) (integer) 3
127.0.0.1:6379> JSON.GET k1
"[[\"c\"],[\"c\",\"a\"],[\"c\",\"a\",\"b\"]]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRINSERT k1 . 0 '"c"'
(integer) 4
127.0.0.1:6379> JSON.GET k1
"[\"c\",[],[\"a\"],[\"a\",\"b\"]]"
```
# JSON.ARRLEN
Obtenez la longueur des valeurs du tableau sur le chemin.
Syntaxe
```
JSON.ARRLEN [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la longueur du tableau à chaque chemin.
+ Si une valeur n'est pas un tableau, sa valeur de retour correspondante est nulle.
+ Valeur nulle si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Tableau de chaînes en bloc. Chaque élément est un nom de clé dans l'objet.
+ Entier, longueur du tableau.
+ Si plusieurs objets sont sélectionnés, la commande renvoie la longueur du premier tableau.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un tableau.
+ Erreur `WRONGTYPE` si le chemin n'existe pas.
+ Valeur nulle si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[[], [\"a\"], [\"a\", \"b\"], [\"a\", \"b\", \"c\"]]'
(error) SYNTAXERR Failed to parse JSON string due to syntax error
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRLEN k1 $[*]
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 3
127.0.0.1:6379> JSON.SET k2 . '[[], "a", ["a", "b"], ["a", "b", "c"], 4]'
OK
127.0.0.1:6379> JSON.ARRLEN k2 $[*]
1) (integer) 0
2) (nil)
3) (integer) 2
4) (integer) 3
5) (nil)
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRLEN k1 [*]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k1 $[3]
1) (integer) 3
127.0.0.1:6379> JSON.SET k2 . '[[], "a", ["a", "b"], ["a", "b", "c"], 4]'
OK
127.0.0.1:6379> JSON.ARRLEN k2 [*]
(integer) 0
127.0.0.1:6379> JSON.ARRLEN k2 $[1]
1) (nil)
127.0.0.1:6379> JSON.ARRLEN k2 $[2]
1) (integer) 2
```
# JSON.ARRPOP
Supprime et renvoie l'élément à l'index du tableau. L'extraction d'un tableau vide renvoie valeur nulle.
Syntaxe
```
JSON.ARRPOP [path [index]]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
+ index (facultatif) — position dans le tableau à partir de laquelle commencer à apparaître.
+ La valeur par défaut est -1 si elle n'est pas fournie, ce qui signifie le dernier élément.
+ Une valeur négative signifie une position à partir du dernier élément.
+ Les index hors limites sont arrondis à leurs limites de tableau respectives.
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau de chaînes groupées, représentant les valeurs affichées à chaque chemin.
+ Si une valeur est un tableau vide, sa valeur de retour correspondante est nulle.
+ Si une valeur n'est pas un tableau, sa valeur de retour correspondante est nulle.
Si le chemin est une syntaxe restreinte :
+ Chaîne en bloc, représentant la valeur JSON affichée
+ Valeur nulle si le tableau est vide.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un tableau.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k1 $[*]
1) (nil)
2) "\"a\""
3) "\"b\""
127.0.0.1:6379> JSON.GET k1
"[[],[],[\"a\"]]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k1
"[\"a\",\"b\"]"
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"]]"
127.0.0.1:6379> JSON.SET k2 . '[[], ["a"], ["a", "b"]]'
OK
127.0.0.1:6379> JSON.ARRPOP k2 . 0
"[]"
127.0.0.1:6379> JSON.GET k2
"[[\"a\"],[\"a\",\"b\"]]"
```
# JSON.ARRTRIM
Découpez les tableaux au niveau du chemin pour qu'il devienne un sous-réseau [début, fin], inclus dans les deux cas.
+ Si le tableau est vide, ne rien faire, retourner 0.
+ Si start <0, le traiter comme 0.
+ Si end >= size (taille du tableau), le traiter comme size-1.
+ Si start >= size ou start > end, vider le tableau et retourner 0.
Syntaxe
```
JSON.ARRINSERT
```
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — un chemin JSON
+ start (obligatoire) — index de départ inclus.
+ fin (obligatoire) — index de fin, inclus.
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la nouvelle longueur du tableau à chaque chemin.
+ Si une valeur est un tableau vide, sa valeur de retour correspondante est nulle.
+ Si une valeur n'est pas un tableau, sa valeur de retour correspondante est nulle.
+ Erreur `OUTOFBOUNDARIES` si un argument d'index est hors limites.
Si le chemin est une syntaxe restreinte :
+ Entier, la nouvelle longueur du tableau.
+ Valeur nulle si le tableau est vide.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un tableau.
+ Erreur `OUTOFBOUNDARIES` si un argument d'index est hors limites.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[[], ["a"], ["a", "b"], ["a", "b", "c"]]'
OK
127.0.0.1:6379> JSON.ARRTRIM k1 $[*] 0 1
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 2
127.0.0.1:6379> JSON.GET k1
"[[],[\"a\"],[\"a\",\"b\"],[\"a\",\"b\"]]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.ARRTRIM k1 .children 0 1
(integer) 2
127.0.0.1:6379> JSON.GET k1 .children
"[\"John\",\"Jack\"]"
```
# JSON.CLEAR
Effacez les tableaux ou les objets situés sur le chemin.
Syntaxe
```
JSON.CLEAR [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
+ Entier, le nombre de conteneurs effacés.
+ La suppression d'un tableau ou d'un objet vide équivaut à 0 conteneur effacé.
**Note**
Avant la version 6.2.6.R2 de Redis OSS, la suppression d'un tableau ou d'un objet vide équivaut à la suppression d'un conteneur.
+ L'effacement d'une valeur non-conteneur retourne 0.
+ Si aucune valeur de tableau ou d'objet n'est localisée près du chemin, la commande renvoie 0.
**Exemples**
```
127.0.0.1:6379> JSON.SET k1 . '[[], [0], [0,1], [0,1,2], 1, true, null, "d"]'
OK
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 6
127.0.0.1:6379> JSON.CLEAR k1 $[*]
(integer) 0
127.0.0.1:6379> JSON.SET k2 . '{"children": ["John", "Jack", "Tom", "Bob", "Mike"]}'
OK
127.0.0.1:6379> JSON.CLEAR k2 .children
(integer) 1
127.0.0.1:6379> JSON.GET k2 .children
"[]"
```
# JSON.DEBUG
Informations sur le rapport. Les sous-commandes prises en charge sont :
+ MEMORY [chemin] : indique l'utilisation de la mémoire en octets d'une valeur JSON. Le chemin d'accès est par défaut la racine s'il n'est pas fourni.
+ DEPTH [path] — Indique la profondeur de chemin maximale du document JSON.
**Note**
Cette sous-commande est uniquement disponible avec Valkey 7.2 ou version ultérieure, ou avec le moteur Redis OSS version 6.2.6.R2 ou ultérieure.
+ CHAMPS [chemin] : indique le nombre de champs dans le chemin du document spécifié. Le chemin d'accès est par défaut la racine s'il n'est pas fourni. Chaque valeur JSON sans conteneur compte pour un champ. Les objets et les tableaux comptent récursivement un champ pour chacune de leurs valeurs JSON contenantes. Chaque valeur de conteneur, à l'exception du conteneur racine, compte pour un champ supplémentaire.
+ AIDE — affiche les messages d'aide de la commande.
Syntaxe
```
JSON.DEBUG
```
Dépend de la sous-commande :
MEMORY
+ Si le chemin est une syntaxe améliorée :
+ renvoie un tableau d'entiers, représentant la taille de la mémoire (en octets) de la valeur JSON pour chaque chemin.
+ renvoie un tableau vide si la clé n'existe pas.
+ Si le chemin est une syntaxe restreinte :
+ renvoie un entier, la taille de la mémoire est la valeur JSON en octets.
+ renvoie null si la clé n'existe pas.
DEPTH
+ Renvoie un entier qui représente la profondeur de chemin maximale du document JSON.
+ Renvoie null si la clé n'existe pas.
FIELDS
+ Si le chemin est une syntaxe améliorée :
+ renvoie un tableau d'entiers, représentant le nombre de champs de valeur JSON à chaque chemin.
+ renvoie un tableau vide si la clé n'existe pas.
+ Si le chemin est une syntaxe restreinte :
+ renvoie un entier, le nombre de champs de la valeur JSON.
+ renvoie null si la clé n'existe pas.
HELP — renvoie un tableau de messages d'aide.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[1, 2.3, "foo", true, null, {}, [], {"a":1, "b":2}, [1,2,3]]'
OK
127.0.0.1:6379> JSON.DEBUG MEMORY k1 $[*]
1) (integer) 16
2) (integer) 16
3) (integer) 19
4) (integer) 16
5) (integer) 16
6) (integer) 16
7) (integer) 16
8) (integer) 50
9) (integer) 64
127.0.0.1:6379> JSON.DEBUG FIELDS k1 $[*]
1) (integer) 1
2) (integer) 1
3) (integer) 1
4) (integer) 1
5) (integer) 1
6) (integer) 0
7) (integer) 0
8) (integer) 2
9) (integer) 3
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.DEBUG MEMORY k1
(integer) 632
127.0.0.1:6379> JSON.DEBUG MEMORY k1 .phoneNumbers
(integer) 166
127.0.0.1:6379> JSON.DEBUG FIELDS k1
(integer) 19
127.0.0.1:6379> JSON.DEBUG FIELDS k1 .address
(integer) 4
127.0.0.1:6379> JSON.DEBUG HELP
1) JSON.DEBUG MEMORY [path] - report memory size (bytes) of the JSON element. Path defaults to root if not provided.
2) JSON.DEBUG FIELDS [path] - report number of fields in the JSON element. Path defaults to root if not provided.
3) JSON.DEBUG HELP - print help message.
```
# JSON.DEL
Supprimez les valeurs JSON dans le chemin d'une clé de document. Si le chemin est la racine, cela revient à supprimer la clé de Valkey ou Redis OSS.
Syntaxe
```
JSON.DEL [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
+ Nombre d'éléments supprimés.
+ 0 si la clé n'existe pas.
+ 0 si le chemin JSON n'est pas valide ou n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.DEL k1 $.d.*
(integer) 3
127.0.0.1:6379> JSOn.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.DEL k1 $.e[*]
(integer) 5
127.0.0.1:6379> JSOn.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[]}"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.DEL k1 .d.*
(integer) 3
127.0.0.1:6379> JSON.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.DEL k1 .e[*]
(integer) 5
127.0.0.1:6379> JSON.GET k1
"{\"a\":{},\"b\":{\"a\":1},\"c\":{\"a\":1,\"b\":2},\"d\":{},\"e\":[]}"
```
# JSON.FORGET
Un alias de [JSON.DEL](json-del.md)
# JSON.GET
Renvoie le JSON sérialisé sur un ou plusieurs chemins.
Syntaxe
```
JSON.GET
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ key (obligatoire) — clé de type de document JSON
+ INDENT/NEWLINE/SPACE(facultatif) — contrôle le format de la chaîne JSON renvoyée, c'est-à-dire « pretty print ». La valeur par défaut de chacun est une chaîne vide. Ils peuvent être annulés dans n'importe quelle combinaison. Elles peuvent être spécifiées dans n'importe quel ordre.
+ NOESCAPE - facultatif, autorisé à être présent pour des raisons de compatibilité héritées et n'a aucun autre effet.
+ path (facultatif) — zéro ou plusieurs chemins JSON, la valeur par défaut est la racine si aucun n'est indiqué. Les arguments de chemin doivent être placés à la fin.
**Retour**
Syntaxe de chemin améliorée :
Si un seul chemin est fourni :
+ Renvoie une chaîne sérialisée d'un tableau de valeurs.
+ Si aucune valeur n'est sélectionnée, la commande renvoie un tableau vide.
Si plusieurs chemins sont fournis :
+ Renvoie un objet JSON sous forme de chaînes, dans lequel chaque chemin est une clé.
+ Si la syntaxe des chemins est mixte, améliorée et restreinte, le résultat est conforme à la syntaxe améliorée.
+ Si un chemin n'existe pas, sa valeur correspondante est un tableau vide.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.GET k1 $.address.*
"[\"21 2nd Street\",\"New York\",\"NY\",\"10021-3100\"]"
127.0.0.1:6379> JSON.GET k1 indent "\t" space " " NEWLINE "\n" $.address.*
"[\n\t\"21 2nd Street\",\n\t\"New York\",\n\t\"NY\",\n\t\"10021-3100\"\n]"
127.0.0.1:6379> JSON.GET k1 $.firstName $.lastName $.age
"{\"$.firstName\":[\"John\"],\"$.lastName\":[\"Smith\"],\"$.age\":[27]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}}'
OK
127.0.0.1:6379> json.get k2 $..*
"[{},{\"a\":1},{\"a\":1,\"b\":2},1,1,2]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.GET k1 .address
"{\"street\":\"21 2nd Street\",\"city\":\"New York\",\"state\":\"NY\",\"zipcode\":\"10021-3100\"}"
127.0.0.1:6379> JSON.GET k1 indent "\t" space " " NEWLINE "\n" .address
"{\n\t\"street\": \"21 2nd Street\",\n\t\"city\": \"New York\",\n\t\"state\": \"NY\",\n\t\"zipcode\": \"10021-3100\"\n}"
127.0.0.1:6379> JSON.GET k1 .firstName .lastName .age
"{\".firstName\":\"John\",\".lastName\":\"Smith\",\".age\":27}"
```
# JSON.MGET
Faites-vous sérialiser JSONs sur le chemin à partir de plusieurs clés de document. Renvoie null pour une clé ou un chemin JSON inexistant.
Syntaxe
```
JSON.MGET [key ...]
```
+ clé (obligatoire) — Une ou plusieurs clés de type de document.
+ chemin (obligatoire) — un chemin JSON
**Retour**
+ Tableau de chaînes groupées. La taille du tableau est égale au nombre de clés dans la commande. Chaque élément du tableau est renseigné avec (a) le JSON sérialisé tel qu'il est situé par le chemin ou (b) Null si la clé n'existe pas ou si le chemin n'existe pas dans le document ou si le chemin n'est pas valide (erreur de syntaxe).
+ Si l'une des clés spécifiées existe et n'est pas une clé JSON, la commande renvoie l'erreur `WRONGTYPE`.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021"}}'
OK
127.0.0.1:6379> JSON.SET k2 . '{"address":{"street":"5 main Street","city":"Boston","state":"MA","zipcode":"02101"}}'
OK
127.0.0.1:6379> JSON.SET k3 . '{"address":{"street":"100 Park Ave","city":"Seattle","state":"WA","zipcode":"98102"}}'
OK
127.0.0.1:6379> JSON.MGET k1 k2 k3 $.address.city
1) "[\"New York\"]"
2) "[\"Boston\"]"
3) "[\"Seattle\"]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021"}}'
OK
127.0.0.1:6379> JSON.SET k2 . '{"address":{"street":"5 main Street","city":"Boston","state":"MA","zipcode":"02101"}}'
OK
127.0.0.1:6379> JSON.SET k3 . '{"address":{"street":"100 Park Ave","city":"Seattle","state":"WA","zipcode":"98102"}}'
OK
127.0.0.1:6379> JSON.MGET k1 k2 k3 .address.city
1) "\"New York\""
2) "\"Seattle\""
3) "\"Seattle\""
```
# JSON.NUMINCRBY
Incrémentez les valeurs numériques sur le chemin d'un nombre donné.
Syntaxe
```
JSON.NUMINCRBY
```
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — un chemin JSON
+ numéro (obligatoire) — un chiffre
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau de chaînes groupées représentant la valeur résultante pour chaque chemin.
+ Si une valeur n'est pas un nombre, sa valeur de retour correspondante est nulle.
+ Erreur `WRONGTYPE` si le nombre ne peut pas être analysé.
+ Erreur `OVERFLOW` si le résultat est hors de la plage des doubles IEEE 64 bits.
+ `NONEXISTENT` si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Chaîne en bloc représentant la valeur résultante.
+ Si plusieurs valeurs sont sélectionnées, la commande renvoie le résultat de la dernière valeur mise à jour.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un nombre.
+ Erreur `WRONGTYPE` si le nombre ne peut pas être analysé.
+ Erreur `OVERFLOW` si le résultat est hors de la plage des doubles IEEE 64 bits.
+ `NONEXISTENT` si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 $.d[*] 10
"[11,12,13]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[11,12,13]}"
127.0.0.1:6379> JSON.SET k1 $ '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 $.a[*] 1
"[]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.b[*] 1
"[2]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.c[*] 1
"[2,3]"
127.0.0.1:6379> JSON.NUMINCRBY k1 $.d[*] 1
"[2,3,4]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[2,3,4]}"
127.0.0.1:6379> JSON.SET k2 $ '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k2 $.a.* 1
"[]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.b.* 1
"[2]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.c.* 1
"[2,3]"
127.0.0.1:6379> JSON.NUMINCRBY k2 $.d.* 1
"[2,3,4]"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":2,\"b\":3,\"c\":4}}"
127.0.0.1:6379> JSON.SET k3 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k3 $.a.* 1
"[null]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.b.* 1
"[null,2]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.c.* 1
"[null,null]"
127.0.0.1:6379> JSON.NUMINCRBY k3 $.d.* 1
"[2,null,4]"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":2,\"b\":\"b\",\"c\":4}}"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 .d[1] 10
"12"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[1,12,3]}"
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k1 .a[*] 1
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMINCRBY k1 .b[*] 1
"2"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[1,2],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMINCRBY k1 .c[*] 1
"3"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMINCRBY k1 .d[*] 1
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,3],\"d\":[2,3,4]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k2 .a.* 1
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMINCRBY k2 .b.* 1
"2"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":1,\"b\":2},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMINCRBY k2 .c.* 1
"3"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMINCRBY k2 .d.* 1
"4"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":3},\"d\":{\"a\":2,\"b\":3,\"c\":4}}"
127.0.0.1:6379> JSON.SET k3 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMINCRBY k3 .a.* 1
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMINCRBY k3 .b.* 1
"2"
127.0.0.1:6379> JSON.NUMINCRBY k3 .c.* 1
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMINCRBY k3 .d.* 1
"4"
```
# JSON.NUMMULTBY
Multipliez les valeurs numériques du chemin par un nombre donné.
Syntaxe
```
JSON.NUMMULTBY
```
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — un chemin JSON
+ numéro (obligatoire) — un chiffre
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau de chaînes groupées représentant la valeur résultante pour chaque chemin.
+ Si une valeur n'est pas un nombre, sa valeur de retour correspondante est nulle.
+ Erreur `WRONGTYPE` si le nombre ne peut pas être analysé.
+ Erreur `OVERFLOW` si le résultat est hors de la plage des doubles IEEE 64 bits.
+ `NONEXISTENT` si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Chaîne en bloc représentant la valeur résultante.
+ Si plusieurs valeurs sont sélectionnées, la commande renvoie le résultat de la dernière valeur mise à jour.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas un nombre.
+ Erreur `WRONGTYPE` si le nombre ne peut pas être analysé.
+ Erreur `OVERFLOW` si le résultat est hors de la plage des doubles IEEE 64 bits.
+ `NONEXISTENT` si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 $.d[*] 2
"[2,4,6]"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[2,4,6]}"
127.0.0.1:6379> JSON.SET k1 $ '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 $.a[*] 2
"[]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.b[*] 2
"[2]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.c[*] 2
"[2,4]"
127.0.0.1:6379> JSON.NUMMULTBY k1 $.d[*] 2
"[2,4,6]"
127.0.0.1:6379> JSON.SET k2 $ '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k2 $.a.* 2
"[]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.b.* 2
"[2]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.c.* 2
"[2,4]"
127.0.0.1:6379> JSON.NUMMULTBY k2 $.d.* 2
"[2,4,6]"
127.0.0.1:6379> JSON.SET k3 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k3 $.a.* 2
"[null]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.b.* 2
"[null,2]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.c.* 2
"[null,null]"
127.0.0.1:6379> JSON.NUMMULTBY k3 $.d.* 2
"[2,null,6]"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 .d[1] 2
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[1],\"c\":[1,2],\"d\":[1,4,3]}"
127.0.0.1:6379> JSON.SET k1 . '{"a":[], "b":[1], "c":[1,2], "d":[1,2,3]}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k1 .a[*] 2
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMMULTBY k1 .b[*] 2
"2"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[1,2],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMMULTBY k1 .c[*] 2
"4"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,4],\"d\":[1,2,3]}"
127.0.0.1:6379> JSON.NUMMULTBY k1 .d[*] 2
"6"
127.0.0.1:6379> JSON.GET k1
"{\"a\":[],\"b\":[2],\"c\":[2,4],\"d\":[2,4,6]}"
127.0.0.1:6379> JSON.SET k2 . '{"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}, "d":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k2 .a.* 2
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.NUMMULTBY k2 .b.* 2
"2"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":1,\"b\":2},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k2 .c.* 2
"4"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":4},\"d\":{\"a\":1,\"b\":2,\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k2 .d.* 2
"6"
127.0.0.1:6379> JSON.GET k2
"{\"a\":{},\"b\":{\"a\":2},\"c\":{\"a\":2,\"b\":4},\"d\":{\"a\":2,\"b\":4,\"c\":6}}"
127.0.0.1:6379> JSON.SET k3 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"b"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.NUMMULTBY k3 .a.* 2
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMMULTBY k3 .b.* 2
"2"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":1,\"b\":\"b\",\"c\":3}}"
127.0.0.1:6379> JSON.NUMMULTBY k3 .c.* 2
(error) WRONGTYPE JSON element is not a number
127.0.0.1:6379> JSON.NUMMULTBY k3 .d.* 2
"6"
127.0.0.1:6379> JSON.GET k3
"{\"a\":{\"a\":\"a\"},\"b\":{\"a\":\"a\",\"b\":2},\"c\":{\"a\":\"a\",\"b\":\"b\"},\"d\":{\"a\":2,\"b\":\"b\",\"c\":6}}"
```
# JSON.OBJLEN
Obtenez le nombre de clés dans les valeurs des objets sur le chemin.
Syntaxe
```
JSON.OBJLEN [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la longueur de l'objet à chaque chemin.
+ Si une valeur n'est pas un objet, sa valeur de retour correspondante est nulle.
+ Valeur nulle si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Entier, nombre de clés dans l'objet.
+ Si plusieurs objets sont sélectionnés, la commande renvoie la longueur du premier objet.
+ Erreur `WRONGTYPE` si la valeur au chemin n'est pas un objet.
+ Erreur `WRONGTYPE` si le chemin n'existe pas.
+ Valeur nulle si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJLEN k1 $.a
1) (integer) 0
127.0.0.1:6379> JSON.OBJLEN k1 $.a.*
(empty array)
127.0.0.1:6379> JSON.OBJLEN k1 $.b
1) (integer) 1
127.0.0.1:6379> JSON.OBJLEN k1 $.b.*
1) (nil)
127.0.0.1:6379> JSON.OBJLEN k1 $.c
1) (integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 $.c.*
1) (nil)
2) (nil)
127.0.0.1:6379> JSON.OBJLEN k1 $.d
1) (integer) 3
127.0.0.1:6379> JSON.OBJLEN k1 $.d.*
1) (nil)
2) (nil)
3) (integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 $.*
1) (integer) 0
2) (integer) 1
3) (integer) 2
4) (integer) 3
5) (nil)
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJLEN k1 .a
(integer) 0
127.0.0.1:6379> JSON.OBJLEN k1 .a.*
(error) NONEXISTENT JSON path does not exist
127.0.0.1:6379> JSON.OBJLEN k1 .b
(integer) 1
127.0.0.1:6379> JSON.OBJLEN k1 .b.*
(error) WRONGTYPE JSON element is not an object
127.0.0.1:6379> JSON.OBJLEN k1 .c
(integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 .c.*
(error) WRONGTYPE JSON element is not an object
127.0.0.1:6379> JSON.OBJLEN k1 .d
(integer) 3
127.0.0.1:6379> JSON.OBJLEN k1 .d.*
(integer) 2
127.0.0.1:6379> JSON.OBJLEN k1 .*
(integer) 0
```
# JSON.OBJKEYS
Obtenez les noms des clés dans les valeurs des objets situés sur le chemin.
Syntaxe
```
JSON.OBJKEYS [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau de tableaux de chaînes en bloc. Chaque élément est un tableau de clés dans un objet correspondant.
+ Si une valeur n'est pas un objet, sa valeur de retour correspondante est une valeur vide.
+ Valeur nulle si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Tableau de chaînes en bloc. Chaque élément est un nom de clé dans l'objet.
+ Si plusieurs objets sont sélectionnés, la commande renvoie les clés du premier objet.
+ Erreur `WRONGTYPE` si la valeur au chemin n'est pas un objet.
+ Erreur `WRONGTYPE` si le chemin n'existe pas.
+ Valeur nulle si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJKEYS k1 $.*
1) (empty array)
2) 1) "a"
3) 1) "a"
2) "b"
4) 1) "a"
2) "b"
3) "c"
5) (empty array)
127.0.0.1:6379> JSON.OBJKEYS k1 $.d
1) 1) "a"
2) "b"
3) "c"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{}, "b":{"a":"a"}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":{"a":3,"b":4}}, "e":1}'
OK
127.0.0.1:6379> JSON.OBJKEYS k1 .*
1) "a"
127.0.0.1:6379> JSON.OBJKEYS k1 .d
1) "a"
2) "b"
3) "c"
```
# JSON.RESP
Renvoie la valeur JSON au chemin donné dans le protocole de sérialisation Valkey ou Redis OSS (RESP). Si la valeur est un conteneur, la réponse est un tableau RESP ou un tableau imbriqué.
+ La valeur nulle de JSON est mappée à Null Bulk String de RESP.
+ Les valeurs booléennes JSON sont mappées aux chaînes simples RESP respectives.
+ Les nombres entiers sont mappés aux entiers de RESP.
+ Les nombres à virgule flottante double IEEE de 64 bits sont mappés aux chaînes en bloc de RESP.
+ Les chaînes JSON sont mappées aux chaînes en vrac RESP.
+ Les tableaux JSON sont représentés sous forme de tableaux RESP, où le premier élément est la simple chaîne [, suivie des éléments du tableau.
+ Les objets JSON sont représentés sous forme de tableaux RESP, où le premier élément est la chaîne simple \$1, suivie de paires clé-valeur, chacune étant une chaîne en vrac RESP.
Syntaxe
```
JSON.RESP [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau de tableaux. Chaque élément du tableau représente la forme RESP de la valeur au niveau d'un chemin.
+ Tableau vide si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Tableau, représentant la forme RESP de la valeur sur le chemin.
+ Valeur nulle si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.RESP k1 $.address
1) 1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
127.0.0.1:6379> JSON.RESP k1 $.address.*
1) "21 2nd Street"
2) "New York"
3) "NY"
4) "10021-3100"
127.0.0.1:6379> JSON.RESP k1 $.phoneNumbers
1) 1) [
2) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "555 555-1234"
3) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
127.0.0.1:6379> JSON.RESP k1 $.phoneNumbers[*]
1) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "212 555-1234"
2) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.RESP k1 .address
1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
127.0.0.1:6379> JSON.RESP k1
1) {
2) 1) "firstName"
2) "John"
3) 1) "lastName"
2) "Smith"
4) 1) "age"
2) (integer) 27
5) 1) "weight"
2) "135.25"
6) 1) "isAlive"
2) true
7) 1) "address"
2) 1) {
2) 1) "street"
2) "21 2nd Street"
3) 1) "city"
2) "New York"
4) 1) "state"
2) "NY"
5) 1) "zipcode"
2) "10021-3100"
8) 1) "phoneNumbers"
2) 1) [
2) 1) {
2) 1) "type"
2) "home"
3) 1) "number"
2) "212 555-1234"
3) 1) {
2) 1) "type"
2) "office"
3) 1) "number"
2) "555 555-4567"
9) 1) "children"
2) 1) [
10) 1) "spouse"
2) (nil)
```
# JSON.SET
Définissez des valeurs JSON sur le chemin.
Si le chemin fait appel à un membre d'objet :
+ Si l'élément parent n'existe pas, la commande renvoie une erreur NON EXISTANTE.
+ Si l'élément parent existe mais n'est pas un objet, la commande renvoie ERROR.
+ Si l'élément parent existe et est un objet :
+ Si l'élément n'existe pas, un nouvel élément sera ajouté à l'objet parent si et seulement si l'objet parent est le dernier enfant dans le chemin. Sinon, la commande renverra une erreur INEXISTANTE.
+ Si le membre existe, sa valeur sera remplacée par la valeur JSON.
Si le chemin fait appel à un index de tableau :
+ Si l'élément parent n'existe pas, la commande renvoie une erreur INEXISTANTE.
+ Si l'élément parent existe mais n'est pas un tableau, la commande renvoie ERROR.
+ Si l'élément parent existe mais que l'index est hors limites, la commande renvoie l'erreur OUTOFBOUNDARIES.
+ Si l'élément parent existe et que l'index est valide, l'élément sera remplacé par la nouvelle valeur JSON.
Si le chemin fait appel à un objet ou à un tableau, la valeur (objet ou tableau) sera remplacée par la nouvelle valeur JSON.
Syntaxe
```
JSON.SET [NX | XX]
```
[NX \$1 XX] Où vous pouvez avoir 0 ou 1 des identifiants [NX \$1 XX]
+ key (obligatoire) — clé de type de document JSON
+ chemin (obligatoire) — chemin JSON. Pour une nouvelle clé, le chemin JSON doit être la racine «. ».
+ NX (facultatif) — Si le chemin est la racine, définissez la valeur uniquement si la clé n'existe pas, c'est-à-dire insérez un nouveau document. Si le chemin n'est pas la racine, définissez la valeur uniquement si le chemin n'existe pas, c'est-à-dire insérez une valeur dans le document.
+ XX (facultatif) — Si le chemin est la racine, définissez la valeur uniquement si la clé existe, c'est-à-dire remplacez le document existant. Si le chemin n'est pas la racine, définissez la valeur uniquement si le chemin existe, c'est-à-dire mettez à jour la valeur existante.
**Retour**
+ Simple String « OK » en cas de succès.
+ Valeur nulle si la condition NX ou XX n'est pas remplie.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{"a":1, "b":2, "c":3}}'
OK
127.0.0.1:6379> JSON.SET k1 $.a.* '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"a\":{\"a\":0,\"b\":0,\"c\":0}}"
127.0.0.1:6379> JSON.SET k2 . '{"a": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.SET k2 $.a[*] '0'
OK
127.0.0.1:6379> JSON.GET k2
"{\"a\":[0,0,0,0,0]}"
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"c":{"a":1, "b":2}, "e": [1,2,3,4,5]}'
OK
127.0.0.1:6379> JSON.SET k1 .c.a '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"c\":{\"a\":0,\"b\":2},\"e\":[1,2,3,4,5]}"
127.0.0.1:6379> JSON.SET k1 .e[-1] '0'
OK
127.0.0.1:6379> JSON.GET k1
"{\"c\":{\"a\":0,\"b\":2},\"e\":[1,2,3,4,0]}"
127.0.0.1:6379> JSON.SET k1 .e[5] '0'
(error) OUTOFBOUNDARIES Array index is out of bounds
```
# JSON.STRAPPEND
Ajoutez une chaîne aux chaînes JSON au niveau du chemin.
Syntaxe
```
JSON.STRAPPEND [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
+ json\$1string (obligatoire) — Représentation JSON d'une chaîne. Notez qu'une chaîne JSON doit être entre guillemets, c'est-à-dire « foo"'.
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la nouvelle longueur de la chaîne à chaque chemin.
+ Si une valeur au niveau du chemin n'est pas une chaîne, sa valeur de retour correspondante est nulle.
+ `SYNTAXERR `erreur si l'argument json d'entrée n'est pas une chaîne JSON valide.
+ `NONEXISTENT `erreur si le chemin n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Entier, la nouvelle longueur de la chaîne.
+ Si plusieurs valeurs de chaîne sont sélectionnées, la commande renvoie la nouvelle longueur de la dernière chaîne mise à jour.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas une chaîne.
+ Erreur `WRONGTYPE` si l'argument json en entrée n'est pas une chaîne JSON valide.
+ Erreur `NONEXISTENT` si le chemin n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRAPPEND k1 $.a.a '"a"'
1) (integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 $.a.* '"a"'
1) (integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 $.b.* '"a"'
1) (integer) 2
2) (nil)
127.0.0.1:6379> JSON.STRAPPEND k1 $.c.* '"a"'
1) (integer) 2
2) (integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 $.c.b '"a"'
1) (integer) 4
127.0.0.1:6379> JSON.STRAPPEND k1 $.d.* '"a"'
1) (nil)
2) (integer) 2
3) (nil)
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRAPPEND k1 .a.a '"a"'
(integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 .a.* '"a"'
(integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 .b.* '"a"'
(integer) 2
127.0.0.1:6379> JSON.STRAPPEND k1 .c.* '"a"'
(integer) 3
127.0.0.1:6379> JSON.STRAPPEND k1 .c.b '"a"'
(integer) 4
127.0.0.1:6379> JSON.STRAPPEND k1 .d.* '"a"'
(integer) 2
```
# JSON.STRLEN
Obtenez les longueurs des valeurs de chaîne JSON sur le chemin.
Syntaxe
```
JSON.STRLEN [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers, représentant la longueur de la valeur de chaîne à chaque chemin.
+ Si une valeur n'est pas une chaîne, sa valeur de retour correspondante est nulle.
+ Valeur nulle si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Entier, la longueur de la chaîne.
+ Si plusieurs valeurs de chaîne sont sélectionnées, la commande renvoie la longueur de la première chaîne.
+ Erreur `WRONGTYPE` si la valeur au niveau du chemin n'est pas une chaîne.
+ Erreur `NONEXISTENT` si le chemin n'existe pas.
+ Valeur nulle si la clé du document n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRLEN k1 $.a.a
1) (integer) 1
127.0.0.1:6379> JSON.STRLEN k1 $.a.*
1) (integer) 1
127.0.0.1:6379> JSON.STRLEN k1 $.c.*
1) (integer) 1
2) (integer) 2
127.0.0.1:6379> JSON.STRLEN k1 $.c.b
1) (integer) 2
127.0.0.1:6379> JSON.STRLEN k1 $.d.*
1) (nil)
2) (integer) 1
3) (nil)
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 $ '{"a":{"a":"a"}, "b":{"a":"a", "b":1}, "c":{"a":"a", "b":"bb"}, "d":{"a":1, "b":"b", "c":3}}'
OK
127.0.0.1:6379> JSON.STRLEN k1 .a.a
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .a.*
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .c.*
(integer) 1
127.0.0.1:6379> JSON.STRLEN k1 .c.b
(integer) 2
127.0.0.1:6379> JSON.STRLEN k1 .d.*
(integer) 1
```
# JSON.TOGGLE
Basculez les valeurs booléennes entre vrai et faux sur le chemin.
Syntaxe
```
JSON.TOGGLE [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau d'entiers (0 - faux, 1 - vrai) représentant la valeur booléenne résultante pour chaque chemin.
+ Si une valeur n'est pas une valeur booléenne, la valeur de retour correspondante est nulle.
+ `NONEXISTENT` si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Chaîne (« true » /"false ») représentant la valeur booléenne résultante.
+ `NONEXISTENT` si la clé du document n'existe pas.
+ `WRONGTYPE`erreur si la valeur du chemin n'est pas une valeur booléenne.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '{"a":true, "b":false, "c":1, "d":null, "e":"foo", "f":[], "g":{}}'
OK
127.0.0.1:6379> JSON.TOGGLE k1 $.*
1) (integer) 0
2) (integer) 1
3) (nil)
4) (nil)
5) (nil)
6) (nil)
7) (nil)
127.0.0.1:6379> JSON.TOGGLE k1 $.*
1) (integer) 1
2) (integer) 0
3) (nil)
4) (nil)
5) (nil)
6) (nil)
7) (nil)
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . true
OK
127.0.0.1:6379> JSON.TOGGLE k1
"false"
127.0.0.1:6379> JSON.TOGGLE k1
"true"
127.0.0.1:6379> JSON.SET k2 . '{"isAvailable": false}'
OK
127.0.0.1:6379> JSON.TOGGLE k2 .isAvailable
"true"
127.0.0.1:6379> JSON.TOGGLE k2 .isAvailable
"false"
```
# JSON.TYPE
Type de rapport des valeurs sur le chemin donné.
Syntaxe
```
JSON.TYPE [path]
```
+ key (obligatoire) — clé de type de document JSON
+ path (facultatif) — un chemin JSON. La valeur par défaut est la racine si elle n'est pas fournie
**Retour**
Si le chemin est une syntaxe améliorée :
+ Tableau de chaînes représentant le type de valeur de chaque chemin. Le type est l'un de \$1"null", "boolean", "string", "number", "integer", "object" et "array"\$1.
+ Si un chemin n'existe pas, sa valeur de retour correspondante est nulle.
+ Tableau vide si la clé du document n'existe pas.
Si le chemin est une syntaxe restreinte :
+ Chaîne, type de la valeur
+ Valeur nulle si la clé du document n'existe pas.
+ Valeur nulle si le chemin JSON n'est pas valide ou n'existe pas.
**Exemples**
Syntaxe de chemin améliorée :
```
127.0.0.1:6379> JSON.SET k1 . '[1, 2.3, "foo", true, null, {}, []]'
OK
127.0.0.1:6379> JSON.TYPE k1 $[*]
1) integer
2) number
3) string
4) boolean
5) null
6) object
7) array
```
Syntaxe de chemin restreinte :
```
127.0.0.1:6379> JSON.SET k1 . '{"firstName":"John","lastName":"Smith","age":27,"weight":135.25,"isAlive":true,"address":{"street":"21 2nd Street","city":"New York","state":"NY","zipcode":"10021-3100"},"phoneNumbers":[{"type":"home","number":"212 555-1234"},{"type":"office","number":"646 555-4567"}],"children":[],"spouse":null}'
OK
127.0.0.1:6379> JSON.TYPE k1
object
127.0.0.1:6379> JSON.TYPE k1 .children
array
127.0.0.1:6379> JSON.TYPE k1 .firstName
string
127.0.0.1:6379> JSON.TYPE k1 .age
integer
127.0.0.1:6379> JSON.TYPE k1 .weight
number
127.0.0.1:6379> JSON.TYPE k1 .isAlive
boolean
127.0.0.1:6379> JSON.TYPE k1 .spouse
null
```