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 Ausdrücken in DynamoDB
In Amazon DynamoDB können Sie mithilfe von *Ausdrücken* angeben, welche Attribute aus einem Element gelesen werden sollen, Daten schreiben, wenn eine Bedingung erfüllt ist, angeben, wie ein Element aktualisiert werden soll, Abfragen definieren und die Ergebnisse einer Abfrage filtern.
In dieser Tabelle werden die grundlegende Ausdrucksgrammatik und die verfügbaren Ausdrucksarten beschrieben.
| Ausdruckstyp | Description |
| --- | --- |
| Projektionsausdruck | Ein Projektionsausdruck identifiziert die Attribute, die Sie aus einem Element abrufen möchten GetItem, wenn Sie Operationen wie Abfragen oder Scannen verwenden. |
| Bedingungsausdruck | Ein Bedingungsausdruck bestimmt, welche Elemente geändert werden sollen, wenn Sie die DeleteItem Operationen PutItem UpdateItem, und verwenden. |
| Aktualisierungsausdruck | Ein Aktualisierungsausdruck gibt an, wie die Attribute eines Elements geändert UpdateItem werden, z. B. durch das Festlegen eines Skalarwerts oder das Entfernen von Elementen aus einer Liste oder einer Map. |
| Schlüsselbedingungsausdruck | Ein Schlüsselbedingungsausdruck bestimmt, welche Elemente eine Abfrage aus einer Tabelle oder einem Index liest. |
| Filterausdruck | Ein Filterausdruck bestimmt, welche Elemente in den Abfrageergebnissen zurückgegeben werden. Alle anderen Ergebnisse werden verworfen. |
Weitere Informationen zur Ausdruckssyntax und Details zu jedem Ausdruckstyp finden Sie in folgenden Abschnitten.
**Topics**
+ [Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB](Expressions.Attributes.md)
+ [Ausdrucksattributnamen (Aliasse) in DynamoDB](Expressions.ExpressionAttributeNames.md)
+ [Verwenden von Ausdrucksattributwerten in DynamoDB](Expressions.ExpressionAttributeValues.md)
+ [Verwenden von Projektionsausdrücken in DynamoDB](Expressions.ProjectionExpressions.md)
+ [Verwenden von Aktualisierungsausdrücken in DynamoDB](Expressions.UpdateExpressions.md)
+ [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md)
+ [CLI-Beispiel für DynamoDB-Bedingungsausdrücke](Expressions.ConditionExpressions.md)
**Anmerkung**
Für die Abwärtskompatibilität unterstützt DynamoDB ebenfalls bedingte Parameter, die keine Ausdrücke verwenden. Weitere Informationen finden Sie unter [Bedingte Legacy-Parameter für DynamoDB](LegacyConditionalParameters.md).
Neue Anwendungen sollten Ausdrücke anstelle der Legacy-Parameter verwenden.
# Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB
Dieser Abschnitt beschreibt, wie Sie sich auf die Elementattribute in einem Ausdruck in Amazon DynamoDB beziehen können. Sie können mit jedem beliebigen Attribut arbeiten, auch wenn es tief innerhalb mehrerer Listen und Zuordnungen verschachtelt ist.
**Topics**
+ [Attribute der obersten Stufe](#Expressions.Attributes.TopLevelAttributes)
+ [Verschachtelte Attribute](#Expressions.Attributes.NestedAttributes)
+ [Dokumentpfade](#Expressions.Attributes.NestedElements.DocumentPathExamples)
**Ein Beispielelement: ProductCatalog**
Bei den Beispielen auf dieser Seite wurde folgendes Musterelement in der `ProductCatalog`-Tabelle verwendet. (Diese Tabelle wird in [Beispieltabellen und -daten zur Verwendung in DynamoDB](AppendixSampleTables.md) beschrieben.)
```
{
"Id": 123,
"Title": "Bicycle 123",
"Description": "123 description",
"BicycleType": "Hybrid",
"Brand": "Brand-Company C",
"Price": 500,
"Color": ["Red", "Black"],
"ProductCategory": "Bicycle",
"InStock": true,
"QuantityOnHand": null,
"RelatedItems": [
341,
472,
649
],
"Pictures": {
"FrontView": "http://example.com/products/123_front.jpg",
"RearView": "http://example.com/products/123_rear.jpg",
"SideView": "http://example.com/products/123_left_side.jpg"
},
"ProductReviews": {
"FiveStar": [
"Excellent! Can't recommend it highly enough! Buy it!",
"Do yourself a favor and buy this."
],
"OneStar": [
"Terrible product! Do not buy this."
]
},
"Comment": "This product sells out quickly during the summer",
"Safety.Warning": "Always wear a helmet"
}
```
Beachten Sie Folgendes:
+ Der Partitions-Schlüsselwert (`Id`) ist `123`. Es gibt keinen Sortierschlüssel.
+ Die meisten Attribute verfügen über skalare Datentypen, z. B. `String`, `Number`, `Boolean` und `Null`.
+ Ein Attribut (`Color`) ist ein `String Set`.
+ Die folgenden Attribute sind Dokumentdatentypen:
+ Eine Liste von `RelatedItems`. Jedes Element ist eine `Id` für ein zugehöriges Produkt.
+ Eine Zuordnung von `Pictures`. Jedes Element ist eine kurze Beschreibung eines Bildes, zusammen mit einem URL für die entsprechende Imagedatei.
+ Eine Zuordnung von `ProductReviews`. Jedes Element repräsentiert eine Bewertung und eine Liste von Rezensionen dieser Bewertung. Zunächst wird diese Zuordnung mit 5-Sterne- und 1-Stern-Rezensionen gefüllt.
## Attribute der obersten Stufe
Ein Attribut befindet sich auf *oberster Ebene*, wenn es nicht in einem anderen Attribut eingebettet ist. Für das `ProductCatalog`-Element lauten die Attribute auf oberster Ebene wie folgt:
+ `Id`
+ `Title`
+ `Description`
+ `BicycleType`
+ `Brand`
+ `Price`
+ `Color`
+ `ProductCategory`
+ `InStock`
+ `QuantityOnHand`
+ `RelatedItems`
+ `Pictures`
+ `ProductReviews`
+ `Comment`
+ `Safety.Warning`
Alle diese Attribute auf oberster Ebene sind Skalare, mit Ausnahme von `Color` (Liste), `RelatedItems` (Liste), `Pictures` (Zuordnung) und `ProductReviews` (Zuordnung).
## Verschachtelte Attribute
Ein Attribut gilt als *verschachtelt*, wenn es in einem anderen Attribut eingebettet ist. Um auf das verschachtelte Attribut zuzugreifen, verwenden Sie die *Dereferenzierungsoperatoren*:
+ `[n]` – für Listenelemente
+ `.` (Punkt) – für Zuordnungselemente
### Zugriff auf Listenelemente
Der Dereferenzierungsoperator für das Listenelement ist **[*N*]**, wobei *n* die Elementnummer ist. Listenelemente sind nullbasiert, sodass [0] das erste Element in der Liste darstellt, [1] das zweite und so weiter. Hier sind einige Beispiele:
+ `MyList[0]`
+ `AnotherList[12]`
+ `ThisList[5][11]`
Das Element `ThisList[5]` ist selbst eine verschachtelte Liste. Daher bezieht sich `ThisList[5][11]` auf das zwölfte Element in dieser Liste.
Die Zahl innerhalb der eckigen Klammern muss eine nicht negative ganze Zahl sein. Daher sind die folgenden Ausdrücke ungültig:
+ `MyList[-1]`
+ `MyList[0.4]`
### Zugriff auf Zuweisungselemente
Der Dereferenzierungsoperator für ein Zuordnungselement ist **.** (Punkt). Verwenden Sie einen Punkt als Trennzeichen zwischen den Elementen in einer Zuordnung:
+ `MyMap.nestedField`
+ `MyMap.nestedField.deeplyNestedField`
## Dokumentpfade
In einem Ausdruck verwenden Sie einen *Dokumentpfad*, um DynamoDB mitzuteilen, wo ein Attribut zu finden ist. Für eine Attribut auf oberster Ebene ist der Dokumentpfad einfach der Attributname. Sie erstellen den Dokumentpfad für ein verschachteltes Attribut mithilfe des Dereferenzoperators.
Es folgen einige Beispiele für Dokumentpfade. (Beziehen Sie sich auf das Element, das in [Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB](#Expressions.Attributes) gezeigt wird.)
+ Ein skalares Attribut auf oberster Ebene.
`Description`
+ Ein Listenattribut auf oberster Ebene. (Dies gibt die gesamte Liste zurück und nicht nur einige der Elemente.)
`RelatedItems`
+ Das dritte Element aus der `RelatedItems`-Liste. (Denken Sie daran, dass Listenelemente nullbasiert sind.)
`RelatedItems[2]`
+ Das Bild des Produkts in der Vorderansicht
`Pictures.FrontView`
+ Alle 5-Sterne-Rezensionen
`ProductReviews.FiveStar`
+ Die erste 5-Sterne-Rezension
`ProductReviews.FiveStar[0]`
**Anmerkung**
Die maximale Tiefe eines Dokumentpfads ist 32. Aus diesem Grund kann die Anzahl der Dereferenzoperatoren in einem Pfad diesen Grenzwert nicht überschreiten.
Sie können jeden Attributnamen in einem Dokumentpfad verwenden, sofern er die folgenden Anforderungen erfüllt:
+ Das erste Zeichen ist `a-z` oder `A-Z` und/oder `0-9`.
+ Das zweite Zeichen (falls vorhanden) ist `a-z`, `A-Z`.
**Anmerkung**
Wenn ein Attributname diesen Anforderungen nicht entspricht, müssen Sie einen Ausdrucksattributnamen als Platzhalter definieren.
Weitere Informationen finden Sie unter [Ausdrucksattributnamen (Aliasse) in DynamoDB](Expressions.ExpressionAttributeNames.md).
# Ausdrucksattributnamen (Aliasse) in DynamoDB
Ein *Ausdrucksattributname* ist ein Alias (oder Platzhalter), den Sie in einem Amazon-DynamoDB-Ausdruck als Alternative zu einem tatsächlichen Attributnamen verwenden. Ein Ausdrucksattributname muss mit einem Rautezeichen (`#`) beginnen, gefolgt von einem oder mehreren alphanumerischen Zeichen. Der Unterstrich (`_`) ist ebenfalls zulässig.
Dieser Abschnitt beschreibt einige Situationen, in denen Sie Ausdrucksattributnamen verwenden müssen.
**Anmerkung**
Die Beispiele in diesem Abschnitt verwenden das AWS Command Line Interface (AWS CLI).
**Topics**
+ [Reservierte Wörter](#Expressions.ExpressionAttributeNames.ReservedWords)
+ [Attributnamen mit Sonderzeichen](#Expressions.ExpressionAttributeNames.AttributeNamesContainingSpecialCharacters)
+ [Verschachtelte Attribute](#Expressions.ExpressionAttributeNames.NestedAttributes)
+ [Wiederholtes Verweisen auf Attributnamen](#Expressions.ExpressionAttributeNames.RepeatingAttributeNames)
## Reservierte Wörter
In einigen Fällen kann es erforderlich sein, einen Ausdruck mit einem Attributnamen zu erstellen, der mit einem für DynamoDB reservierten Wort in Konflikt steht. (Eine vollständige Liste der reservierten Wörter finden Sie unter [Reservierte Wörter in DynamoDB](ReservedWords.md).)
Das folgende Beispiel würde AWS CLI beispielsweise fehlschlagen, da es sich um ein reserviertes Wort `COMMENT` handelt.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Comment"
```
Um dieses Problem zu vermeiden, können Sie `Comment` durch einen Ausdrucksattributnamen wie `#c` ersetzen. Das Rautezeichen `#` ist erforderlich und gibt an, dass es sich um einen Platzhalter für einen Attributnamen handelt. Das AWS CLI Beispiel würde jetzt wie folgt aussehen.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#c" \
--expression-attribute-names '{"#c":"Comment"}'
```
**Anmerkung**
Wenn ein Attributname mit einer Zahl beginnt, ein Leerzeichen oder ein reserviertes Wort enthält, *müssen* Sie einen Ausdrucksattributnamen verwenden, um den Namen des Attributs im Ausdruck zu ersetzen.
## Attributnamen mit Sonderzeichen
In einem Ausdruck wird ein Punkt (".") als Trennzeichen in einem Dokumentpfad interpretiert. DynamoDB bietet allerdings die Möglichkeit, ein Punktzeichen und andere Sonderzeichen wie einen Bindestrich („-“) in einem Attributnamen zu verwenden. Dies kann in einigen Fällen zweideutig sein. Angenommen, Sie möchten das Attribut `Safety.Warning` aus einem `ProductCatalog`-Element abrufen (siehe [Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB](Expressions.Attributes.md)).
In diesem Beispiel gehen wir davon aus, dass Sie auf `Safety.Warning` mit einem Projektionsausdruck zugreifen möchten.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Safety.Warning"
```
DynamoDB gibt statt der erwarteten Zeichenfolge („`Always wear a helmet`“) ein leeres Ergebnis zurück. Der Grund dafür ist, dass DynamoDB einen Punkt in einem Ausdruck als Dokumentpfadtrennzeichen interpretiert. In diesem Fall müssen Sie einen Ausdrucksattributnamen (z. B. `#sw`) als Ersatz für `Safety.Warning` definieren. Anschließend können Sie den folgenden Projektionsausdruck verwenden.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#sw" \
--expression-attribute-names '{"#sw":"Safety.Warning"}'
```
DynamoDB gibt dann das richtige Ergebnis zurück.
**Anmerkung**
Wenn ein Attributname einen Punkt („.“) oder einen Bindestrich („-“) enthält, *müssen* Sie einen Ausdrucksattributnamen verwenden, um den Namen dieses Attributs im Ausdruck zu ersetzen.
## Verschachtelte Attribute
Angenommen, Sie möchten auf das verschachtelte Attribut `ProductReviews.OneStar` zugreifen. In einem Ausdrucksattributnamen behandelt DynamoDB den Punkt („.“) als Zeichen in einem Attributnamen. Um auf das verschachtelte Attribut zu verweisen, definieren Sie einen Ausdrucksattributnamen für jedes Element im Dokumentpfad:
+ `#pr — ProductReviews`
+ `#1star — OneStar`
Anschließend können Sie `#pr.#1star` für den folgenden Projektionsausdruck verwenden.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.#1star" \
--expression-attribute-names '{"#pr":"ProductReviews", "#1star":"OneStar"}'
```
DynamoDB gibt dann das richtige Ergebnis zurück.
## Wiederholtes Verweisen auf Attributnamen
Ausdrucksattributnamen sind hilfreich, wenn Sie sich wiederholt auf den gleichen Attributnamen beziehen müssen. Betrachten Sie z. B. den folgenden Ausdruck zum Abrufen einiger Rezensionen aus einem `ProductCatalog`-Element.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "ProductReviews.FiveStar, ProductReviews.ThreeStar, ProductReviews.OneStar"
```
Um den Ausdruck prägnanter zu gestalten, können Sie `ProductReviews` durch einen Ausdrucksattributnamen wie `#pr` ersetzen. Der geänderte Ausdruck sieht wie folgt aus:
+ `#pr.FiveStar, #pr.ThreeStar, #pr.OneStar`
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.FiveStar, #pr.ThreeStar, #pr.OneStar" \
--expression-attribute-names '{"#pr":"ProductReviews"}'
```
Wenn Sie einen Ausdrucksattributnamen definieren, müssen Sie ihn im gesamten Ausdruck einheitlich verwenden. Sie dürfen außerdem nicht das Symbol `#` weglassen.
# Verwenden von Ausdrucksattributwerten in DynamoDB
*Ausdrucksattributwerte* in Amazon DynamoDB agieren als Variablen. Sie ersetzen die tatsächlichen Werte, die Sie vergleichen möchten – Werte, die Sie möglicherweise bis zur Laufzeit nicht kennen. Ein Ausdrucksattributwert muss mit einem Doppelpunkt (`:`) beginnen, gefolgt von einem oder mehreren alphanumerischen Zeichen.
Angenommen, Sie möchten alle `ProductCatalog`-Elemente, die in `Black` verfügbar sind und `500` oder weniger kosten, zurückgeben. Sie können eine `Scan`-Operation mit einem Filterausdruck verwenden, wie in diesem AWS Command Line Interface (AWS CLI)-Beispiel gezeigt:
```
aws dynamodb scan \
--table-name ProductCatalog \
--filter-expression "contains(Color, :c) and Price <= :p" \
--expression-attribute-values file://values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":c": { "S": "Black" },
":p": { "N": "500" }
}
```
Wenn Sie einen Ausdrucksattributwert definieren, müssen Sie ihn während des gesamten Ausdrucks einheitlich verwenden. Sie dürfen außerdem das Symbol `:` nicht weglassen.
Ausdrucksattributwerte werden mit Schlüsselbedingungsausdrücken, Bedingungsausdrücken, Aktualisierungsausdrücken und Filterausdrücken verwendet.
# Verwenden von Projektionsausdrücken in DynamoDB
Um Daten aus einer Tabelle zu lesen, verwenden sie Operationen wie `GetItem`, `Query` oder `Scan`. Amazon DynamoDB gibt standardmäßig alle Elementattribute zurück. Verwenden Sie einen Projektionsausdruck, um nur einige und nicht alle Attribute abzurufen.
Ein *Projektionsausdruck* ist eine Zeichenfolge, mit der die gewünschten Attribute identifiziert werden. Zum Abrufen eines einzelnen Attributs geben Sie seinen Namen an. Für mehrere Attribute müssen die Namen durch Kommas getrennt werden.
Es folgen einige Beispiele für Projektionsausdrücke, basierend auf dem `ProductCatalog`-Element von [Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB](Expressions.Attributes.md):
+ Ein einzelnes Attribut auf oberster Ebene:
`Title `
+ Drei Attribute auf oberster Ebene. DynamoDB ruft die gesamte `Color`-Einstellung.
`Title, Price, Color`
+ Vier Attribute auf oberster Ebene. DynamoDB gibt den gesamten Inhalt von `RelatedItems` und `ProductReviews` zurück.
`Title, Description, RelatedItems, ProductReviews`
**Anmerkung**
Der Projektionsausdruck wirkt sich nicht auf den Verbrauch des bereitgestellten Durchsatzes aus. DynamoDB ermittelt die verbrauchten Kapazitätseinheiten basierend auf der Elementgröße, nicht anhand der Menge der Daten, die an eine Anwendung zurückgegeben werden.
**Reservierte Wörter und Sonderzeichen**
DynamoDB verfügt über reservierte Wörter und Sonderzeichen. DynamoDB lässt diese reservierten Wörter und Sonderzeichen für Namen zu. Dennoch empfehlen wir, diese nicht zu verwenden, da Sie Aliasse für diese Namen definieren müssen, sobald Sie sie in einem Ausdruck verwenden. Eine vollständige Liste finden Sie hier: [Reservierte Wörter in DynamoDB](ReservedWords.md).
In folgenden Fällen müssen Sie Ausdrucksattributnamen anstelle des eigentlichen Namens verwenden:
+ Der Attributname steht auf der Liste der reservierten Wörter von DynamoDB.
+ Der Attributname erfüllt nicht die Anforderung, dass das erste Zeichen `a-z` oder `A-Z` und das zweite Zeichen (falls vorhanden) `a-Z`, `A-Z` oder `0-9` sein muss.
+ Der Attributname enthält **\$1** (Raute) oder **:** (Doppelpunkt).
Das folgende AWS CLI Beispiel zeigt, wie ein Projektionsausdruck mit einer `GetItem` Operation verwendet wird. Dieser Projektionsausdruck ruft ein skalares Attribut auf oberster Ebene (`Description`), das erste Element in einer Liste (`RelatedItems[0]`) und eine Liste, die innerhalb einer Zuordnung verschachtelt ist (`ProductReviews.FiveStar`), ab.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '"Id": { "N": "123" } \
--projection-expression "Description, RelatedItems[0], ProductReviews.FiveStar"
```
In diesem Beispiel wird der folgende JSON zurückgegeben.
```
{
"Item": {
"Description": {
"S": "123 description"
},
"ProductReviews": {
"M": {
"FiveStar": {
"L": [
{
"S": "Excellent! Can't recommend it highly enough! Buy it!"
},
{
"S": "Do yourself a favor and buy this."
}
]
}
}
},
"RelatedItems": {
"L": [
{
"N": "341"
}
]
}
}
}
```
# 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
```
# Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB
Zum Bearbeiten der Daten in einer DynamoDB-Tabelle verwenden Sie die Operationen `PutItem`, `UpdateItem` und `DeleteItem`. Für diese Datenmanipulationsoperationen können Sie einen Bedingungsausdruck angeben, um zu ermitteln, welche Elemente geändert werden sollten. Wenn der Bedingungsausdruck „true“ ergibt, ist die Operation erfolgreich. Andernfalls schlägt sie fehl.
In diesem Abschnitt werden die integrierten Funktionen und Schlüsselwörter zum Schreiben von Filter- und Bedingungsausdrücken in Amazon DynamoDB erörtert. Ausführlichere Informationen zu Funktionen und Programmierung mit DynamoDB finden Sie unter [Programmieren mit DynamoDB und AWS SDKs](Programming.md) und in der [DynamoDB-API-Referenz](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/).
**Topics**
+ [Syntax für Filter- und Bedingungsausdrücke](#Expressions.OperatorsAndFunctions.Syntax)
+ [Durchführen von Vergleichen](#Expressions.OperatorsAndFunctions.Comparators)
+ [Funktionen](#Expressions.OperatorsAndFunctions.Functions)
+ [Logische Auswertungen](#Expressions.OperatorsAndFunctions.LogicalEvaluations)
+ [Klammern](#Expressions.OperatorsAndFunctions.Parentheses)
+ [Priorität in Bedingungen](#Expressions.OperatorsAndFunctions.Precedence)
## Syntax für Filter- und Bedingungsausdrücke
In der folgenden Syntaxzusammenfassung *operand* kann ein wie folgt lauten:
+ Ein Attributname auf oberster Ebene, z. B. `Id`, `Title`, `Description` oder `ProductCategory`
+ Ein Dokumentpfad, der auf ein verschachteltes Attribut verweist
```
condition-expression ::=
operand comparator operand
| operand BETWEEN operand AND operand
| operand IN ( operand (',' operand (, ...) ))
| function
| condition AND condition
| condition OR condition
| NOT condition
| ( condition )
comparator ::=
=
| <>
| <
| <=
| >
| >=
function ::=
attribute_exists (path)
| attribute_not_exists (path)
| attribute_type (path, type)
| begins_with (path, substr)
| contains (path, operand)
| size (path)
```
## Durchführen von Vergleichen
Verwenden Sie diese Komparatoren, um einen Operanden mit einem einzelnen Wert zu vergleichen:
+ `a = b`— Wahr, wenn gleich *a* ist*b*.
+ `a <> b`— Wahr, wenn ungleich *a* ist*b*.
+ `a < b`— Stimmt, wenn *a* es kleiner ist als*b*.
+ `a <= b`— Wahr, wenn kleiner oder gleich *a* ist*b*.
+ `a > b`— Stimmt, wenn größer als *a* ist*b*.
+ `a >= b`— Wahr, wenn größer als oder gleich *a* ist*b*.
Verwenden Sie die Schlüsselwörter `BETWEEN` und `IN`, um einen Operanden mit einer Reihe von Werten oder einer Aufzählung von Werten zu vergleichen:
+ `a BETWEEN b AND c`— Wahr*b*, wenn größer als oder gleich und kleiner als oder gleich *a* ist*c*.
+ `a IN (b, c, d) `— Wahr, wenn *a* der Wert einem beliebigen Wert in der Liste entspricht, z. B. einem beliebigen Wert von *b**c*, oder. *d* Die Liste kann bis zu 100 Werte enthalten, die durch Kommas getrennt sind.
## Funktionen
Verwenden Sie die folgenden Funktionen, um zu bestimmen, ob ein Attribut in einem Element vorhanden ist, oder um den Wert eines Attributs zu bewerten. Bei Funktionsnamen wird zwischen Groß- und Kleinschreibung unterschieden. Bei einem verschachtelten Attribut müssen Sie den vollständigen Dokumentpfad angeben.
****
| Funktion | Description |
| --- | --- |
| `attribute_exists (path)` | True, wenn das Element das von `path` angegebene Attribut enthält. Beispiel: Prüfung, ob ein Element in der Tabelle `Product` über ein Seitenansichtsbild verfügt. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
| `attribute_not_exists (path)` | True, wenn das Element das von `path` angegebene Attribut nicht enthält. Beispiel: Prüfung, ob ein Element über ein `Manufacturer`-Attribut verfügt [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
| `attribute_type (path, type)` | True, wenn das Attribut am angegebenen Pfad einen bestimmten Datentyp hat. Der Parameter `type` muss einer der folgenden Werte aufweisen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Sie müssen einen Ausdrucksattributwert für den Parameter `type` verwenden. Beispiel: Prüfung, ob das Attribut `QuantityOnHand` vom Typ Liste ist. In diesem Beispiel ist `:v_sub` ein Platzhalter für die Zeichenfolge `L`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Sie müssen einen Ausdrucksattributwert für den Parameter `type` verwenden. |
| `begins_with (path, substr)` | True, wenn das von `path` angegebene Attribut mit einer bestimmten Teilzeichenfolge beginnt. Beispiel: Prüfung, ob die ersten Zeichen der URL zum Vorderansichtsbild `http://` lauten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `http://`. |
| `contains (path, operand)` | True, wenn das von `path` angegebene Attribut Folgendes ist: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Wenn das von `path` angegebene Attribut eine `String` ist, muss der `operand` `String` sein. Wenn das von `path` angegebene Attribut `Set` ist muss `operand` der Elementtyp des Satzes sein. Der Pfad und der Operand müssen unterschiedlich sein. Das heißt, bei `contains (a, a)` wird ein Fehler zurückgegeben. Beispiel: Prüfung, ob das Attribut `Brand` die Teilzeichenfolge `Company` enthält. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `Company`. Beispiel: Prüfung, ob das Produkt in rot verfügbar ist. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `Red`. |
| `size (path)` | Gibt eine Zahl zurück, die für die Größe eines Attributs steht. Die folgenden sind gültige Datentypen, die mit `size` verwendet werden können. Wenn das Attribut vom Typ `String` ist, gibt `size` die Länge der Zeichenfolge zurück. Beispiel: Prüfung, ob die Zeichenfolge `Brand` kleiner oder gleich 20 Zeichen ist. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `20`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Wenn das Attribut vom Typ `Binary` ist, gibt `size` die Anzahl der Bytes im Attributwert zurück. Beispiel: Angenommen, das Element `ProductCatalog` verfügt über ein binäres Attribut mit der Bezeichnung `VideoClip`, das ein kurzes Video über das betreffende Produkt enthält. Der folgende Ausdruck überprüft, ob `VideoClip` 64.000 Byte überschreitet. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `64000`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Wenn das Attribut vom Typ `Set` ist, gibt `size` die Anzahl der Elemente im Satz zurück. Beispiel: Prüfung, ob das Produkt in mehr als einer Farbe verfügbar ist. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `1`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Wenn das Attribut vom Typ `List` oder `Map` ist, gibt `size` die Anzahl der untergeordneten Elemente zurück. Beispiel: Prüfung, ob die Anzahl der `OneStar`-Rezensionen einen bestimmten Grenzwert überschritten hat. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `3`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
## Logische Auswertungen
Verwenden Sie die Schlüsselwörter `AND`, `OR` und `NOT`, um logische Auswertungen durchzuführen. In der folgenden Liste *a* und *b* stellen Bedingungen dar, die ausgewertet werden sollen.
+ `a AND b`— Stimmt, wenn *a* und beide wahr *b* sind.
+ `a OR b`— Stimmt, wenn entweder *a* oder *b* (oder beide) wahr sind.
+ `NOT a`— Wahr, wenn falsch *a* ist. Falsch, wenn *a* es wahr ist.
Im Folgenden finden Sie ein Codebeispiel für AND in einer Operation.
`dynamodb-local (*)> select * from exprtest where a > 3 and a < 5;`
## Klammern
Verwenden Sie Klammern, um die Priorität einer logischen Auswertung zu ändern. Nehmen wir zum Beispiel an, dass die Bedingungen *a* und wahr *b* sind und diese Bedingung falsch *c* ist. Der folgenden Ausdruck ergibt True:
+ `a OR b AND c`
Wenn Sie jedoch eine Bedingung in Klammern setzen, wird diese zuerst ausgewertet. Folgendes ergibt z. B. False:
+ `(a OR b) AND c`
**Anmerkung**
Sie können Klammern in einem Ausdruck schachteln. Die innersten Klammern werden zuerst ausgewertet.
Im Folgenden finden Sie ein Codebeispiel mit Klammern in einer logischen Auswertung.
`dynamodb-local (*)> select * from exprtest where attribute_type(b, string) or ( a = 5 and c = “coffee”);`
## Priorität in Bedingungen
DynamoDB wertet Bedingungen von links nach rechts entsprechend der folgenden Prioritätsregeln aus:
+ `= <> < <= > >=`
+ `IN`
+ `BETWEEN`
+ `attribute_exists attribute_not_exists begins_with contains`
+ Klammern
+ `NOT`
+ `AND`
+ `OR`
# CLI-Beispiel für DynamoDB-Bedingungsausdrücke
Im Folgenden finden Sie einige AWS Command Line Interface (AWS CLI) Beispiele für die Verwendung von Bedingungsausdrücken. Diese Beispiele basieren auf der Tabelle `ProductCatalog`, die in [Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB](Expressions.Attributes.md) eingeführt wurde. Der Partitionsschlüssel für diese Tabelle lautet `Id`. Es gibt keinen Sortierschlüssel. Die folgende `PutItem`-Operation erstellt ein `ProductCatalog`-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": "456" },
"ProductCategory": {"S": "Sporting Goods" },
"Price": {"N": "650" }
}
```
**Topics**
+ [Conditional Put (Bedingtes Setzen)](#Expressions.ConditionExpressions.PreventingOverwrites)
+ [Bedingte Löschungen](#Expressions.ConditionExpressions.AdvancedComparisons)
+ [Bedingte Aktualisierungen](#Expressions.ConditionExpressions.SimpleComparisons)
+ [Beispiele für bedingte Ausdrücke](#Expressions.ConditionExpressions.ConditionalExamples)
## Conditional Put (Bedingtes Setzen)
Die `PutItem`-Operation überschreibt ein Element mit demselben Primärschlüssel (falls vorhanden). Wenn Sie dies vermeiden möchten, verwenden Sie einen Bedingungsausdruck. Dies ermöglicht das Fortsetzen des Schreibvorgangs nur dann, wenn das in Frage stehende Element nicht bereits über denselben Primärschlüssel verfügt.
Im folgenden Beispiel wird mit `attribute_not_exists()` überprüft, ob der Primärschlüssel in der Tabelle vorhanden ist, bevor versucht wird, den Schreibvorgang durchzuführen.
**Anmerkung**
Wenn Ihr Primärschlüssel sowohl aus einem Partitionsschlüssel (pk) als auch aus einem Sortierschlüssel (sk) besteht, überprüft der Parameter, ob `attribute_not_exists(pk)` UND `attribute_not_exists(sk)` als gesamte Anweisung als wahr oder falsch ausgewertet werden, bevor versucht wird, den Schreibvorgang durchzuführen.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json \
--condition-expression "attribute_not_exists(Id)"
```
Wenn der Bedingungsausdruck mit „falsch“ ausgewertet wird, gibt DynamoDB die folgende Fehlermeldung zurück: Die bedingte Anforderung ist fehlgeschlagen.
**Anmerkung**
Weitere Informationen zu `attribute_not_exists` und anderen Funktionen finden Sie unter [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md).
## Bedingte Löschungen
Um ein bedingtes Löschen durchzuführen, nutzen Sie eine `DeleteItem`-Operation mit einem Bedingungsausdruck. Der Bedingungsausdruck muss mit "true" ausgewertet werden, damit die Operation erfolgreich ist; andernfalls schlägt sie fehl.
Betrachten Sie das oben definierte Element.
Angenommen, Sie möchten das Element löschen, aber nur unter den folgenden Bedingungen:
+ Die `ProductCategory` ist entweder "Sportartikel" oder "Gartenzubehör".
+ Der `Price` liegt zwischen 500 und 600.
Im folgenden Beispiel wird versucht, das Element zu löschen:
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"456"}}' \
--condition-expression "(ProductCategory IN (:cat1, :cat2)) and (Price between :lo and :hi)" \
--expression-attribute-values file://values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":cat1": {"S": "Sporting Goods"},
":cat2": {"S": "Gardening Supplies"},
":lo": {"N": "500"},
":hi": {"N": "600"}
}
```
**Anmerkung**
In dem Bedingungsausdruck weist der `:` (Doppelpunkt) auf einen *Ausdrucksattributwert* hin – Platzhalter für den tatsächlichen Wert. Weitere Informationen finden Sie unter [Verwenden von Ausdrucksattributwerten in DynamoDB](Expressions.ExpressionAttributeValues.md).
Weitere Informationen zu `IN`, `AND` und anderen Schlüsselwörtern finden Sie unter [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md).
In diesem Beispiel wird der `ProductCategory`-Vergleich mit True, aber der `Price`-Vergleich mit False ausgewertet. Dadurch wird der Bedingungsausdruck mit "false" ausgewertet und die `DeleteItem`-Operation schlägt fehl.
## Bedingte Aktualisierungen
Um eine bedingte Aktualisierung durchzuführen, nutzen Sie eine `UpdateItem`-Operation mit einem Bedingungsausdruck. Der Bedingungsausdruck muss mit "true" ausgewertet werden, damit die Operation erfolgreich ist; andernfalls schlägt sie fehl.
**Anmerkung**
`UpdateItem` unterstützt auch *Aktualisierungsausdrücke*, in denen Sie die gewünschten Änderungen festlegen, die Sie an einem Element durchführen möchten. Weitere Informationen finden Sie unter [Verwenden von Aktualisierungsausdrücken in DynamoDB](Expressions.UpdateExpressions.md).
Angenommen, Sie beginnen mit dem oben definierten Element.
Das folgende Beispiel führt eine `UpdateItem`-Operation durch. Es versucht, den `Price` eines Produkts um 75 zu reduzieren – der Bedingungsausdruck verhindert jedoch die Aktualisierung, wenn der aktuelle `Price` unter 500 liegt.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--update-expression "SET Price = Price - :discount" \
--condition-expression "Price > :limit" \
--expression-attribute-values file://values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":discount": { "N": "75"},
":limit": {"N": "500"}
}
```
Wenn der Start-`Price` 650 ist, reduziert die `UpdateItem`-Operation den `Price` auf 575. Wenn Sie die `UpdateItem`-Operation erneut ausführen, wird der `Price` auf 500 reduziert. Wenn Sie ein drittes Mal ausführen, wird der Bedingungsausdruck mit False ausgewertet und die Aktualisierung schlägt fehl.
**Anmerkung**
In dem Bedingungsausdruck weist der `:` (Doppelpunkt) auf einen *Ausdrucksattributwert* hin – Platzhalter für den tatsächlichen Wert. Weitere Informationen finden Sie unter [Verwenden von Ausdrucksattributwerten in DynamoDB](Expressions.ExpressionAttributeValues.md).
Weitere Informationen zu "*>*" und anderen Operatoren finden Sie unter [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md).
## Beispiele für bedingte Ausdrücke
Weitere Hinweise zu den Funktionen, die in den folgenden Beispielen verwendet werden, finden Sie unter [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md). Weitere Informationen zum Angeben verschiedener Attributtypen in einem Ausdruck finden Sie unter [Verweisen auf Elementattribute beim Verwenden von Ausdrücken in DynamoDB](Expressions.Attributes.md).
### Überprüfen der Attribute in einem Element
Sie können das Vorhandensein (oder Fehlen) jedes Attributs überprüfen. Wenn der Bedingungsausdruck mit "true" ausgewertet wird, ist die Operation erfolgreich; andernfalls schlägt sie fehl.
Das folgenden Beispiel verwendet `attribute_not_exists` zum Löschen eines Produkts nur, wenn es noch nicht über ein `Price`-Attribut verfügt:
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_not_exists(Price)"
```
DynamoDB stellt auch eine `attribute_exists`-Funktion bereit. Das folgende Beispiel löscht ein Produkt nur dann, wenn es schlechte Bewertungen erhalten hat.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_exists(ProductReviews.OneStar)"
```
### Prüfung auf Attributtyp
Mit der `attribute_type`-Funktion können Sie den Datentyp eines Attributwerts überprüfen. Wenn der Bedingungsausdruck mit "true" ausgewertet wird, ist die Operation erfolgreich; andernfalls schlägt sie fehl.
Im folgenden Beispiel wird `attribute_type` nur dann zum Löschen eines Produkts verwendet, wenn es über ein `Color`-Attribut des Typs String Set verfügt.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_type(Color, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json
```
Die Argumente für `--expression-attribute-values` sind in der expression-attribute-values JSON-Datei gespeichert.
```
{
":v_sub":{"S":"SS"}
}
```
### Prüfen des Startwerts der Zeichenfolge
Sie können überprüfen, ob ein Zeichenfolge-Attributwert mit einer bestimmten Teilzeichenfolge beginnt, indem Sie die `begins_with`-Funktion verwenden. Wenn der Bedingungsausdruck mit "true" ausgewertet wird, ist die Operation erfolgreich; andernfalls schlägt sie fehl.
Im folgenden Beispiel wird `begins_with` nur dann zum Löschen eines Produkts verwendet, wenn das `FrontView`-Element der `Pictures`-Karte mit einem bestimmten Wert beginnt.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "begins_with(Pictures.FrontView, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json
```
Die Argumente für `--expression-attribute-values` werden in der expression-attribute-values JSON-Datei gespeichert.
```
{
":v_sub":{"S":"http://"}
}
```
### Prüfen auf ein Element in einem Satz
Sie können nach einem Element in einem Satz oder nach einer Teilzeichenfolge innerhalb einer Zeichenfolge suchen, indem Sie die `contains`-Funktion verwenden. Wenn der Bedingungsausdruck mit "true" ausgewertet wird, ist die Operation erfolgreich; andernfalls schlägt sie fehl.
Im folgenden Beispiel wird `contains` nur dann zum Löschen eines Produkts verwendet, wenn der `Color`-Zeichenfolgensatz ein Element mit einem bestimmten Wert aufweist.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "contains(Color, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json
```
Die Argumente für `--expression-attribute-values` werden in der expression-attribute-values JSON-Datei gespeichert.
```
{
":v_sub":{"S":"Red"}
}
```
### Überprüfen der Größe eines Attributwerts
Sie können die Größe eines Attributwerts überprüfen, indem Sie die `size`-Funktion verwenden. Wenn der Bedingungsausdruck mit "true" ausgewertet wird, ist die Operation erfolgreich; andernfalls schlägt sie fehl.
Im folgenden Beispiel wird `size` nur dann zum Löschen eines Produkts verwendet, wenn die Größe des `VideoClip`-Binärattributs größer als `64000` Byte ist.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "size(VideoClip) > :v_sub" \
--expression-attribute-values file://expression-attribute-values.json
```
Die Argumente für `--expression-attribute-values` werden in der expression-attribute-values JSON-Datei gespeichert.
```
{
":v_sub":{"N":"64000"}
}
```