Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Comandi supportati
Sono supportati i seguenti comandi JSON:
**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
Aggiunge uno o più valori ai valori dell'array nel percorso.
Sintassi
```
JSON.ARRAPPEND [json ...]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (obbligatorio) — un percorso JSON
+ json (obbligatorio) — Valore JSON da aggiungere all'array
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la nuova lunghezza dell'array in ogni percorso.
+ Se un valore non è un array, il valore restituito corrispondente è null.
+ Errore `SYNTAXERR` se uno degli argomenti json di input non è una stringa JSON valida.
+ Errore `NONEXISTENT` se il percorso non esiste.
Se il percorso è una sintassi limitata:
+ Numero intero, la nuova lunghezza dell'array.
+ Se sono selezionati più valori array, il comando restituisce la nuova lunghezza dell'ultimo array aggiornato.
+ Errore `WRONGTYPE` se il valore nel percorso non è un array.
+ Errore `SYNTAXERR` se uno degli argomenti json di input non è una stringa JSON valida.
+ Errore `NONEXISTENT` se il percorso non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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\"]]"
```
Sintassi limitata del percorso:
```
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
Cerca la prima occorrenza di un valore JSON scalare negli array del percorso.
+ Gli errori “fuori intervallo” vengono gestiti arrotondando l'indice all'inizio e alla fine dell'array.
+ Se l’inizio è maggiore della fine, restituisce -1 (non trovato).
Sintassi
```
JSON.ARRINDEX [start [end]]
```
+ chiave (obbligatoria) — chiave del tipo di documento JSON
+ path (obbligatorio) — un percorso JSON
+ json-scalar (obbligatorio) — valore scalare da cercare; JSON scalar si riferisce a valori che non sono oggetti o array. Ad esempio, String, number, boolean e null sono valori scalari.
+ start (opzionale) — indice iniziale, incluso. Se non è fornito, viene utilizzata l’impostazione predefinita, 0.
+ end (opzionale) — indice finale, esclusivo. Il valore predefinito è 0 se non viene fornito, il che significa che è incluso l'ultimo elemento. 0 o -1 significa che l'ultimo elemento è incluso.
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Array di numeri interi. Ogni valore è l'indice dell'elemento corrispondente nell'array nel percorso. Se non viene trovato, il valore è -1.
+ Se un valore non è un array, il valore restituito corrispondente è null.
Se il percorso è una sintassi limitata:
+ Numero intero, l'indice dell'elemento corrispondente o -1 se non viene trovato.
+ Errore `WRONGTYPE` se il valore nel percorso non è un array.
**Esempi**
Sintassi avanzata del percorso:
```
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
```
Sintassi limitata del percorso:
```
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
Inserisce uno o più valori nei valori dell'array nel percorso che precede l'indice.
Sintassi
```
JSON.ARRINSERT [json ...]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (obbligatorio) — un percorso JSON
+ index (obbligatorio) — indice dell'array prima del quale vengono inseriti i valori.
+ json (obbligatorio) — Valore JSON da aggiungere all'array
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la nuova lunghezza dell'array in ogni percorso.
+ Se un valore è un array vuoto, il valore restituito corrispondente è null.
+ Se un valore non è un array, il valore restituito corrispondente è null.
+ Errore `OUTOFBOUNDARIES` se l'argomento indice è fuori dai limiti.
Se il percorso è una sintassi limitata:
+ Numero intero, la nuova lunghezza dell'array.
+ Errore `WRONGTYPE` se il valore nel percorso non è un array.
+ Errore `OUTOFBOUNDARIES` se l'argomento indice è fuori dai limiti.
**Esempi**
Sintassi avanzata del percorso:
```
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\"]]"
```
Sintassi limitata del percorso:
```
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
Ottieni la lunghezza dei valori dell'array nel percorso.
Sintassi
```
JSON.ARRLEN [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la lunghezza dell'array in ogni percorso.
+ Se un valore non è un array, il valore restituito corrispondente è null.
+ Null se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Array di stringhe in blocco. Ogni elemento è un nome chiave nell'oggetto.
+ Numero intero, lunghezza dell'array.
+ Se sono selezionati più oggetti, il comando restituisce la lunghezza del primo array.
+ Errore `WRONGTYPE` se il valore nel percorso non è un array.
+ Errore `WRONGTYPE` se il percorso non esiste.
+ Null se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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)
```
Sintassi limitata del percorso:
```
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
Rimuove e restituisce l'elemento all'indice dell'array. Il prelievo di un array vuoto restituisce null.
Sintassi
```
JSON.ARRPOP [path [index]]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
+ index (opzionale) — posizione nell'array da cui iniziare il popping.
+ Viene ripristinato il valore predefinito -1 se non è fornito, ossia l'ultimo elemento.
+ Un valore negativo indica la posizione dall'ultimo elemento.
+ Gli indici fuori limite vengono arrotondati ai rispettivi limiti dell'array.
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di stringhe in blocco, che rappresentano i valori visualizzati in ogni percorso.
+ Se un valore è un array vuoto, il valore restituito corrispondente è null.
+ Se un valore non è un array, il valore restituito corrispondente è null.
Se il percorso è una sintassi limitata:
+ Stringa di massa, che rappresenta il valore JSON visualizzato
+ Null se l'array è vuoto.
+ Errore `WRONGTYPE` se il valore nel percorso non è un array.
**Esempi**
Sintassi avanzata del percorso:
```
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\"]]"
```
Sintassi limitata del percorso:
```
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
Taglia gli array sul percorso in modo che diventi un sottoarray [start, end], entrambi inclusi.
+ Se l'array è vuoto, non eseguire nulla, restituire 0.
+ Se start <0, considerarlo come 0.
+ Se end >= size (dimensione dell’array), considerarlo comesize-1.
+ Se start >= size o start > end, svuotare l'array e restituire 0.
Sintassi
```
JSON.ARRINSERT
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (obbligatorio) — un percorso JSON
+ start (obbligatorio) — indice iniziale, incluso.
+ end (obbligatorio) — indice finale, incluso.
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la nuova lunghezza dell'array in ogni percorso.
+ Se un valore è un array vuoto, il valore restituito corrispondente è null.
+ Se un valore non è un array, il valore restituito corrispondente è null.
+ Errore `OUTOFBOUNDARIES` se un argomento indice è fuori dai limiti.
Se il percorso è una sintassi limitata:
+ Numero intero, la nuova lunghezza dell'array.
+ Null se l'array è vuoto.
+ Errore `WRONGTYPE` se il valore nel percorso non è un array.
+ Errore `OUTOFBOUNDARIES` se un argomento indice è fuori dai limiti.
**Esempi**
Sintassi avanzata del percorso:
```
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\"]]"
```
Sintassi limitata del percorso:
```
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
Cancella gli array o gli oggetti sul percorso.
Sintassi
```
JSON.CLEAR [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
+ Numero intero, il numero di container cancellati.
+ La cancellazione di un array o di un oggetto vuoto rappresenta 0 contenitori cancellati.
**Nota**
Prima della versione 6.2.6.R2 di Redis OSS, la cancellazione di un array o di un oggetto vuoto veniva cancellata per 1 contenitore.
+ La cancellazione di un valore non container restituisce 0.
+ Se il percorso non contiene alcun valore di matrice o oggetto, il comando restituisce 0.
**Esempi**
```
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
Informazioni sul rapporto. Sottocomandi supportati:
+ MEMORIA [percorso]: riporta l'utilizzo della memoria in byte di un valore JSON. Se non è fornito, viene ripristinato il percorso predefinito, la radice.
+ DEPTH [percorso] — Riporta la profondità massima del percorso del documento JSON.
**Nota**
Questo sottocomando è disponibile solo utilizzando Valkey 7.2 o versione successiva o il motore Redis OSS versione 6.2.6.R2 o successiva.
+ FIELDS [percorso]: riporta il numero di campi nel percorso del documento specificato. Se non è fornito, viene ripristinato il percorso predefinito, la radice. Ogni valore JSON non container viene conteggiato come un singolo campo. Oggetti e array vengono conteggiati ricorsivamente come singolo campo per ognuno dei loro valori JSON contenenti. Ogni valore container, tranne il container radice, viene conteggiato come un campo aggiuntivo.
+ HELP — stampa i messaggi di aiuto del comando.
Sintassi
```
JSON.DEBUG
```
Dipende dal sottocomando:
MEMORY
+ Se il percorso è una sintassi avanzata:
+ restituisce un array di numeri interi, che rappresenta la dimensione della memoria (in byte) del valore JSON in ogni percorso.
+ restituisce un array vuoto se la chiave non esiste.
+ Se il percorso è una sintassi limitata:
+ restituisce un numero intero, la dimensione della memoria è il valore JSON in byte.
+ restituisce null se la chiave non esiste.
DEPTH
+ Restituisce un numero intero che rappresenta la profondità massima del percorso del documento JSON.
+ Restituisce null se la chiave non esiste.
FIELDS
+ Se il percorso è una sintassi avanzata:
+ restituisce una matrice di numeri interi, che rappresenta il numero di campi di valore JSON in ogni percorso.
+ restituisce un array vuoto se la chiave non esiste.
+ Se il percorso è una sintassi limitata:
+ restituisce un numero intero, il numero di campi del valore JSON.
+ restituisce null se la chiave non esiste.
HELP: restituisce una serie di messaggi di aiuto.
**Esempi**
Sintassi avanzata del percorso:
```
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
```
Sintassi limitata del percorso:
```
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
Elimina i valori JSON nel percorso in una chiave di documento. Se il percorso è la radice, equivale a eliminare la chiave da Valkey o Redis OSS.
Sintassi
```
JSON.DEL [path]
```
+ chiave (richiesta) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
+ Numero di elementi eliminati.
+ 0 se la chiave non esiste.
+ 0 se il percorso JSON non è valido o non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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\":[]}"
```
Sintassi limitata del percorso:
```
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 di [JSON.DEL](json-del.md)
# JSON.GET
Restituisce il codice JSON serializzato su uno o più percorsi.
Sintassi
```
JSON.GET
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ key (obbligatorio): chiave del tipo di documento JSON
+ INDENT/NEWLINE/SPACE(opzionale) — controlla il formato della stringa JSON restituita, ad esempio «pretty print». Il valore predefinito di ognuno è una stringa vuota. Possono essere sostituiti in qualsiasi combinazione. Possono essere specificati in qualunque ordine.
+ NOESCAPE: opzionale, può essere presente per motivi di compatibilità con le versioni precedenti e non ha altri effetti.
+ path (opzionale): zero o più percorsi JSON, il valore predefinito è root se non ne viene fornito nessuno. Gli argomenti del percorso devono essere collocati alla fine.
**Valori restituiti**
Sintassi avanzata del percorso:
Se viene fornito un percorso:
+ Restituisce una stringa serializzata di una matrice di valori.
+ Se non è selezionato alcun valore, il comando restituisce un array vuoto.
Se vengono forniti più percorsi:
+ Restituisce un oggetto JSON con stringhe, in cui ogni percorso è una chiave.
+ in presenza di sintassi mista e avanzata dei percorsi, il risultato è conforme alla sintassi avanzata.
+ Se un percorso non esiste, il valore corrispondente è un array vuoto.
**Esempi**
Sintassi avanzata del percorso:
```
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]"
```
Sintassi limitata del percorso:
```
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
Fatti serializzare JSONs nel percorso da più chiavi del documento. Restituisce null per una chiave o un percorso JSON inesistente.
Sintassi
```
JSON.MGET [key ...]
```
+ chiave (obbligatoria): una o più chiavi del tipo di documento.
+ path (obbligatorio) — un percorso JSON
**Valori restituiti**
+ Matrice di stringhe di massa. La dimensione dell'array è uguale al numero di chiavi nel comando. Ogni elemento dell'array viene compilato con (a) il codice JSON serializzato indicato dal percorso o (b) Null se la chiave non esiste o il percorso non esiste nel documento o il percorso non è valido (errore di sintassi).
+ Se una delle chiavi specificate esiste e non è una chiave JSON, il comando restituisce l’errore `WRONGTYPE`.
**Esempi**
Sintassi avanzata del percorso:
```
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\"]"
```
Sintassi limitata del percorso:
```
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
Incrementa i valori numerici sul percorso di un dato numero.
Sintassi
```
JSON.NUMINCRBY
```
+ chiave (obbligatoria) — chiave del tipo di documento JSON
+ path (obbligatorio) — un percorso JSON
+ numero (obbligatorio): un numero
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di stringhe in blocco che rappresentano il valore risultante in ogni percorso.
+ Se un valore non è un numero, il valore restituito corrispondente è null.
+ Errore `WRONGTYPE` se il numero non può essere analizzato.
+ Errore `OVERFLOW` se il risultato non rientra nell'intervallo del doppio IEEE a 64 bit.
+ `NONEXISTENT` se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Stringa di massa che rappresenta il valore risultante.
+ Se sono selezionati più valori array, il comando restituisce il risultato dell’ultimo valore aggiornato.
+ Errore `WRONGTYPE` se il valore nel percorso non è un numero.
+ Errore `WRONGTYPE` se il numero non può essere analizzato.
+ Errore `OVERFLOW` se il risultato non rientra nell'intervallo del doppio IEEE a 64 bit.
+ `NONEXISTENT` se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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}}"
```
Sintassi limitata del percorso:
```
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
Moltiplica i valori numerici sul percorso per un dato numero.
Sintassi
```
JSON.NUMMULTBY
```
+ chiave (obbligatoria): chiave del tipo di documento JSON
+ path (obbligatorio) — un percorso JSON
+ numero (obbligatorio): un numero
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di stringhe in blocco che rappresentano il valore risultante in ogni percorso.
+ Se un valore non è un numero, il valore restituito corrispondente è null.
+ Errore `WRONGTYPE` se il numero non può essere analizzato.
+ Errore `OVERFLOW` se il risultato non rientra nell'intervallo del doppio IEEE a 64 bit.
+ `NONEXISTENT` se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Stringa di massa che rappresenta il valore risultante.
+ Se sono selezionati più valori array, il comando restituisce il risultato dell’ultimo valore aggiornato.
+ Errore `WRONGTYPE` se il valore nel percorso non è un numero.
+ Errore `WRONGTYPE` se il numero non può essere analizzato.
+ Errore `OVERFLOW` se il risultato non rientra nell'intervallo del doppio IEEE a 64 bit.
+ `NONEXISTENT` se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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]"
```
Sintassi limitata del percorso:
```
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
Ottieni il numero di chiavi nei valori dell'oggetto nel percorso.
Sintassi
```
JSON.OBJLEN [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la lunghezza dell'oggetto in ogni percorso.
+ Se un valore non è un oggetto, il valore restituito corrispondente è null.
+ Null se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Numero intero, numero di chiavi nell'oggetto.
+ Se sono selezionati più oggetti, il comando restituisce la lunghezza del primo oggetto.
+ Errore `WRONGTYPE` se il valore nel percorso non è un oggetto.
+ Errore `WRONGTYPE` se il percorso non esiste.
+ Null se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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)
```
Sintassi limitata del percorso:
```
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
Ottieni i nomi delle chiavi nei valori degli oggetti nel percorso.
Sintassi
```
JSON.OBJKEYS [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Array di array di stringhe in blocco. Ogni elemento è un array di chiavi in un oggetto corrispondente.
+ Se un valore non è un oggetto, il valore restituito corrispondente è un valore vuoto.
+ Null se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Array di stringhe in blocco. Ogni elemento è un nome chiave nell'oggetto.
+ Se sono selezionati più oggetti, il comando restituisce le chiavi del primo oggetto.
+ Errore `WRONGTYPE` se il valore nel percorso non è un oggetto.
+ Errore `WRONGTYPE` se il percorso non esiste.
+ Null se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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"
```
Sintassi limitata del percorso:
```
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
Restituisce il valore JSON nel percorso specificato nel Valkey o Redis OSS Serialization Protocol (RESP). Se il valore è container, la risposta è un array RESP o un array annidato.
+ Un valore null JSON è mappato alla stringa in blocco null RESP.
+ I valori booleani JSON vengono mappati alle rispettive stringhe semplici RESP.
+ I numeri interi sono mappati a numeri interi RESP.
+ I numeri a virgola mobile doppia IEEE a 64 bit sono mappati a stringhe in blocco RESP.
+ Le stringhe JSON sono mappate su RESP Bulk Strings.
+ Gli array JSON sono rappresentati come array RESP, dove il primo elemento è la semplice stringa [, seguita dagli elementi dell'array.
+ Gli oggetti JSON sono rappresentati come array RESP, dove il primo elemento è la semplice stringa \$1, seguita da coppie chiave-valore, ognuna delle quali è una stringa di massa RESP.
Sintassi
```
JSON.RESP [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Array di array. Ogni elemento dell'array rappresenta la forma RESP del valore in un unico percorso.
+ Array vuoto se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Array, che rappresenta la forma RESP del valore nel percorso.
+ Null se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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"
```
Sintassi limitata del percorso:
```
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
Imposta i valori JSON nel percorso.
Se il percorso richiede un membro oggetto:
+ Se l'elemento principale non esiste, il comando restituirà l'errore NONEXISTENT.
+ Se l'elemento principale esiste ma non è un oggetto, il comando restituirà ERROR.
+ Se l'elemento padre esiste ed è un oggetto:
+ Se il membro non esiste, un nuovo membro verrà accodato all'oggetto padre se e solo se l'oggetto padre è l'ultimo figlio nel percorso. In caso contrario, il comando restituirà un errore INESISTENTE.
+ Se il membro esiste, il suo valore verrà sostituito dal valore JSON.
Se il percorso richiede un indice di array:
+ Se l'elemento principale non esiste, il comando restituirà un errore INESISTENTE.
+ Se l'elemento principale esiste ma non è un array, il comando restituirà ERROR.
+ Se l'elemento principale esiste ma l'indice non è compreso nei limiti, il comando restituirà l'errore OUTOFBOUNDARIES.
+ Se l'elemento padre esiste e l'indice è valido, l'elemento verrà sostituito dal nuovo valore JSON.
Se il percorso richiede un oggetto o un array, il valore (oggetto o array) verrà sostituito dal nuovo valore JSON.
Sintassi
```
JSON.SET [NX | XX]
```
[NX \$1 XX] Dove è possibile avere 0 o 1 degli identificatori [NX \$1 XX]
+ chiave (obbligatoria) — chiave del tipo di documento JSON
+ path (obbligatorio) — percorso JSON. Per una nuova chiave, il percorso JSON deve essere la radice «.».
+ NX (opzionale): se il percorso è la radice, imposta il valore solo se la chiave non esiste, ad esempio inserisci un nuovo documento. Se il percorso non è la radice, imposta il valore solo se il percorso non esiste, ad esempio inserisci un valore nel documento.
+ XX (opzionale) — Se il percorso è la radice, imposta il valore solo se la chiave esiste, ad esempio sostituisci il documento esistente. Se il percorso non è la radice, imposta il valore solo se il percorso esiste, ad esempio aggiorna il valore esistente.
**Valori restituiti**
+ Stringa semplice 'OK' se l’esito è positivo.
+ Null se la condizione NX o XX non viene soddisfatta.
**Esempi**
Sintassi avanzata del percorso:
```
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]}"
```
Sintassi limitata del percorso:
```
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
Aggiungi una stringa alle stringhe JSON nel percorso.
Sintassi
```
JSON.STRAPPEND [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
+ json\$1string (obbligatorio) — Rappresentazione JSON di una stringa. Nota che una stringa JSON deve essere citata, ad esempio '"foo"'.
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la nuova lunghezza della stringa in ogni percorso.
+ Se un valore nel percorso non è una stringa, il valore restituito corrispondente è null.
+ `SYNTAXERR `errore se l'argomento json di input non è una stringa JSON valida.
+ `NONEXISTENT `errore se il percorso non esiste.
Se il percorso è una sintassi limitata:
+ Numero intero, la nuova lunghezza della stringa.
+ Se sono selezionati più valori array, il comando restituisce la nuova lunghezza dell'ultima stringa aggiornata.
+ Errore `WRONGTYPE` se il valore nel percorso non è una stringa.
+ Errore `WRONGTYPE` se l’argomento json di input non è una stringa JSON valida.
+ Errore `NONEXISTENT` se il percorso non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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)
```
Sintassi limitata del percorso:
```
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
Ottieni le lunghezze dei valori delle stringhe JSON nel percorso.
Sintassi
```
JSON.STRLEN [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi, che rappresenta la lunghezza del valore della stringa in ogni percorso.
+ Se un valore non è una stringa, il valore restituito corrispondente è null.
+ Null se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Numero intero, la lunghezza della stringa.
+ Se sono selezionati più valori stringa, il comando restituisce la lunghezza della prima stringa.
+ Errore `WRONGTYPE` se il valore nel percorso non è una stringa.
+ Errore `NONEXISTENT` se il percorso non esiste.
+ Null se la chiave del documento non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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)
```
Sintassi limitata del percorso:
```
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
Alterna i valori booleani tra vero e falso nel percorso.
Sintassi
```
JSON.TOGGLE [path]
```
+ key (obbligatorio) — chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di numeri interi (0 - false, 1 - true) che rappresentano il valore booleano risultante in ogni percorso.
+ Se un valore non è booleano, il valore restituito corrispondente è nullo.
+ `NONEXISTENT` se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ String («true» /"false») che rappresenta il valore booleano risultante.
+ `NONEXISTENT` se la chiave del documento non esiste.
+ `WRONGTYPE`errore se il valore nel percorso non è un valore booleano.
**Esempi**
Sintassi avanzata del percorso:
```
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)
```
Sintassi limitata del percorso:
```
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
Tipo di rapporto dei valori nel percorso specificato.
Sintassi
```
JSON.TYPE [path]
```
+ chiave (obbligatoria): chiave del tipo di documento JSON
+ path (opzionale) — un percorso JSON. Il valore predefinito è root se non viene fornito
**Valori restituiti**
Se il percorso è una sintassi avanzata:
+ Matrice di stringhe, che rappresenta il tipo di valore in ogni percorso. Il tipo è uno di \$1"null", "boolean", "string", "number", "integer", "object" e "array"\$1.
+ Se un percorso non esiste, il valore restituito corrispondente è null.
+ Array vuoto se la chiave del documento non esiste.
Se il percorso è una sintassi limitata:
+ Stringa, tipo di valore
+ Null se la chiave del documento non esiste.
+ Null se il percorso JSON non è valido o non esiste.
**Esempi**
Sintassi avanzata del percorso:
```
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
```
Sintassi limitata del percorso:
```
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
```