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.
# Verwenden von Aktualisierungsausdrücken in DynamoDB
Die `UpdateItem`-Operation aktualisiert ein vorhandenes Elements oder fügt ein neues Element in die Tabelle ein, wenn es noch nicht existiert. Sie müssen den Schlüssel des Elements angeben, das Sie aktualisieren möchten. Außerdem müssen Sie einen Aktualisierungsausdruck angeben, der die zu ändernden Attribute sowie die Werte enthält, die Sie ihnen zuweisen möchten.
Ein *Aktualisierungsausdruck* gibt an, wie `UpdateItem` die Attribute eines Elements ändert, z. B. durch Festlegen eines Skalarwerts oder durch Entfernen von Elementen aus einer Liste oder Zuordnung.
Im Folgenden finden Sie eine Syntaxzusammenfassung für Aktualisierungsausdrücke.
```
update-expression ::=
[ SET action [, action] ... ]
[ REMOVE action [, action] ...]
[ ADD action [, action] ... ]
[ DELETE action [, action] ...]
```
Ein Aktualisierungsausdruck besteht aus einer oder mehreren Klauseln. Jede Klausel beginnt mit einem `SET`-, `REMOVE`-, `ADD`- oder `DELETE`-Schlüsselwort. Sie können jede dieser Klauseln in beliebiger Reihenfolge in einen Aktualisierungsausdruck einfügen. Jedes Aktionsschlüsselwort kann jedoch nur einmal angezeigt werden.
Jede Klausel umfasst eine oder mehrere Aktionen, die durch Komma getrennt sind. Jede Aktion stellt eine Datenänderung dar.
Die Beispiele in diesem Abschnitt basieren auf dem Element `ProductCatalog`, wie in [Verwenden von Projektionsausdrücken in DynamoDB](Expressions.ProjectionExpressions.md) dargestellt.
Die folgenden Themen behandeln verschiedene Anwendungsfälle für die `SET`-Aktion.
**Topics**
+ [SET – Ändern oder Hinzufügen von Elementattributen](#Expressions.UpdateExpressions.SET)
+ [REMOVE – Löschen von Attributen aus einem Element](#Expressions.UpdateExpressions.REMOVE)
+ [ADD – Aktualisieren von Zahlen und Sätzen](#Expressions.UpdateExpressions.ADD)
+ [DELETE – Entfernen von Elementen aus einem Satz](#Expressions.UpdateExpressions.DELETE)
+ [Verwenden mehrerer Aktualisierungsausdrücke](#Expressions.UpdateExpressions.Multiple)
## SET – Ändern oder Hinzufügen von Elementattributen
Verwenden Sie die `SET`-Aktion in einem Aktualisierungsausdruck, um ein oder mehrere Attribute zu einem Element hinzuzufügen. Wenn diese Attribute bereits vorhanden sind, werden sie durch die neuen Werte überschrieben. Wenn Sie verhindern möchten, dass ein vorhandenes Attribut überschrieben wird, können Sie `SET` mit der Funktion `if_not_exists` verwenden. Die Funktion `if_not_exists` gilt spezifisch für die `SET`-Aktion und kann nur in einem Aktualisierungsausdruck verwendet werden.
Wenn Sie `SET` verwenden, um ein Listenelement zu aktualisieren, wird der Inhalt dieses Elements durch die neuen Daten ersetzt, die Sie angeben. Wenn das Element noch nicht vorhanden ist, fügt `SET` das neue Element am Ende der Liste an.
Wenn Sie mehrere Elemente in einer einzigen `SET`-Operation hinzufügen, werden die Elemente nach Elementnummer sortiert.
Sie können `SET` auch verwenden, um einen Wert zu einem Attribut des Typs `Number` zu addieren oder von diesem zu subtrahieren. Wenn Sie mehrere `SET`-Aktionen durchführen möchten, trennen Sie sie durch Komma.
Schauen Sie sich die folgende Syntaxzusammenfassung an:
+ Das *path* Element ist der Dokumentpfad zu dem Element.
+ Ein **operand**Element kann entweder ein Dokumentpfad zu einem Element oder eine Funktion sein.
```
set-action ::=
path = value
value ::=
operand
| operand '+' operand
| operand '-' operand
operand ::=
path | function
function ::=
if_not_exists (path, value)
```
Wenn das Element kein Attribut im angegebenen Pfad enthält, ergibt `if_not_exists` `value`. Andernfalls ergibt es `path`.
Die folgende `PutItem`-Operation erstellt ein Beispielelement, auf das wir uns in den Beispielen beziehen werden.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json
```
Die Argumente für `--item` werden in der Datei `item.json` gespeichert. (Der Einfachheit halber werden nur wenige Elementattribute verwendet.)
```
{
"Id": {"N": "789"},
"ProductCategory": {"S": "Home Improvement"},
"Price": {"N": "52"},
"InStock": {"BOOL": true},
"Brand": {"S": "Acme"}
}
```
**Topics**
+ [Ändern von Attributen](#Expressions.UpdateExpressions.SET.ModifyingAttributes)
+ [Hinzufügen von Listen und Zuordnungen](#Expressions.UpdateExpressions.SET.AddingListsAndMaps)
+ [Hinzufügen von Elementen zu einer Liste](#Expressions.UpdateExpressions.SET.AddingListElements)
+ [Hinzufügen verschachtelter Zuordnungsattribute](#Expressions.UpdateExpressions.SET.AddingNestedMapAttributes)
+ [Vergrößern und Verkleinern numerischer Attribute](#Expressions.UpdateExpressions.SET.IncrementAndDecrement)
+ [Anfügen von Elementen zu einer Liste](#Expressions.UpdateExpressions.SET.UpdatingListElements)
+ [Verhindern der Überschreibung eines vorhandenen Attributs](#Expressions.UpdateExpressions.SET.PreventingAttributeOverwrites)
### Ändern von Attributen
**Example**
Aktualisieren Sie die Attribute `ProductCategory` und `Price`.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET ProductCategory = :c, Price = :p" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":c": { "S": "Hardware" },
":p": { "N": "60" }
}
```
**Anmerkung**
In der Operation `UpdateItem` führt `--return-values ALL_NEW` dazu, dass DynamoDB das Element so zurückgibt, wie es nach der Aktualisierung erscheint.
### Hinzufügen von Listen und Zuordnungen
**Example**
Hinzufügen einer neuen Liste und Zuordnung:
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems = :ri, ProductReviews = :pr" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":ri": {
"L": [
{ "S": "Hammer" }
]
},
":pr": {
"M": {
"FiveStar": {
"L": [
{ "S": "Best product ever!" }
]
}
}
}
}
```
### Hinzufügen von Elementen zu einer Liste
**Example**
Fügen Sie der Liste `RelatedItems` ein neues Attribut hinzu. (Denken Sie daran, dass Listenelemente nullbasiert sind, sodass [0] das erste Element in der Liste darstellt, [1] das zweite und so weiter.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems[1] = :ri" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":ri": { "S": "Nails" }
}
```
**Anmerkung**
Wenn Sie `SET` verwenden, um ein Listenelement zu aktualisieren, wird der Inhalt dieses Elements durch die neuen Daten ersetzt, die Sie angeben. Wenn das Element noch nicht vorhanden ist, fügt `SET` das neue Element am Ende der Liste an.
Wenn Sie mehrere Elemente in einer einzigen `SET`-Operation hinzufügen, werden die Elemente nach Elementnummer sortiert.
### Hinzufügen verschachtelter Zuordnungsattribute
**Example**
Fügen Sie einige verschachtelte Zuordnungsattribute hinzu.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #pr.#5star[1] = :r5, #pr.#3star = :r3" \
--expression-attribute-names file://names.json \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Die Argumente für `--expression-attribute-names` werden in der Datei `names.json` gespeichert.
```
{
"#pr": "ProductReviews",
"#5star": "FiveStar",
"#3star": "ThreeStar"
}
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":r5": { "S": "Very happy with my purchase" },
":r3": {
"L": [
{ "S": "Just OK - not that great" }
]
}
}
```
**Wichtig**
Sie können die Attribute einer verschachtelten Map nicht aktualisieren, wenn die übergeordnete Map nicht existiert. Wenn Sie versuchen, ein verschachteltes Attribut zu aktualisieren (z. B.`ProductReviews.FiveStar`), obwohl die übergeordnete Zuordnung (`ProductReviews`) nicht vorhanden ist, gibt DynamoDB a `ValidationException` mit der Meldung *„Der im Aktualisierungsausdruck angegebene Dokumentpfad ist für die Aktualisierung ungültig*“ zurück.
Wenn Sie Elemente erstellen, für die die Attribute der verschachtelten Map später aktualisiert werden, initialisieren Sie leere Maps für die übergeordneten Attribute. Beispiel:
```
{
"Id": {"N": "789"},
"ProductReviews": {"M": {}},
"Metadata": {"M": {}}
}
```
Auf diese Weise können Sie verschachtelte Attribute ohne Fehler aktualisieren. `ProductReviews.FiveStar`
### Vergrößern und Verkleinern numerischer Attribute
Sie können ein vorhandenes numerisches Attribut vergrößern oder verkleinern. Dazu verwenden Sie die Operatoren `+` (plus) und `-` (minus).
**Example**
Verringern Sie den `Price` eines Elements.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = Price - :p" \
--expression-attribute-values '{":p": {"N":"15"}}' \
--return-values ALL_NEW
```
Um den `Price` zu erhöhen, verwenden Sie den Operator `+` im Aktualisierungsausdruck.
### Anfügen von Elementen zu einer Liste
Sie können Elemente an das Ende einer Liste anfügen. Dazu verwenden Sie `SET` mit der Funktion `list_append`. (Beim Funktionsnamen muss die Groß- und Kleinschreibung beachtet werden.) Die Funktion `list_append` gilt spezifisch für die `SET`-Aktion und kann nur in einem Aktualisierungsausdruck verwendet werden. Die Syntax ist wie folgt.
+ `list_append (list1, list2)`
Die Funktion nimmt zwei Listen als Eingabe und fügt alle Elemente von `list2` bis ` list1` an.
**Example**
Unter [Hinzufügen von Elementen zu einer Liste](#Expressions.UpdateExpressions.SET.AddingListElements) erstellen Sie die Liste `RelatedItems` und fügen ihr zwei Elemente hinzu: `Hammer` und `Nails`. Nun fügen Sie zwei weitere Elemente an das Ende von `RelatedItems` an.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #ri = list_append(#ri, :vals)" \
--expression-attribute-names '{"#ri": "RelatedItems"}' \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":vals": {
"L": [
{ "S": "Screwdriver" },
{"S": "Hacksaw" }
]
}
}
```
Am Schluss fügen Sie ein weiteres Element an den *Anfang* von `RelatedItems` an. Vertauschen Sie dazu die Reihenfolge der `list_append`-Elemente. (Beachten Sie, dass `list_append` die beiden Listen als Eingabe übernimmt und die zweite Liste an die erste anfügt.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #ri = list_append(:vals, #ri)" \
--expression-attribute-names '{"#ri": "RelatedItems"}' \
--expression-attribute-values '{":vals": {"L": [ { "S": "Chisel" }]}}' \
--return-values ALL_NEW
```
Das daraus resultierende Attribut `RelatedItems` enthält jetzt fünf Elemente in der folgenden Reihenfolge: `Chisel`, `Hammer`, `Nails`, `Screwdriver`, `Hacksaw`.
### Verhindern der Überschreibung eines vorhandenen Attributs
**Example**
Legen Sie den `Price` eines Elements fest, jedoch nur dann, wenn das Element noch nicht über ein `Price`-Attribut verfügt. (Wenn `Price` bereits vorhanden ist, ändert sich nichts.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = if_not_exists(Price, :p)" \
--expression-attribute-values '{":p": {"N": "100"}}' \
--return-values ALL_NEW
```
## REMOVE – Löschen von Attributen aus einem Element
Verwenden Sie die `REMOVE`-Aktion in einem Aktualisierungsausdruck, um ein oder mehrere Attribute aus einem Element in Amazon DynamoDB zu entfernen. Wenn Sie mehrere `REMOVE`-Aktionen durchführen möchten, trennen Sie sie durch Komma.
Im Folgenden finden Sie eine Syntaxzusammenfassung für `REMOVE` in einem Aktualisierungsausdruck. Der einzige Operand ist der Dokumentpfad für das Attribut, das Sie entfernen möchten.
```
remove-action ::=
path
```
**Example**
Löschen einiger Attribute aus einem Element. (Wenn die Attribute nicht vorhanden sind, ändert sich nichts.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE Brand, InStock, QuantityOnHand" \
--return-values ALL_NEW
```
### Entfernen von Elementen aus einer Liste
Sie können `REMOVE` verwenden, um einzelne Element aus einer Liste zu löschen.
**Example**
Unter [Anfügen von Elementen zu einer Liste](#Expressions.UpdateExpressions.SET.UpdatingListElements) haben Sie ein Listenattribut (`RelatedItems`) so geändert, dass es fünf Elemente enthält:
+ `[0]`—`Chisel`
+ `[1]`—`Hammer`
+ `[2]`—`Nails`
+ `[3]`—`Screwdriver`
+ `[4]`—`Hacksaw`
Das folgende Beispiel AWS Command Line Interface (AWS CLI) löscht `Hammer` und `Nails` aus der Liste.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE RelatedItems[1], RelatedItems[2]" \
--return-values ALL_NEW
```
Nach dem Entfernen von `Hammer` und `Nails` werden die verbleibenden Elemente verschoben. Die Liste enthält nun Folgendes:
+ `[0]`—`Chisel`
+ `[1]`—`Screwdriver`
+ `[2]`—`Hacksaw`
## ADD – Aktualisieren von Zahlen und Sätzen
**Anmerkung**
Im Allgemeinen empfehlen wir, idempotente Operationen `ADD` zu verwenden, `SET` anstatt sie sicherzustellen.
Verwenden Sie die `ADD`-Aktion in einem Aktualisierungsausdruck, um ein neues Attribut mit seinen zugehörigen Werten einem Element hinzuzufügen.
Wenn das Attribut bereits vorhanden ist, hängt das Verhalten von `ADD` vom Datentyp des Attributs ab.
+ Wenn das vorhandene Attribut eine Zahl ist und der Wert, den Sie hinzufügen, ebenfalls eine Zahl, wird der Wert mathematisch zum vorhandenen Attribut addiert. (Wenn der Wert eine negative Zahl ist, wird er vom vorhandenen Attribut abgezogen.)
+ Wenn es sich bei dem Attribut um einen Satz handelt und der Wert, den Sie hinzufügen, ebenfalls ein Satz ist, wird der Wert an den vorhandenen Satz angefügt.
**Anmerkung**
Die `ADD`-Aktion unterstützt nur die Datentypen "Zahl" und "Satz".
Wenn Sie mehrere `ADD`-Aktionen durchführen möchten, trennen Sie sie durch Komma.
Schauen Sie sich die folgende Syntaxzusammenfassung an:
+ Das *path* Element ist der Dokumentpfad zu einem Attribut. Das Attribut muss entweder vom Datentyp `Number` oder "Satz" sein.
+ Das *value* Element ist eine Zahl, die Sie dem Attribut hinzufügen möchten (für `Number` Datentypen), oder ein Satz, der an das Attribut angehängt werden soll (für Satztypen).
```
add-action ::=
path value
```
Die folgenden Themen behandeln verschiedene Anwendungsfälle für die `ADD`-Aktion.
**Topics**
+ [Hinzufügen einer Zahl](#Expressions.UpdateExpressions.ADD.Number)
+ [Hinzufügen von Elementen zu einem Satz](#Expressions.UpdateExpressions.ADD.Set)
### Hinzufügen einer Zahl
Angenommen, das Attribut `QuantityOnHand` ist nicht vorhanden. Im folgenden AWS CLI Beispiel wird der Wert `QuantityOnHand` auf 5 gesetzt.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD QuantityOnHand :q" \
--expression-attribute-values '{":q": {"N": "5"}}' \
--return-values ALL_NEW
```
Da `QuantityOnHand` nun vorhanden ist, können Sie das Beispiel erneut ausführen, um `QuantityOnHand` jedes Mal um 5 zu erhöhen.
### Hinzufügen von Elementen zu einem Satz
Angenommen, das Attribut `Color` ist nicht vorhanden. Im folgenden AWS CLI -Beispiel wird `Color` auf einen Zeichenfolgensatz mit zwei Elementen festgelegt.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD Color :c" \
--expression-attribute-values '{":c": {"SS":["Orange", "Purple"]}}' \
--return-values ALL_NEW
```
Da `Color` nun vorhanden ist, können wir weitere Elemente hinzufügen.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD Color :c" \
--expression-attribute-values '{":c": {"SS":["Yellow", "Green", "Blue"]}}' \
--return-values ALL_NEW
```
## DELETE – Entfernen von Elementen aus einem Satz
**Wichtig**
Die `DELETE`-Aktion unterstützt nur den Datentyp `Set`.
Verwenden Sie die `DELETE`-Aktion in einem Aktualisierungsausdruck, um ein oder mehrere Elemente aus einem Satz zu entfernen. Wenn Sie mehrere `DELETE`-Aktionen durchführen möchten, trennen Sie sie durch Komma.
Schauen Sie sich die folgende Syntaxzusammenfassung an:
+ Das *path* Element ist der Dokumentpfad zu einem Attribut. Das Attribut muss vom Datentyp "Satz" sein.
+ Das *subset* ist ein oder mehrere Elemente, aus denen Sie löschen möchten*path*. Sie müssen einen Satztyp angeben*subset*.
```
delete-action ::=
path subset
```
**Example**
Unter [Hinzufügen von Elementen zu einem Satz](#Expressions.UpdateExpressions.ADD.Set) erstellen Sie den `Color`-Zeichenfolgendsatz. In diesem Beispiel werden einige der Elemente aus diesem Satz entfernt:
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "DELETE Color :p" \
--expression-attribute-values '{":p": {"SS": ["Yellow", "Purple"]}}' \
--return-values ALL_NEW
```
## Verwenden mehrerer Aktualisierungsausdrücke
Sie können mehrere Aktionen in einem einzigen Aktualisierungsausdruck verwenden. Alle Attributverweise werden anhand des Status des Elements aufgelöst, bevor eine der Aktionen angewendet wird.
**Example**
Bei einem bestimmten Element `{"id": "1", "a": 1, "b": 2, "c": 3}` entfernt `a` und verschiebt der folgende Ausdruck die Werte von `b` und`c`:
```
aws dynamodb update-item \
--table-name test \
--key '{"id":{"S":"1"}}' \
--update-expression "REMOVE a SET b = a, c = b" \
--return-values ALL_NEW
```
Das Ergebnis ist`{"id": "1", "b": 1, "c": 2}`. Obwohl `a` es entfernt und im selben Ausdruck neu zugewiesen `b` wird, werden beide Verweise auf ihre ursprünglichen Werte aufgelöst.
**Example**
Wenn Sie den Wert eines Attributs ändern und ein anderes Attribut vollständig entfernen möchten, können Sie eine SET-Aktion und eine REMOVE-Aktion in einer einzelnen Anweisung verwenden. Dieser Vorgang würde den `Price`-Wert auf 15 verringern und gleichzeitig das `InStock`-Attribut aus dem Element entfernen.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = Price - :p REMOVE InStock" \
--expression-attribute-values '{":p": {"N":"15"}}' \
--return-values ALL_NEW
```
**Example**
Wenn Sie einer Liste etwas hinzufügen und gleichzeitig den Wert eines anderen Attributs ändern möchten, können Sie zwei SET-Aktionen in einer einzelnen Anweisung verwenden. Diese Operation würde dem `RelatedItems`-Listenattribut „Nails“ hinzufügen und den `Price`-Wert auf 21 setzen.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems[1] = :newValue, Price = :newPrice" \
--expression-attribute-values '{":newValue": {"S":"Nails"}, ":newPrice": {"N":"21"}}' \
--return-values ALL_NEW
```