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à.
# Nozioni di base di JSON
MemoryDB supporta il formato nativo JavaScript Object Notation (JSON), un modo semplice e senza schemi per codificare set di dati complessi all'interno di cluster Valkey o Redis OSS. È possibile archiviare e accedere in modo nativo ai dati utilizzando il formato JavaScript Object Notation (JSON) all'interno dei cluster e aggiornare i dati JSON archiviati in tali cluster, senza dover gestire codice personalizzato per serializzarli e deserializzarli.
Oltre a sfruttare Valkey o Redis OSS APIs per le applicazioni che funzionano su JSON, ora puoi recuperare e aggiornare in modo efficiente parti specifiche di un documento JSON senza dover manipolare l'intero oggetto, il che può migliorare le prestazioni e ridurre i costi. Puoi cercare anche contenuti del documento JSON utilizzando l’interrogazione `JSONPath` di [tipo Goessner](https://goessner.net/articles/JsonPath/).
Dopo aver creato un cluster con una versione del motore supportata, il tipo di dati JSON e i comandi associati sono automaticamente disponibili. È compatibile con le API e RDB con la versione 2 del modulo RedisJSON, quindi puoi migrare facilmente le applicazioni Valkey o Redis OSS esistenti basate su JSON in MemoryDB. Per ulteriori informazioni [Comandi supportati](json-list-commands.md) sui comandi supportati, vedere.
La metrica relativa a JSON `JsonBasedCmds` è incorporata CloudWatch per monitorare l'utilizzo di questo tipo di dati. [Per ulteriori informazioni, consulta Metrics for MemoryDB.](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html)
**Nota**
Per utilizzare JSON, è necessario utilizzare Valkey 7.2 o versione successiva oppure il motore Redis OSS versione 6.2.6 o successiva.
**Topics**
+ [Panoramica dei tipi di dati JSON](json-document-overview.md)
+ [Comandi supportati](json-list-commands.md)
# Panoramica dei tipi di dati JSON
MemoryDB supporta una serie di comandi Valkey e Redis OSS per lavorare con il tipo di dati JSON. Di seguito è riportata una panoramica del tipo di dati JSON e un elenco dettagliato dei comandi supportati.
## Terminology
****
| Termine | Description |
| --- | --- |
| Documento JSON | si riferisce al valore di una chiave JSON |
| Valore JSON | si riferisce a un sottoinsieme di un documento JSON, inclusa la radice che rappresenta l'intero documento. Un valore può essere un contenitore o una voce all'interno di un contenitore |
| Elemento JSON | equivalente al valore JSON |
## Standard JSON supportati
Il formato JSON è compatibile con lo standard di interscambio dati JSON [RFC 7159](https://www.ietf.org/rfc/rfc7159.txt) e [ECMA-404](https://www.ietf.org/rfc/rfc7159.txt). Nel testo JSON è supportato [Unicode](https://www.unicode.org/standard/WhatIsUnicode.html) UTF-8.
## Elemento radice
L'elemento radice può essere qualsiasi tipo di dati JSON. Tieni presente che nello standard RFC 4627 precedente, come valori radice erano consentiti soo oggetti o array. Dopo l'aggiornamento allo standard RFC 7159, la radice di un documento JSON può essere qualunque tipo di dati JSON.
## Limite delle dimensioni del documento
I documenti JSON sono archiviati internamente in un formato ottimizzato per un accesso e una modifica rapidi. Questo formato in genere comporta un consumo di memoria leggermente superiore rispetto alla rappresentazione serializzata equivalente dello stesso documento. Il consumo di memoria da parte di un singolo documento JSON è limitato a 64 MB, che è la dimensione della struttura dei dati in memoria, non della stringa JSON. La quantità di memoria consumata da un documento JSON può essere verificata utilizzando il comando. `JSON.DEBUG MEMORY`
## JSON ACLs
+ Il tipo di dati JSON è completamente integrato nella funzionalità ACL ([Access](https://valkey.io/topics/acl/) Control Lists) di Valkey e Redis OSS. Analogamente alle categorie esistenti per tipo di dati (@string, @hash, ecc.), viene aggiunta una nuova categoria @json per semplificare la gestione dell'accesso ai comandi e ai dati JSON. Nessun altro comando Valkey o Redis OSS esistente è membro della categoria @json. Tutti i comandi JSON impongono restrizioni e autorizzazioni per lo spazio delle chiavi o i comandi.
+ Esistono cinque categorie ACL esistenti che vengono aggiornate per includere i nuovi comandi JSON: @read, @write, @fast, @slow e @admin. La tabella seguente indica la mappatura dei comandi JSON alle categorie appropriate.
**ACL**
| Comando 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 di profondità di nidificazione
Quando un oggetto o un array JSON ha un elemento che è esso stesso un altro oggetto o array JSON, si dice che tale oggetto o array si nidifica nell'oggetto o nell'array esterno. Il limite massimo di profondità di nidificazione è 128. Qualunque tentativo di creare un documento che contenga una profondità di nidificazione maggiore di 128 verrà rifiutato con un errore.
## Sintassi dei comandi
La maggior parte dei comandi richiede un nome di chiave Valkey o Redis OSS come primo argomento. Alcuni comandi hanno anche un argomento path. L'argomento path per impostazione predefinita è root se è facoltativo e non fornito.
Notazione:
+ Gli argomenti obbligatori sono racchiusi tra parentesi angolari, ad es.
+ Gli argomenti opzionali sono racchiusi tra parentesi quadre, ad esempio [percorso]
+ Gli argomenti opzionali aggiuntivi sono indicati da..., ad esempio [json...]
## Sintassi del percorso
JSON per Valkey e Redis OSS supporta due tipi di sintassi di percorso:
+ **Sintassi avanzata: segue la JSONPath sintassi** descritta da [Goessner](https://goessner.net/articles/JsonPath/), come mostrato nella tabella seguente. Abbiamo riordinato e modificato le descrizioni nella tabella per maggiore chiarezza.
+ **Sintassi limitata**: ha limitate capacità di interrogazione.
**Nota**
I risultati di alcuni comandi dipendono dal tipo di sintassi del percorso utilizzato.
Se un percorso di interrogazione inizia con '\$1', utilizza la sintassi avanzata. In caso contrario, viene utilizzata la sintassi limitata.
**Sintassi migliorata**
****
| Simbolo/espressione | Description |
| --- | --- |
| \$1 | l'elemento radice |
| . o [] | operatore bambino |
| .. | discesa ricorsiva |
| \$1 | jolly. Tutti gli elementi di un oggetto o un array. |
| [] | operatore array subscript. L'indice è basato su 0. |
| [,] | operatore sindacale |
| [start:end:step] | operatore array slice |
| ?() | applica un'espressione di filtro (script) all'array o all'oggetto corrente |
| () | espressione di filtro |
| @ | utilizzata nelle espressioni di filtro che si riferiscono al nodo corrente in fase di elaborazione |
| == | uguale a, utilizzato nelle espressioni di filtro. |
| \$1= | diverso da, utilizzato nelle espressioni di filtro. |
| > | maggiore di, utilizzato nelle espressioni di filtro. |
| >= | maggiore o uguale a, utilizzato nelle espressioni di filtro. |
| < | minore di, utilizzato nelle espressioni di filtro. |
| <= | minore o uguale a, utilizzato nelle espressioni di filtro. |
| && | AND logico, utilizzato per combinare più espressioni di filtro. |
| \$1\$1 | OR logico, utilizzato per combinare più espressioni di filtro. |
**Esempi**
Gli esempi seguenti si basano sui dati XML [di esempio di Goessner](https://goessner.net/articles/JsonPath/), che abbiamo modificato aggiungendo campi aggiuntivi.
```
{ "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
}
}
}
```
****
| Path | Description |
| --- | --- |
| \$1.store.book[\$1].author | gli autori di tutti i libri del negozio |
| \$1..author | tutti gli autori |
| \$1.store.\$1 | tutti i membri del negozio |
| \$1["store"].\$1 | tutti i membri del negozio |
| \$1.store..price | il prezzo di tutto ciò che si trova nel negozio |
| \$1..\$1 | tutti i membri ricorsivi della struttura JSON |
| \$1..book[\$1] | tutti i libri |
| \$1..book[0] | il primo libro |
| \$1..book[-1] | l'ultimo libro |
| \$1..book[0:2] | i primi due libri |
| \$1..book[0,1] | i primi due libri |
| \$1..book[0:4] | libri dall'indice 0 a 3 (l'indice finale non è comprensivo) |
| \$1..book[0:4:2] | libri all'indice 0, 2 |
| \$1..book[?(@.isbn)] | tutti i libri con numero isbn |
| \$1..book[?(@.price<10)] | tutti i libri sono più economici di \$110 |
| '\$1..book[?(@.price < 10)]' | tutti i libri sono più economici di \$110. (Il percorso deve essere citato se contiene spazi bianchi) |
| '\$1..book[?(@["price"] < 10)]' | tutti i libri sono più economici di \$110 |
| '\$1..book[?(@.["price"] < 10)]' | tutti i libri sono più economici di \$110 |
| \$1..book[?(@.price>=10&&@.price<=100)] | tutti i libri nella fascia di prezzo compresa tra \$110 e \$1100, inclusi |
| '\$1..book[?(@.price>=10 && @.price<=100)]' | tutti i libri nella fascia di prezzo compresa tra \$110 e \$1100, inclusi. (Il percorso deve essere citato se contiene spazi bianchi) |
| \$1..book[?(@.sold==true\$1\$1@.in-stock==false)] | tutti i libri venduti o esauriti |
| '\$1..book[?(@.sold == true \$1\$1 @.in-stock == false)]' | tutti i libri venduti o esauriti. (Il percorso deve essere citato se contiene spazi bianchi) |
| '\$1.store.book[?(@.["category"] == "fiction")]' | tutti i libri della categoria narrativa |
| '\$1.store.book[?(@.["category"] \$1= "fiction")]' | tutti i libri nelle categorie di saggistica |
Altri esempi di espressioni di filtro:
```
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]"
```
**Sintassi limitata**
****
| Simbolo/espressione | Description |
| --- | --- |
| . o [] | operatore per bambini |
| [] | operatore array subscript. L'indice è basato su 0. |
**Esempi**
****
| Path | Description |
| --- | --- |
| .store.book[0].author | l'autore del primo libro |
| .store.book[-1].author | l'autore dell'ultimo libro |
| .address.city | nome della città |
| ["store"]["book"][0]["title"] | il titolo del primo libro |
| ["store"]["book"][-1]["title"] | il titolo dell'ultimo libro |
**Nota**
Tutti i contenuti di [Goessner](https://goessner.net/articles/JsonPath/) citati in questa documentazione sono soggetti alla [Creative Commons License](https://creativecommons.org/licenses/by/2.5/).
## Prefissi di errori comuni
Ogni messaggio di errore ha un prefisso. Di seguito è riportato un elenco di prefissi di errore comuni:
****
| Prefix | Description |
| --- | --- |
| ERR | un errore generale |
| LIMIT | errore di dimensione superato. Ad esempio, il limite di dimensione del documento o il limite di profondità di nidificazione sono stati superati |
| NONEXISTENT | una chiave o un percorso non esiste |
| OUTOFBOUNDARIES | indice dell'array fuori dai limiti |
| SYNTAXERR | errore di sintassi |
| WRONGTYPE | tipo di valore errato |
## metriche relative a JSON
Di seguito sono fornite le seguenti metriche di informazioni JSON:
****
| Informazioni | Description |
| --- | --- |
| json\$1total\$1memory\$1bytes | memoria totale allocata agli oggetti JSON |
| json\$1num\$1documents | numero totale di documenti nel motore Valkey o Redis OSS |
Per interrogare le metriche principali, esegui il comando:
```
info json_core_metrics
```
## In che modo MemoryDB interagisce con JSON
Di seguito viene illustrato come MemoryDB interagisce con il tipo di dati JSON.
### Precedenza degli operatori
Durante la valutazione delle espressioni condizionali per il filtro, && hanno la precedenza, quindi vengono valutati \$1\$1, come nella maggior parte dei linguaggi. Le operazioni all'interno delle parentesi verranno eseguite per prime.
### Comportamento del limite massimo di nidificazione dei percorsi
Il limite massimo di annidamento dei percorsi di MemoryDB è 128. Per cui, un valore come `$.a.b.c.d...` può raggiungere solo 128 livelli.
### Gestione dei valori numerici
JSON non dispone di tipi di dati separati per numeri interi e numeri in virgola mobile. Sono tutti definiti “numeri”.
Quando viene ricevuto un numero JSON, viene memorizzato in uno dei due formati. Se il numero rientra in un numero intero con segno a 64 bit, viene convertito in quel formato; in caso contrario, viene memorizzato come stringa. Le operazioni aritmetiche su due numeri JSON (ad esempio JSON.NUMINCRBY e JSON.NUMMULTBY) cercano di mantenere la massima precisione possibile. Se i due operandi e il valore risultante rientrano in un numero intero con segno a 64 bit, viene eseguita l'aritmetica dei numeri interi. In caso contrario, gli operandi di input vengono convertiti in numeri a virgola mobile IEEE a doppia precisione a 64 bit, viene eseguita l'operazione aritmetica e il risultato viene riconvertito in una stringa.
Comandi aritmetici `NUMINCRBY` e `NUMMULTBY`:
+ Se entrambi i numeri sono numeri interi e il risultato non rientra nell'intervallo di int64, diventerà automaticamente un numero in virgola mobile a doppia precisione.
+ Se almeno uno dei numeri è in virgola mobile, il risultato sarà un numero in virgola mobile a doppia precisione.
+ Se il risultato supera l'intervallo del doppio, il comando restituirà un errore. `OVERFLOW`
**Nota**
Prima della versione 6.2.6.R2 del motore Redis OSS, quando un numero JSON viene ricevuto in input, viene convertito in una delle due rappresentazioni binarie interne: un intero con segno a 64 bit o un numero a virgola mobile IEEE a doppia precisione a 64 bit. La stringa originaria e tutta la formattazione non vengono mantenute. Pertanto, quando un numero viene emesso come parte di una risposta JSON, viene convertito dalla rappresentazione binaria interna in una stringa stampabile che utilizza regole di formattazione generiche. Queste regole potrebbero determinare la generazione di una stringa diversa da quella ricevuta.
Se entrambi i numeri sono interi e il risultato non rientra nell'intervallo `int64`, diventa automaticamente un numero in virgola mobile a doppia precisione IEEE a 64 bit.
Se almeno uno dei numeri è in virgola mobile, il risultato è un numero in virgola mobile a doppia precisione IEEE a 64 bit.
Se il risultato supera l'intervallo doppio IEEE a 64 bit, il comando restituisce un errore `OVERFLOW`.
Per un elenco dei comandi disponibili, consulta [Comandi supportati](json-list-commands.md).
### Valutazione della sintassi rigida
MemoryDBnon consente percorsi JSON con sintassi non valida, neppure se un sottoinsieme del percorso contiene un percorso valido. Ciò permantenere un comportamento corretto per i nostri clienti.
# 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
```