Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit JSON
MemoryDB unterstützt das native JSON-Format ( JavaScript Object Notation), eine einfache, schemalose Methode zur Kodierung komplexer Datensätze in Valkey- oder Redis-OSS-Clustern. Sie können Daten mithilfe des JSON-Formats ( JavaScript Object Notation) nativ innerhalb von Clustern speichern und darauf zugreifen und die in diesen Clustern gespeicherten JSON-Daten aktualisieren, ohne dass Sie benutzerdefinierten Code für die Serialisierung und Deserialisierung verwalten müssen.
Neben der Nutzung von Valkey oder Redis OSS APIs für Anwendungen, die über JSON arbeiten, können Sie jetzt auch bestimmte Teile eines JSON-Dokuments effizient abrufen und aktualisieren, ohne das gesamte Objekt bearbeiten zu müssen, was die Leistung verbessern und die Kosten senken kann. Sie können den Inhalt Ihres JSON-Dokuments auch mit der [Goessner](https://goessner.net/articles/JsonPath/)-Abfrage abfragen.
Nach dem Erstellen eines Clusters mit einer unterstützten Engine-Version sind der JSON-Datentyp und die zugehörigen Befehle automatisch verfügbar. Dies ist API-kompatibel und RDB-kompatibel mit Version 2 des RedisJSON-Moduls, sodass Sie bestehende JSON-basierte Valkey- oder Redis OSS-Anwendungen problemlos in MemoryDB migrieren können. Weitere Informationen zu [Unterstützte Befehle](json-list-commands.md) den unterstützten Befehlen finden Sie unter.
JSON-bezogene Metriken `JsonBasedCmds` sind integriert CloudWatch , um die Verwendung dieses Datentyps zu überwachen. [Weitere Informationen finden Sie unter Metriken für MemoryDB.](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html)
**Anmerkung**
Um JSON verwenden zu können, müssen Sie Valkey 7.2 oder höher oder Redis OSS Engine Version 6.2.6 oder höher ausführen.
**Topics**
+ [Überblick über den JSON-Datentyp](json-document-overview.md)
+ [Unterstützte Befehle](json-list-commands.md)
# Überblick über den JSON-Datentyp
MemoryDB unterstützt eine Reihe von Valkey- und Redis OSS-Befehlen für die Arbeit mit dem JSON-Datentyp. Im Folgenden finden Sie eine Übersicht über den JSON-Datentyp und eine detaillierte Liste der unterstützten Befehle.
## Terminologie
****
| Begriff | Description |
| --- | --- |
| JSON-Dokument | bezieht sich auf den Wert eines JSON-Schlüssels |
| JSON-Wert | bezieht sich auf eine Teilmenge eines JSON-Dokuments, einschließlich der Wurzel, die das gesamte Dokument darstellt. Ein Wert kann ein Container oder ein Eintrag innerhalb eines Containers sein |
| JSON-Element | entspricht dem JSON-Wert |
## Unterstützter JSON-Standard
Das JSON-Format ist mit [RFC 7159](https://www.ietf.org/rfc/rfc7159.txt) und dem [ECMA-404](https://www.ietf.org/rfc/rfc7159.txt)-JSON-Datenaustauschstandard konform. UTF-8 [Unicode](https://www.unicode.org/standard/WhatIsUnicode.html) wird im JSON-Text unterstützt.
## Stammelement
Das Stammelement kann von jedem JSON-Datentyp stammen. Beachten Sie, dass in früheren RFC 4627 nur Objekte oder Arrays als Stammwerte zugelassen waren. Seit dem Update auf RFC 7159 kann das Stammverzeichnis eines JSON-Dokuments einen beliebigen JSON-Datentyp haben.
## Begrenzung der Dokumentgröße
JSON-Dokumente werden intern in einem Format gespeichert, das für schnellen Zugriff und Änderungen optimiert ist. Dieses Format führt in der Regel dazu, dass etwas mehr Speicher verbraucht wird als die entsprechende serialisierte Darstellung desselben Dokuments. Der Speicherverbrauch eines einzelnen JSON-Dokuments ist auf 64 MB begrenzt. Dies entspricht der Größe der speicherinternen Datenstruktur, nicht der JSON-Zeichenfolge. Die Menge des von einem JSON-Dokument verbrauchten Speichers kann mithilfe des `JSON.DEBUG MEMORY` Befehls überprüft werden.
## JSON ACLs
+ Der JSON-Datentyp ist vollständig in die Funktionen der [Access Control Lists (](https://valkey.io/topics/acl/)ACL) von Valkey und Redis OSS integriert. Ähnlich wie bei den bestehenden Kategorien pro Datentyp (@string, @hash usw.) wurde eine neue Kategorie @json hinzugefügt, um die Verwaltung des Zugriffs auf JSON-Befehle und -Daten zu vereinfachen. Keine anderen vorhandenen Valkey- oder Redis OSS-Befehle gehören zur Kategorie @json. Alle JSON-Befehle erzwingen alle Keyspace- oder Befehlseinschränkungen und -berechtigungen.
+ Es gibt fünf bestehende ACL-Kategorien, die um die neuen JSON-Befehle aktualisiert wurden: @read, @write, @fast, @slow und @admin. Die folgende Tabelle zeigt die Zuordnung von JSON-Befehlen zu den entsprechenden Kategorien.
**ACL**
| JSON-Befehl | @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 | | |
## Begrenzung der Verschachtelungstiefe
Wenn ein JSON-Objekt oder Array ein Element hat, das selbst ein anderes JSON-Objekt oder Array ist, wird gesagt, dass dieses innere Objekt oder Array innerhalb des äußeren Objekts oder Arrays „verschachtelt“ wird. Die maximale Verschachtelungstiefe ist 128. Jeder Versuch, ein Dokument zu erstellen, das eine Verschachtelungstiefe von mehr als 128 enthält, wird mit einem Fehler abgelehnt.
## Befehlssyntax
Die meisten Befehle erfordern einen Valkey- oder Redis OSS-Schlüsselnamen als erstes Argument. Einige Befehle haben auch ein Pfadargument. Das Pfadargument ist standardmäßig das Stammverzeichnis, wenn es optional ist und nicht angegeben wird.
Notation:
+ Erforderliche Argumente sind in spitzen Klammern eingeschlossen, z. B.
+ Optionale Argumente werden in eckige Klammern eingeschlossen, z. B. [Pfad]
+ Zusätzliche optionale Argumente werden durch... gekennzeichnet, z. B. [json...]
## Pfadsyntax
JSON für Valkey und Redis OSS unterstützt zwei Arten von Pfadsyntaxen:
+ **Verbesserte Syntax** — Folgt der von [Goessner](https://goessner.net/articles/JsonPath/) beschriebenen JSONPath Syntax, wie in der folgenden Tabelle dargestellt. Wir haben die Beschreibungen in der Tabelle zur besseren Übersicht neu angeordnet und geändert.
+ **Beschränkte Syntax** – Hat begrenzte Abfragemöglichkeiten.
**Anmerkung**
Die Ergebnisse einiger Befehle hängen davon ab, welche Art von Pfadsyntax verwendet wird.
Wenn ein Abfragepfad mit „\$1“ beginnt, verwendet er die erweiterte Syntax. Andernfalls wird eine eingeschränkte Syntax verwendet.
**Verbesserte Syntax**
****
| Symbol/Ausdruck | Description |
| --- | --- |
| \$1 | das Stammelement |
| . oder [] | untergeordneter Operator |
| .. | rekursiver Abstieg |
| \$1 | Platzhalter. Alle Elemente in einem Objekt oder Array. |
| [] | Array-Indexoperator. Der Index basiert auf 0. |
| [,] | Union-Operator |
| [start:end:step] | Array-Slice-Operator |
| ?() | wendet einen Filterausdruck (Skriptausdruck) auf das aktuelle Array oder Objekt an |
| () | Filterausdruck |
| @ | wird in Filterausdrücken verwendet, die sich auf den aktuell verarbeiteten Knoten beziehen |
| == | entspricht, wird in Filterausdrücken verwendet. |
| \$1= | ungleich, wird in Filterausdrücken verwendet. |
| > | größer als, wird in Filterausdrücken verwendet. |
| >= | größer als oder gleich, wird in Filterausdrücken verwendet. |
| < | kleiner als, wird in Filterausdrücken verwendet. |
| <= | kleiner als oder gleich, wird in Filterausdrücken verwendet. |
| && | logisches UND, wird verwendet, um mehrere Filterausdrücke zu kombinieren. |
| \$1\$1 | logisches ODER, wird verwendet, um mehrere Filterausdrücke zu kombinieren. |
**Beispiele**
Die folgenden Beispiele basieren auf den XML-Beispieldaten [von Goessner](https://goessner.net/articles/JsonPath/), die wir durch Hinzufügen zusätzlicher Felder modifiziert haben.
```
{ "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
}
}
}
```
****
| Pfad | Description |
| --- | --- |
| \$1.store.book[\$1].author | die Autoren aller Bücher im Shop |
| \$1..author | alle Autoren |
| \$1.store.\$1 | alle Mitglieder des Shops |
| \$1["store"].\$1 | alle Mitglieder des Shops |
| \$1.store..price | der Preis von allem im Laden |
| \$1..\$1 | alle rekursiven Mitglieder der JSON-Struktur |
| \$1..book[\$1] | alle Bücher |
| \$1..book[0] | das erste Buch |
| \$1..book[-1] | das letzte Buch |
| \$1..book[0:2] | die ersten beiden Bücher |
| \$1..book[0,1] | die ersten beiden Bücher |
| \$1..book[0:4] | Bücher von Index 0 bis 3 (der Endindex ist nicht inklusive) |
| \$1..book[0:4:2] | Bücher mit Index 0, 2 |
| \$1..book[?(@.isbn)] | alle Bücher mit ISBN-Nummer |
| \$1..book[?(@.price<10)] | alle Bücher sind billiger als 10\$1 |
| '\$1..book[?(@.price < 10)]' | alle Bücher sind billiger als 10\$1. (Der Pfad muss in Anführungszeichen gesetzt werden, wenn er Leerzeichen enthält) |
| '\$1..book[?(@["price"] < 10)]' | alle Bücher sind billiger als 10\$1 |
| '\$1..book[?(@.["price"] < 10)]' | alle Bücher sind billiger als 10\$1 |
| \$1..book[?(@.price>=10&&@.price<=100)] | alle Bücher in der Preisklasse von 10 bis 100\$1, inklusive |
| '\$1..book[?(@.price>=10 && @.price<=100)]' | alle Bücher in der Preisklasse von 10 bis 100\$1, einschließlich. (Der Pfad muss in Anführungszeichen gesetzt werden, wenn er Leerzeichen enthält) |
| \$1..book[?(@.sold==true\$1\$1@.in-stock==false)] | alle Bücher sind verkauft oder ausverkauft |
| '\$1..book[?(@.sold == true \$1\$1 @.in-stock == false)]' | alle Bücher verkauft oder ausverkauft. (Der Pfad muss in Anführungszeichen gesetzt werden, wenn er Leerzeichen enthält) |
| '\$1.store.book[?(@.["category"] == "fiction")]' | alle Bücher in der Kategorie Belletristik |
| '\$1.store.book[?(@.["category"] \$1= "fiction")]' | alle Bücher in den Kategorien Sachliteratur |
Weitere Beispiele für Filterausdrücke:
```
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]"
```
**Beschränkte Syntax**
****
| Symbol/Ausdruck | Description |
| --- | --- |
| . oder [] | untergeordneter Operator |
| [] | Array-Indexoperator. Der Index basiert auf 0. |
**Beispiele**
****
| Pfad | Description |
| --- | --- |
| .store.book[0].author | der Autor des ersten Buches |
| .store.book[-1].author | der Autor des letzten Buches |
| .address.city | Name der Stadt |
| ["store"]["book"][0]["title"] | der Titel des ersten Buches |
| ["store"]["book"][-1]["title"] | der Titel des letzten Buches |
**Anmerkung**
Alle [Goessner](https://goessner.net/articles/JsonPath/)-Inhalte, die in dieser Dokumentation erwähnt werden, unterliegen der [Creative-Commons-Lizenz](https://creativecommons.org/licenses/by/2.5/).
## Häufige Fehlerpräfixe
Jede Fehlermeldung hat ein Präfix. Im Folgenden finden Sie eine Liste gängiger Fehlerpräfixe:
****
| Präfix | Description |
| --- | --- |
| ERR | ein allgemeiner Fehler |
| LIMIT | Fehler beim Überschreiten der Größenbeschränkung. Beispiel: Die Größenbeschränkung für Dokumente oder die maximale Verschachtelungstiefe wurde überschritten |
| NONEXISTENT | ein Schlüssel oder Pfad ist nicht vorhanden |
| OUTOFBOUNDARIES | Der Array-Index ist außerhalb der Grenzen |
| SYNTAXERR | Syntaxfehler |
| WRONGTYPE | falscher Wertetyp |
## JSON-bezogene Metriken
Die folgenden JSON-Infometriken werden bereitgestellt:
****
| Info | Description |
| --- | --- |
| json\$1total\$1memory\$1bytes | gesamter Speicher, der JSON-Objekten zugewiesen ist |
| json\$1num\$1documents | Gesamtzahl der Dokumente in der Valkey- oder Redis OSS-Engine |
Führen Sie den folgenden Befehl aus, um Kernmetriken abzufragen:
```
info json_core_metrics
```
## Wie interagiert MemoryDB mit JSON
Im Folgenden wird veranschaulicht, wie MemoryDB mit dem JSON-Datentyp interagiert.
### Rangfolge der Operatoren
Bei der Bewertung bedingter Ausdrücke zum Filtern, haben &&s zuerst Vorrang, und dann werden \$1\$1s ausgewertet, wie es in den meisten Sprachen üblich ist. Operationen innerhalb von Klammern werden zuerst ausgeführt.
### Verhalten der maximalen Verschachtelungsbeschränkung
Das maximale Limit für die Verschachtelung von Pfaden in MemoryDB liegt bei 128. Ein Wert wie `$.a.b.c.d...` kann also nur 128 Level erreichen.
### Umgang mit numerischen Werten
JSON hat keine separaten Datentypen für Ganzzahlen und Fließkommazahlen. Sie werden alle Zahlen genannt.
Wenn eine JSON-Nummer empfangen wird, wird sie in einem von zwei Formaten gespeichert. Wenn die Zahl in eine 64-Bit-Ganzzahl mit Vorzeichen passt, wird sie in dieses Format konvertiert. Andernfalls wird sie als Zeichenfolge gespeichert. Arithmetische Operationen mit zwei JSON-Nummern (z. B. JSON.NUMINCRBY und JSON.NUMMULTBY) versuchen, so viel Genauigkeit wie möglich beizubehalten. Wenn die beiden Operanden und der resultierende Wert in eine 64-Bit-Ganzzahl mit Vorzeichen passen, wird Integer-Arithmetik ausgeführt. Andernfalls werden die Eingabeoperanden in 64-Bit-IEEE-Gleitkommazahlen mit doppelter Genauigkeit umgewandelt, die arithmetische Operation wird ausgeführt und das Ergebnis wird wieder in eine Zeichenfolge konvertiert.
Arithmetische Befehle `NUMINCRBY` und `NUMMULTBY`:
+ Wenn beide Zahlen ganze Zahlen sind und das Ergebnis außerhalb des Bereichs von int64 liegt, wird es automatisch zu einer Gleitkommazahl mit doppelter Genauigkeit.
+ Wenn mindestens eine der Zahlen eine Fließkommazahl ist, ist das Ergebnis eine Gleitkommazahl mit doppelter Genauigkeit.
+ Wenn das Ergebnis den Bereich von Double überschreitet, gibt der Befehl einen `OVERFLOW` Fehler zurück.
**Anmerkung**
Vor Version 6.2.6.R2 der Redis OSS-Engine wurde eine JSON-Nummer, wenn sie bei der Eingabe empfangen wurde, in eine der beiden internen Binärdarstellungen umgewandelt: eine 64-Bit-Ganzzahl mit Vorzeichen oder eine 64-Bit-IEEE-Gleitkommazahl mit doppelter Genauigkeit. Die Ursprüngliche Zeichenfolge und alle ihre Formatierungen werden nicht beibehalten. Wenn also eine Zahl als Teil einer JSON-Antwort ausgegeben wird, wird sie von der internen Binärdarstellung in eine druckbare Zeichenfolge konvertiert, die generische Formatierungsregeln verwendet. Diese Regeln könnten dazu führen, dass eine andere Zeichenfolge generiert wird als empfangen wurde.
Wenn beide Zahlen ganze Zahlen sind und das Ergebnis außerhalb des Bereichs von `int64` liegt, ergibt sich daraus automatisch eine doppelt genaue 64-Bit-Gleitkommazahl.
Wenn mindestens eine der Zahlen eine Gleitkommazahl ist, ergibt sich daraus eine doppelt genaue 64-Bit-Gleitkommazahl.
Wenn das Ergebnis den Bereich einer doppelt genauen 64-Bit-Gleitkommazahl überschreitet, gibt der Befehl einen `OVERFLOW`-Fehler aus.
Eine detaillierte Liste der verfügbaren Befehle finden Sie unter [Unterstützte Befehle](json-list-commands.md).
### Strikte Syntaxbewertung
MemoryDB erlaubt keine JSON-Pfade mit ungültiger Syntax, selbst wenn eine Teilmenge des Pfads einen gültigen Pfad enthält. Dies soll für unsere Kunden ein korrektes Verhalten sicherstellen.
# Unterstützte Befehle
Die folgenden JSON-Befehle werden unterstützt:
**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
Hängen Sie einen oder mehrere Werte an die Array-Werte im Pfad an.
Syntax
```
JSON.ARRAPPEND [json ...]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ json (erforderlich) — JSON-Wert, der an das Array angehängt werden soll
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die neue Länge des Arrays an jedem Pfad darstellt.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ `SYNTAXERR`-Fehler, wenn eines der eingegebenen JSON-Argumente keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge des Arrays.
+ Wenn mehrere Array-Werte ausgewählt wurden, gibt der Befehl die neue Länge des zuletzt aktualisierten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `SYNTAXERR`-Fehler, wenn eines der eingegebenen JSON-Argumente keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Sucht nach dem ersten Vorkommen eines skalaren JSON-Werts in den Arrays am Pfad.
+ Fehler außerhalb des Bereichs werden behandelt, indem der Index auf den Anfang und das Ende des Arrays gerundet wird.
+ Wenn start > end, return -1 (nicht gefunden).
Syntax
```
JSON.ARRINDEX [start [end]]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ json-scalar (erforderlich) — Skalarwert, nach dem gesucht werden soll; JSON-Skalar bezieht sich auf Werte, die keine Objekte oder Arrays sind. Das heißt, String, Zahl, Boolean und Null sind Skalarwerte.
+ start (optional) — Startindex, einschließlich. Es gilt der Standardwert „0“, falls nicht vorhanden.
+ end (optional) — Endindex, exklusiv. Der Standardwert ist 0, falls nicht angegeben, was bedeutet, dass das letzte Element enthalten ist. 0 oder -1 bedeutet, dass das letzte Element enthalten ist.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen. Jeder Wert ist der Index des übereinstimmenden Elements im Array am Pfad. Der Wert ist -1, falls nicht gefunden.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, der Index des übereinstimmenden Elements oder -1, falls nicht gefunden.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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
```
Eingeschränkte Pfad-Syntax:
```
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
Fügt einen oder mehrere Werte in die Array-Werte am Pfad vor dem Index ein.
Syntax
```
JSON.ARRINSERT [json ...]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ index (erforderlich) — Array-Index, vor dem Werte eingefügt werden.
+ json (erforderlich) — JSON-Wert, der an das Array angehängt werden soll
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die neue Länge des Arrays an jedem Pfad darstellt.
+ Wenn ein Wert ein leeres Array ist, ist der entsprechende Rückgabewert Null.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ `OUTOFBOUNDARIES`-Fehler, wenn das Index-Argument außerhalb des gültigen Bereichs liegt.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge des Arrays.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `OUTOFBOUNDARIES`-Fehler, wenn das Index-Argument außerhalb des gültigen Bereichs liegt.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Ermittelt die Länge der Array-Werte im Pfad.
Syntax
```
JSON.ARRLEN [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen, die die Array-Länge an jedem Pfad darstellen.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Array von Bulk-Strings. Jedes Element ist ein Schlüsselname im Objekt.
+ Ganzzahl, Array-Länge.
+ Wenn mehrere Objekte ausgewählt sind, gibt der Befehl die Länge des ersten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `WRONGTYPE`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Entferne das Element am Index aus dem Array und gib es zurück. Das Öffnen eines leeren Arrays gibt null zurück.
Syntax
```
JSON.ARRPOP [path [index]]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
+ index (optional) — Position im Array, von der aus der Pop-up gestartet werden soll.
+ Ist standardmäßig -1, falls nicht angegeben, was auf das letzte Element verweist.
+ Negativer Wert bedeutet Position vom letzten Element.
+ Außerhalb der Grenzen liegende Indizes werden auf ihre jeweiligen Array-Grenzen gerundet.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Massenzeichenfolgen, die Werte in Popups für jeden Pfad darstellen.
+ Wenn ein Wert ein leeres Array ist, ist der entsprechende Rückgabewert Null.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Massenzeichenfolge, die den JSON-Wert im Popup-Fenster darstellt
+ Null, wenn das Array leer ist.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Kürzen Sie die Arrays am Pfad so, dass sie zu einem Subarray [Start, Ende] werden, beides inklusive.
+ Wenn das Array leer ist, tun Sie nichts, und geben Sie 0 zurück.
+ Wenn start <0 ist, behandeln Sie es als 0.
+ Wenn end >= size (Größe des Arrays), behandeln Sie es als size-1.
+ Wenn start >= size oder start > end, leeren Sie das Array und geben 0 zurück.
Syntax
```
JSON.ARRINSERT
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ start (erforderlich) — Startindex, einschließlich.
+ end (erforderlich) — Endindex, einschließlich.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen, die die neue Länge des Arrays an jedem Pfad darstellen.
+ Wenn ein Wert ein leeres Array ist, ist der entsprechende Rückgabewert Null.
+ Wenn ein Wert kein Array ist, ist der entsprechende Rückgabewert Null.
+ `OUTOFBOUNDARIES`-Fehler, wenn ein Indexargument außerhalb des gültigen Bereichs liegt.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge des Arrays.
+ Null, wenn das Array leer ist.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Array ist.
+ `OUTOFBOUNDARIES`-Fehler, wenn ein Indexargument außerhalb des gültigen Bereichs liegt.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]]"
```
Eingeschränkte Pfad-Syntax:
```
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
Löscht die Arrays oder Objekte im Pfad.
Syntax
```
JSON.CLEAR [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
+ Ganzzahl, die Anzahl der entfernten Container.
+ Beim Löschen eines leeren Arrays oder Objekts wurde der Container 0 gelöscht.
**Anmerkung**
Vor Redis OSS Version 6.2.6.R2 wurde das Löschen eines leeren Arrays oder Objekts für einen Container gelöscht.
+ Das Löschen eines Nicht-Container-Werts gibt 0 zurück.
+ Wenn sich neben dem Pfad kein Array- oder Objektwert befindet, gibt der Befehl 0 zurück.
**Beispiele**
```
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
Informationen melden. Unterstützte Unterbefehle sind:
+ MEMORY [Pfad] — meldet die Speichernutzung eines JSON-Werts in Byte. Falls nicht angegeben, gilt der Root-Standardwert für den Pfad.
+ DEPTH [Pfad] — Meldet die maximale Pfadtiefe des JSON-Dokuments.
**Anmerkung**
Dieser Unterbefehl ist nur mit Valkey 7.2 oder höher oder der Redis OSS-Engine-Version 6.2.6.R2 oder höher verfügbar.
+ FIELDS [path] — gibt die Anzahl der Felder im angegebenen Dokumentpfad an. Falls nicht angegeben, gilt der Root-Standardwert für den Pfad. Jeder JSON-Wert, der kein Container ist, zählt als ein Feld. Objekte und Arrays zählen rekursiv ein Feld für jeden ihrer JSON-Werte. Jeder Containerwert, mit Ausnahme des Root-Containers, zählt als ein zusätzliches Feld.
+ HELP — gibt Hilfemeldungen zum Befehl aus.
Syntax
```
JSON.DEBUG
```
Hängt vom Unterbefehl ab:
MEMORY
+ Wenn der Pfad eine erweiterte Syntax ist:
+ gibt ein Array von Ganzzahlen zurück, das die Speichergröße (in Byte) des JSON-Werts in jedem Pfad darstellt.
+ gibt ein leeres Array zurück, wenn der Schlüssel nicht existiert.
+ Wenn der Pfad eine eingeschränkte Syntax hat:
+ gibt eine Ganzzahl zurück, Speichergröße den JSON-Wert in Byte.
+ gibt null zurück, wenn der Schlüssel nicht existiert.
DEPTH
+ Gibt eine Ganzzahl zurück, die die maximale Pfadtiefe des JSON-Dokuments darstellt.
+ Gibt Null zurück, wenn der Schlüssel nicht existiert.
FIELDS
+ Wenn der Pfad eine erweiterte Syntax ist:
+ gibt ein Array von Ganzzahlen zurück, das die Anzahl der Felder mit JSON-Werten in jedem Pfad darstellt.
+ gibt ein leeres Array zurück, wenn der Schlüssel nicht existiert.
+ Wenn der Pfad eine eingeschränkte Syntax hat:
+ gibt eine Ganzzahl zurück, die Anzahl der Felder des JSON-Werts.
+ gibt null zurück, wenn der Schlüssel nicht existiert.
HELP — gibt eine Reihe von Hilfemeldungen zurück.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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
```
Eingeschränkte Pfad-Syntax:
```
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
Löscht die JSON-Werte im Pfad in einem Dokumentschlüssel. Wenn der Pfad das Stammverzeichnis ist, entspricht dies dem Löschen des Schlüssels aus Valkey oder Redis OSS.
Syntax
```
JSON.DEL [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
+ Anzahl der gelöschten Elemente.
+ 0, wenn der Schlüssel nicht existiert.
+ 0, wenn der JSON-Pfad ungültig ist oder nicht existiert.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\":[]}"
```
Eingeschränkte Pfad-Syntax:
```
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
Ein Alias von [JSON.DEL](json-del.md)
# JSON.GET
Gibt das serialisierte JSON in einem oder mehreren Pfaden zurück.
Syntax
```
JSON.GET
[INDENT indentation-string]
[NEWLINE newline-string]
[SPACE space-string]
[NOESCAPE]
[path ...]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ INDENT/NEWLINE/SPACE(optional) — steuert das Format der zurückgegebenen JSON-Zeichenfolge, d. h. „pretty print“. Der Standardwert jedes einzelnen ist eine leere Zeichenfolge. Sie können in beliebiger Kombination überschrieben werden. Sie können in beliebiger Reihenfolge angegeben werden.
+ NOESCAPE — optional, darf aus Gründen der Kompatibilität mit älteren Versionen vorhanden sein und hat keine weiteren Auswirkungen.
+ path (optional) — null oder mehr JSON-Pfade, standardmäßig das Stammverzeichnis, falls keiner angegeben ist. Die Pfadargumente müssen am Ende platziert werden.
**Ergebnis**
Erweiterte Pfad-Syntax:
Wenn ein Pfad angegeben ist:
+ Gibt eine serialisierte Zeichenfolge eines Wertearrays zurück.
+ Wenn kein Wert ausgewählt ist, gibt der Befehl ein leeres Array zurück.
Wenn mehrere Pfade angegeben sind:
+ Gibt ein stringifiziertes JSON-Objekt zurück, in dem jeder Pfad ein Schlüssel ist.
+ Wenn es gemischte, erweiterte und eingeschränkte Pfadsyntax gibt, entspricht das Ergebnis der erweiterten Syntax.
+ Wenn ein Pfad nicht existiert, ist der entsprechende Wert ein leeres Array.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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]"
```
Eingeschränkte Pfad-Syntax:
```
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
Lassen Sie sich JSONs am Pfad aus mehreren Dokumentenschlüsseln serialisieren. Gibt Null zurück, wenn der Schlüssel oder der JSON-Pfad nicht existiert.
Syntax
```
JSON.MGET [key ...]
```
+ Schlüssel (erforderlich) — Ein oder mehrere Schlüssel des Dokumenttyps.
+ path (erforderlich) — ein JSON-Pfad
**Ergebnis**
+ Array von Massenzeichenfolgen. Die Größe des Arrays entspricht der Anzahl der Schlüssel im Befehl. Jedes Element des Arrays wird entweder mit (a) dem serialisierten JSON gefüllt, wie es im Pfad gefunden wird, oder (b) Null, wenn der Schlüssel nicht existiert oder der Pfad nicht im Dokument existiert oder der Pfad ungültig ist (Syntaxfehler).
+ Wenn einer der angegebenen Schlüssel existiert und kein JSON-Schlüssel ist, gibt der Befehl den Fehler `WRONGTYPE` zurück.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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\"]"
```
Eingeschränkte Pfad-Syntax:
```
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
Erhöhen Sie die Zahlenwerte im Pfad um eine bestimmte Zahl.
Syntax
```
JSON.NUMINCRBY
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ Zahl (erforderlich) — eine Zahl
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Massenzeichenfolgen, die den resultierenden Wert für jeden Pfad darstellen.
+ Wenn ein Wert keine Zahl ist, ist der entsprechende Rückgabewert Null.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Massenzeichenfolge, die den resultierenden Wert darstellt.
+ Wenn mehrere Werte ausgewählt wurden, gibt der Befehl das Ergebnis des zuletzt aktualisierten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zahl ist.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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}}"
```
Eingeschränkte Pfad-Syntax:
```
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
Multipliziert die Zahlenwerte im Pfad mit einer bestimmten Zahl.
Syntax
```
JSON.NUMMULTBY
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — ein JSON-Pfad
+ Zahl (erforderlich) — eine Zahl
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Massenzeichenfolgen, die den resultierenden Wert für jeden Pfad darstellen.
+ Wenn ein Wert keine Zahl ist, ist der entsprechende Rückgabewert Null.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Massenzeichenfolge, die den resultierenden Wert darstellt.
+ Wenn mehrere Werte ausgewählt wurden, gibt der Befehl das Ergebnis des zuletzt aktualisierten Arrays zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zahl ist.
+ `WRONGTYPE`-Fehler, wenn die Zahl nicht analysiert werden kann.
+ `OVERFLOW`-Fehler, wenn das Ergebnis außerhalb des Bereichs der doppelt genauen 64-Bit-Gleitkommazahl liegt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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]"
```
Eingeschränkte Pfad-Syntax:
```
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
Ruft die Anzahl der Schlüssel in den Objektwerten im Pfad ab.
Syntax
```
JSON.OBJLEN [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen, die die Objektlänge an jedem Pfad darstellen.
+ Wenn ein Wert kein Objekt ist, ist der entsprechende Rückgabewert null.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, Anzahl der Schlüssel im Objekt.
+ Wenn mehrere Objekte ausgewählt sind, gibt der Befehl die Länge des ersten Objekts zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Objekt ist.
+ `WRONGTYPE`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Ruft Schlüsselnamen in den Objektwerten im Pfad ab.
Syntax
```
JSON.OBJKEYS [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Arrays von Bulk-Strings. Jedes Element ist ein Array von Schlüsseln in einem übereinstimmenden Objekt.
+ Wenn ein Wert kein Objekt ist, ist der entsprechende Rückgabewert leer.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Array von Bulk-Strings. Jedes Element ist ein Schlüsselname im Objekt.
+ Wenn mehrere Objekte ausgewählt sind, gibt der Befehl die Schlüssel des ersten Objekts zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad kein Objekt ist.
+ `WRONGTYPE`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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"
```
Eingeschränkte Pfad-Syntax:
```
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
Gibt den JSON-Wert im angegebenen Pfad im Valkey- oder Redis OSS Serialization Protocol (RESP) zurück. Wenn der Wert Container ist, ist die Antwort ein RESP-Array oder ein verschachteltes Array.
+ JSON null wird dem RESP Null Bulk String zugeordnet.
+ Boolesche JSON-Werte werden den jeweiligen RESP-Simple-Strings zugeordnet.
+ Ganzzahlen werden RESP-Ganzzahlen zugeordnet.
+ Doppelt genaue 64-Bit-Gleitkommazahlen werden RESP-Bulk-Strings zugeordnet.
+ JSON-Zeichenfolgen werden RESP-Bulk-Strings zugeordnet.
+ JSON-Arrays werden als RESP-Arrays dargestellt, wobei das erste Element die einfache Zeichenfolge [ist, gefolgt von den Elementen des Arrays.
+ JSON-Objekte werden als RESP-Arrays dargestellt, wobei das erste Element die einfache Zeichenfolge \$1ist, gefolgt von Schlüssel-Wert-Paaren, von denen jedes eine RESP-Bulk-String ist.
Syntax
```
JSON.RESP [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Arrays. Jedes Array-Element repräsentiert die RESP-Form des Werts in einem Pfad.
+ Leeres Array wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Array, das die RESP-Form des Werts im Pfad darstellt.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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"
```
Eingeschränkte Pfad-Syntax:
```
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
Legt JSON-Werte für den Pfad fest.
Wenn der Pfad ein Objektmitglied aufruft:
+ Wenn das übergeordnete Element nicht existiert, gibt der Befehl den Fehler NONEXISTENT zurück.
+ Wenn das übergeordnete Element existiert, aber kein Objekt ist, gibt der Befehl ERROR zurück.
+ Wenn das übergeordnete Element existiert und ein Objekt ist:
+ Wenn das Mitglied nicht existiert, wird ein neues Mitglied an das übergeordnete Objekt angehängt, wenn das übergeordnete Objekt das letzte untergeordnete Objekt im Pfad ist. Andernfalls gibt der Befehl den Fehler NONEXISTENT zurück.
+ Wenn das Mitglied existiert, wird sein Wert durch den JSON-Wert ersetzt.
Wenn der Pfad einen Array-Index aufruft:
+ Wenn das übergeordnete Element nicht existiert, gibt der Befehl den Fehler NONEXISTENT zurück.
+ Wenn das übergeordnete Element existiert, aber kein Array ist, gibt der Befehl ERROR zurück.
+ Wenn das übergeordnete Element existiert, der Index jedoch außerhalb der Grenzen liegt, gibt der Befehl den Fehler OUTOFBOUNDARIES zurück.
+ Wenn das übergeordnete Element existiert und der Index gültig ist, wird das Element durch den neuen JSON-Wert ersetzt.
Wenn der Pfad ein Objekt oder Array aufruft, wird der Wert (Objekt oder Array) durch den neuen JSON-Wert ersetzt.
Syntax
```
JSON.SET [NX | XX]
```
[NX \$1 XX] Dabei können Sie 0 oder 1 von [NX \$1 XX] -Bezeichnern haben
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (erforderlich) — JSON-Pfad. Für einen neuen Schlüssel muss der JSON-Pfad der Stamm „.“ sein.
+ NX (optional) — Wenn es sich bei dem Pfad um das Stammverzeichnis handelt, legen Sie den Wert nur fest, wenn der Schlüssel nicht existiert, d. h. fügen Sie ein neues Dokument ein. Wenn der Pfad nicht das Stammverzeichnis ist, legen Sie den Wert nur fest, wenn der Pfad nicht existiert, d. h. fügen Sie einen Wert in das Dokument ein.
+ XX (optional) — Wenn es sich bei dem Pfad um das Stammverzeichnis handelt, legen Sie den Wert nur fest, wenn der Schlüssel vorhanden ist, d. h. ersetzen Sie das vorhandene Dokument. Wenn es sich bei dem Pfad nicht um das Stammverzeichnis handelt, legen Sie den Wert nur fest, wenn der Pfad existiert, d. h. aktualisieren Sie den vorhandenen Wert.
**Ergebnis**
+ Einfache Zeichenfolge 'OK' bei Erfolg.
+ Null, wenn die NX- oder XX-Bedingungen nicht erfüllt sind.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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]}"
```
Eingeschränkte Pfad-Syntax:
```
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
Hängt eine Zeichenfolge an die JSON-Zeichenketten im Pfad an.
Syntax
```
JSON.STRAPPEND [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
+ json\$1string (erforderlich) — JSON-Darstellung einer Zeichenfolge. Beachten Sie, dass eine JSON-Zeichenfolge in Anführungszeichen gesetzt werden muss, d. h. '"foo"'.
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die neue Länge der Zeichenfolge an jedem Pfad darstellt.
+ Wenn ein Wert im Pfad keine Zeichenfolge ist, ist der entsprechende Rückgabewert Null.
+ `SYNTAXERR `Fehler, wenn das Eingabe-JSON-Argument keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT `Fehler, wenn der Pfad nicht existiert.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die neue Länge der Zeichenfolge.
+ Wenn mehrere Zeichenfolgenwerte ausgewählt wurden, gibt der Befehl die neue Länge der zuletzt aktualisierten Zeichenfolge zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zeichenfolge ist.
+ `WRONGTYPE`-Fehler, wenn das angegebene JSON-Argument keine gültige JSON-Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Ruft die Längen der JSON-Zeichenkettenwerte im Pfad ab.
Syntax
```
JSON.STRLEN [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von Ganzzahlen, das die Länge des Zeichenkettenwerts in jedem Pfad darstellt.
+ Wenn ein Wert keine Zeichenfolge ist, ist der entsprechende Rückgabewert Null.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Ganzzahl, die Länge der Zeichenfolge.
+ Wenn mehrere Zeichenfolgenwerte ausgewählt wurden, gibt der Befehl die erste Zeichenfolgenlänge zurück.
+ `WRONGTYPE`-Fehler, wenn der Wert im Pfad keine Zeichenfolge ist.
+ `NONEXISTENT`-Fehler, wenn der Pfad nicht vorhanden ist.
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Schaltet boolesche Werte im Pfad zwischen wahr und falsch um.
Syntax
```
JSON.TOGGLE [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Array von ganzen Zahlen (0 — falsch, 1 — wahr), die den resultierenden booleschen Wert für jeden Pfad darstellen.
+ Wenn ein Wert kein boolescher Wert ist, ist der entsprechende Rückgabewert Null.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Zeichenfolge („true“ /"false“), die den resultierenden booleschen Wert darstellt.
+ `NONEXISTENT` wenn der Dokumentschlüssel nicht vorhanden ist.
+ `WRONGTYPE`Fehler, wenn der Wert im Pfad kein boolescher Wert ist.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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)
```
Eingeschränkte Pfad-Syntax:
```
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
Berichtstyp der Werte im angegebenen Pfad.
Syntax
```
JSON.TYPE [path]
```
+ key (erforderlich) — Schlüssel des JSON-Dokumenttyps
+ path (optional) — ein JSON-Pfad. Standardmäßig das Stammverzeichnis, falls nicht angegeben
**Ergebnis**
Wenn der Pfad eine erweiterte Syntax ist:
+ Zeichenkettenarray, das den Typ des Werts in jedem Pfad darstellt. Typ \$1„null“, „boolean“, „string“, „number“, „integer“, „object“ und „array"\$1.
+ Wenn ein Pfad nicht existiert, ist der entsprechende Ausgabewert null.
+ Leeres Array wenn der Dokumentschlüssel nicht vorhanden ist.
Wenn der Pfad eine eingeschränkte Syntax hat:
+ Zeichenfolge, Typ des Werts
+ Null, wenn der Dokumentschlüssel nicht vorhanden ist.
+ Null, wenn der JSON-Pfad ungültig ist oder nicht existiert.
**Beispiele**
Erweiterte Pfad-Syntax:
```
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
```
Eingeschränkte Pfad-Syntax:
```
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
```