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.
# Arbeiten mit Elementen und Attributen in DynamoDB
In Amazon DynamoDB ist ein *Element* eine Sammlung von Attributen. Jedes Attribut verfügt über einen Namen und einen Wert. Ein Attributwert kann eine Skalarfunktion, eine Gruppe oder ein Dokumenttyp sein. Weitere Informationen finden Sie unter [Amazon DynamoDB: Funktionsweise](HowItWorks.md).
DynamoDB bietet vier Operationen für grundlegende CRUD-Funktionalität (erstellen/lesen/aktualisieren/löschen). Alle diese Operationen sind atomar.
+ `PutItem` – ein Element erstellen.
+ `GetItem` – ein Element lesen.
+ `UpdateItem` – ein Element aktualisieren.
+ `DeleteItem` – ein Element löschen.
Jede dieser Operationen erfordert, dass Sie den Primärschlüssel des Elements angeben, mit dem Sie arbeiten möchten. Um z. B. ein Element mit `GetItem` zu lesen, müssen Sie den Partitions- und den Sortierschlüssel (sofern zutreffend) für das Element angeben.
Zusätzlich zu den vier grundlegenden CRUD-Operationen bietet DynamoDB außerdem Folgendes:
+ `BatchGetItem` – Liest bis zu 100 Elemente aus einer oder mehreren Tabellen.
+ `BatchWriteItem` – erstellt oder löscht bis zu 25 Elemente in einer oder mehreren Tabellen.
Diese Stapeloperationen kombinieren mehrere CRUD-Operationen in einer einzigen Anforderung. Darüber hinaus können die Stapeloperationen Elemente parallel lesen und schreiben, um Antwortlatenzen zu minimieren.
In diesem Abschnitt wird beschrieben, wie Sie diese Operationen verwenden. Außerdem wird auf verwandte Themen, wie z. B. bedingte Updates und unteilbare Zähler, eingegangen. Dieser Abschnitt enthält auch Beispielcode, der die verwendet AWS SDKs.
**Topics**
+ [Elementgrößen und -formate in DynamoDB](CapacityUnitCalculations.md)
+ [Lesen eines Elements](#WorkingWithItems.ReadingData)
+ [Schreiben eines Elements](#WorkingWithItems.WritingData)
+ [Rückgabewerte](#WorkingWithItems.ReturnValues)
+ [Batch-Vorgänge](#WorkingWithItems.BatchOperations)
+ [Unteilbare Zähler](#WorkingWithItems.AtomicCounters)
+ [Bedingte Schreibvorgänge](#WorkingWithItems.ConditionalUpdate)
+ [Verwenden von Ausdrücken in DynamoDB](Expressions.md)
+ [Verwenden von Time to Live (TTL) in DynamoDB](TTL.md)
+ [Abfragen von Tabellen in DynamoDB](Query.md)
+ [Scannen von Tabellen in DynamoDB](Scan.md)
+ [PartiQL – Eine SQL-kompatible Abfragesprache für Amazon DynamoDB](ql-reference.md)
+ [Arbeiten mit Elementen: Java](JavaDocumentAPIItemCRUD.md)
+ [Arbeiten mit Elementen: .NET](LowLevelDotNetItemCRUD.md)
# Elementgrößen und -formate in DynamoDB
DynamoDB-Tabellen sind schemalos, mit Ausnahme des Primärschlüssels, sodass alle Elemente in einer Tabelle verschiedene Attribute, Größen und Datentypen haben können.
Die Gesamtgröße eines Elements ist die Summe der Längenwerte seiner Attributnamen und Werte, zuzüglich eventuell zutreffender Overhead, wie nachfolgend beschrieben. Sie können die folgenden Richtlinien zum Schätzen von Attributgrößen verwenden:
+ Die Zeichenfolgen sind Unicode mit binärer UTF-8-Kodierung. Die Größe einer Zeichenkette ist *(Anzahl der UTF-8-kodierten Byte des Attributnamens) \$1 (Anzahl der UTF-8-kodierten Byte)*.
+ Zahlen sind variable Länge mit bis zu 38 signifikanten Ziffern. Nullen am Anfang und am Ende werden abgeschnitten. Die Größe einer Zahl ist ca. *(Anzahl der UTF-8-kodierten Byte des Attributnamens) \$1 (1 Byte pro zwei signifikanten Ziffern) \$1 (1 Byte)*.
+ Ein binärer Wert muss im Base64-Format kodiert werden, bevor er an DynamoDB gesendet werden kann, aber die reine Bytelänge des Werts wird für die Größenberechnung verwendet. Die Größe eines binären Attributs ist *(Anzahl der UTF-8-kodierten Byte des Attributnamens) \$1 (Anzahl der reinen Byte).*
+ Die Größe eines Null-Attributs oder eines Booleschen Attributs ist *(Anzahl der UTF-8-kodierten Byte des Attributnamens) \$1 (1 Byte)*.
+ Ein Attribut vom Typ `List` oder `Map` erfordert 3 Byte Overhead, unabhängig von dessen Inhalten. Die Größe einer `List` oder `Map` ist *(Anzahl der UTF-8-kodierten Byte des Attributnamens) \$1 Summe (Größe der verschachtelten Elemente) \$1 (3 Byte)*. Die Größe einer leeren `List` oder `Map` ist *(Anzahl der UTF-8-kodierten Byte des Attributnamens) \$1 (3 Byte)*.
+ Jedes `List`- oder `Map`-Element benötigt außerdem einen Overhead von 1 Byte.
**Anmerkung**
Wir empfehlen, dass Sie eher kürzere Attributnamen als längere wählen. Dies hilft Ihnen, den benötigten Speicherplatz zu reduzieren, kann aber auch den RCU/WCUs Speicherverbrauch verringern.
Für Speicher-Abrechnungszwecke enthält jedes Element einen Speicherzuschlag pro Element, der von den Funktionen abhängt, die Sie aktiviert haben.
+ Alle Elemente in DynamoDB benötigen 100 Byte Speicheraufwand für die Indizierung.
+ Einige DynamoDB-Funktionen (globale Tabellen, Transaktionen, Änderungsdatenerfassung für Kinesis Data Streams mit DynamoDB) erfordern zusätzlichen Speicheraufwand, um vom System erstellte Attribute zu berücksichtigen, die sich aus der Aktivierung dieser Funktionen ergeben. Globale Tabellen erfordern beispielsweise zusätzliche 48 Byte Speicheraufwand.
## Lesen eines Elements
Verwenden Sie zum Lesen eines Elements von einer DynamoDB-Tabelle die Operation `GetItem`. Sie müssen den Namen der Tabelle sowie den Primärschlüssel des gewünschten Elements angeben.
**Example**
Das folgende AWS CLI Beispiel zeigt, wie ein Element aus der `ProductCatalog` Tabelle gelesen wird.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}'
```
**Anmerkung**
Mit `GetItem` müssen Sie den Primärschlüssel *vollständig* und nicht nur teilweise angeben. Wenn eine Tabelle über einen zusammengesetzten Primärschlüssel (Partitions- und Sortierschlüssel) verfügt, müssen Sie einen Wert für den Partitionsschlüssel und einen Wert für den Sortierschlüssel angeben.
Eine `GetItem`-Anforderung führt standardmäßig einen Eventually Consistent-Lesevorgang durch. Sie können den Parameter `ConsistentRead` verwenden, um stattdessen einen Strongly Consistent-Lesevorgang anzufordern. (Dadurch werden zusätzliche Lesekapazitätseinheiten verbraucht, es wird jedoch die meiste up-to-date Version des Elements zurückgegeben.)
`GetItem` gibt alle Attribute des Elements zurück. Sie können einen *Projektionsausdruck* verwenden, um nur einige der Attribute zurückzugeben. Weitere Informationen finden Sie unter [Verwenden von Projektionsausdrücken in DynamoDB](Expressions.ProjectionExpressions.md).
Um die Anzahl der von `GetItem` verbrauchten Lesekapazitätseinheiten zurückzugeben, legen Sie den Parameter `ReturnConsumedCapacity` auf `TOTAL` fest.
**Example**
Das folgende Beispiel AWS Command Line Interface (AWS CLI) zeigt einige der optionalen `GetItem` Parameter.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--consistent-read \
--projection-expression "Description, Price, RelatedItems" \
--return-consumed-capacity TOTAL
```
## Schreiben eines Elements
Zum Erstellen, Aktualisieren oder Löschen eines Elements in einer DynamoDB-Tabelle verwenden Sie eine der folgenden Operationen:
+ `PutItem`
+ `UpdateItem`
+ `DeleteItem`
Für diese Operationen müssen Sie jeweils den Primärschlüssel vollständig und nicht nur teilweise angeben. Wenn eine Tabelle über einen zusammengesetzten Primärschlüssel (Partitions- und Sortierschlüssel) verfügt, müssen Sie einen Wert für den Partitionsschlüssel und einen Wert für den Sortierschlüssel angeben.
Um die Anzahl der von einer dieser Operationen verbrauchten Schreibkapazitätseinheiten zurückzugeben, legen Sie den Parameter `ReturnConsumedCapacity` auf einen der folgenden Werte fest:
+ `TOTAL` – Gibt die Gesamtanzahl der verbrauchten Schreibkapazitätseinheiten zurück.
+ `INDEXES` – Gibt die Gesamtzahl der verbrauchten Schreibkapazitätseinheiten mit Zwischensummen für die Tabelle und alle sekundären Indizes zurück, die vom Vorgang betroffen waren.
+ `NONE` – Es werden keine Schreibkapazitätsdetails zurückgegeben. (Dies ist die Standardeinstellung.)
### PutItem
`PutItem` erstellt ein neues Element. Wenn ein Element mit demselben Schlüssel bereits in der Tabelle vorhanden ist, wird es durch das neue Element ersetzt.
**Example**
Schreiben Sie ein neues Element in die `Thread`-Tabelle. Der Primärschlüssel für die `Thread`-Tabelle besteht aus `ForumName` (Partitionsschlüssel) und `Subject` (Sortierschlüssel).
```
aws dynamodb put-item \
--table-name Thread \
--item file://item.json
```
Die Argumente für `--item` werden in der Datei `item.json` gespeichert.
```
{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"},
"Message": {"S": "First post in this thread"},
"LastPostedBy": {"S": "fred@example.com"},
"LastPostDateTime": {"S": "201603190422"}
}
```
### UpdateItem
Wenn kein Element mit dem angegebenen Schlüssel vorhanden ist, erstellt `UpdateItem` ein neues Element. Andernfalls werden die Attribute eines vorhandenen Elements geändert.
Sie verwenden einen *Aktualisierungsausdruck*, um die zu ändernden Attribute und deren neue Werte anzugeben. Weitere Informationen finden Sie unter [Verwenden von Aktualisierungsausdrücken in DynamoDB](Expressions.UpdateExpressions.md).
Innerhalb des Aktualisierungsausdrucks verwenden Sie die Ausdrucksattributwerte als Platzhalter für die tatsächlichen Werte. Weitere Informationen finden Sie unter [Verwenden von Ausdrucksattributwerten in DynamoDB](Expressions.ExpressionAttributeValues.md).
**Example**
Ändern Sie verschiedene Attribute im Element `Thread`. Der optionale Parameter `ReturnValues` zeigt das Element so an, wie es nach der Aktualisierung dargestellt wird. Weitere Informationen finden Sie unter [Rückgabewerte](#WorkingWithItems.ReturnValues).
```
aws dynamodb update-item \
--table-name Thread \
--key file://key.json \
--update-expression "SET Answered = :zero, Replies = :zero, LastPostedBy = :lastpostedby" \
--expression-attribute-values file://expression-attribute-values.json \
--return-values ALL_NEW
```
Die Argumente für `--key` werden in der Datei `key.json` gespeichert.
```
{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"}
}
```
Die Argumente für `--expression-attribute-values` werden in der Datei `expression-attribute-values.json` gespeichert.
```
{
":zero": {"N":"0"},
":lastpostedby": {"S":"barney@example.com"}
}
```
### DeleteItem
`DeleteItem` löscht das Element mit dem angegebenen Schlüssel.
**Example**
Das folgende AWS CLI Beispiel zeigt, wie das `Thread` Element gelöscht wird.
```
aws dynamodb delete-item \
--table-name Thread \
--key file://key.json
```
## Rückgabewerte
In einigen Fällen soll DynamoDB bestimmte Attributwerte so zurückgeben, wie sie vor oder nach der Änderung erschienen. Die Operationen `PutItem`, `UpdateItem` und `DeleteItem` verfügen über einen Parameter `ReturnValues`, mit dem Sie Attributwerte zurückgeben können, bevor oder nachdem diese geändert wurden.
Der Standardwert für `ReturnValues` ist `NONE`. Dies bedeutet, dass DynamoDB keine Informationen über Attribute zurückgibt, die geändert wurden.
Nachfolgend sind die anderen gültigen Einstellungen für `ReturnValues` nach DynamoDB-API-Operation sortiert aufgeführt.
### PutItem
+ `ReturnValues`: `ALL_OLD`
+ Wenn Sie ein vorhandenes Element überschreiben, gibt `ALL_OLD` das gesamte Element so zurück, wie es vor dem Überschreiben dargestellt wurde.
+ Wenn Sie ein nicht vorhandenes Element schreiben, hat `ALL_OLD` keine Auswirkung.
### UpdateItem
Die häufigste Nutzung für `UpdateItem` ist das Aktualisieren eines vorhandenen Elements. `UpdateItem` führt eigentlich eine *upsert*-Operation aus. Dies bedeutet, dass das Element automatisch erstellt wird, wenn es noch nicht vorhanden ist.
+ `ReturnValues`: `ALL_OLD`
+ Wenn Sie ein vorhandenes Element aktualisieren, gibt `ALL_OLD` das gesamte Element so zurück, wie es vor dem Aktualisieren dargestellt wurde.
+ Wenn Sie ein nicht vorhandenes Element aktualisieren (Upsert-Operation), hat `ALL_OLD` keine Auswirkung.
+ `ReturnValues`: `ALL_NEW`
+ Wenn Sie ein vorhandenes Element aktualisieren, gibt `ALL_NEW` das gesamte Element so zurück, wie es nach dem Aktualisieren dargestellt wird.
+ Wenn Sie ein nicht vorhandenes Element aktualisieren (Upsert-Operation), gibt `ALL_NEW` das gesamte Element zurück.
+ `ReturnValues`: `UPDATED_OLD`
+ Wenn Sie ein vorhandenes Element aktualisieren, gibt `UPDATED_OLD` nur die aktualisierten Attribute so zurück, wie sie vor dem Aktualisieren dargestellt wurden.
+ Wenn Sie ein nicht vorhandenes Element aktualisieren (Upsert-Operation), hat `UPDATED_OLD` keine Auswirkung.
+ `ReturnValues`: `UPDATED_NEW`
+ Wenn Sie ein vorhandenes Element aktualisieren, gibt `UPDATED_NEW` nur die betroffenen Attribute so zurück, wie sie nach dem Aktualisieren dargestellt werden.
+ Wenn Sie ein nicht vorhandenes Element aktualisieren (Upsert-Operation), gibt `UPDATED_NEW` nur die aktualisierten Attribute so zurück, wie sie nach dem Aktualisieren dargestellt werden.
### DeleteItem
+ `ReturnValues`: `ALL_OLD`
+ Wenn Sie ein vorhandenes Element löschen, gibt `ALL_OLD` das gesamte Element so zurück, wie es vor dem Löschen dargestellt wurde.
+ Wenn Sie ein nicht vorhandenes Element löschen, gibt `ALL_OLD` keine Daten zurück.
## Batch-Vorgänge
Für Anwendungen, die mehrere Elemente lesen oder schreiben müssen, stellt DynamoDB die Operationen `BatchGetItem` und `BatchWriteItem` bereit. Mithilfe dieser Operationen können Sie die Anzahl der Netzläufe von Ihrer Anwendung für DynamoDB reduzieren. Außerdem führt DynamoDB die einzelnen Lese- oder Schreibvorgänge parallel aus. Ihre Anwendungen profitieren von dieser Parallelität, ohne Gleichzeitigkeit oder Threads verwalten zu müssen.
Die Stapeloperationen sind im Wesentlichen Wrapper für mehrere Lese- oder Schreibanforderungen. Wenn eine `BatchGetItem`-Anforderung z. B. fünf Elemente enthält, führt DynamoDB fünf `GetItem`-Operationen in Ihrem Namen aus. Wenn eine `BatchWriteItem`-Anforderung zwei PUT-Anforderungen und vier DELETE-Anforderungen enthält, führt DynamoDB zwei `PutItem`- und vier `DeleteItem`-Anforderungen aus.
Im Allgemeinen treten bei einer Stapeloperation nur Fehler auf, wenn *alle* im Stapel enthaltenen Anforderungen fehlschlagen. Angenommen, Sie führen eine `BatchGetItem`-Operation aus, doch bei einer der `GetItem`-Einzelanforderungen des Stapels tritt ein Fehler auf. In diesem Fall gibt `BatchGetItem` die Schlüssel und Daten der fehlgeschlagenen `GetItem`-Anforderung zurück. Die anderen `GetItem`-Anforderungen des Stapels sind davon nicht betroffen.
### BatchGetItem
Eine einzelne `BatchGetItem`-Operation kann bis zu 10 individuelle `GetItem`-Anforderungen enthalten und bis zu 16 MB Daten abrufen. Darüber hinaus kann eine `BatchGetItem`-Operation Elemente aus mehreren Tabellen abrufen.
**Example**
Rufen Sie zwei Elemente aus der `Thread`-Tabelle mit einem Projektionsausdruck ab, um nur einige der Attribute zurückzugeben.
```
aws dynamodb batch-get-item \
--request-items file://request-items.json
```
Die Argumente für `--request-items` werden in der Datei `request-items.json` gespeichert.
```
{
"Thread": {
"Keys": [
{
"ForumName":{"S": "Amazon DynamoDB"},
"Subject":{"S": "DynamoDB Thread 1"}
},
{
"ForumName":{"S": "Amazon S3"},
"Subject":{"S": "S3 Thread 1"}
}
],
"ProjectionExpression":"ForumName, Subject, LastPostedDateTime, Replies"
}
}
```
### BatchWriteItem
Die `BatchWriteItem`-Operation kann bis zu 25 individuelle `PutItem` und `DeleteItem`-Anforderungen enthalten und bis zu 16 MB Daten schreiben. (Die maximale Größe eines einzelnen Elements beträgt 400 KB.) Darüber hinaus kann eine `BatchWriteItem`-Operation Elemente in mehreren Tabellen einfügen oder daraus löschen.
**Anmerkung**
`BatchWriteItem` unterstützt keine `UpdateItem`-Anforderungen.
**Example**
Fügen Sie der `ProductCatalog`-Tabelle zwei Elemente hinzu.
```
aws dynamodb batch-write-item \
--request-items file://request-items.json
```
Die Argumente für `--request-items` werden in der Datei `request-items.json` gespeichert.
```
{
"ProductCatalog": [
{
"PutRequest": {
"Item": {
"Id": { "N": "601" },
"Description": { "S": "Snowboard" },
"QuantityOnHand": { "N": "5" },
"Price": { "N": "100" }
}
}
},
{
"PutRequest": {
"Item": {
"Id": { "N": "602" },
"Description": { "S": "Snow shovel" }
}
}
}
]
}
```
## Unteilbare Zähler
Mit der `UpdateItem`-Operation können Sie einen *unteilbaren Zähler* implementieren. Hierbei handelt es sich um ein numerisches Attribut, das erhöht wird, und zwar ohne Bedingung und ohne Konflikte mit anderen Schreibanforderungen. (Alle Schreibanforderungen werden in der Reihenfolge angewendet, in der sie empfangen wurden.) Mit einem unteilbaren Zähler sind die Updates nicht idempotent. Mit anderen Worten, der numerische Wert wird bei jedem Aufruf von `UpdateItem` erhöht oder verringert. Wenn der zur Aktualisierung des unteilbaren Zählers verwendete Inkrementwert positiv ist, kann dies zu einer Überzählung führen. Wenn der Inkrementwert negativ ist, kann dies zu einer Unterzählung führen.
Sie können einen unteilbaren Zähler verwenden, um die Anzahl der Besucher einer Website zu verfolgen. In diesem Fall erhöht Ihre Anwendung einen numerischen Wert, unabhängig vom aktuellen Wert. Wenn bei einer `UpdateItem`-Operation ein Fehler auftritt, kann die Anwendung die Operation einfach wiederholen. Das bringt zwar das Risiko mit sich, den Zähler zweimal zu aktualisieren, doch eine leichte Unter- oder Überzählung der Websitebesucher ist tolerierbar.
Ein unteilbarer Zähler ist nicht geeignet, wenn eine Überzählung oder Unterzählung nicht toleriert werden kann (z. B. in einer Bankanwendung). In diesem Fall ist es sicherer, ein bedingtes Update anstelle eines unteilbaren Zählers zu verwenden.
Weitere Informationen finden Sie unter [Vergrößern und Verkleinern numerischer Attribute](Expressions.UpdateExpressions.md#Expressions.UpdateExpressions.SET.IncrementAndDecrement).
**Example**
Im folgenden AWS CLI Beispiel wird der Wert `Price` eines Produkts um 5 erhöht. In diesem Beispiel war bekannt, dass das Element existiert, bevor der Zähler aktualisiert wurde. Da `UpdateItem` nicht idempotent ist, steigt `Price` bei jedem Ausführen dieses Codes an.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id": { "N": "601" }}' \
--update-expression "SET Price = Price + :incr" \
--expression-attribute-values '{":incr":{"N":"5"}}' \
--return-values UPDATED_NEW
```
## Bedingte Schreibvorgänge
Standardmäßig sind die DynamoDB-Schreiboperationen (`PutItem`,`DeleteItem`) *bedingungslos*: Jede Operation überschreibt ein vorhandenes Element, das den angegebenen Primärschlüssel hat.
DynamoDB unterstützt optional bedingte Schreibvorgänge für diese Operationen. Ein bedingter Schreibvorgang wird nur dann erfolgreich ausgeführt, wenn die Elementattribute eine oder mehrere erwartete Bedingungen erfüllen. Andernfalls wird ein Fehler zurückgegeben.
Bedingte Schreibvorgänge vergleichen ihre Bedingungen mit der zuletzt aktualisierten Version des Elements. Beachten Sie, dass der bedingte Schreibvorgang kein vorheriges Element findet, wenn das Element zuvor noch nicht vorhanden war oder wenn der letzte erfolgreiche Vorgang für dieses Element ein Löschvorgang war.
Bedingte Schreibvorgänge sind in vielen Situationen hilfreich. Eine `PutItem`-Operation soll beispielsweise nur erfolgreich abgeschlossen werden, wenn noch kein Element mit demselben Primärschlüssel vorhanden ist. Sie können eine `UpdateItem`-Operation auch daran hindern, ein Element zu ändern, wenn eines seiner Attribute einen bestimmten Wert aufweist.
Bedingte Schreibvorgänge sind hilfreich, wenn mehrere Benutzer versuchen, dasselbe Element zu ändern. Betrachten Sie das folgende Diagramm, in dem zwei Benutzer (Alice und Bob) mit demselben Element aus einer DynamoDB-Tabelle arbeiten:
![\[Die Benutzer Alice und Bob versuchen, ein Element mit der ID 1 zu ändern, was zeigt, dass bedingte Schreibvorgänge erforderlich sind.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/update-no-condition.png)
Angenommen, Alice verwendet das, AWS CLI um das Attribut auf 8 zu aktualisieren. `Price`
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--update-expression "SET Price = :newval" \
--expression-attribute-values file://expression-attribute-values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `expression-attribute-values.json` gespeichert:
```
{
":newval":{"N":"8"}
}
```
Angenommen, Bob erstellt später eine ähnliche `UpdateItem`-Anforderung, ändert den `Price` jedoch in 12. Für Bob sieht der Parameter `--expression-attribute-values` wie folgt aus:
```
{
":newval":{"N":"12"}
}
```
Bobs Anforderung wird erfolgreich ausgeführt, aber das Update, das Alice vorher vorgenommen hatte, geht verloren.
Für eine bedingte `PutItem`-, `DeleteItem`- oder `UpdateItem`-Anforderung geben Sie einen Bedingungsausdruck an. Ein *Bedingungsausdruck* ist eine Zeichenfolge, die Attributnamen, bedingte Operatoren und integrierte Funktionen enthält. Der gesamte Ausdruck muss mit True ausgewertet werden. Andernfalls schlägt sie fehl.
Betrachten Sie jetzt das folgende Diagramm, das zeigt, wie bedingte Schreibvorgänge verhindern würden, dass die von Alice vorgenommene Aktualisierung überschrieben wird:
![\[Durch bedingtes Schreiben wird verhindert, dass die Aktualisierung von Benutzer Bob die Änderung von Benutzerin Alice am selben Element überschreibt.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/update-yes-condition.png)
Alice versucht zunächst, `Price` auf 8 zu aktualisieren, jedoch nur wenn der aktuelle `Price` 10 beträgt.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--update-expression "SET Price = :newval" \
--condition-expression "Price = :currval" \
--expression-attribute-values file://expression-attribute-values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `expression-attribute-values.json` gespeichert.
```
{
":newval":{"N":"8"},
":currval":{"N":"10"}
}
```
Das Update von Alice wird erfolgreich ausgeführt, da die Bedingung mit True ausgewertet wird.
Als Nächstes versucht Bob, den `Price` auf 12 zu aktualisieren, jedoch nur wenn der aktuelle `Price` 10 beträgt. Für Bob sieht der Parameter `--expression-attribute-values` wie folgt aus:
```
{
":newval":{"N":"12"},
":currval":{"N":"10"}
}
```
Da Alice den `Price` zuvor in 8 geändert hat, wird der Bedingungsausdruck mit False ausgewertet und Bobs Aktualisierung schlägt fehl.
Weitere Informationen finden Sie unter [CLI-Beispiel für DynamoDB-Bedingungsausdrücke](Expressions.ConditionExpressions.md).
### Idempotenz von bedingten Schreibvorgängen
Bedingte Schreibvorgänge können *idempotent* sein, wenn die bedingte Prüfung für dasselbe Attribut ausgeführt wird, das aktualisiert wird. Das bedeutet, dass DynamoDB den jeweiligen Schreibvorgang nur ausführt, wenn bestimmte Attributwerte in dem Element mit den zum Zeitpunkt der Anforderung erwarteten Werten übereinstimmen.
Angenommen, Sie erstellen eine `UpdateItem`-Anforderung, um den `Price` eines Elements um 3 zu erhöhen, jedoch nur wenn der `Price` aktuell 20 beträgt. Nachdem Sie die Anforderung senden und bevor Sie die Ergebnisse erhalten, tritt ein Netzwerkfehler auf und Sie wissen nicht, ob die Anforderung erfolgreich war. Da dieser bedingte Schreibvorgang idempotent ist, können Sie dieselbe `UpdateItem`-Anforderung wiederholen und DynamoDB aktualisiert das Element nur, wenn `Price` gegenwärtig 20 beträgt.
### Von bedingten Schreibvorgängen verbrauchte Kapazitätseinheiten
Wenn `ConditionExpression` während eines bedingten Schreibvorgangs als falsch ausgewertet wird, verbraucht DynamoDB weiterhin Schreibkapazität aus der Tabelle. Die verbrauchte Menge hängt von der Größe des vorhandenen Elements ab (oder beträgt mindestens 1). Wenn beispielsweise ein vorhandenes Element 300 KB groß ist und das neue Element, das Sie erstellen oder aktualisieren möchten, 310 KB hat, entsprechen die verbrauchten Schreibkapazitätseinheiten 300, wenn die Bedingung fehlschlägt, und 310, wenn die Bedingung erfolgreich ist. Wenn es sich um ein neues Element handelt (kein vorhandenes Element), beträgt die verbrauchte Schreibkapazität 1, wenn die Bedingung fehlschlägt, und 310, wenn die Bedingung erfolgreich ist.
**Anmerkung**
Schreibvorgänge verbrauchen nur *Schreib*kapazitätseinheiten. Sie belegen keine *Lese*kapazitätseinheiten.
Tritt bei einem bedingten Schreibvorgang ein Fehler auf, wird eine `ConditionalCheckFailedException` zurückgegeben. In diesem Fall erhalten Sie in der Antwort keine Informationen über die verbrauchte Schreibkapazität.
Um die Anzahl von Schreibkapazitätseinheiten zurückzugeben, die während eines bedingten Schreibvorgangs verbraucht wurden, verwenden Sie den Parameter `ReturnConsumedCapacity`:
+ `TOTAL` – Gibt die Gesamtanzahl der verbrauchten Schreibkapazitätseinheiten zurück.
+ `INDEXES` – Gibt die Gesamtzahl der verbrauchten Schreibkapazitätseinheiten mit Zwischensummen für die Tabelle und alle sekundären Indizes zurück, die vom Vorgang betroffen waren.
+ `NONE` – Es werden keine Schreibkapazitätsdetails zurückgegeben. (Dies ist die Standardeinstellung.)
**Anmerkung**
Im Unterschied zu einem globalen sekundären Index teilt ein lokaler sekundärer Index seine bereitgestellte Durchsatzkapazität mit der Tabelle. Die Lese- und Schreibaktivität auf einem lokalen sekundären Index verbraucht die bereitgestellte Durchsatzkapazität aus der Tabelle.
# 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"}
}
```
# Verwenden von Time to Live (TTL) in DynamoDB
Time To Live (TTL) für DynamoDB ist eine kosteneffiziente Methode zum Löschen von Elementen, die nicht mehr relevant sind. TTL ermöglicht es Ihnen, einen Ablaufzeitstempel pro Element zu definieren, um festzulegen, wann ein Element nicht mehr benötigt wird. DynamoDB löscht abgelaufene Elemente automatisch innerhalb weniger Tage nach ihrem Ablauftermin, ohne dass dafür Schreibdurchsatz verbraucht wird.
Um TTL zu verwenden, aktivieren Sie es zunächst in einer Tabelle. Definieren Sie dann ein bestimmtes Attribut zum Speichern des TTL-Ablaufzeitstempels. Der Zeitstempel muss als Datentyp [Zahl](HowItWorks.NamingRulesDataTypes.md#HowItWorks.DataTypes) im [Unix-Epochenzeitformat](https://en.wikipedia.org/wiki/Unix_time) mit der Granularität Sekunden gespeichert werden. Elemente mit einem TTL-Attribut, das kein Zahlentyp ist, werden vom TTL-Prozess ignoriert. Immer, wenn ein Element erstellt oder aktualisiert wird, können Sie die Ablaufzeit berechnen und sie im TTL-Attribut speichern.
Elemente mit gültigen, abgelaufenen TTL-Attributen können vom System jederzeit gelöscht werden. In der Regel geschieht das innerhalb weniger Tage nach ihrem Ablauf. Sie können die abgelaufenen Elemente, deren Löschung noch aussteht, weiterhin aktualisieren. Dazu gehören auch das Ändern oder Entfernen ihrer TTL-Attribute. Wenn Sie ein abgelaufenes Element aktualisieren, empfiehlt es sich, einen Bedingungsausdruck zu verwenden, um sicherzustellen, dass das Element anschließend nicht gelöscht wurde. Verwenden Sie Filterausdrücke, um abgelaufene Elemente aus [Scan](Scan.md#Scan.FilterExpression)- und [Abfrageergebnissen](Query.FilterExpression.md) zu entfernen.
Gelöschte Elemente funktionieren ähnlich wie Objekte, die bei typischen Löschvorgängen gelöscht wurden. Nach dem Löschen fließen Elemente als Servicelöschungen statt als Benutzerlöschungen in DynamoDB Streams ein und werden wie andere Löschvorgänge aus lokalen und globalen sekundären Indizes entfernt.
Wenn Sie [Version 2019.11.21 der globalen Tabellen (aktuell)](GlobalTables.md) und außerdem die TTL-Funktion verwenden, repliziert DynamoDB TTL-Löschungen in alle Replikattabellen. Die anfängliche TTL-Löschung verbraucht keine Schreibkapazitätseinheiten (WCU) in der Region, in der die TTL abläuft. Die in die Replikattabellen replizierte TTL-Löschung verbraucht jedoch in jeder Region mit einem Replikat bei Verwendung bereitgestellter Kapazität eine Einheit für replizierte Schreibkapazität bzw. bei Verwendung von On-Demand-Kapazität eine replizierte Schreibeinheit. Dafür werden die entsprechenden Gebühren berechnet.
Weitere Informationen zu TTL finden Sie in den folgenden Themen:
**Topics**
+ [Aktivieren von Time to Live (TTL) in DynamoDB](time-to-live-ttl-how-to.md)
+ [Berechnen der Time to Live (TTL) in DynamoDB](time-to-live-ttl-before-you-start.md)
+ [Arbeiten mit abgelaufenen Elementen und Time to Live (TTL)](ttl-expired-items.md)
# Aktivieren von Time to Live (TTL) in DynamoDB
**Anmerkung**
Um das Debugging und die Verifizierung des ordnungsgemäßen Betriebs der TTL-Funktion zu erleichtern, werden die Werte für die Element-TTL in DynamoDB-Diagnoseprotokollen in Klartext angegeben.
Sie können TTL in der Amazon DynamoDB DynamoDB-Konsole, der AWS Command Line Interface (AWS CLI), oder mithilfe der [Amazon DynamoDB DynamoDB-API-Referenz](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/) mit einer der angegebenen Optionen aktivieren. AWS SDKs Es dauert ungefähr eine Stunde, um TTL auf allen Partitionen zu aktivieren.
## DynamoDB TTL über die Konsole aktivieren AWS
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Wählen Sie **Tabellen** und anschließend die Tabelle aus, die Sie ändern möchten.
1. Wählen Sie auf der Registerkarte **Zusätzliche Einstellungen** im Abschnitt **Time to Live (TTL)** die Option **Einschalten** aus, um TTL zu aktivieren.
1. Wenn Sie TTL für eine Tabelle aktivieren, müssen Sie bei DynamoDB einen bestimmten Attributnamen angeben, nach dem der Service sucht, wenn bestimmt wird, ob der Ablauf eines Elements veranlasst werden soll. Beim Namen des TTL-Attributs (siehe unten) wird zwischen Groß- und Kleinschreibung unterschieden. Außerdem muss er mit dem in Ihren Lese- und Schreibvorgängen definierten Attribut übereinstimmen. Andernfalls werden abgelaufene Elemente nicht gelöscht. Um das TTL-Attribut umzubenennen, müssen Sie TTL zunächst deaktivieren und dann mit dem neuen Attribut aktivieren. TTL verarbeitet Löschungen etwa 30 Minuten lang weiter, nachdem es deaktiviert wurde. Bei wiederhergestellten Tabellen muss TTL neu konfiguriert werden.
![\[TTL-Attributname mit Berücksichtigung von Groß- und Kleinschreibung, anhand dessen DynamoDB bestimmt, ob ein Element abläuft.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/EnableTTL-Settings.png)
1. (Optional) Sie können einen Test durchführen, indem Sie Datum und Uhrzeit des Ablaufs simulieren und einige Elemente abgleichen. Dadurch erhalten Sie eine Beispielliste mit Elementen, die bestätigt, dass es Elemente mit dem angegebenen TTL-Attributnamen und der Ablaufzeit gibt.
Nachdem TTL aktiviert wurde, wird das TTL-Attribut mit **TTL** gekennzeichnet, wenn Sie Elemente in der DynamoDB-Konsole ansehen. Sie können den Termin anzeigen, an dem ein Element abläuft, indem Sie mit dem Mauszeiger über das Attribut fahren.
## Aktivieren von DynamoDB TTL mithilfe der API
------
#### [ Python ]
Sie können TTL mithilfe des Vorgangs mit Code aktivieren. [UpdateTimeToLive](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/update_time_to_live.html)
```
import boto3
def enable_ttl(table_name, ttl_attribute_name):
"""
Enables TTL on DynamoDB table for a given attribute name
on success, returns a status code of 200
on error, throws an exception
:param table_name: Name of the DynamoDB table
:param ttl_attribute_name: The name of the TTL attribute being provided to the table.
"""
try:
dynamodb = boto3.client('dynamodb')
# Enable TTL on an existing DynamoDB table
response = dynamodb.update_time_to_live(
TableName=table_name,
TimeToLiveSpecification={
'Enabled': True,
'AttributeName': ttl_attribute_name
}
)
# In the returned response, check for a successful status code.
if response['ResponseMetadata']['HTTPStatusCode'] == 200:
print("TTL has been enabled successfully.")
else:
print(f"Failed to enable TTL, status code {response['ResponseMetadata']['HTTPStatusCode']}")
except Exception as ex:
print("Couldn't enable TTL in table %s. Here's why: %s" % (table_name, ex))
raise
# your values
enable_ttl('your-table-name', 'expirationDate')
```
Sie können überprüfen, ob TTL aktiviert ist, indem Sie den [DescribeTimeToLive](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_time_to_live.html)Vorgang verwenden, der den TTL-Status in einer Tabelle beschreibt. Der `TimeToLive`-Status ist entweder `ENABLED` oder `DISABLED`.
```
# create a DynamoDB client
dynamodb = boto3.client('dynamodb')
# set the table name
table_name = 'YourTable'
# describe TTL
response = dynamodb.describe_time_to_live(TableName=table_name)
```
------
#### [ JavaScript ]
Sie können TTL mithilfe des Vorgangs mit Code aktivieren. [UpdateTimeToLiveCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-dynamodb/Class/UpdateTimeToLiveCommand/)
```
import { DynamoDBClient, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb";
const enableTTL = async (tableName, ttlAttribute) => {
const client = new DynamoDBClient({});
const params = {
TableName: tableName,
TimeToLiveSpecification: {
Enabled: true,
AttributeName: ttlAttribute
}
};
try {
const response = await client.send(new UpdateTimeToLiveCommand(params));
if (response.$metadata.httpStatusCode === 200) {
console.log(`TTL enabled successfully for table ${tableName}, using attribute name ${ttlAttribute}.`);
} else {
console.log(`Failed to enable TTL for table ${tableName}, response object: ${response}`);
}
return response;
} catch (e) {
console.error(`Error enabling TTL: ${e}`);
throw e;
}
};
// call with your own values
enableTTL('ExampleTable', 'exampleTtlAttribute');
```
------
## Aktivieren Sie Time to Live mit dem AWS CLI
1. Aktivieren Sie TTL in der `TTLExample`-Tabelle.
```
aws dynamodb update-time-to-live --table-name TTLExample --time-to-live-specification "Enabled=true, AttributeName=ttl"
```
1. Beschreiben Sie TTL in der `TTLExample`-Tabelle.
```
aws dynamodb describe-time-to-live --table-name TTLExample
{
"TimeToLiveDescription": {
"AttributeName": "ttl",
"TimeToLiveStatus": "ENABLED"
}
}
```
1. Fügen Sie der `TTLExample`-Tabelle mit dem Time-to-Live-Attributsatz ein Element mit der BASH-Shell und AWS CLI hinzu:
```
EXP=`date -d '+5 days' +%s`
aws dynamodb put-item --table-name "TTLExample" --item '{"id": {"N": "1"}, "ttl": {"N": "'$EXP'"}}'
```
In diesem Beispiel wurde mit dem aktuellen Datum begonnen und es wurden 5 Tage hinzugefügt, um ein Ablaufdatum zu erstellen. Anschließend wird das Ablaufdatum in ein Epoch-Zeitformat umgewandelt, um der Tabelle "`TTLExample`" ein Element hinzuzufügen.
**Anmerkung**
Eine Möglichkeit, Ablaufwerte für Time to Live festzulegen, besteht darin, die Anzahl von Sekunden zu berechnen, die dem Ablaufdatum hinzugefügt werden. Beispielsweise sind 5 Tage 432.000 Sekunden. Es ist jedoch häufig besser, mit einem Datum zu beginnen und dieses als Ausgangspunkt zu nehmen.
Es ist relativ einfach, die aktuelle Zeit im Epoch-Zeitformat zu erhalten, wie in folgenden Beispielen veranschaulicht.
+ Linux-Terminal: `date +%s`
+ Python: `import time; int(time.time())`
+ Java: `System.currentTimeMillis() / 1000L`
+ JavaScript: `Math.floor(Date.now() / 1000)`
## Aktivieren Sie DynamoDB TTL mit CloudFormation
```
AWSTemplateFormatVersion: "2010-09-09"
Resources:
TTLExampleTable:
Type: AWS::DynamoDB::Table
Description: "A DynamoDB table with TTL Specification enabled"
Properties:
AttributeDefinitions:
- AttributeName: "Album"
AttributeType: "S"
- AttributeName: "Artist"
AttributeType: "S"
KeySchema:
- AttributeName: "Album"
KeyType: "HASH"
- AttributeName: "Artist"
KeyType: "RANGE"
ProvisionedThroughput:
ReadCapacityUnits: "5"
WriteCapacityUnits: "5"
TimeToLiveSpecification:
AttributeName: "TTLExampleAttribute"
Enabled: true
```
[Weitere Informationen zur Verwendung von TTL in Ihren CloudFormation Vorlagen finden Sie hier.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-table-timetolivespecification.html)
# Berechnen der Time to Live (TTL) in DynamoDB
Eine gängige Methode zur Implementierung von TTL besteht darin, eine Ablaufzeit für Elemente festzulegen, die auf dem Erstellungs- oder letzten Aktualisierungsdatum basiert. Dies kann durch Hinzufügen von Zeit zu den Zeitstempeln `createdAt` und `updatedAt` erreicht werden. Beispielsweise kann die TTL für neu erstellte Elemente auf `createdAt` \$1 90 Tage festgelegt werden. Wenn das Element aktualisiert wird, kann die TTL mit `updatedAt` \$1 90 Tage neu berechnet werden.
Die berechnete Ablaufzeit muss im Unix-Format in Sekunden angegeben werden. Damit Elemente für Ablauf und Löschung infrage kommen, darf die TTL nicht länger als fünf Jahre zurückliegen. Wenn Sie ein anderes Format verwenden, ignorieren die TTL-Prozesse das Element. Wenn Sie die Ablaufzeit auf einen Zeitpunkt in der future festlegen, an dem der Artikel ablaufen soll, läuft der Artikel nach dieser Zeit ab. Angenommen, Sie haben die Ablaufzeit auf 1724241326 festgelegt (das ist Montag, 21. August 2024 11:55:26 (UTC)). Der Artikel läuft nach der angegebenen Zeit ab. Es gibt keine TTL-Mindestdauer. Sie können die Ablaufzeit auf einen beliebigen Zeitpunkt in der future festlegen, z. B. auf 5 Minuten ab der aktuellen Uhrzeit. DynamoDB löscht abgelaufene Elemente jedoch in der Regel innerhalb von 48 Stunden nach deren Ablauf, nicht sofort, wenn der Artikel abläuft.
**Topics**
+ [Erstellen eines Elements und Festlegen der Time to Live](#time-to-live-ttl-before-you-start-create)
+ [Aktualisieren eines Elements und der Time to Live](#time-to-live-ttl-before-you-start-update)
## Erstellen eines Elements und Festlegen der Time to Live
Das folgende Beispiel zeigt, wie die Ablaufzeit berechnet wird, wenn ein neues Element erstellt wird. Dabei wird `expireAt` als TTL-Attributname verwendet. Eine Zuweisungsanweisung ruft die aktuelle Uhrzeit als Variable ab. In diesem Beispiel wird die Ablaufzeit als 90 Tage ab der aktuellen Uhrzeit berechnet. Die Zeit wird dann in das Unix-Format umgewandelt und als Ganzzahl-Datentyp im TTL-Attribut gespeichert.
Die folgenden Codebeispiele veranschaulichen, wie Sie ein Element mit TTL erstellen.
------
#### [ Java ]
**SDK für Java 2.x**
```
package com.amazon.samplelib.ttl;
import com.amazon.samplelib.CodeSampleUtils;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
/**
* Creates an item in a DynamoDB table with TTL attributes.
* This class demonstrates how to add TTL expiration timestamps to DynamoDB items.
*/
public class CreateTTL {
private static final String USAGE =
"""
Usage:
Where:
tableName - The Amazon DynamoDB table being queried.
primaryKey - The name of the primary key. Also known as the hash or partition key.
sortKey - The name of the sort key. Also known as the range attribute.
region (optional) - The AWS region that the Amazon DynamoDB table is located in. (Default: us-east-1)
""";
private static final int DAYS_TO_EXPIRE = 90;
private static final int SECONDS_PER_DAY = 24 * 60 * 60;
private static final String PRIMARY_KEY_ATTR = "primaryKey";
private static final String SORT_KEY_ATTR = "sortKey";
private static final String CREATION_DATE_ATTR = "creationDate";
private static final String EXPIRE_AT_ATTR = "expireAt";
private static final String SUCCESS_MESSAGE = "%s PutItem operation with TTL successful.";
private static final String TABLE_NOT_FOUND_ERROR = "Error: The Amazon DynamoDB table \"%s\" can't be found.";
private final DynamoDbClient dynamoDbClient;
/**
* Constructs a CreateTTL instance with the specified DynamoDB client.
*
* @param dynamoDbClient The DynamoDB client to use
*/
public CreateTTL(final DynamoDbClient dynamoDbClient) {
this.dynamoDbClient = dynamoDbClient;
}
/**
* Constructs a CreateTTL with a default DynamoDB client.
*/
public CreateTTL() {
this.dynamoDbClient = null;
}
/**
* Main method to demonstrate creating an item with TTL.
*
* @param args Command line arguments
*/
public static void main(final String[] args) {
try {
int result = new CreateTTL().processArgs(args);
System.exit(result);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
/**
* Process command line arguments and create an item with TTL.
*
* @param args Command line arguments
* @return 0 if successful, non-zero otherwise
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
* @throws IllegalArgumentException If arguments are invalid
*/
public int processArgs(final String[] args) {
// Argument validation (remove or replace this line when reusing this code)
CodeSampleUtils.validateArgs(args, new int[] {3, 4}, USAGE);
final String tableName = args[0];
final String primaryKey = args[1];
final String sortKey = args[2];
final Region region = Optional.ofNullable(args.length > 3 ? args[3] : null)
.map(Region::of)
.orElse(Region.US_EAST_1);
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final CreateTTL createTTL = new CreateTTL(ddb);
createTTL.createItemWithTTL(tableName, primaryKey, sortKey);
return 0;
} catch (Exception e) {
throw e;
}
}
/**
* Creates an item in the specified table with TTL attributes.
*
* @param tableName The name of the table
* @param primaryKeyValue The value for the primary key
* @param sortKeyValue The value for the sort key
* @return The response from the PutItem operation
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
*/
public PutItemResponse createItemWithTTL(
final String tableName, final String primaryKeyValue, final String sortKeyValue) {
// Get current time in epoch second format
final long createDate = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = createDate + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
final Map itemMap = new HashMap<>();
itemMap.put(
PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKeyValue).build());
itemMap.put(SORT_KEY_ATTR, AttributeValue.builder().s(sortKeyValue).build());
itemMap.put(
CREATION_DATE_ATTR,
AttributeValue.builder().n(String.valueOf(createDate)).build());
itemMap.put(
EXPIRE_AT_ATTR,
AttributeValue.builder().n(String.valueOf(expireDate)).build());
final PutItemRequest request =
PutItemRequest.builder().tableName(tableName).item(itemMap).build();
try {
final PutItemResponse response = dynamoDbClient.putItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return response;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
}
```
+ *Einzelheiten zur API finden Sie unter [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)API-Referenz.AWS SDK for Java 2.x *
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
```
import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
export function createDynamoDBItem(table_name, region, partition_key, sort_key) {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
// Get the current time in epoch second format
const current_time = Math.floor(new Date().getTime() / 1000);
// Calculate the expireAt time (90 days from now) in epoch second format
const expire_at = Math.floor((new Date().getTime() + 90 * 24 * 60 * 60 * 1000) / 1000);
// Create DynamoDB item
const item = {
'partitionKey': {'S': partition_key},
'sortKey': {'S': sort_key},
'createdAt': {'N': current_time.toString()},
'expireAt': {'N': expire_at.toString()}
};
const putItemCommand = new PutItemCommand({
TableName: table_name,
Item: item,
ProvisionedThroughput: {
ReadCapacityUnits: 1,
WriteCapacityUnits: 1,
},
});
client.send(putItemCommand, function(err, data) {
if (err) {
console.log("Exception encountered when creating item %s, here's what happened: ", data, err);
throw err;
} else {
console.log("Item created successfully: %s.", data);
return data;
}
});
}
// Example usage (commented out for testing)
// createDynamoDBItem('your-table-name', 'us-east-1', 'your-partition-key-value', 'your-sort-key-value');
```
+ Einzelheiten zur API finden Sie [PutItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/PutItemCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
```
from datetime import datetime, timedelta
import boto3
def create_dynamodb_item(table_name, region, primary_key, sort_key):
"""
Creates a DynamoDB item with an attached expiry attribute.
:param table_name: Table name for the boto3 resource to target when creating an item
:param region: string representing the AWS region. Example: `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:return: Void (nothing)
"""
try:
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Get the current time in epoch second format
current_time = int(datetime.now().timestamp())
# Calculate the expiration time (90 days from now) in epoch second format
expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())
item = {
"primaryKey": primary_key,
"sortKey": sort_key,
"creationDate": current_time,
"expireAt": expiration_time,
}
response = table.put_item(Item=item)
print("Item created successfully.")
return response
except Exception as e:
print(f"Error creating item: {e}")
raise e
# Use your own values
create_dynamodb_item(
"your-table-name", "us-west-2", "your-partition-key-value", "your-sort-key-value"
)
```
+ Einzelheiten zur API finden Sie [PutItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem)in *AWS SDK for Python (Boto3) API* Reference.
------
## Aktualisieren eines Elements und der Time to Live
Dies ist eine Fortsetzung des Beispiels aus dem [vorherigen Abschnitt](#time-to-live-ttl-before-you-start-create). Die Ablaufzeit kann neu berechnet werden, wenn das Element aktualisiert wird. Im folgenden Beispiel wird der Zeitstempel `expireAt` neu berechnet, sodass er 90 Tage nach der aktuellen Uhrzeit liegt.
Die folgenden Codebeispiele veranschaulichen, wie Sie die TTL eines Elements aktualisieren.
------
#### [ Java ]
**SDK für Java 2.x**
Aktualisieren Sie die TTL für ein vorhandenes DynamoDB-Element in einer Tabelle.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public UpdateItemResponse updateItemWithTTL(
final String tableName, final String primaryKeyValue, final String sortKeyValue) {
// Get current time in epoch second format
final long currentTime = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = currentTime + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
// Create the key map for the item to update
final Map keyMap = new HashMap<>();
keyMap.put(PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKeyValue).build());
keyMap.put(SORT_KEY_ATTR, AttributeValue.builder().s(sortKeyValue).build());
// Create the expression attribute values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
":c", AttributeValue.builder().n(String.valueOf(currentTime)).build());
expressionAttributeValues.put(
":e", AttributeValue.builder().n(String.valueOf(expireDate)).build());
final UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(keyMap)
.updateExpression(UPDATE_EXPRESSION)
.expressionAttributeValues(expressionAttributeValues)
.build();
try {
final UpdateItemResponse response = dynamoDbClient.updateItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return response;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
```
+ Einzelheiten zur API finden Sie unter [UpdateItem AWS SDK for Java 2.x](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)*API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
```
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const updateItem = async (tableName, partitionKey, sortKey, region = 'us-east-1') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const expireAt = Math.floor((Date.now() + 90 * 24 * 60 * 60 * 1000) / 1000);
const params = {
TableName: tableName,
Key: marshall({
partitionKey: partitionKey,
sortKey: sortKey
}),
UpdateExpression: "SET updatedAt = :c, expireAt = :e",
ExpressionAttributeValues: marshall({
":c": currentTime,
":e": expireAt
}),
};
try {
const data = await client.send(new UpdateItemCommand(params));
const responseData = unmarshall(data.Attributes);
console.log("Item updated successfully: %s", responseData);
return responseData;
} catch (err) {
console.error("Error updating item:", err);
throw err;
}
}
// Example usage (commented out for testing)
// updateItem('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
```
+ Einzelheiten zur API finden Sie [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
```
from datetime import datetime, timedelta
import boto3
def update_dynamodb_item(table_name, region, primary_key, sort_key):
"""
Update an existing DynamoDB item with a TTL.
:param table_name: Name of the DynamoDB table
:param region: AWS Region of the table - example `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:return: Void (nothing)
"""
try:
# Create the DynamoDB resource.
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Get the current time in epoch second format
current_time = int(datetime.now().timestamp())
# Calculate the expireAt time (90 days from now) in epoch second format
expire_at = int((datetime.now() + timedelta(days=90)).timestamp())
table.update_item(
Key={"partitionKey": primary_key, "sortKey": sort_key},
UpdateExpression="set updatedAt=:c, expireAt=:e",
ExpressionAttributeValues={":c": current_time, ":e": expire_at},
)
print("Item updated successfully.")
except Exception as e:
print(f"Error updating item: {e}")
# Replace with your own values
update_dynamodb_item(
"your-table-name", "us-west-2", "your-partition-key-value", "your-sort-key-value"
)
```
+ Einzelheiten zur API finden Sie [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)in *AWS SDK for Python (Boto3) API* Reference.
------
Die in dieser Einführung vorgestellten TTL-Beispiele sind ein Weg, um sicherzustellen, dass nur kürzlich aktualisierte Elemente in einer Tabelle gespeichert bleiben. Die Lebensdauer aktualisierter Elemente wird verlängert, wohingegen Elemente, die seit ihrer Erstellung nicht mehr aktualisiert wurden, ablaufen und kostenlos gelöscht werden. So wird Speicherplatz reduziert und die Tabellen werden auf dem neuesten Stand gehalten.
# Arbeiten mit abgelaufenen Elementen und Time to Live (TTL)
Abgelaufene Elemente, deren Löschung noch aussteht, können aus Lese- und Schreibvorgängen herausgefiltert werden. Dies ist nützlich in Szenarien, in denen abgelaufene Daten nicht mehr gültig sind und nicht verwendet werden sollten. Wenn sie nicht gefiltert werden, werden sie weiterhin bei Lese- und Schreibvorgängen angezeigt, bis sie vom Hintergrundprozess gelöscht werden.
**Anmerkung**
Diese Elemente werden weiterhin auf die Speicher- und Lesekosten angerechnet, bis sie gelöscht werden.
TTL-Löschungen können in DynamoDB Streams identifiziert werden, jedoch nur in der Region, in der die Löschung stattgefunden hat. TTL-Löschungen, die in globale Tabellenbereiche repliziert werden, sind in DynamoDB-Streams in den Regionen, in die die Löschung repliziert wurde, nicht identifizierbar.
## Filtern abgelaufener Elemente aus Lesevorgängen
Bei Lesevorgängen wie [Scan](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html) und [Abfrage](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html) kann ein Filterausdruck abgelaufene Elemente herausfiltern, deren Löschung noch aussteht. Wie im folgenden Codeausschnitt gezeigt, kann der Filterausdruck Elemente herausfiltern, bei denen die TTL-Zeit gleich oder kleiner als die aktuelle Zeit ist. Der Python-SDK-Code enthält beispielsweise eine Zuweisungsanweisung, die die aktuelle Uhrzeit als Variable (`now`) abruft und sie in `int` für das Unix-Zeitformat konvertiert.
In den folgenden Codebeispielen wird gezeigt, wie TTL-Elemente abgefragt werden.
------
#### [ Java ]
**SDK für Java 2.x**
Abfragen eines gefilterten Ausdrucks zum Sammeln von TTL-Elementen in einer DynamoDB-Tabelle mithilfe von. AWS SDK for Java 2.x
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.QueryRequest;
import software.amazon.awssdk.services.dynamodb.model.QueryResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.Map;
import java.util.Optional;
final QueryRequest request = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.filterExpression(FILTER_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final QueryResponse response = ddb.query(request);
System.out.println("Query successful. Found " + response.count() + " items that have not expired yet.");
// Print each item
response.items().forEach(item -> {
System.out.println("Item: " + item);
});
return 0;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
```
+ Weitere API-Informationen finden Sie unter [Abfragen](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Abfragen eines gefilterten Ausdrucks zum Sammeln von TTL-Elementen in einer DynamoDB-Tabelle mithilfe von. AWS SDK für JavaScript
```
import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const queryFiltered = async (tableName, primaryKey, region = 'us-east-1') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const params = {
TableName: tableName,
KeyConditionExpression: "#pk = :pk",
FilterExpression: "#ea > :ea",
ExpressionAttributeNames: {
"#pk": "primaryKey",
"#ea": "expireAt"
},
ExpressionAttributeValues: marshall({
":pk": primaryKey,
":ea": currentTime
})
};
try {
const { Items } = await client.send(new QueryCommand(params));
Items.forEach(item => {
console.log(unmarshall(item))
});
return Items;
} catch (err) {
console.error(`Error querying items: ${err}`);
throw err;
}
}
// Example usage (commented out for testing)
// queryFiltered('your-table-name', 'your-partition-key-value');
```
+ Weitere API-Informationen finden Sie unter [Abfragen](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Abfragen eines gefilterten Ausdrucks zum Sammeln von TTL-Elementen in einer DynamoDB-Tabelle mithilfe von. AWS SDK für Python (Boto3)
```
from datetime import datetime
import boto3
def query_dynamodb_items(table_name, partition_key):
"""
:param table_name: Name of the DynamoDB table
:param partition_key:
:return:
"""
try:
# Initialize a DynamoDB resource
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
# Specify your table
table = dynamodb.Table(table_name)
# Get the current time in epoch format
current_time = int(datetime.now().timestamp())
# Perform the query operation with a filter expression to exclude expired items
# response = table.query(
# KeyConditionExpression=boto3.dynamodb.conditions.Key('partitionKey').eq(partition_key),
# FilterExpression=boto3.dynamodb.conditions.Attr('expireAt').gt(current_time)
# )
response = table.query(
KeyConditionExpression=dynamodb.conditions.Key("partitionKey").eq(partition_key),
FilterExpression=dynamodb.conditions.Attr("expireAt").gt(current_time),
)
# Print the items that are not expired
for item in response["Items"]:
print(item)
except Exception as e:
print(f"Error querying items: {e}")
# Call the function with your values
query_dynamodb_items("Music", "your-partition-key-value")
```
+ Weitere API-Informationen finden Sie unter [Abfragen](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
## Bedingtes Schreiben in abgelaufene Elemente
Ein Bedingungsausdruck kann verwendet werden, um Schreibvorgänge auf abgelaufene Elemente zu verhindern. Der folgende Codeausschnitt ist eine bedingte Aktualisierung, die prüft, ob die Ablaufzeit nach der aktuellen Zeit liegt. Falls ja, wird der Schreibvorgang fortgesetzt.
In den folgenden Codebeispielen wird gezeigt, wie die TTL eines Elements bedingungsabhängig aktualisiert wird.
------
#### [ Java ]
**SDK für Java 2.x**
Aktualisieren Sie die TTL für ein vorhandenes DynamoDB-Element in einer Tabelle mit einer Bedingung.
```
package com.amazon.samplelib.ttl;
import com.amazon.samplelib.CodeSampleUtils;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.ConditionalCheckFailedException;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse;
import java.util.Map;
import java.util.Optional;
/**
* Updates an item in a DynamoDB table with TTL attributes using a conditional expression.
* This class demonstrates how to conditionally update TTL expiration timestamps.
*/
public class UpdateTTLConditional {
private static final String USAGE =
"""
Usage:
Where:
tableName - The Amazon DynamoDB table being queried.
primaryKey - The name of the primary key. Also known as the hash or partition key.
sortKey - The name of the sort key. Also known as the range attribute.
region (optional) - The AWS region that the Amazon DynamoDB table is located in. (Default: us-east-1)
""";
private static final int DAYS_TO_EXPIRE = 90;
private static final int SECONDS_PER_DAY = 24 * 60 * 60;
private static final String PRIMARY_KEY_ATTR = "primaryKey";
private static final String SORT_KEY_ATTR = "sortKey";
private static final String UPDATED_AT_ATTR = "updatedAt";
private static final String EXPIRE_AT_ATTR = "expireAt";
private static final String UPDATE_EXPRESSION = "SET " + UPDATED_AT_ATTR + "=:c, " + EXPIRE_AT_ATTR + "=:e";
private static final String CONDITION_EXPRESSION = "attribute_exists(" + PRIMARY_KEY_ATTR + ")";
private static final String SUCCESS_MESSAGE = "%s UpdateItem operation with TTL successful.";
private static final String CONDITION_FAILED_MESSAGE = "Condition check failed. Item does not exist.";
private static final String TABLE_NOT_FOUND_ERROR = "Error: The Amazon DynamoDB table \"%s\" can't be found.";
private final DynamoDbClient dynamoDbClient;
/**
* Constructs an UpdateTTLConditional with a default DynamoDB client.
*/
public UpdateTTLConditional() {
this.dynamoDbClient = null;
}
/**
* Constructs an UpdateTTLConditional with the specified DynamoDB client.
*
* @param dynamoDbClient The DynamoDB client to use
*/
public UpdateTTLConditional(final DynamoDbClient dynamoDbClient) {
this.dynamoDbClient = dynamoDbClient;
}
/**
* Main method to demonstrate conditionally updating an item with TTL.
*
* @param args Command line arguments
*/
public static void main(final String[] args) {
try {
int result = new UpdateTTLConditional().processArgs(args);
System.exit(result);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
/**
* Process command line arguments and conditionally update an item with TTL.
*
* @param args Command line arguments
* @return 0 if successful, non-zero otherwise
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
* @throws IllegalArgumentException If arguments are invalid
*/
public int processArgs(final String[] args) {
// Argument validation (remove or replace this line when reusing this code)
CodeSampleUtils.validateArgs(args, new int[] {3, 4}, USAGE);
final String tableName = args[0];
final String primaryKey = args[1];
final String sortKey = args[2];
final Region region = Optional.ofNullable(args.length > 3 ? args[3] : null)
.map(Region::of)
.orElse(Region.US_EAST_1);
// Get current time in epoch second format
final long currentTime = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = currentTime + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
// Create the key map for the item to update
final Map keyMap = Map.of(
PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKey).build(),
SORT_KEY_ATTR, AttributeValue.builder().s(sortKey).build());
// Create the expression attribute values
final Map expressionAttributeValues = Map.of(
":c", AttributeValue.builder().n(String.valueOf(currentTime)).build(),
":e", AttributeValue.builder().n(String.valueOf(expireDate)).build());
final UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(keyMap)
.updateExpression(UPDATE_EXPRESSION)
.conditionExpression(CONDITION_EXPRESSION)
.expressionAttributeValues(expressionAttributeValues)
.build();
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final UpdateItemResponse response = ddb.updateItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return 0;
} catch (ConditionalCheckFailedException e) {
System.err.println(CONDITION_FAILED_MESSAGE);
throw e;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
}
```
+ *Einzelheiten zur API finden Sie unter [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)API-Referenz.AWS SDK for Java 2.x *
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Aktualisieren Sie die TTL für ein vorhandenes DynamoDB-Element in einer Tabelle mit einer Bedingung.
```
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const updateItemConditional = async (tableName, partitionKey, sortKey, region = 'us-east-1', newAttribute = 'default-value') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const params = {
TableName: tableName,
Key: marshall({
artist: partitionKey,
album: sortKey
}),
UpdateExpression: "SET newAttribute = :newAttribute",
ConditionExpression: "expireAt > :expiration",
ExpressionAttributeValues: marshall({
':newAttribute': newAttribute,
':expiration': currentTime
}),
ReturnValues: "ALL_NEW"
};
try {
const response = await client.send(new UpdateItemCommand(params));
const responseData = unmarshall(response.Attributes);
console.log("Item updated successfully: ", responseData);
return responseData;
} catch (error) {
if (error.name === "ConditionalCheckFailedException") {
console.log("Condition check failed: Item's 'expireAt' is expired.");
} else {
console.error("Error updating item: ", error);
}
throw error;
}
};
// Example usage (commented out for testing)
// updateItemConditional('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
```
+ Einzelheiten zur API finden Sie [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Aktualisieren Sie die TTL für ein vorhandenes DynamoDB-Element in einer Tabelle mit einer Bedingung.
```
from datetime import datetime, timedelta
import boto3
from botocore.exceptions import ClientError
def update_dynamodb_item_ttl(table_name, region, primary_key, sort_key, ttl_attribute):
"""
Updates an existing record in a DynamoDB table with a new or updated TTL attribute.
:param table_name: Name of the DynamoDB table
:param region: AWS Region of the table - example `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:param ttl_attribute: name of the TTL attribute in the target DynamoDB table
:return:
"""
try:
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Generate updated TTL in epoch second format
updated_expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())
# Define the update expression for adding/updating a new attribute
update_expression = "SET newAttribute = :val1"
# Define the condition expression for checking if 'expireAt' is not expired
condition_expression = "expireAt > :val2"
# Define the expression attribute values
expression_attribute_values = {":val1": ttl_attribute, ":val2": updated_expiration_time}
response = table.update_item(
Key={"primaryKey": primary_key, "sortKey": sort_key},
UpdateExpression=update_expression,
ConditionExpression=condition_expression,
ExpressionAttributeValues=expression_attribute_values,
)
print("Item updated successfully.")
return response["ResponseMetadata"]["HTTPStatusCode"] # Ideally a 200 OK
except ClientError as e:
if e.response["Error"]["Code"] == "ConditionalCheckFailedException":
print("Condition check failed: Item's 'expireAt' is expired.")
else:
print(f"Error updating item: {e}")
except Exception as e:
print(f"Error updating item: {e}")
# replace with your values
update_dynamodb_item_ttl(
"your-table-name",
"us-east-1",
"your-partition-key-value",
"your-sort-key-value",
"your-ttl-attribute-value",
)
```
+ Einzelheiten zur API finden Sie [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)in *AWS SDK for Python (Boto3) API* Reference.
------
## Identifizieren gelöschter Elemente in DynamoDB Streams
Der Stream-Datensatz enthält ein Benutzeridentitätsfeld `Records[].userIdentity`. Elemente, die durch den TTL-Prozess gelöscht wurden, haben die folgenden Felder:
```
Records[].userIdentity.type
"Service"
Records[].userIdentity.principalId
"dynamodb.amazonaws.com"
```
Der folgende JSON-Ausdruck zeigt den relevanten Teil eines einzelnen Stream-Datensatzes:
```
"Records": [
{
...
"userIdentity": {
"type": "Service",
"principalId": "dynamodb.amazonaws.com"
}
...
}
]
```
# Abfragen von Tabellen in DynamoDB
Sie können die `Query`–API-Operation in Amazon DynamoDB verwenden, um Elemente auf der Basis von Primärschlüsselwerten zu finden.
Sie müssen den Namen des Partitionsschlüsselattributs und einen einzelnen Wert für dieses Attribut angeben. `Query` gibt alle Elemente mit diesem Partitionsschlüsselwert zurück. Sie können optional ein Sortierschlüsselattribut angeben und einen Vergleichsoperator verwenden, um die Suchergebnisse zu verfeinern.
Weitere Informationen zur Verwendung von `Query`, wie beispielsweise die Anforderungssyntax, Antwortparameter und zusätzliche Beispiele, finden Sie unter [Abfragen](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html) in der *API-Referenz zu Amazon DynamoDB*.
**Topics**
+ [Schlüsselbedingungsausdrücke für die Abfrage-Operation in DynamoDB](Query.KeyConditionExpressions.md)
+ [Filterausdrücke für die Abfrage-Operation in DynamoDB](Query.FilterExpression.md)
+ [Paginieren von Tabellenabfrageergebnissen in DynamoDB](Query.Pagination.md)
+ [Weitere Aspekte der Arbeit mit der Abfrage-Operation in DynamoDB](Query.Other.md)
# Schlüsselbedingungsausdrücke für die Abfrage-Operation in DynamoDB
Sie können alle Attributnamen in einem Schlüsselbedingungsausdruck verwenden, sofern das erste Zeichen `a-z` oder `A-Z` ist und die übrigen Zeichen (ab dem zweiten Zeichen, sofern vorhanden) `a-z`, `A-Z` oder `0-9` sind. Darüber hinaus müssen die Attributnamen nicht DynamoDB-reservierte Wörter sein. (Eine vollständige Liste finden Sie unter [Reservierte Wörter in DynamoDB](ReservedWords.md).) Wenn ein Attributname diesen Anforderungen nicht entspricht, müssen Sie einen Ausdruckattributnamen als Platzhalter definieren. Weitere Informationen finden Sie unter [Ausdrucksattributnamen (Aliasse) in DynamoDB](Expressions.ExpressionAttributeNames.md).
Für Objekte, die mit einem bestimmten Partitionsschlüsselwert versehen sind, speichert DynamoDB diese Elemente nah beieinander, sortiert nach Sortierschlüsselwerten. In einer `Query`-Operation ruft DynamoDB die Elemente sortiert ab und verarbeitet dann die Elemente mit `KeyConditionExpression` und allen `FilterExpression`, die möglicherweise vorhanden sind. Nur dann werden die `Query`-Ergebnisse an den Client zurückgesendet.
Die `Query`-Operation gibt immer eine Ergebnismenge zurück. Wenn keine übereinstimmenden Elemente gefunden werden, ist die Ergebnismenge leer.
`Query`-Ergebnisse werden immer von dem Sortierschlüsselwert sortiert. Wenn der Datentyp des Sortierschlüssels als `Number` festgelegt ist, werden die Ergebnisse in der numerischen Reihenfolge zurückgegeben. Andernfalls werden die Ergebnisse in der Reihenfolge der UTF-8-Bytes zurückgegeben. Standardmäßig ist die Sortierreihenfolge aufsteigend. Um die Reihenfolge umzukehren, setzen Sie den Parameter `ScanIndexForward` auf `false`.
Eine einzelne `Query`-Operation kann bis zu 1 MB an Daten abrufen. Diese Größenbeschränkung gilt, bevor ein `FilterExpression` oder `ProjectionExpression` den Ergebnissen zugeordnet wird. Wenn `LastEvaluatedKey` in der Antwort vorhanden ist und nicht Null ist, müssen Sie die Ergebnismenge wechseln (siehe [Paginieren von Tabellenabfrageergebnissen in DynamoDB](Query.Pagination.md)).
## Beispiele für Schlüsselbedingungsausdrücke
Wenn Sie Suchkriterien angeben, verwenden Sie einen *Schlüsselbedingungsausdruck* – eine Zeichenkette, die die Elemente bestimmt, die von der Tabelle oder dem Index gelesen werden müssen.
Sie müssen den Namen und Wert des Partitionsschlüssels als Gleichheitsbedingung angeben. Sie können kein Nicht-Schlüssel-Attribut in einem Schlüsselbedingungsausdruck verwenden.
Sie können optional eine zweite Bedingung für den Sortierschlüssel (sofern vorhanden) angeben. Die Bedingung des Sortierschlüssels muss einen der folgenden Vergleichsoperatoren verwenden:
+ `a = b`— wahr, wenn *a* das Attribut dem Wert entspricht *b*
+ `a < b`— wahr, wenn *a* es kleiner ist als *b*
+ `a <= b`— wahr, wenn kleiner oder gleich *a* ist *b*
+ `a > b`— wahr, wenn größer *a* ist als *b*
+ `a >= b`— wahr, wenn größer oder gleich *a* ist *b*
+ `a BETWEEN b AND c`— wahr, wenn größer als oder gleich *b* und kleiner als oder gleich *a* ist*c*.
Folgende Funktionen werden ebenfalls unterstützt:
+ `begins_with (a, substr)` – True, wenn der Wert von Attribut `a` mit einer bestimmten Teilkettenfolge beginnt.
Die folgenden Beispiele AWS Command Line Interface (AWS CLI) veranschaulichen die Verwendung von Ausdrücken für Schlüsselbedingungen. Diese Ausdrücke verwenden Platzhalter (z. B. `:name` und `:sub`) anstelle tatsächlicher Werte. Weitere Informationen erhalten Sie unter [Ausdrucksattributnamen (Aliasse) in DynamoDB](Expressions.ExpressionAttributeNames.md) und [Verwenden von Ausdrucksattributwerten in DynamoDB](Expressions.ExpressionAttributeValues.md).
**Example**
Fragen Sie die `Thread`-Tabelle nach einem bestimmten `ForumName` (Partitionsschlüssel) ab. Alle Elemente mit diesem `ForumName`-Wert werden von der Abfrage gelesen, da der Sortierschlüssel (`Subject`) in `KeyConditionExpression` nicht enthalten ist.
```
aws dynamodb query \
--table-name Thread \
--key-condition-expression "ForumName = :name" \
--expression-attribute-values '{":name":{"S":"Amazon DynamoDB"}}'
```
**Example**
Fragen Sie die `Thread`-Tabelle nach einem bestimmten `ForumName` (Partitions-Schlüssel) ab, aber dieses Mal geben Sie nur die Elemente mit einem bestimmten `Subject` (Sortierschlüssel) zurück.
```
aws dynamodb query \
--table-name Thread \
--key-condition-expression "ForumName = :name and Subject = :sub" \
--expression-attribute-values file://values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":name":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"}
}
```
**Example**
Fragen Sie die `Reply`-Tabelle nach einer bestimmten `Id` (Partitionsschlüssel) ab, aber geben Sie nur die Elemente zurück, deren `ReplyDateTime` (Sortierschlüssel) mit bestimmten Zeichen beginnt.
```
aws dynamodb query \
--table-name Reply \
--key-condition-expression "Id = :id and begins_with(ReplyDateTime, :dt)" \
--expression-attribute-values file://values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":id":{"S":"Amazon DynamoDB#DynamoDB Thread 1"},
":dt":{"S":"2015-09"}
}
```
# Filterausdrücke für die Abfrage-Operation in DynamoDB
Wenn Sie die `Query`-Ergebnisse weiter eingrenzen müssen, können Sie optional einen Filterausdruck angeben. Ein *Filterausdruck* bestimmt, welche Elemente in den `Query`-Ergebnissen an Sie zurückgegeben werden. Alle anderen Ergebnisse werden verworfen.
Ein Filterausdruck wird angewendet, nachdem eine `Query` abgeschlossen ist, aber bevor die Ergebnisse zurückgegeben werden. Folglich verbraucht eine `Query` unabhängig davon, ob ein Filterausdruck vorhanden ist oder nicht, gleich viel Lesekapazität.
Eine `Query`-Operation kann bis zu 1 MB an Daten abrufen. Diese Größenbeschränkung gilt, bevor der Filterausdruck ausgewertet wird.
Ein Filterausdruck darf keine Partitionsschlüssel- oder Sortierschlüsselattribute enthalten. Sie müssen diese Attribute in dem Schlüsselbedingungsausdruck und nicht in dem Filterausdruck angeben.
Die Syntax für einen Filterausdruck ist der eines Schlüsselbedingungsausdrucks ähnlich. Filterausdrücke können dieselben Vergleichsoperatoren, Funktionen und logischen Operatoren wie ein Schlüsselbedingungsausdruck verwenden. Darüber hinaus können Filterausdrücke den Nicht-Gleichheitsoperator (`<>`), den`OR`-Operator, den`CONTAINS`-Operator, den `IN`-Operator, den `BEGINS_WITH`-Operator, den `BETWEEN`-Operator, den `EXISTS`-Operator und den`SIZE`-Operator verwenden. Weitere Informationen erhalten Sie unter [Schlüsselbedingungsausdrücke für die Abfrage-Operation in DynamoDB](Query.KeyConditionExpressions.md) und [Syntax für Filter- und Bedingungsausdrücke](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Syntax).
**Example**
Im folgenden AWS CLI Beispiel wird die `Thread` Tabelle nach einem bestimmten `ForumName` (Partitionsschlüssel) und `Subject` (Sortierschlüssel) abgefragt. Von den gefundenen Elementen werden nur die beliebtesten Diskussionsthreads zurückgegeben, also nur die Threads mit mehr als einer bestimmten Anzahl von `Views`.
```
aws dynamodb query \
--table-name Thread \
--key-condition-expression "ForumName = :fn and Subject begins_with :sub" \
--filter-expression "#v >= :num" \
--expression-attribute-names '{"#v": "Views"}' \
--expression-attribute-values file://values.json
```
Die Argumente für `--expression-attribute-values` werden in der Datei `values.json` gespeichert.
```
{
":fn":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"},
":num":{"N":"3"}
}
```
Beachten Sie, dass `Views` ein reserviertes Wort in DynamoDB ist (siehe [Reservierte Wörter in DynamoDB](ReservedWords.md)), daher verwendet dieses Beispiel `#v` als Platzhalter. Weitere Informationen finden Sie unter [Ausdrucksattributnamen (Aliasse) in DynamoDB](Expressions.ExpressionAttributeNames.md).
**Anmerkung**
Ein Filterausdruck entfernt Elemente aus der `Query`-Ergebnismenge. Verwenden Sie nach Möglichkeit `Query` nicht, wenn Sie erwarten, eine große Anzahl von Elementen abzurufen, jedoch auch die meisten dieser Elemente verwerfen zu müssen.
# Paginieren von Tabellenabfrageergebnissen in DynamoDB
DynamoDB *paginiert* die Ergebnisse von `Query`-Operationen. Bei der Paginierung werden die `Query`-Ergebnisse in „Seiten“ mit Daten von einer Größe von 1 MB (oder weniger) unterteilt. Eine Anwendung kann die erste Ergebnisseite verarbeiten, dann die zweite Seite und so weiter.
Eine einzelne `Query` gibt nur einen Ergebnissatz zurück, der innerhalb des Grenzwerts von 1 MB liegt. Um zu bestimmen, ob es mehr Ergebnisse gibt, und diese seitenweise abzurufen, sollte eine Anwendung die folgenden Schritte ausführen:
1. Überprüfen Sie das `Query`-Low-Level-Ergebnis:
+ Wenn das Ergebnis ein `LastEvaluatedKey`-Element enthält und es ist ungleich null, fahren Sie mit Schritt 2 fort.
+ Wenn im Ergebnis *kein* `LastEvaluatedKey` vorhanden ist, sind keine Elemente mehr zum Abrufen vorhanden.
1. Erstellen Sie eine `Query` mit demselben `KeyConditionExpression`. Verwenden Sie jedoch dieses Mal den `LastEvaluatedKey`-Wert aus Schritt 1 als `ExclusiveStartKey`-Parameter in der neuen `Query`-Anforderung.
1. Führen Sie die neue `Query`-Anforderung aus.
1. Fahren Sie mit Schritt 1 fort.
Mit anderen Worten: Der `LastEvaluatedKey` einer `Query`-Antwort sollte als `ExclusiveStartKey` für die nächste `Query`-Anforderung verwendet werden. Wenn in einer `LastEvaluatedKey`-Antwort kein `Query`-Element vorhanden ist, haben Sie die letzte Ergebnisseite abgerufen. Wenn `LastEvaluatedKey` nicht leer ist, bedeutet dies nicht notwendigerweise, dass die Ergebnismenge mehr Daten enthält. Die einzige Möglichkeit zu erfahren, dass das Ende des Ergebnissatzes erreicht wurde, ist, dass `LastEvaluatedKey` leer ist.
Sie können das verwenden AWS CLI , um sich dieses Verhalten anzusehen. Der AWS CLI sendet wiederholt `Query` Anfragen auf niedriger Ebene an DynamoDB, bis er in den Ergebnissen nicht mehr vorhanden `LastEvaluatedKey` ist. Betrachten Sie das folgende AWS CLI Beispiel, in dem Filmtitel aus einem bestimmten Jahr abgerufen werden.
```
aws dynamodb query --table-name Movies \
--projection-expression "title" \
--key-condition-expression "#y = :yyyy" \
--expression-attribute-names '{"#y":"year"}' \
--expression-attribute-values '{":yyyy":{"N":"1993"}}' \
--page-size 5 \
--debug
```
Normalerweise AWS CLI verarbeitet der die Seitennummerierung automatisch. In diesem Beispiel begrenzt der AWS CLI `--page-size` Parameter jedoch die Anzahl der Elemente pro Seite. Der `--debug`-Parameter gibt Low-Level-Informationen zu Anforderungen und Antworten aus.
Wenn Sie das Beispiel ausführen, sieht die erste Antwort von DynamoDB ungefähr folgendermaßen aus.
```
2017-07-07 11:13:15,603 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":5,"Items":[{"title":{"S":"A Bronx Tale"}},
{"title":{"S":"A Perfect World"}},{"title":{"S":"Addams Family Values"}},
{"title":{"S":"Alive"}},{"title":{"S":"Benny & Joon"}}],
"LastEvaluatedKey":{"year":{"N":"1993"},"title":{"S":"Benny & Joon"}},
"ScannedCount":5}'
```
Der `LastEvaluatedKey` in der Antwort gibt an, dass nicht alle Elemente abgerufen wurden. Das sendet AWS CLI dann eine weitere `Query` Anfrage an DynamoDB. Dieses Anforderungs- und Antwortmuster wird bis zur endgültigen Antwort fortgesetzt.
```
2017-07-07 11:13:16,291 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":1,"Items":[{"title":{"S":"What\'s Eating Gilbert Grape"}}],"ScannedCount":1}'
```
Das Fehlen von `LastEvaluatedKey` gibt an, dass keine abrufbaren Elemente mehr vorhanden sind.
**Anmerkung**
Sie AWS SDKs verarbeiten DynamoDB-Antworten auf niedriger Ebene (einschließlich des Vorhandenseins oder Fehlens von`LastEvaluatedKey`) und bieten verschiedene Abstraktionen für die Paginierung von Ergebnissen. `Query` Beispielsweise stellt SDK für die Java-Dokumentschnittstelle `java.util.Iterator`-Unterstützung bereit, sodass Sie die Ergebnisse nacheinander durchgehen können.
Codebeispiele in verschiedenen Programmiersprachen finden Sie im [Amazon-DynamoDB-Handbuch für erste Schritte](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) und in der AWS SDK-Dokumentation für Ihre Sprache.
Sie können die Seitengröße auch reduzieren, indem Sie die Anzahl der Elemente in der Ergebnismenge mit dem `Limit`-Parameter der`Query`-Operation verwenden.
Weitere Informationen zur Verwendung der Abfrage mit DynamoDB finden Sie unter [Abfragen von Tabellen in DynamoDB](Query.md).
# Weitere Aspekte der Arbeit mit der Abfrage-Operation in DynamoDB
In diesem Abschnitt werden weitere Aspekte der DynamoDB-Abfrageoperation behandelt, darunter die Beschränkung der Ergebnisgröße, das Zählen gescannter gegenüber zurückgegebener Elemente, die Überwachung des Lesekapazitätsverbrauchs und die Steuerung der Lesekonsistenz.
## Begrenzung der Anzahl an Elementen in der Ergebnismenge
Die `Query`-Operation ermöglicht Ihnen, die Anzahl der Elemente einzuschränken, die gelesen werden. Legen Sie dazu den Parameter `Limit` auf die maximale Anzahl Elemente fest, die zurückgegeben werden sollen.
Beispiel: Sie führen eine `Query` für eine Tabelle mit einem `Limit`-Wert von `6` und ohne Filterausdruck durch. Das `Query`-Ergebnis enthält die ersten sechs Elemente der Tabelle, die mit dem Schlüsselbedingungsausdruck der Anforderung übereinstimmen.
Angenommen, Sie fügen nun einen Filterausdruck der `Query` hinzu. In diesem Fall liest DynamoDB bis zu sechs Elemente und gibt dann nur diejenigen zurück, die mit dem Filterausdruck übereinstimmen. Das `Query`-Endergebnis enthält sechs oder weniger Elemente, selbst wenn mehr Elemente mit dem Filterausdruck übereinstimmen würden, wenn DynamoDB weitere Elemente gelesen hätte.
## Zählen der Elemente in den Ergebnissen
Zusätzlich zu den Elementen, die mit Ihren Kriterien übereinstimmen, enthält die `Query`-Antwort noch die folgenden Elemente:
+ `ScannedCount` – die Anzahl der Elemente, die mit dem Schlüsselbedingungsausdruck übereinstimmten, *bevor* ein Filterausdruck (falls vorhanden) angewendet wurde.
+ `Count` – die Anzahl der Elemente, die verbleiben, *nachdem* ein Filterausdruck (falls vorhanden) angewendet wurde.
**Anmerkung**
Wenn Sie keinen Filterausdruck verwenden, haben `ScannedCount` und `Count` den gleichen Wert.
Wenn der `Query`-Ergebnissatz größer als 1 MB ist, repräsentieren `ScannedCount` und `Count` nur eine Teilmenge der Gesamtelemente. Sie müssen mehrere `Query`-Operationen ausführen, um alle Ergebnisse abzurufen (siehe [Paginieren von Tabellenabfrageergebnissen in DynamoDB](Query.Pagination.md)).
Jede `Query`-Antwort enthält die `ScannedCount` und `Count` für die Elemente, die von der betreffenden `Query`-Anforderung verarbeitet wurden. Um eine Gesamtsumme für alle `Query`-Anforderungen zu erhalten, könnten Sie eine laufende Zählung der Werte `ScannedCount` und `Count` vornehmen.
## Durch die Abfrage verbrauchte Kapazitätseinheiten
Sie können `Query` für jede Tabelle oder jeden sekundären Index verwenden, sofern Sie den Namen des Partitionsschlüsselattributs und einen einzelnen Wert für dieses Attribut angeben. `Query` gibt alle Elemente mit diesem Partitionsschlüsselwert zurück. Sie können optional ein Sortierschlüsselattribut angeben und einen Vergleichsoperator verwenden, um die Suchergebnisse zu verfeinern. `Query` API-Operationen verbrauchen Lesekapazitätseinheiten wie folgt.
****
| Wenn Sie `Query` eine ... | DynamoDB verbraucht Lesekapazitätseinheiten von ... |
| --- | --- |
| Tabelle | Die bereitgestellte Lesekapazität der Tabelle. |
| Globaler sekundärer Index | Die bereitgestellte Lesekapazität des Index. |
| Lokaler sekundärer Index | Die bereitgestellte Lesekapazität der Basistabelle. |
Standardmäßig gibt eine `Query`-Operation keine Daten über seinen Lesekapazitätsverbrauch zurück. Jedoch können Sie den `ReturnConsumedCapacity`-Parameter in einer `Query`-Anforderung angeben, um diese Information zu erhalten. Folgende sind die gültigen Einstellungen für `ReturnConsumedCapacity`:
+ `NONE` – Es werden keine verbrauchten Kapazitätsdaten zurückgegeben. (Dies ist die Standardeinstellung.)
+ `TOTAL` – Die Antwort enthält die zusammengefasste Anzahl der verbrauchten Lesekapazitätseinheiten.
+ `INDEXES` – Die Antwort zeigt die zusammengefasste Anzahl der verbrauchten Lesekapazitätseinheiten, zusammen mit der verbrauchten Kapazität für jede aufgerufene Tabelle und jeden aufgerufenen Index, an.
DynamoDB berechnet die Anzahl von verbrauchten Lesekapazitätseinheiten basierend auf der Anzahl und Größe der Elemente, nicht der Menge der Daten, die an eine Anwendung zurückgegeben werden. Aus diesem Grund bleibt die Anzahl der verbrauchten Kapazitätseinheiten gleich, unabhängig davon, ob Sie alle Attribute (das Standardverhalten) oder nur einige von ihnen anfordern (mithilfe eines Projektionsausdrucks). Die Anzahl ist auch gleich, unabhängig davon, ob Sie einen Filterausdruck verwenden oder nicht. `Query` verbraucht eine Mindestlesekapazitätseinheit für einen strikt konsistenten Lesevorgang pro Sekunde oder zwei letztendlich konsistente Lesevorgänge pro Sekunde für ein Element von bis zu 4 KB. Wenn Sie ein Element lesen möchten, das größer als 4 KB ist, benötigt DynamoDB zusätzliche Leseanforderungseinheiten. Bei leeren Tabellen und sehr großen Tabellen mit einer geringen Anzahl an Partitionsschlüsseln können zusätzliche RCUs Gebühren anfallen, die über die abgefragte Datenmenge hinausgehen. Dies deckt die Kosten für die `Query`-Bearbeitung der Anfrage, auch wenn keine Daten vorhanden sind.
## Lesekonsistenz für die Abfrage
Eine `Query`-Operation führt standardmäßig lEventually Consistent-Lesevorgänge aus. Dies bedeutet, dass die `Query`-Ergebnisse Änderungen aufgrund kürzlich abgeschlossener `PutItem` oder `UpdateItem`-Operationen, nicht wiedergeben könnten. Weitere Informationen finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).
Wenn Sie Strongly Consistent-Lesevorgänge benötigen, legen Sie den `ConsistentRead`-Parameter in der `Query`-Anforderung auf `true` fest.
# Scannen von Tabellen in DynamoDB
Eine `Scan`-Operation in Amazon DynamoDB liest jedes Element in einer Tabelle oder einem Sekundärindex. Standardmäßig gibt ein `Scan`-Vorgang für jedes Element in der Tabelle oder im Index alle Datenattribute zurück. Sie können den `ProjectionExpression`-Parameter verwenden, sodass `Scan` nur einige der Attribute und nicht alle zurückgibt.
`Scan` gibt immer einen Ergebnissatz zurück. Wenn keine übereinstimmenden Elemente gefunden werden, ist die Ergebnismenge leer.
Eine einzelne `Scan`-Anforderung kann maximal 1 MB Daten abrufen. DynamoDB kann optional einen Filterausdruck auf diese Daten anwenden, um die Ergebnisse einzugrenzen, bevor sie an den Benutzer zurückgegeben werden.
**Topics**
+ [Filterausdrücke für Scan](#Scan.FilterExpression)
+ [Begrenzung der Anzahl an Elementen in der Ergebnismenge](#Scan.Limit)
+ [Paginierung der Ergebnisse](#Scan.Pagination)
+ [Zählen der Elemente in den Ergebnissen](#Scan.Count)
+ [Durch die Abfrage verbrauchte Kapazitätseinheiten](#Scan.CapacityUnits)
+ [Lesekonsistenz für Scan](#Scan.ReadConsistency)
+ [Parallele Scans](#Scan.ParallelScan)
## Filterausdrücke für Scan
Wenn Sie die `Scan`-Ergebnisse weiter eingrenzen müssen, können Sie optional einen Filterausdruck angeben. Ein *Filterausdruck* bestimmt, welche Elemente in den `Scan`-Ergebnissen an Sie zurückgegeben werden. Alle anderen Ergebnisse werden verworfen.
Ein Filterausdruck wird angewendet, nachdem eine `Scan` abgeschlossen ist, aber bevor die Ergebnisse zurückgegeben werden. Folglich verbraucht eine `Scan` unabhängig davon, ob ein Filterausdruck vorhanden ist oder nicht, gleich viel Lesekapazität.
Eine `Scan`-Operation kann bis zu 1 MB an Daten abrufen. Diese Größenbeschränkung gilt, bevor der Filterausdruck ausgewertet wird.
Mit `Scan` können Sie Attribute in einem Filterausdruck angeben—einschließlich Partitionsschlüsseln und Sortierschlüsselattributen.
Die Syntax für einen Filterausdruck ist identisch mit der für einen Bedingungsausdruck. Filterausdrücke können dieselben Vergleichsoperatoren, Funktionen und logischen Operatoren wie ein Bedingungsausdruck verwenden. Weitere Informationen zu logischen Operatoren finden Sie unter [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md).
**Example**
Das folgende Beispiel AWS Command Line Interface (AWS CLI) scannt die `Thread` Tabelle und gibt nur die Elemente zurück, die zuletzt von einem bestimmten Benutzer gepostet wurden.
```
aws dynamodb scan \
--table-name Thread \
--filter-expression "LastPostedBy = :name" \
--expression-attribute-values '{":name":{"S":"User A"}}'
```
## Begrenzung der Anzahl an Elementen in der Ergebnismenge
Die `Scan`-Operation ermöglicht es Ihnen, die Anzahl der Elemente einzuschränken, die in den Ergebnissen zurückgegeben werden. Legen Sie dafür vor dem Filtern der Ausdrucksauswertung den Parameter `Limit` auf die maximale Anzahl von Elementen fest, die die `Scan`-Operation zurückgeben soll.
Beispiel: Sie führen eine `Scan`-Operation für eine Tabelle mit einem `Limit`-Wert von `6` und ohne Filterausdruck durch. Die`Scan`-Ergebnis enthält die ersten sechs Elemente der Tabelle.
Angenommen, Sie fügen nun einen Filterausdruck der `Scan` hinzu. In diesem Fall wendet DynamoDB den entsprechenden Filterausdruck auf die sechs zurückgegebenen Elemente an, wobei die nicht übereinstimmenden verworfen werden. Das letzte `Scan`-Ergebnis enthält sechs Elemente oder weniger, je nachdem, wie viele Elemente gefiltert wurden.
## Paginierung der Ergebnisse
DynamoDB *paginiert* die Ergebnisse von `Scan`-Operationen. Bei der Paginierung werden die `Scan`-Ergebnisse in „Seiten“ mit Daten von einer Größe von 1 MB (oder weniger) unterteilt. Eine Anwendung kann die erste Ergebnisseite verarbeiten, dann die zweite Seite und so weiter.
Eine einzelne `Scan`-Operation gibt nur einen Ergebnissatz zurück, der innerhalb des Grenzwerts von 1 MB liegt.
Um zu bestimmen, ob es mehr Ergebnisse gibt, und diese seitenweise abzurufen, sollten Anwendungen die folgenden Schritte ausführen:
1. Überprüfen Sie das `Scan`-Low-Level-Ergebnis:
+ Wenn das Ergebnis ein `LastEvaluatedKey`-Element enthält, fahren Sie mit Schritt 2 fort.
+ Wenn im Ergebnis *kein* `LastEvaluatedKey` vorhanden ist, sind keine Elemente mehr zum Abrufen vorhanden.
1. Erstellen Sie eine neue `Scan`-Anforderung mit den gleichen Parametern wie bei der vorherigen Anforderung. Verwenden Sie jedoch dieses Mal den `LastEvaluatedKey`-Wert aus Schritt 1 als `ExclusiveStartKey`-Parameter in der neuen `Scan`-Anforderung.
1. Führen Sie die neue `Scan`-Anforderung aus.
1. Fahren Sie mit Schritt 1 fort.
Mit anderen Worten: Der `LastEvaluatedKey` einer `Scan`-Antwort sollte als `ExclusiveStartKey` für die nächste `Scan`-Anforderung verwendet werden. Wenn in einer `Scan`-Antwort kein `LastEvaluatedKey`-Element vorhanden ist, haben Sie die letzte Ergebnisseite abgerufen. (Dass `LastEvaluatedKey` nicht vorhanden ist, ist der einzige Hinweis darauf, dass Sie das Ende des Ergebnissatzes erreicht haben.)
Sie können das verwenden AWS CLI , um sich dieses Verhalten anzusehen. Der AWS CLI sendet wiederholt `Scan` Anfragen auf niedriger Ebene an DynamoDB, bis er in den Ergebnissen nicht mehr vorhanden `LastEvaluatedKey` ist. Stellen Sie sich das folgende AWS CLI Beispiel vor, das die gesamte `Movies` Tabelle scannt, aber nur die Filme eines bestimmten Genres zurückgibt.
```
aws dynamodb scan \
--table-name Movies \
--projection-expression "title" \
--filter-expression 'contains(info.genres,:gen)' \
--expression-attribute-values '{":gen":{"S":"Sci-Fi"}}' \
--page-size 100 \
--debug
```
Normalerweise AWS CLI verarbeitet der die Seitennummerierung automatisch. In diesem Beispiel begrenzt der AWS CLI `--page-size` Parameter jedoch die Anzahl der Elemente pro Seite. Der `--debug`-Parameter gibt Low-Level-Informationen zu Anforderungen und Antworten aus.
**Anmerkung**
Ihre Paginierungsergebnisse unterscheiden sich auch basierend auf den Eingabeparametern, die Sie übergeben.
Die Verwendung von `aws dynamodb scan --table-name Prices --max-items 1` gibt `NextToken` zurück.
Die Verwendung von `aws dynamodb scan --table-name Prices --limit 1` gibt `LastEvaluatedKey` zurück.
Beachten Sie auch, dass insbesondere die Verwendung von `--starting-token` den Wert `NextToken` erfordert.
Wenn Sie das Beispiel ausführen, sieht die erste Antwort von DynamoDB ungefähr folgendermaßen aus.
```
2017-07-07 12:19:14,389 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":7,"Items":[{"title":{"S":"Monster on the Campus"}},{"title":{"S":"+1"}},
{"title":{"S":"100 Degrees Below Zero"}},{"title":{"S":"About Time"}},{"title":{"S":"After Earth"}},
{"title":{"S":"Age of Dinosaurs"}},{"title":{"S":"Cloudy with a Chance of Meatballs 2"}}],
"LastEvaluatedKey":{"year":{"N":"2013"},"title":{"S":"Curse of Chucky"}},"ScannedCount":100}'
```
Der `LastEvaluatedKey` in der Antwort gibt an, dass nicht alle Elemente abgerufen wurden. Das sendet AWS CLI dann eine weitere `Scan` Anfrage an DynamoDB. Dieses Anforderungs- und Antwortmuster wird bis zur endgültigen Antwort fortgesetzt.
```
2017-07-07 12:19:17,830 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":1,"Items":[{"title":{"S":"WarGames"}}],"ScannedCount":6}'
```
Das Fehlen von `LastEvaluatedKey` gibt an, dass keine abrufbaren Elemente mehr vorhanden sind.
**Anmerkung**
Sie AWS SDKs verarbeiten DynamoDB-Antworten auf niedriger Ebene (einschließlich des Vorhandenseins oder Fehlens von`LastEvaluatedKey`) und bieten verschiedene Abstraktionen für die Paginierung von Ergebnissen. `Scan` Beispielsweise stellt SDK für die Java-Dokumentschnittstelle `java.util.Iterator`-Unterstützung bereit, sodass Sie die Ergebnisse nacheinander durchgehen können.
Codebeispiele in verschiedenen Programmiersprachen finden Sie im [Amazon-DynamoDB-Handbuch für erste Schritte](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) und in der AWS SDK-Dokumentation für Ihre Sprache.
## Zählen der Elemente in den Ergebnissen
Zusätzlich zu den Elementen, die mit Ihren Kriterien übereinstimmen, enthält die `Scan`-Antwort noch die folgenden Elemente:
+ `ScannedCount` – Anzahl der ausgewerteten Elemente vor jedem `ScanFilter` angewendet wird. Ein hoher `ScannedCount`-Wert mit wenigen oder gar keinen `Count`-Ergebnissen weist auf eine ineffiziente `Scan`-Operation hin. Wenn Sie keinen Filter in der Anforderung verwendet haben, haben `ScannedCount` und `Count` denselben Wert.
+ `Count` – die Anzahl der Elemente, die verbleiben, *nachdem* ein Filterausdruck (falls vorhanden) angewendet wurde.
**Anmerkung**
Wenn Sie keinen Filterausdruck verwenden, haben `ScannedCount` und `Count` denselben Wert.
Wenn der `Scan`-Ergebnissatz größer als 1 MB ist, repräsentieren `ScannedCount` und `Count` nur eine Teilmenge der Gesamtelemente. Sie müssen mehrere `Scan`-Operationen ausführen, um alle Ergebnisse abzurufen (siehe [Paginierung der Ergebnisse](#Scan.Pagination)).
Jede `Scan`-Antwort enthält die `ScannedCount` und `Count` für die Elemente, die von der betreffenden `Scan`-Anforderung verarbeitet wurden. Um eine Gesamtsumme für alle `Scan`-Anforderungen zu erhalten, könnten Sie eine laufende Zählung von `ScannedCount` und `Count` vornehmen.
## Durch die Abfrage verbrauchte Kapazitätseinheiten
Sie können `Scan` für jede Tabelle und jeden Sekundärindex ausführen. `Scan`-Operationen verbrauchen Lesekapazitätseinheiten wie folgt.
****
| Wenn Sie `Scan` eine ... | DynamoDB verbraucht Lesekapazitätseinheiten von ... |
| --- | --- |
| Tabelle | Die bereitgestellte Lesekapazität der Tabelle. |
| Globaler sekundärer Index | Die bereitgestellte Lesekapazität des Index. |
| Lokaler sekundärer Index | Die bereitgestellte Lesekapazität der Basistabelle. |
**Anmerkung**
Kontoübergreifender Zugriff für sekundäre Indexscanvorgänge wird derzeit nicht für [ressourcenbasierte Richtlinien](access-control-resource-based.md) unterstützt.
Standardmäßig gibt eine `Scan`-Operation keine Daten über seinen Lesekapazitätsverbrauch zurück. Jedoch können Sie den `ReturnConsumedCapacity`-Parameter in einer `Scan`-Anforderung angeben, um diese Information zu erhalten. Folgende sind die gültigen Einstellungen für `ReturnConsumedCapacity`:
+ `NONE` – Es werden keine verbrauchten Kapazitätsdaten zurückgegeben. (Dies ist die Standardeinstellung.)
+ `TOTAL` – Die Antwort enthält die zusammengefasste Anzahl der verbrauchten Lesekapazitätseinheiten.
+ `INDEXES` – Die Antwort zeigt die zusammengefasste Anzahl der verbrauchten Lesekapazitätseinheiten, zusammen mit der verbrauchten Kapazität für jede aufgerufene Tabelle und jeden aufgerufenen Index, an.
DynamoDB berechnet die Anzahl von verbrauchten Lesekapazitätseinheiten basierend auf der Anzahl und Größe der Elemente, nicht der Menge der Daten, die an eine Anwendung zurückgegeben werden. Aus diesem Grund bleibt die Anzahl der verbrauchten Kapazitätseinheiten gleich, unabhängig davon, ob Sie alle Attribute (das Standardverhalten) oder nur einige von ihnen anfordern (mithilfe eines Projektionsausdrucks). Die Anzahl ist auch gleich, unabhängig davon, ob Sie einen Filterausdruck verwenden oder nicht. `Scan` verbraucht eine Mindestlesekapazitätseinheit für einen strikt konsistenten Lesevorgang pro Sekunde oder zwei letztendlich konsistente Lesevorgänge pro Sekunde für ein Element von bis zu 4 KB. Wenn Sie ein Element lesen möchten, das größer als 4 KB ist, benötigt DynamoDB zusätzliche Leseanforderungseinheiten. Bei leeren Tabellen und sehr großen Tabellen mit einer geringen Anzahl an Partitionsschlüsseln können zusätzliche RCUs Gebühren anfallen, die über die Menge der gescannten Daten hinausgehen. Damit werden die Kosten für die Bearbeitung der `Scan`-Anfrage gedeckt, auch wenn keine Daten vorhanden sind.
## Lesekonsistenz für Scan
Eine `Scan`-Operation führt standardmäßig lEventually Consistent-Lesevorgänge aus. Dies bedeutet, dass die `Scan`-Ergebnisse Änderungen aufgrund kürzlich abgeschlossener `PutItem` oder `UpdateItem`-Operationen, nicht wiedergeben könnten. Weitere Informationen finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).
Wenn Sie Strongly Consistent-Lesevorgänge benötigen, setzen Sie zum Zeitpunkt, an dem der `Scan` beginnt, den `ConsistentRead`-Parameter in der `Scan`-Anforderung auf `true`. Dadurch wird sichergestellt, dass alle Schreibvorgänge, die vor `Scan`-Beginn abgeschlossen wurden, in die `Scan`-Antwort aufgenommen werden.
Die Festlegung von `ConsistentRead` für `true` kann beim Backup von Tabellen oder in Replikationsszenarien mit [DynamoDB Streams](./Streams.html) hilfreich sein. Sie verwenden zuerst `Scan`, während `ConsistentRead` auf "true" eingestellt ist, um eine konsistente Kopie der Daten in der Tabelle zu erhalten. Während der `Scan`-Operation zeichnet DynamoDB Streams alle zusätzlichen Schreibaktivitäten auf, die in der Tabelle ausgeführt werden. Nach Abschluss der `Scan` können Sie die Schreibaktivität vom Stream auf die Tabelle anwenden.
**Anmerkung**
Beachten Sie, dass eine `Scan`-Operation, bei der `ConsistentRead` auf `true` festgelegt ist, doppelt so viele Lesekapazitätseinheiten verbraucht wie mit dem `ConsistentRead`-Standardwert (`false`).
## Parallele Scans
Standardmäßig verarbeitet die `Scan`-Operation Daten sequenziell. Amazon DynamoDB gibt Daten in Schritten von 1 MB an die Anwendung zurück, und eine Anwendung führt zusätzliche `Scan`-Operationen aus, um die nächsten 1 MB Daten abzurufen.
Je größer die gescannte Tabelle oder der Index, desto mehr Zeit benötigt `Scan` um zu beenden. Außerdem kann eine sequenzielle `Scan` möglicherweise die bereitgestellte Lesedurchsatzkapazität nicht immer vollständig nutzen: Auch wenn DynamoDB die Daten einer großen Tabelle über mehrere physische Partitionen verteilt, kann eine `Scan`-Operation nur jeweils eine Partition lesen. Aus diesem Grund wird der Durchsatz einer `Scan`-Operation durch den maximalen Durchsatz einer einzelnen Partition beschränkt.
Um diese Probleme zu beheben, kann die `Scan`-Operation eine Tabelle oder einen sekundären Index in mehrere *Segmente* logisch unterteilen, wobei mehrere Anwendungs-Worker die Segmente parallel scannen. Jeder Worker kann ein Thread (in Programmiersprachen, die Multithreading unterstützen) oder ein Betriebssystemprozess sein. Zum Durchführen eines parallelen Scans erstellt jeder Worker eine eigene `Scan`-Anforderung mit den folgenden Parametern:
+ `Segment` – Ein Segment, das von einem bestimmten Worker gescannt werden soll. Jeder Worker sollte einen anderen Wert für `Segment` verwenden.
+ `TotalSegments` – Die Gesamtanzahl der Segmente für den parallelen Scan. Dieser Wert muss mit der Anzahl der Worker übereinstimmen, die Ihre Anwendung verwenden wird.
Das folgende Diagramm zeigt, wie eine Multithread-Anwendung eine parallele `Scan`-Operation mit drei Grad Parallelität ausführt.
![\[Eine Multithread-Anwendung, die einen parallelen Scan durchführt, indem sie eine Tabelle in drei Segmente unterteilt.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/ParallelScan.png)
In diesem Diagramm ruft die Anwendung drei Threads auf und weist jedem Thread eine Zahl zu. (Segmente sind nullbasiert, sodass die erste Zahl immer 0 ist.) Jeder Thread erstellt eine `Scan`-Anforderung, mit der `Segment` auf die zugewiesene Zahl und `TotalSegments` auf 3 eingestellt wird. Jeder Thread scannt ein zugewiesenes Segment, indem 1 MB Daten abgerufen werden, und gibt die Daten an den Haupt-Thread der Anwendung zurück.
DynamoDB weist Elemente *Segmenten* zu, indem es eine Hash-Funktion auf den Partitionsschlüssel jedes Elements anwendet. Bei einem bestimmten `TotalSegments` Wert werden alle Elemente mit demselben Partitionsschlüssel immer demselben zugewiesen. `Segment` Das bedeutet, dass in einer Tabelle, in der sich *Element 1**, Element 2* *und Element 3* alle teilen `pk="account#123"` (aber unterschiedliche Sortierschlüssel haben), diese Elemente von demselben Worker verarbeitet werden, unabhängig von den Sortierschlüsselwerten oder der Größe der *Elementsammlung*.
Da die *Segmentzuweisung* ausschließlich auf dem Hash des Partitionsschlüssels basiert, können Segmente ungleichmäßig verteilt sein. Einige Segmente enthalten möglicherweise keine Elemente, während andere viele Partitionsschlüssel mit großen Elementsammlungen enthalten können. Daher garantiert eine Erhöhung der Gesamtzahl der Segmente keine schnellere Scanleistung, insbesondere wenn die Partitionsschlüssel nicht gleichmäßig über den Schlüsselraum verteilt sind.
Die Werte für `Segment` und `TotalSegments` gelten für einzelne `Scan`-Anforderungen. Sie können jederzeit andere Werte verwenden. Sie müssen ggf. mit diesen Werten und der Anzahl der verwendeten Worker experimentieren, bis Ihre Anwendung eine optimale Leistung erzielt.
**Anmerkung**
Ein paralleler Scan mit einer großen Anzahl von Workern kann leicht den gesamten bereitgestellten Durchsatz für die Tabelle oder den Index, die bzw. der gescannt wird, verbrauchen. Es ist am besten, solche Scans zu verhindern, wenn für die Tabelle oder den Index auch viele Lese- und Schreibaktivitäten von anderen Anwendungen erfolgen.
Zur Steuerung der Datenmenge, die pro Anforderung zurückgegeben wird, verwenden Sie den Parameter `Limit`. Auf diese Weise können Sie Situationen verhindern, in denen ein Worker den gesamten bereitgestellten Durchsatz auf Kosten aller anderen Worker verbraucht.
# PartiQL – Eine SQL-kompatible Abfragesprache für Amazon DynamoDB
Amazon DynamoDB unterstützt [PartiQL](https://partiql.org/), eine SQL-kompatible Abfragesprache, um Daten in Amazon DynamoDB auszuwählen, einzufügen, zu aktualisieren und zu löschen. Mit PartiQL können Sie problemlos mit DynamoDB-Tabellen interagieren und Ad-hoc-Abfragen mithilfe von NoSQL Workbench und DynamoDB for PartiQL ausführen. AWS-Managementkonsole AWS Command Line Interface APIs
PartiQL-Operationen bieten die gleiche Verfügbarkeit, Latenz und Performance wie die anderen DynamoDB-Datenebenen-Operationen.
In den folgenden Abschnitten wird die DynamoDB-Implementierung von PartiQL beschrieben.
**Topics**
+ [Was ist PartiQL?](#ql-reference.what-is)
+ [PartiQL in Amazon DynamoDB](#ql-reference.what-is)
+ [Erste Schritte](ql-gettingstarted.md)
+ [Datentypen](ql-reference.data-types.md)
+ [Anweisungen](ql-reference.statements.md)
+ [Funktionen](ql-functions.md)
+ [Betreiber](ql-operators.md)
+ [Transaktionen](ql-reference.multiplestatements.transactions.md)
+ [Batch-Vorgänge](ql-reference.multiplestatements.batching.md)
+ [IAM-Richtlinien](ql-iam.md)
## Was ist PartiQL?
*PartiQL* bietet SQL-kompatiblen Abfragezugriff über mehrere Datenspeicher mit strukturierten, halbstrukturierten und verschachtelten Daten hinweg. Es ist bei Amazon weit verbreitet und ist jetzt als Teil vieler AWS Dienste verfügbar, einschließlich DynamoDB.
Die PartiQL-Spezifikation und ein Tutorial zur Core-Abfragesprache finden Sie in der [PartiQL-Dokumentation](https://partiql.org/docs.html).
**Anmerkung**
Amazon DynamoDB unterstützt eine *Teilmenge* der [PartiQL](https://partiql.org/)-Abfragesprache.
Amazon DynamoDB unterstützt das [Amazon-Ion](http://amzn.github.io/ion-docs/)-Datenformat oder Amazon-Ion-Literale nicht.
## PartiQL in Amazon DynamoDB
Zum Ausführen von PartiQL-Abfragen in DynamoDB können Sie Folgendes verwenden:
+ Die DynamoDB-Konsole
+ NoSQL Workbench
+ Das AWS Command Line Interface ()AWS CLI
+ Die DynamoDB APIs
Weitere Informationen zum Verwenden dieser Methoden für den Zugriff auf DynamoDB finden Sie unter [Zugreifen auf DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html).
# Erste Schritte mit PartiQL für DynamoDB
In diesem Abschnitt wird beschrieben, wie PartiQL für DynamoDB von der Amazon DynamoDB DynamoDB-Konsole, der AWS Command Line Interface ()AWS CLI und DynamoDB aus verwendet wird. APIs
In den folgenden Beispielen ist die DynamoDB-Tabelle, die im Tutorial [Erste Schritte mit DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) definiert ist, eine Voraussetzung.
[Informationen zur Verwendung der DynamoDB-Konsole oder DynamoDB für den Zugriff auf DynamoDB finden Sie unter APIs Accessing DynamoDB. AWS Command Line Interface](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html)
Um die [NoSQL Workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) [herunterzuladen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) und zu verwenden, um [PartiQL for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (PartiQL für DynamoDB) Anweisungen zu erstellen, wählen Sie **PartiQL operations** (PartiQL-Operationen) in der oberen rechten Ecke der NoSQL Workbench für DynamoDB [Operation Builder](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html).
------
#### [ Console ]
![\[PartiQL-Editor-Schnittstelle, die das Ergebnis der Abfrage-Operation in der Tabelle Music anzeigt.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png)
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Wählen Sie im Navigationsbereich auf der linken Seite der Konsole **PartiQL editor** (PartiQL-Editor) aus.
1. Wählen Sie die Tabelle **Music** (Musik).
1. Klicken Sie auf die **Query table** (Abfragetabelle). Diese Aktion generiert eine Abfrage, die nicht zu einem vollständigen Tabellenscan führt.
1. ErsetzenSie `partitionKeyValue` mit dem Zeichenfolgen-Wert `Acme Band`. ErsetzenSie `sortKeyValue` mit dem Zeichenfolgen-Wert `Happy Day`.
1. Wählen Sie die Schaltfläche **Run** (Ausführen) aus.
1. Sie können die Ergebnisse der Abfrage anzeigen, indem Sie die Schaltflächen **Table view** (Tabellenansicht) oder **JSON view** (JSON-Ansicht) auswählen.
------
#### [ NoSQL workbench ]
![\[NoSQL Workbench-Schnittstelle. Sie zeigt eine PartiQL SELECT-Anweisung, die Sie in der Tabelle Music ausführen können.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png)
1. Klicken Sie auf **PartiQL statement** (PartiQL-Anweisung).
1. Geben Sie die folgende PartiQL-[SELECT-Anweisung](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) ein
```
SELECT *
FROM Music
WHERE Artist=? and SongTitle=?
```
1. So geben Sie einen Wert für den `Artist`- und `SongTitle`-Parameter ein:
1. Klicken Sie auf **Optional request parameter** (Optionale Anfrageparameter).
1. Klicken Sie auf **Add new parameters** (Fügen Sie neue Parameter hinzu).
1. Wählen Sie den Attributtyp **string** (Zeichenfolge) und den Wert `Acme Band`.
1. Wiederholen Sie die Schritte b und c, und wählen Sie den Typ **string** (Zeichenfolge) und den Wert `PartiQL Rocks`.
1. Falls Sie Code generieren möchten, wählen Sie **Generate code** (Code generieren) aus.
Wählen Sie in den angezeigten Tabs Ihre gewünschte Sprache aus. Sie können diesen Code jetzt kopieren und in Ihrer Anwendung verwenden.
1. Falls die Operation sofort ausgeführt werden soll, wählen Sie **Run** (Ausführen).
------
#### [ AWS CLI ]
1. Erstellen Sie mit der INSERT-PartiQL-Anweisung ein Element in der Tabelle `Music`.
```
aws dynamodb execute-statement --statement "INSERT INTO Music \
VALUE \
{'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}"
```
1. Rufen Sie mit der SELECT-PartiQL-Anweisung ein Element aus der Musiktabelle ab.
```
aws dynamodb execute-statement --statement "SELECT * FROM Music \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
1. Aktualisieren Sie ein Element in der Tabelle `Music` mit der UPDATE-PartiQL-Anweisung.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AwardsWon=1 \
SET AwardDetail={'Grammys':[2020, 2018]} \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Fügen Sie einen Listenwert für ein Element in der `Music`-Tabelle ein
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Entfernen Sie einen Listenwert für ein Element in der `Music`-Tabelle
```
aws dynamodb execute-statement --statement "UPDATE Music \
REMOVE AwardDetail.Grammys[2] \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Fügen Sie ein neues Kartenelement für ein Element in der `Music`-Tabelle ein
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AwardDetail.BillBoard=[2020] \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Fügen Sie ein neues Zeichenfolgensatzattribut für ein Element in der `Music`-Tabelle hinzu.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET BandMembers =<<'member1', 'member2'>> \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Aktualisieren Sie ein neues Zeichenfolgensatzattribut für ein Element in der `Music`-Tabelle-
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET BandMembers =set_add(BandMembers, <<'newmember'>>) \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
1. Löschen Sie ein Element aus dem`Music`-Tabelle mit der DELETE-PartiQL-Anweisung.
```
aws dynamodb execute-statement --statement "DELETE FROM Music \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
------
#### [ Java ]
```
import java.util.ArrayList;
import java.util.List;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import software.amazon.dynamodb.AmazonDynamoDB;
import software.amazon.dynamodb.AmazonDynamoDBClientBuilder;
import software.amazon.dynamodb.model.AttributeValue;
import software.amazon.dynamodb.model.ConditionalCheckFailedException;
import software.amazon.dynamodb.model.ExecuteStatementRequest;
import software.amazon.dynamodb.model.ExecuteStatementResult;
import software.amazon.dynamodb.model.InternalServerErrorException;
import software.amazon.dynamodb.model.ItemCollectionSizeLimitExceededException;
import software.amazon.dynamodb.model.ProvisionedThroughputExceededException;
import software.amazon.dynamodb.model.RequestLimitExceededException;
import software.amazon.dynamodb.model.ResourceNotFoundException;
import software.amazon.dynamodb.model.TransactionConflictException;
public class DynamoDBPartiQGettingStarted {
public static void main(String[] args) {
// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1");
try {
// Create ExecuteStatementRequest
ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest();
List parameters= getPartiQLParameters();
//Create an item in the Music table using the INSERT PartiQL statement
processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value {'Artist':?,'SongTitle':?}", parameters));
//Retrieve an item from the Music table using the SELECT PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters));
//Update an item in the Music table using the UPDATE PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?", parameters));
//Add a list value for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and SongTitle=?", parameters));
//Remove a list value for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters));
//Add a new map member for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music set AwardDetail.BillBoard=[2020] where Artist=? and SongTitle=?", parameters));
//Add a new string set attribute for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters));
//update a string set attribute for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =set_add(BandMembers, <<'newmember'>>) where Artist=? and SongTitle=?", parameters));
//Retrieve an item from the Music table using the SELECT PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters));
//delete an item from the Music Table
processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where Artist=? and SongTitle=?", parameters));
} catch (Exception e) {
handleExecuteStatementErrors(e);
}
}
private static AmazonDynamoDB createDynamoDbClient(String region) {
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
private static List getPartiQLParameters() {
List parameters = new ArrayList();
parameters.add(new AttributeValue("Acme Band"));
parameters.add(new AttributeValue("PartiQL Rocks"));
return parameters;
}
private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB client, String statement, List parameters ) {
ExecuteStatementRequest request = new ExecuteStatementRequest();
request.setStatement(statement);
request.setParameters(parameters);
return client.executeStatement(request);
}
private static void processResults(ExecuteStatementResult executeStatementResult) {
System.out.println("ExecuteStatement successful: "+ executeStatementResult.toString());
}
// Handles errors during ExecuteStatement execution. Use recommendations in error messages below to add error handling specific to
// your application use-case.
private static void handleExecuteStatementErrors(Exception exception) {
try {
throw exception;
} catch (ConditionalCheckFailedException ccfe) {
System.out.println("Condition check specified in the operation failed, review and update the condition " +
"check before retrying. Error: " + ccfe.getErrorMessage());
} catch (TransactionConflictException tce) {
System.out.println("Operation was rejected because there is an ongoing transaction for the item, generally " +
"safe to retry with exponential back-off. Error: " + tce.getErrorMessage());
} catch (ItemCollectionSizeLimitExceededException icslee) {
System.out.println("An item collection is too large, you\'re using Local Secondary Index and exceeded " +
"size limit of items per partition key. Consider using Global Secondary Index instead. Error: " + icslee.getErrorMessage());
} catch (Exception e) {
handleCommonErrors(e);
}
}
private static void handleCommonErrors(Exception exception) {
try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " +
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage());
}
}
}
```
------
## Verwenden von parametrisierten Anweisungen
Anstatt Werte direkt in eine PartiQL-Anweisungszeichenfolge einzubetten, können Sie Fragezeichen-Platzhalter (`?`) verwenden und die Werte separat in das Feld eingeben. `Parameters` Jeder Wert `?` wird durch den entsprechenden Parameterwert ersetzt, und zwar in der Reihenfolge, in der er angegeben wurde.
Die Verwendung parametrisierter Anweisungen ist eine bewährte Methode, da sie die Anweisungsstruktur von den Datenwerten trennt, sodass Anweisungen leichter zu lesen und wiederzuverwenden sind. Außerdem müssen Attributwerte in der Anweisungszeichenfolge nicht manuell formatiert und maskiert werden.
Parametrisierte Anweisungen werden in `ExecuteStatement``BatchExecuteStatement`, und `ExecuteTransaction` -Operationen unterstützt.
In den folgenden Beispielen wird mithilfe parametrisierter Werte für den Partitionsschlüssel und den Sortierschlüssel ein Element aus der `Music` Tabelle abgerufen.
------
#### [ AWS CLI parameterized ]
```
aws dynamodb execute-statement \
--statement "SELECT * FROM \"Music\" WHERE Artist=? AND SongTitle=?" \
--parameters '[{"S": "Acme Band"}, {"S": "PartiQL Rocks"}]'
```
------
#### [ Java parameterized ]
```
List parameters = new ArrayList<>();
parameters.add(new AttributeValue("Acme Band"));
parameters.add(new AttributeValue("PartiQL Rocks"));
ExecuteStatementRequest request = new ExecuteStatementRequest()
.withStatement("SELECT * FROM Music WHERE Artist=? AND SongTitle=?")
.withParameters(parameters);
ExecuteStatementResult result = dynamoDB.executeStatement(request);
```
------
#### [ Python parameterized ]
```
response = dynamodb_client.execute_statement(
Statement="SELECT * FROM Music WHERE Artist=? AND SongTitle=?",
Parameters=[
{'S': 'Acme Band'},
{'S': 'PartiQL Rocks'}
]
)
```
------
**Anmerkung**
Das Java-Beispiel im vorherigen Abschnitt „Erste Schritte“ verwendet durchweg parametrisierte Anweisungen. Die `getPartiQLParameters()` Methode erstellt die Parameterliste, und jede Anweisung verwendet `?` Platzhalter anstelle von Inline-Werten.
# PartiQL-Datentypen für DynamoDB
In der folgenden Tabelle sind die Datentypen aufgeführt, die Sie mit PartiQL für DynamoDB verwenden können.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/ql-reference.data-types.html)
## Beispiele
Die folgende Anweisung veranschaulicht, wie die folgenden Datentypen eingefügt werden: `String`, `Number`, `Map`, `List`, `Number Set` und `String Set`.
```
INSERT INTO TypesTable value {'primarykey':'1',
'NumberType':1,
'MapType' : {'entryname1': 'value', 'entryname2': 4},
'ListType': [1,'stringval'],
'NumberSetType':<<1,34,32,4.5>>,
'StringSetType':<<'stringval','stringval2'>>
}
```
Die folgende Anweisung veranschaulicht, wie neue Elemente in die `Map`, `List`, `Number Set` und `String Set`-Typen eingefügt werden und den Wert eines `Number`-Typ ändern.
```
UPDATE TypesTable
SET NumberType=NumberType + 100
SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4]
SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>])
SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>)
SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>)
WHERE primarykey='1'
```
Die folgende Anweisung veranschaulicht, wie neue Elemente aus den `Map`, `List`, `Number Set` und `String Set`-Typen entfernt werden und den Wert eines `Number`-Typ ändern.
```
UPDATE TypesTable
SET NumberType=NumberType - 1
REMOVE ListType[1]
REMOVE MapType.NewMapEntry
SET NumberSetType = SET_DELETE( NumberSetType, <<345>>)
SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>)
WHERE primarykey='1'
```
Weitere Informationen finden Sie unter [DynamoDB-Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes).
# PartiQL-Anweisungen für DynamoDB
Amazon DynamoDB unterstützt die folgenden PartiQL-Anweisungen.
**Anmerkung**
DynamoDB unterstützt nicht alle PartiQL-Anweisungen.
Diese Referenz enthält grundlegende Syntax- und Verwendungsbeispiele für PartiQL-Anweisungen, die Sie manuell mit dem AWS CLI oder APIs ausführen.
*Data Manipulation Language* (DML) ist die Gruppe von PartiQL-Anweisungen, die Sie zum Verwalten von Daten in DynamoDB-Tabellen verwenden. Sie verwenden DML-Anweisungen, um Daten in einer Tabelle hinzuzufügen, zu ändern oder zu löschen.
Die folgenden Anweisungen für DML- und Abfragesprachen werden unterstützt:
+ [PartiQL-Select-Anweisungen für DynamoDB](ql-reference.select.md)
+ [Aktualisierungen für PartiQL-Anweisungen für DynamoDB](ql-reference.update.md)
+ [PartiQL-Insert-Anweisungen für DynamoDB](ql-reference.insert.md)
+ [PartiQL-Delete-Anweisungen für DynamoDB](ql-reference.delete.md)
[Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) und [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md) werden auch von PartiQL für DynamoDB unterstützt.
# PartiQL-Select-Anweisungen für DynamoDB
Verwenden Sie die `SELECT`-Anweisung zum Abrufen von Daten aus einer Tabelle in Amazon DynamoDB.
Die Verwendung der `SELECT`-Anweisung kann zu einem vollständigen Tabellenscan führen, wenn in der WHERE-Klausel keine Gleichheitsbedingung oder IN-Bedingung mit einem Partitionsschlüssel angegeben ist. Die Scan-Operation untersucht jedes Element auf die angeforderten Werte und kann den bereitgestellten Durchsatz für eine große Tabelle oder Index in einer einzigen Operation verbrauchen.
Wenn Sie den vollständigen Tabellenscan in PartiQL vermeiden möchten, können Sie:
+ Erstellen Sie Ihre `SELECT`-Anweisungen so, dass keine vollständigen Tabellenscans durchgeführt werden, indem Sie sicherstellen, dass die Bedingung der [WHERE-Klausel entsprechend](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) konfiguriert ist.
+ Deaktivieren Sie vollständige Tabellenscans mithilfe der IAM-Richtlinie, die unter [Beispiel: In PartiQL für DynamoDB Select-Anweisungen erlauben und vollständige Tabellenscan-Anweisungen verweigern](ql-iam.md#access-policy-ql-iam-example6) im DynamoDB-Entwicklerhandbuch.
Weitere Informationen finden Sie unter [Bewährte Methoden für das Abfragen und Scannen von Daten](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html) im DynamoDB-Entwicklerhandbuch.
**Topics**
+ [Syntax](#ql-reference.select.syntax)
+ [Parameters](#ql-reference.select.parameters)
+ [Beispiele](#ql-reference.select.examples)
## Syntax
```
SELECT expression [, ...]
FROM table[.index]
[ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...]
```
## Parameters
***expression***
(erforderlich) Eine Projektion aus dem `*`-Platzhalter oder eine Projektionsliste aus einem oder mehreren Attributnamen oder Dokumentpfaden aus dem Ergebnissatz. Ein Ausdruck kann aus Aufrufen an [Verwenden von PartiQL-Funktionen mit DynamoDB](ql-functions.md) oder Feldern bestehen, die von [PartiQL-Arithmetik-, Vergleichs- und logische Operatoren für DynamoDB](ql-operators.md) geändert werden.
***table***
(Erforderlich) Der abzufragende Tabellenname.
***index***
(Optional) Der Name des abzufragenden Indexes.
Sie müssen dem Tabellennamen und dem Indexnamen doppelte Anführungszeichen hinzufügen, wenn Sie einen Index abfragen.
```
SELECT *
FROM "TableName"."IndexName"
```
***condition***
(Optional) Die Auswahlkriterien für die Abfrage.
Um sicherzustellen, dass eine `SELECT`-Anweisung nicht zu einem vollständigen Tabellenscan führt, muss die `WHERE`-Klauselbedingung einen Partitionsschlüssel angeben. Verwenden Sie den Gleichheits- oder IN-Operator.
Angenommen, Sie haben eine `Orders`-Tabelle mit `OrderID`-Partitionsschlüssel und andere Nicht-Schlüsselattribute, einschließlich eines `Address`, würden die folgenden Anweisungen nicht zu einem vollständigen Tabellenscan führen:
```
SELECT *
FROM "Orders"
WHERE OrderID = 100
SELECT *
FROM "Orders"
WHERE OrderID = 100 and Address='some address'
SELECT *
FROM "Orders"
WHERE OrderID = 100 or OrderID = 200
SELECT *
FROM "Orders"
WHERE OrderID IN [100, 300, 234]
```
Folgende `SELECT`-Anweisungen führen jedoch zu einem vollständigen Tabellenscan:
```
SELECT *
FROM "Orders"
WHERE OrderID > 1
SELECT *
FROM "Orders"
WHERE Address='some address'
SELECT *
FROM "Orders"
WHERE OrderID = 100 OR Address='some address'
```
***key***
(Optional) Ein Hash-Schlüssel oder ein Sortierschlüssel, der zum Sortieren von ausgegebenen Ergebnissen verwendet werden soll. Die Standardreihenfolge ist aufsteigend (`ASC`) Geben Sie an.`DESC`, wenn die Ergebnisse in absteigender Reihenfolge neu abgestimmt werden sollen.
**Anmerkung**
Wenn Sie die `WHERE`-Klausel weglassen, werden alle Elemente in der Tabelle abgerufen.
## Beispiele
Die folgende Abfrage gibt ein Element, falls vorhanden, aus der `Orders`-Tabelle zurück, indem der Partitionsschlüssel `OrderID` angegeben und der Gleichheitsoperator verwendet wird.
```
SELECT OrderID, Total
FROM "Orders"
WHERE OrderID = 1
```
Die folgende Abfrage gibt alle Elemente in der `Orders`-Tabelle mit einem bestimmten Partitionsschlüssel `OrderID` zurück, mithilde von Werten mit dem Operator OR.
```
SELECT OrderID, Total
FROM "Orders"
WHERE OrderID = 1 OR OrderID = 2
```
Die folgende Abfrage gibt alle Elemente in der `Orders`-Tabelle mit einem bestimmten Partitionsschlüssel `OrderID` zurück, mithilde von Werten mit dem Operator IN. Die zurückgegebenen Ergebnisse sind in absteigender Reihenfolge, basierend auf dem `OrderID`-Attributwert.
```
SELECT OrderID, Total
FROM "Orders"
WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC
```
Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der alle Elemente aus der `Orders`-Tabelle zurückgibt, deren `Total` größer als 500 ist, wobei `Total` ein Nicht-Schlüsselattribut ist.
```
SELECT OrderID, Total
FROM "Orders"
WHERE Total > 500
```
Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der alle Elemente aus der `Orders`-Tabelle innerhalb eines bestimmten `Total`-Reihenfolgebereichs zurückgibt, wobei der IN-Operator und ein Nicht-Schlüsselattribut `Total` verwendet werden.
```
SELECT OrderID, Total
FROM "Orders"
WHERE Total IN [500, 600]
```
Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der alle Elemente aus der `Orders`-Tabelle innerhalb eines bestimmten `Total`-Reihenfolgebereichs zurückgibt, wobei der BETWEEN-Operator und ein Nicht-Schlüsselattribut `Total` verwendet werden.
```
SELECT OrderID, Total
FROM "Orders"
WHERE Total BETWEEN 500 AND 600
```
Die folgende Abfrage gibt das erste Datum zurück, an dem ein Firestick-Gerät zum Überwachen verwendet wurde, indem der `CustomerID`-Partitionsschlüssel und der `MovieID`-Sortierschlüssel in der Bedingung der WHERE-Klausel angegeben und Dokumentpfade in der SELECT-Klausel verwendet werden.
```
SELECT Devices.FireStick.DateWatched[0]
FROM WatchList
WHERE CustomerID= 'C1' AND MovieID= 'M1'
```
Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der die Liste der Elemente zurückgibt, bei denen ein Firestick-Gerät nach dem 24.12.19 zum ersten Mal unter Verwendung von Dokumentpfaden in der WHERE-Klausel Bedingung verwendet wurde.
```
SELECT Devices
FROM WatchList
WHERE Devices.FireStick.DateWatched[0] >= '12/24/19'
```
# Aktualisierungen für PartiQL-Anweisungen für DynamoDB
Verwenden der `UPDATE`-Anweisung, um den Wert eines oder mehrerer Attribute innerhalb eines Elements in einer Amazon-DynamoDB-Tabelle zu ändern.
**Anmerkung**
Sie können nur ein Element gleichzeitig aktualisieren. Sie können keine einzelne DynamoDB-PartiQL-Anweisung ausgeben, die mehrere Elemente aktualisiert. Weitere Informationen zum Aktualisieren mehrerer Elemente finden Sie unter [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) oder [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md).
**Topics**
+ [Syntax](#ql-reference.update.syntax)
+ [Parameters](#ql-reference.update.parameters)
+ [Rückgabewert](#ql-reference.update.return)
+ [Beispiele](#ql-reference.update.examples)
## Syntax
```
UPDATE table
[SET | REMOVE] path [= data] […]
WHERE condition [RETURNING returnvalues]
::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] *
```
## Parameters
***table***
(erforderlich) Die Benutzertabelle mit den zu ändernden Daten.
***path***
(Erforderlich) Ein Attributname oder Dokumentpfad, der erstellt oder geändert werden soll.
***data***
(Erforderlich) Ein Attributwert oder das Ergebnis einer Operation.
Die unterstützten Operationen, die mit SET verwendet werden sollen:
+ LIST\$1APPEND: fügt einem Listentyp einen Wert hinzu.
+ SET\$1ADD: fügt einem Zahlen- oder Zeichenfolgensatz einen Wert hinzu.
+ SET\$1DELETE: Entfernt einen Wert aus einem Zahlen- oder Zeichenfolgensatz.
***condition***
(erforderlich) Die Auswahlkriterien für die Elemente, die geändert werden sollen. Diese Bedingung muss auf einen einzelnen Primärschlüsselwert aufgelöst werden.
***returnvalues***
(Optional) Verwenden Sie `returnvalues`, wenn Sie die Elementattribute so abrufen möchten, wie sie vor oder nach der Aktualisierung angezeigt werden. Die gültigen Werte sind:
+ `ALL OLD *` – Gibt alle Attribute des Elements so zurück, wie sie vor dem Aktualisieren dargestellt wurden.
+ `MODIFIED OLD *` – Gibt nur die aktualisierten Attribute so zurück, wie sie vor dem Aktualisieren dargestellt wurden.
+ `ALL NEW *` – Gibt alle Attribute des Elements zurück, wie sie nach dem Aktualisierungsvorgang angezeigt werden.
+ `MODIFIED NEW *` – Gibt nur die aktualisierten Attribute so zurück, wie sie nach dem `UpdateItem` vorkommen.
## Rückgabewert
Diese Anweisung gibt keinen Wert zurück, es sei denn der `returnvalues`-Parameter ist angegeben.
**Anmerkung**
Wenn die WHERE-Klausel der UPDATE-Anweisung für kein Element in der DynamoDB-Tabelle als wahr ausgewertet wird, wird `ConditionalCheckFailedException` zurückgegeben.
## Beispiele
Aktualisieren Sie einen Attributwert in einem vorhandenen Element. Wenn das Attribut nicht vorhanden ist, wird es erstellt.
Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Hinzufügen eines Attributs vom Typ „number“ (`AwardsWon`) und ein Attribut vom Typ „map“ (`AwardDetail`) enthalten.
```
UPDATE "Music"
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Sie können `RETURNING ALL OLD *` hinzufügen, um die Attribute so zurückzugeben, wie sie vor der `Update`-Operation erschienen.
```
UPDATE "Music"
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
RETURNING ALL OLD *
```
Damit wird Folgendes zurückgegeben:
```
{
"Items": [
{
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "PartiQL Rocks"
}
}
]
}
```
Sie können `RETURNING ALL NEW *` hinzufügen, um die Attribute so zurückzugeben, wie sie nach der `Update`-Operation erschienen.
```
UPDATE "Music"
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
RETURNING ALL NEW *
```
Damit wird Folgendes zurückgegeben:
```
{
"Items": [
{
"AwardDetail": {
"M": {
"Grammys": {
"L": [
{
"N": "2020"
},
{
"N": "2018"
}
]
}
}
},
"AwardsWon": {
"N": "1"
}
}
]
}
```
Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Anhängen an eine Liste `AwardDetail.Grammys` aktualisiert.
```
UPDATE "Music"
SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016])
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Entfernen aus einer Liste `AwardDetail.Grammys` aktualisiert.
```
UPDATE "Music"
REMOVE AwardDetail.Grammys[2]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Hinzufügen von `BillBoard` zur Karte `AwardDetail` aktualisiert.
```
UPDATE "Music"
SET AwardDetail.BillBoard=[2020]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Die folgende Abfrage aktualisiert ein Element in der `"Music"`-Tabelle durch Hinzufügen des Zeichenfolgensatzattributs `BandMembers`.
```
UPDATE "Music"
SET BandMembers =<<'member1', 'member2'>>
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Die folgende Abfrage aktualisiert ein Element in der `"Music"`-Tabelle, indem `newbandmember` zum Zeichenfolgensatz `BandMembers` hinzugefügt wird.
```
UPDATE "Music"
SET BandMembers =set_add(BandMembers, <<'newbandmember'>>)
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
# PartiQL-Delete-Anweisungen für DynamoDB
Verwenden der`DELETE`-Anweisung verwenden, um ein vorhandenes Element aus Ihrer Amazon-DynamoDB-Tabelle zu löschen.
**Anmerkung**
Sie können nur jeweils ein Element löschen. Sie können keine einzelne DynamoDB-PartiQL-Anweisung ausgeben, die mehrere Elemente löscht. Informationen zum Löschen mehrerer Elemente finden Sie unter [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) oder [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md).
**Topics**
+ [Syntax](#ql-reference.delete.syntax)
+ [Parameters](#ql-reference.delete.parameters)
+ [Rückgabewert](#ql-reference.delete.return)
+ [Beispiele](#ql-reference.delete.examples)
## Syntax
```
DELETE FROM table
WHERE condition [RETURNING returnvalues]
::= ALL OLD *
```
## Parameters
***table***
(Erforderlich) Die DynamoDB-Tabelle, die das zu löschende Element enthält.
***condition***
(Erforderlich) Die Auswahlkriterien für das zu löschende Element; diese Bedingung muss auf einen einzelnen Primärschlüsselwert aufgelöst werden.
***returnvalues***
(Optional) Verwenden Sie `returnvalues`, wenn Sie die Elementattribute so erhalten möchten, wie sie vor dem Löschen dargestellt wurden. Die gültigen Werte sind:
+ `ALL OLD *`- die Inhalte des alten Elements werden zurückgegeben.
## Rückgabewert
Diese Anweisung gibt keinen Wert zurück, es sei denn der `returnvalues`-Parameter ist angegeben.
**Anmerkung**
Wenn in der DynamoDB-Tabelle kein Element mit demselben Primärschlüssel wie dem des Elements vorhanden ist, für das das DELETE ausgegeben wird, wird SUCCESS zurückgegeben, wobei 0 Elemente gelöscht wurden. Wenn die Tabelle ein Element mit demselben Primärschlüssel enthält, aber die Bedingung in der WHERE-Klausel der DELETE-Anweisung als falsch ausgewertet wird, wird `ConditionalCheckFailedException` zurückgegeben.
## Beispiele
Mit der folgenden Abfrage wird ein Element in der Tabelle `"Music"` gelöscht.
```
DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks'
```
Sie können den Parameter `RETURNING ALL OLD *` hinzufügen, um die gelöschten Daten zurückzugeben.
```
DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD *
```
Die `Delete`-Anweisung gibt nun Folgendes zurück:
```
{
"Items": [
{
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "PartiQL Rocks"
}
}
]
}
```
# PartiQL-Insert-Anweisungen für DynamoDB
Verwenden Sie die `INSERT`-Anweisung, um einer Tabelle in Amazon DynamoDB ein Element hinzuzufügen.
**Anmerkung**
Sie können nur ein Element gleichzeitig einfügen. Sie können keine einzelne DynamoDB-PartiQL-Anweisung ausgeben, die mehrere Elemente einfügt. Weitere Informationen zum Einfügen mehrerer Elemente finden Sie unter [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) oder [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md).
**Topics**
+ [Syntax](#ql-reference.insert.syntax)
+ [Parameters](#ql-reference.insert.parameters)
+ [Rückgabewert](#ql-reference.insert.return)
+ [Beispiele](#ql-reference.insert.examples)
## Syntax
Fügen Sie ein einzelnes Element ein.
```
INSERT INTO table VALUE item
```
## Parameters
***table***
(erforderlich) Die Tabelle, in der Sie die Daten einfügen möchten. Die Tabelle muss bereits vorhanden sein.
***item***
(Erforderlich) Ein gültiges DynamoDB Element, das als [PartiQL-Tupel](https://partiql.org/docs.html) gezeigt wird. Sie müssen nur *ein* Element angeben, und bei jedem Attributnamen im Element wird die Groß-/Kleinschreibung beachtet und kann in PartiQL mit *einfachen* Anführungszeichen (`'...'`) gekennzeichnet werden.
Zeichenfolgenwerte werden in PartiQL auch mit *einfachen* Anführungszeichen (`'...'`) angegeben.
## Rückgabewert
Diese Anweisung gibt keine Werte zurück.
**Anmerkung**
Wenn die DynamoDB-Tabelle bereits ein Element mit demselben Primärschlüssel wie der Primärschlüssel des einzufügenden Elements enthält, wird `DuplicateItemException` zurückgegeben.
## Beispiele
```
INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}
```
# Verwenden von PartiQL-Funktionen mit DynamoDB
PartiSQL in Amazon DynamoDB unterstützt die folgenden integrierten Varianten von SQL-Standardfunktionen.
**Anmerkung**
SQL-Funktionen, die nicht in dieser Liste enthalten sind, werden derzeit in DynamoDB nicht unterstützt.
## Aggregationsfunktionen
+ [Verwenden der SIZE-Funktion mit PartiQL für Amazon DynamoDB](ql-functions.size.md)
## Konditionale Funktionen
+ [Verwenden der EXISTS-Funktion mit PartiQL für DynamoDB](ql-functions.exists.md)
+ [Verwenden der ATTRIBUTE\$1TYPE-Funktion mit PartiQL für DynamoDB](ql-functions.attribute_type.md)
+ [Verwenden der BEGINS\$1WITH-Funktion mit PartiQL für DynamoDB](ql-functions.beginswith.md)
+ [Verwenden der CONTAINS-Funktion mit PartiQL für DynamoDB](ql-functions.contains.md)
+ [Verwenden der MISSING-Funktion mit PartiQL für DynamoDB](ql-functions.missing.md)
# Verwenden der EXISTS-Funktion mit PartiQL für DynamoDB
Sie können EXISTS verwenden, um dieselbe Funktion wie `ConditionCheck` in der [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)-API auszuführen. Die EXISTS-Funktion kann nur in Transaktionen verwendet werden.
Gibt bei Vorliegen eines Werts `TRUE` zurück, wenn der Wert eine nicht-leere Sammlung ist. Gibt andernfalls `FALSE` zurück.
**Anmerkung**
Diese Funktion kann nur in Transaktionsoperationen verwendet werden.
## Syntax
```
EXISTS ( statement )
```
## Argumente
*statement*
(Erforderlich) Die SELECT-Anweisung, die die Funktion auswertet.
Die SELECT-Anweisung muss einen vollständigen Primärschlüssel und eine andere Bedingung angeben.
## Rückgabetyp
`bool`
## Beispiele
```
EXISTS(
SELECT * FROM "Music"
WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks')
```
# Verwenden der BEGINS\$1WITH-Funktion mit PartiQL für DynamoDB
Gibt `TRUE` zurück, wenn das angegebene Attribut mit einer bestimmten Teilzeichenfolge beginnt.
## Syntax
```
begins_with(path, value )
```
## Argumente
*path*
(Erforderlich) Der zu verwendende Attributname oder Dokumentpfad.
*value*
(Erforderlich) Die Zeichenfolge, nach der gesucht werden soll.
## Rückgabetyp
`bool`
## Beispiele
```
SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th')
```
# Verwenden der MISSING-Funktion mit PartiQL für DynamoDB
Gibt `TRUE` zurück, wenn das Element das angegebene Attribut nicht enthält. Mit dieser Funktion können nur Gleichheits- und Ungleichheitsoperatoren verwendet werden.
## Syntax
```
attributename IS | IS NOT MISSING
```
## Argumente
*attributename*
(Erforderlich) Der Attributname, nach dem Sie suchen möchten.
## Rückgabetyp
`bool`
## Beispiele
```
SELECT * FROM Music WHERE "Awards" is MISSING
```
# Verwenden der ATTRIBUTE\$1TYPE-Funktion mit PartiQL für DynamoDB
Gibt `TRUE` zurück, wenn das Attribut am angegebenen Pfad einen bestimmten Datentyp hat.
## Syntax
```
attribute_type( attributename, type )
```
## Argumente
*attributename*
(Erforderlich) Der zu verwendende Attributname.
*type*
(Erforderlich) Der Attributtyp, nach dem geprüft werden soll. Eine Liste der gültigen Werte finden Sie unter DynamoDB [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions).
## Rückgabetyp
`bool`
## Beispiele
```
SELECT * FROM "Music" WHERE attribute_type("Artist", 'S')
```
# Verwenden der CONTAINS-Funktion mit PartiQL für DynamoDB
Gibt `TRUE` zurück, wenn das vom Pfad angegebene Attribut Folgendes ist:
+ Eine Zeichenfolge, die eine bestimmte Teilzeichenfolge enthält
+ Einen Satz, der ein bestimmtes Element innerhalb des Satzes enthält
Weitere Informationen finden Sie im Thema zur DynamoDB-[Contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion.
## Syntax
```
contains( path, substring )
```
## Argumente
*path*
(Erforderlich) Der zu verwendende Attributname oder Dokumentpfad.
*substring*
(Erforderlich) Die Attribut-Teilzeichenfolge oder das Satz-Element, nach dem Sie suchen möchten Weitere Informationen finden Sie im Thema zur DynamoDB-[Contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion.
## Rückgabetyp
`bool`
## Beispiele
```
SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland')
```
# Verwenden der SIZE-Funktion mit PartiQL für Amazon DynamoDB
Gibt eine Zahl zurück, die für die Größe eines Attributs in Bytes steht. Die folgenden sind gültige Datentypen, die mit Größe verwendet werden können. Weitere Informationen finden Sie in der DynamoDB-[size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion.
## Syntax
```
size( path)
```
## Argumente
*path*
(Erforderlich) Der Attributname oder Dokumentpfad.
Weitere Informationen zu unterstützten Typen finden Sie im Thema DynamoDB-[SIZE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion.
## Rückgabetyp
`int`
## Beispiele
```
SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300
```
# PartiQL-Arithmetik-, Vergleichs- und logische Operatoren für DynamoDB
PartiSQL in Amazon DynamoDB unterstützt die folgenden [SQL-Standardoperatoren](https://www.w3schools.com/sql/sql_operators.asp).
**Anmerkung**
SQL-Operatoren, die nicht in dieser Liste enthalten sind, werden derzeit in DynamoDB nicht unterstützt.
## Arithmetische Operatoren
****
| Operator | Description |
| --- | --- |
| \$1 | Addition |
| - | Subtraktion |
## Vergleichsoperatoren
****
| Operator | Description |
| --- | --- |
| = | gleich |
| <> | nicht gleich |
| \$1= | nicht gleich |
| > | Größer als |
| < | Kleiner als |
| >= | Größer als oder gleich |
| <= | Kleiner als oder gleich |
## Logische Operatoren
****
| Operator | Description |
| --- | --- |
| AND | TRUE, wenn alle durch AND getrennten Bedingungen TRUE sind |
| BETWEEN | `TRUE`, wenn der Operand innerhalb des Vergleichsbereichs liegt. Dieser Operator umfasst die Unter- und Obergrenze der Operanden, auf die Sie ihn anwenden. |
| IN | `TRUE`wenn der Operand einem aus einer Liste von Ausdrücken entspricht (bei maximal 50 Hash-Attributwerten oder bei maximal 100 Nichtschlüsselattributwerten). Die Ergebnisse werden in Seiten mit bis zu 10 Elementen zurückgegeben. Wenn die `IN` Liste mehr Werte enthält, müssen Sie die in der Antwort `NextToken` zurückgegebenen Werte verwenden, um nachfolgende Seiten abzurufen. |
| IS | TRUE, wenn der Operand ein bestimmter PartiQL-Datentyp ist, einschließlich NULL oder MISSING |
| NOT | Kehrt den Wert eines gegebenen booleschen Ausdrucks um |
| OR | TRUE, wenn eine der von OR getrennten Bedingungen TRUE ist |
Weitere Informationen zu logischen Operatoren finden Sie unter [Durchführen von Vergleichen](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) und [Logische Auswertungen](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations).
# Ausführen von Transaktionen mit PartiQL für DynamoDB
In diesem Abschnitt wird die Verwendung von Transaktionen mit PartiQL für DynamoDB beschrieben. PartiQL-Transaktionen sind auf insgesamt 100 Anweisungen (Aktionen) begrenzt.
Weitere Informationen zu DynamoDB-Transaktionen finden Sie unter [Verwalten komplexer Workflows mit DynamoDB-Transaktionen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html).
**Anmerkung**
Die gesamte Transaktion muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen. Sie können nicht beides in einer Transaktion mischen. Die EXISTS-Funktion ist eine Ausnahme. Sie können es verwenden, um den Zustand bestimmter Attribute des Elements auf ähnliche Weise wie `ConditionCheck` bei der [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API-Operation zu überprüfen.
**Topics**
+ [Syntax](#ql-reference.multiplestatements.transactions.syntax)
+ [Parameters](#ql-reference.multiplestatements.transactions.parameters)
+ [Rückgabewerte](#ql-reference.multiplestatements.transactions.return)
+ [Beispiele](#ql-reference.multiplestatements.transactions.examples)
## Syntax
```
[
{
"Statement":" statement ",
"Parameters":[
{
" parametertype " : " parametervalue "
}, ...]
} , ...
]
```
## Parameters
***statement***
(Erforderlich) Eine unterstützte PartiQL für DynamoDB-Anweisung.
Die gesamte Transaktion muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen. Sie können nicht beides in einer Transaktion mischen.
***parametertype***
(Optional) Ein DynamoDB-Typ, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden.
***parametervalue***
(Optional) Ein Parameterwert, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden.
## Rückgabewerte
Diese Anweisung gibt keine Werte für Schreibvorgänge (INSERT, UPDATE oder DELETE) zurück. Sie gibt jedoch verschiedene Werte für Lesevorgänge (SELECT) basierend auf den in der WHERE-Klausel angegebenen Bedingungen zurück.
**Anmerkung**
Wenn eine der Singleton-Operationen INSERT, UPDATE oder DELETE einen Fehler zurückgibt, werden die Transaktionen mit einer `TransactionCanceledException`-Ausnahme abgebrochen, und der Code für den Abbruchgrund enthält die Fehler der einzelnen Singleton-Operationen.
## Beispiele
Im folgenden Beispiel werden mehrere Anweisungen als Transaktion ausgeführt.
------
#### [ AWS CLI ]
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen partiql.json.
```
[
{
"Statement": "EXISTS(SELECT * FROM \"Music\" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)"
},
{
"Statement": "INSERT INTO Music value {'Artist':?,'SongTitle':'?'}",
"Parameters": [{\"S\": \"Acme Band\"}, {\"S\": \"Best Song\"}]
},
{
"Statement": "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'"
}
]
```
1. Führen Sie in der Eingabeaufforderung den folgenden Befehl aus.
```
aws dynamodb execute-transaction --transact-statements file://partiql.json
```
------
#### [ Java ]
```
public class DynamoDBPartiqlTransaction {
public static void main(String[] args) {
// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2");
try {
// Create ExecuteTransactionRequest
ExecuteTransactionRequest executeTransactionRequest = createExecuteTransactionRequest();
ExecuteTransactionResult executeTransactionResult = dynamoDB.executeTransaction(executeTransactionRequest);
System.out.println("ExecuteTransaction successful.");
// Handle executeTransactionResult
} catch (Exception e) {
handleExecuteTransactionErrors(e);
}
}
private static AmazonDynamoDB createDynamoDbClient(String region) {
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
private static ExecuteTransactionRequest createExecuteTransactionRequest() {
ExecuteTransactionRequest request = new ExecuteTransactionRequest();
// Create statements
List statements = getPartiQLTransactionStatements();
request.setTransactStatements(statements);
return request;
}
private static List getPartiQLTransactionStatements() {
List statements = new ArrayList();
statements.add(new ParameterizedStatement()
.withStatement("EXISTS(SELECT * FROM "Music" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)"));
statements.add(new ParameterizedStatement()
.withStatement("INSERT INTO "Music" value {'Artist':'?','SongTitle':'?'}")
.withParameters(new AttributeValue("Acme Band"),new AttributeValue("Best Song")));
statements.add(new ParameterizedStatement()
.withStatement("UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'"));
return statements;
}
// Handles errors during ExecuteTransaction execution. Use recommendations in error messages below to add error handling specific to
// your application use-case.
private static void handleExecuteTransactionErrors(Exception exception) {
try {
throw exception;
} catch (TransactionCanceledException tce) {
System.out.println("Transaction Cancelled, implies a client issue, fix before retrying. Error: " + tce.getErrorMessage());
} catch (TransactionInProgressException tipe) {
System.out.println("The transaction with the given request token is already in progress, consider changing " +
"retry strategy for this type of error. Error: " + tipe.getErrorMessage());
} catch (IdempotentParameterMismatchException ipme) {
System.out.println("Request rejected because it was retried with a different payload but with a request token that was already used, " +
"change request token for this payload to be accepted. Error: " + ipme.getErrorMessage());
} catch (Exception e) {
handleCommonErrors(e);
}
}
private static void handleCommonErrors(Exception exception) {
try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " +
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage());
}
}
}
```
------
Das folgende Beispiel zeigt die verschiedenen Rückgabewerte, wenn DynamoDB-Elemente mit unterschiedlichen Bedingungen liest, die in der WHERE-Klausel angegeben sind.
------
#### [ AWS CLI ]
1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen partiql.json.
```
[
// Item exists and projected attribute exists
{
"Statement": "SELECT * FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'"
},
// Item exists but projected attributes do not exist
{
"Statement": "SELECT non_existent_projected_attribute FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'"
},
// Item does not exist
{
"Statement": "SELECT * FROM "Music" WHERE Artist='No One I Know' and SongTitle='Call You Today'"
}
]
```
1. Folgenden Befehl in der Eingabeaufforderung eingeben.
```
aws dynamodb execute-transaction --transact-statements file://partiql.json
```
1. Die folgende Antwort wird ausgegeben:
```
{
"Responses": [
// Item exists and projected attribute exists
{
"Item": {
"Artist":{
"S": "No One You Know"
},
"SongTitle":{
"S": "Call Me Today"
}
}
},
// Item exists but projected attributes do not exist
{
"Item": {}
},
// Item does not exist
{}
]
}
```
------
# Ausführen von Batchoperationen mit PartiQL für DynamoDB
In diesem Abschnitt wird die Verwendung von Stapel-Anweisungen mit PartiQL für DynamoDB beschrieben.
**Anmerkung**
Der gesamte Stapel muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen; Sie können nicht beides in einem Stapel mischen.
`BatchExecuteStatement` und `BatchWriteItem` können nicht mehr als 25 Anweisungen pro Stapel ausführen.
`BatchExecuteStatement` verwendet `BatchGetItem`, was eine Liste von Primärschlüsseln in separaten Anweisungen verarbeitet.
**Topics**
+ [Syntax](#ql-reference.multiplestatements.batching.syntax)
+ [Parameters](#ql-reference.multiplestatements.batching.parameters)
+ [Beispiele](#ql-reference.multiplestatements.batching.examples)
## Syntax
```
[
{
"Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#9StkWHYTxm7x2AqSXcrfu7' AND sk = 'info'"
},
{
"Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#isC2ChceGbxHgESc4szoTE' AND sk = 'info'"
}
]
```
```
[
{
"Statement":" statement ",
"Parameters":[
{
" parametertype " : " parametervalue "
}, ...]
} , ...
]
```
## Parameters
***statement***
(Erforderlich) Eine unterstützte PartiQL für DynamoDB-Anweisung.
+ Der gesamte Stapel muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen; Sie können nicht beides in einem Stapel mischen.
+ `BatchExecuteStatement` und `BatchWriteItem` können nicht mehr als 25 Anweisungen pro Stapel ausführen.
***parametertype***
(Optional) Ein DynamoDB-Typ, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden.
***parametervalue***
(Optional) Ein Parameterwert, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden.
## Beispiele
------
#### [ AWS CLI ]
1. Speichern Sie den folgenden JSON in einer Datei namens partiql.json
```
[
{
"Statement": "INSERT INTO Music VALUE {'Artist':?,'SongTitle':?}",
"Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}]
},
{
"Statement": "UPDATE Music SET AwardsWon=1, AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
}
]
```
1. Führen Sie in der Eingabeaufforderung den folgenden Befehl aus.
```
aws dynamodb batch-execute-statement --statements file://partiql.json
```
------
#### [ Java ]
```
public class DynamoDBPartiqlBatch {
public static void main(String[] args) {
// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2");
try {
// Create BatchExecuteStatementRequest
BatchExecuteStatementRequest batchExecuteStatementRequest = createBatchExecuteStatementRequest();
BatchExecuteStatementResult batchExecuteStatementResult = dynamoDB.batchExecuteStatement(batchExecuteStatementRequest);
System.out.println("BatchExecuteStatement successful.");
// Handle batchExecuteStatementResult
} catch (Exception e) {
handleBatchExecuteStatementErrors(e);
}
}
private static AmazonDynamoDB createDynamoDbClient(String region) {
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() {
BatchExecuteStatementRequest request = new BatchExecuteStatementRequest();
// Create statements
List statements = getPartiQLBatchStatements();
request.setStatements(statements);
return request;
}
private static List getPartiQLBatchStatements() {
List statements = new ArrayList();
statements.add(new BatchStatementRequest()
.withStatement("INSERT INTO Music value {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}"));
statements.add(new BatchStatementRequest()
.withStatement("UPDATE Music set AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL Rocks'"));
return statements;
}
// Handles errors during BatchExecuteStatement execution. Use recommendations in error messages below to add error handling specific to
// your application use-case.
private static void handleBatchExecuteStatementErrors(Exception exception) {
try {
throw exception;
} catch (Exception e) {
// There are no API specific errors to handle for BatchExecuteStatement, common DynamoDB API errors are handled below
handleCommonErrors(e);
}
}
private static void handleCommonErrors(Exception exception) {
try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " +
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage());
}
}
}
```
------
# IAM-Sicherheitsrichtlinien mit PartiQL für DynamoDB
Die folgenden Berechtigungen sind erforderlich:
+ Um Elemente mit PartiQL für DynamoDB zu lesen, müssen Sie über die `dynamodb:PartiQLSelect`-Berechtigung für die Tabelle oder den Index verfügen.
+ Um Elemente mit PartiQL für DynamoDB einzufügen, müssen Sie über die `dynamodb:PartiQLInsert`-Berechtigung für die Tabelle oder den Index verfügen.
+ Um Elemente mit PartiQL für DynamoDB zu aktualisieren, müssen Sie über die `dynamodb:PartiQLUpdate`-Berechtigung für die Tabelle oder den Index verfügen.
+ Um Elemente mit PartiQL für DynamoDB zu löschen, müssen Sie über die `dynamodb:PartiQLDelete`-Berechtigung für die Tabelle oder den Index verfügen.
## Beispiel: Alle PartiQL for DynamoDB-Anweisungen (Select/Insert/Update/Delete) in einer Tabelle zulassen
Mit der folgenden IAM-Richtlinie werden alle PartiQL für DynamoDB-Anweisungen in einer Tabelle erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
```
------
## Beispiel: PartiQL für DynamoDB-Auswahlanweisungen für eine Tabelle zulassen
Mit der folgenden IAM-Richtlinie werden die Berechtigungen zum Ausführen der `select`-Anweisung für eine bestimmte Tabelle erteilt
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
```
------
## Beispiel: PartiQL für DynamoDB-Einfügeanweisungen für einen Index zulassen
Mit der folgenden IAM-Richtlinie werden die Berechtigungen zum Ausführen des `insert`-Anweisung auf einen bestimmten Index.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1"
]
}
]
}
```
------
## Beispiel: PartiQL für DynamoDB-Transaktionsanweisungen nur für eine Tabelle zulassen
Mit der folgenden IAM-Richtlinie werden die Berechtigungen nur zum Ausführen transaktionaler Anweisungen für eine bestimmte Tabelle erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
}
]
}
```
------
## Beispiel: Erlauben Sie PartiQL für nicht-transaktionale DynamoDB-Lese- und Schreibvorgänge und blockieren Sie PartiQL-transaktionale Lese- und Schreibvorgänge in einer Tabelle.
Die folgende IAM-Richtlinie gewährt Berechtigungen zum Ausführen von nicht-transaktionalen Lese-/Schreibvorgängen in PartiQL für DynamoDB, während transaktionale Lese-/Schreibvorgänge in PartiQL für DynamoDB blockiert werden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Deny",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
```
------
## Beispiel: In PartiQL für DynamoDB Select-Anweisungen erlauben und vollständige Tabellenscan-Anweisungen verweigern
Mit der folgenden IAM-Richtlinie werden die Berechtigungen zum Ausführen der `select`-Anweisung für eine bestimmte Tabelle beim Blockieren von `select`-Anweisungen, die zu einem vollständigen Tabellenscan führen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Deny",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/WatchList"
],
"Condition":{
"Bool":{
"dynamodb:FullTableScan":[
"true"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/WatchList"
]
}
]
}
```
------
# Arbeiten mit Elementen: Java
Sie können die AWS SDK für Java Dokument-API verwenden, um typische Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge (CRUD) für Amazon DynamoDB DynamoDB-Elemente in einer Tabelle durchzuführen.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
Dieser Abschnitt enthält Java-Beispiele zur Durchführung verschiedener Java-Dokument-API-Elementaktionen und mehrere vollständige Arbeitsbeispiele.
**Topics**
+ [Einfügen eines Elements](#PutDocumentAPIJava)
+ [Abrufen eines Elements](#JavaDocumentAPIGetItem)
+ [Batch Write: Einfügen und Löschen mehrerer Elemente](#BatchWriteDocumentAPIJava)
+ [Batch Get: Abrufen mehrerer Elemente](#JavaDocumentAPIBatchGetItem)
+ [Aktualisieren eines Elements](#JavaDocumentAPIItemUpdate)
+ [Löschen eines Elements](#DeleteMidLevelJava)
+ [Beispiel: CRUD-Operationen mit der AWS SDK für Java Dokument-API](JavaDocumentAPICRUDExample.md)
+ [Beispiel: Batch-Operationen mithilfe der AWS SDK für Java Dokument-API](batch-operation-document-api-java.md)
+ [Beispiel: Umgang mit binären Typattributen mithilfe der AWS SDK für Java Dokument-API](JavaDocumentAPIBinaryTypeExample.md)
## Einfügen eines Elements
Die `putItem`-Methode speichert ein Element in einer Tabelle. Wenn das Element bereits vorhanden ist, wird das ganze Element ersetzt. Anstatt das gesamte Element zu ersetzen und nur spezifische Attribute zu aktualisieren, können Sie die Methode `updateItem` verwenden. Weitere Informationen finden Sie unter [Aktualisieren eines Elements](#JavaDocumentAPIItemUpdate).
------
#### [ Java v2 ]
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To place items into an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client. See the EnhancedPutItem example.
*/
public class PutItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table in which an item is placed (for example, Music3).
key - The key used in the Amazon DynamoDB table (for example, Artist).
keyval - The key value that represents the item to get (for example, Famous Band).
albumTitle - The Album title (for example, AlbumTitle).
AlbumTitleValue - The name of the album (for example, Songs About Life ).
Awards - The awards column (for example, Awards).
AwardVal - The value of the awards (for example, 10).
SongTitle - The song title (for example, SongTitle).
SongTitleVal - The value of the song title (for example, Happy Day).
**Warning** This program will place an item that you specify into a table!
""";
if (args.length != 9) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
String albumTitle = args[3];
String albumTitleValue = args[4];
String awards = args[5];
String awardVal = args[6];
String songTitle = args[7];
String songTitleVal = args[8];
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
putItemInTable(ddb, tableName, key, keyVal, albumTitle, albumTitleValue, awards, awardVal, songTitle,
songTitleVal);
System.out.println("Done!");
ddb.close();
}
public static void putItemInTable(DynamoDbClient ddb,
String tableName,
String key,
String keyVal,
String albumTitle,
String albumTitleValue,
String awards,
String awardVal,
String songTitle,
String songTitleVal) {
HashMap itemValues = new HashMap<>();
itemValues.put(key, AttributeValue.builder().s(keyVal).build());
itemValues.put(songTitle, AttributeValue.builder().s(songTitleVal).build());
itemValues.put(albumTitle, AttributeValue.builder().s(albumTitleValue).build());
itemValues.put(awards, AttributeValue.builder().s(awardVal).build());
PutItemRequest request = PutItemRequest.builder()
.tableName(tableName)
.item(itemValues)
.build();
try {
PutItemResponse response = ddb.putItem(request);
System.out.println(tableName + " was successfully updated. The request id is "
+ response.responseMetadata().requestId());
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
------
#### [ Java v1 ]
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `Table`-Klasse, um die Tabelle zu repräsentieren, mit der Sie arbeiten möchten.
1. Erstellen Sie eine Instance der `Item`-Klasse, um das neue Element zu repräsentieren. Sie müssen den Primärschlüssel und die Attribute für das neue Element angeben.
1. Rufen Sie die `putItem`-Methode des `Table`-Objekts auf, das das `Item` verwendet, das Sie im vorangegangenen Schritt erstellt haben.
Im folgenden Java-Codebeispiel werden die vorherigen Aufgaben veranschaulicht. Der Code schreibt ein neues Element in die `ProductCatalog`-Tabelle.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
// Build a list of related items
List relatedItems = new ArrayList();
relatedItems.add(341);
relatedItems.add(472);
relatedItems.add(649);
//Build a map of product pictures
Map pictures = new HashMap();
pictures.put("FrontView", "http://example.com/products/123_front.jpg");
pictures.put("RearView", "http://example.com/products/123_rear.jpg");
pictures.put("SideView", "http://example.com/products/123_left_side.jpg");
//Build a map of product reviews
Map> reviews = new HashMap>();
List fiveStarReviews = new ArrayList();
fiveStarReviews.add("Excellent! Can't recommend it highly enough! Buy it!");
fiveStarReviews.add("Do yourself a favor and buy this");
reviews.put("FiveStar", fiveStarReviews);
List oneStarReviews = new ArrayList();
oneStarReviews.add("Terrible product! Do not buy this.");
reviews.put("OneStar", oneStarReviews);
// Build the item
Item item = new Item()
.withPrimaryKey("Id", 123)
.withString("Title", "Bicycle 123")
.withString("Description", "123 description")
.withString("BicycleType", "Hybrid")
.withString("Brand", "Brand-Company C")
.withNumber("Price", 500)
.withStringSet("Color", new HashSet(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle")
.withBoolean("InStock", true)
.withNull("QuantityOnHand")
.withList("RelatedItems", relatedItems)
.withMap("Pictures", pictures)
.withMap("Reviews", reviews);
// Write the item to the table
PutItemOutcome outcome = table.putItem(item);
```
Im vorangegangenen Beispiel verfügt das Element über Attribute, die skalar sind (`String`, `Number`, `Boolean`, `Null`), Sätze (`String Set`) sowie Dokumenttypen (`List`, `Map`).
------
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie auch optionale Parameter für die `putItem`-Methode angeben. Zum Beispiel verwendet das folgende Java-Codebeispiel einen optionalen Parameter, um eine Bedingung für das Hochladen des Elements anzugeben. Wenn die von Ihnen angegebene Bedingung nicht erfüllt ist, wird eine ausgelöst. AWS SDK für Java `ConditionalCheckFailedException` Das Codebeispiel gibt die folgenden optionalen Parameter in der `putItem`-Methode an:
+ Ein `ConditionExpression`, der die Bedingungen für die Anforderung definiert. In dem Codebeispiel ist die Bedingung definiert, zu der das vorhandene Element mit demselben Primärschlüssel nur dann ersetzt wird, wenn es über ein ISBN-Attribut verfügt, das mit einem bestimmten Wert übereinstimmt.
+ Eine Zuordnung für `ExpressionAttributeValues`, die in der Bedingung verwendet wird. In diesem Fall ist nur eine Ersetzung erforderlich: Der Platzhalter `:val` im Bedingungsausdruck wird zur Laufzeit durch den tatsächlichen zu prüfenden ISBN-Wert ersetzt.
Im folgenden Beispiel wird ein neues Buchelement mit diesen optionalen Parameter hinzugefügt.
**Example**
```
Item item = new Item()
.withPrimaryKey("Id", 104)
.withString("Title", "Book 104 Title")
.withString("ISBN", "444-4444444444")
.withNumber("Price", 20)
.withStringSet("Authors",
new HashSet(Arrays.asList("Author1", "Author2")));
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", "444-4444444444");
PutItemOutcome outcome = table.putItem(
item,
"ISBN = :val", // ConditionExpression parameter
null, // ExpressionAttributeNames parameter - we're not using it for this example
expressionAttributeValues);
```
### PutItem und JSON-Dokumente
Sie können ein JSON-Dokument in einer DynamoDB-Tabelle als Attribut speichern. Verwenden Sie dazu die `withJSON`-Methode `Item`. Diese Methode analysiert das JSON-Dokument und ordnet jedes Element einem nativen DynamoDB-Datentyp zu.
Angenommen, Sie möchten das folgende JSON-Dokument speichern, welches Anbieter enthält, die Bestellungen für ein bestimmtes Produkt erfüllen können.
**Example**
```
{
"V01": {
"Name": "Acme Books",
"Offices": [ "Seattle" ]
},
"V02": {
"Name": "New Publishers, Inc.",
"Offices": ["London", "New York"
]
},
"V03": {
"Name": "Better Buy Books",
"Offices": [ "Tokyo", "Los Angeles", "Sydney"
]
}
}
```
Sie können die `withJSON`-Methode verwenden, um es in der `ProductCatalog`-Tabelle in einem `Map`´-Attribut mit dem Namen `VendorInfo` zu speichern. Das folgende Java-Codebeispiel veranschaulicht dies.
```
// Convert the document into a String. Must escape all double-quotes.
String vendorDocument = "{"
+ " \"V01\": {"
+ " \"Name\": \"Acme Books\","
+ " \"Offices\": [ \"Seattle\" ]"
+ " },"
+ " \"V02\": {"
+ " \"Name\": \"New Publishers, Inc.\","
+ " \"Offices\": [ \"London\", \"New York\"" + "]" + "},"
+ " \"V03\": {"
+ " \"Name\": \"Better Buy Books\","
+ "\"Offices\": [ \"Tokyo\", \"Los Angeles\", \"Sydney\""
+ " ]"
+ " }"
+ " }";
Item item = new Item()
.withPrimaryKey("Id", 210)
.withString("Title", "Book 210 Title")
.withString("ISBN", "210-2102102102")
.withNumber("Price", 30)
.withJSON("VendorInfo", vendorDocument);
PutItemOutcome outcome = table.putItem(item);
```
## Abrufen eines Elements
Um ein einzelnes Element abzurufen, verwenden Sie die `getItem`-Methode eines `Table`-Objekts. Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `Table`-Klasse, um die Tabelle zu repräsentieren, mit der Sie arbeiten möchten.
1. Rufen Sie die `getItem`-Methode für die `Table`-Instance auf. Sie müssen den Primärschlüssel des Elements angeben, das Sie abrufen möchten.
Im folgenden Java-Codebeispiel werden die vorherigen Schritte veranschaulicht. Im Codebeispiel wird das Element abgerufen, das den angegebenen Partitionsschlüssel aufweist.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Item item = table.getItem("Id", 210);
```
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie auch optionale Parameter für die `getItem`-Methode angeben. Zum Beispiel verwendet das folgende Java-Codebeispiel eine optionale Methode zum Abrufen nur einer bestimmten Liste von Attributen und zum Angeben von Strongly Consistent-Lesevorgängen. (Weitere Informationen zur Lesekonsistenz finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).)
Sie können einen `ProjectionExpression` verwenden, um nur spezifische Attribute oder Elemente anstelle eines ganzen Elements abzurufen. Ein `ProjectionExpression` kann Attribute auf oberster Ebene oder verschachtelte Attribute mithilfe von Dokumentpfaden angeben. Weitere Informationen finden Sie unter [Verwenden von Projektionsausdrücken in DynamoDB](Expressions.ProjectionExpressions.md).
Mit den Parametern der `getItem`-Methode kann keine Read Consistency angegeben werden. Sie können jedoch eine `GetItemSpec` erstellen, die vollständigen Zugriff auf die Eingaben für die `GetItem`-Low-Level-Operation bietet. Durch das Codebeispiel unten wird eine `GetItemSpec` erstellt. Es verwendet diese Spezifikation als Eingabe für die `getItem`-Methode.
**Example**
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 206)
.withProjectionExpression("Id, Title, RelatedItems[0], Reviews.FiveStar")
.withConsistentRead(true);
Item item = table.getItem(spec);
System.out.println(item.toJSONPretty());
```
Um ein `Item` in einem vom Menschen lesbaren Format zu drucken, verwenden Sie die Methode `toJSONPretty`. Die Ausgabe aus dem vorherigen Beispiel sieht wie folgt aus.
```
{
"RelatedItems" : [ 341 ],
"Reviews" : {
"FiveStar" : [ "Excellent! Can't recommend it highly enough! Buy it!", "Do yourself a favor and buy this" ]
},
"Id" : 123,
"Title" : "20-Bicycle 123"
}
```
### GetItem und JSON-Dokumente
Im Abschnitt [PutItem und JSON-Dokumente](#PutItemJavaDocumentAPI.JSON) haben Sie ein JSON-Dokument in einem `Map`-Attribut mit dem Namen `VendorInfo` gespeichert. Sie können die `getItem`-Methode verwenden, um das gesamte Dokument im JSON-Format abzurufen. Sie können auch die Dokumentpfadnotation verwenden, um nur einige der Elemente des Dokuments abzurufen. Das folgende Java-Codebeispiel veranschaulicht diese Vorgehensweisen.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210);
System.out.println("All vendor info:");
spec.withProjectionExpression("VendorInfo");
System.out.println(table.getItem(spec).toJSON());
System.out.println("A single vendor:");
spec.withProjectionExpression("VendorInfo.V03");
System.out.println(table.getItem(spec).toJSON());
System.out.println("First office location for this vendor:");
spec.withProjectionExpression("VendorInfo.V03.Offices[0]");
System.out.println(table.getItem(spec).toJSON());
```
Die Ausgabe aus dem vorherigen Beispiel sieht wie folgt aus.
```
All vendor info:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]},"V02":{"Name":"New Publishers, Inc.","Offices":["London","New York"]},"V01":{"Name":"Acme Books","Offices":["Seattle"]}}}
A single vendor:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]}}}
First office location for a single vendor:
{"VendorInfo":{"V03":{"Offices":["Tokyo"]}}}
```
**Anmerkung**
Mit der `toJSON`-Methode können Sie jedes beliebige Element (oder seine Attribute) in eine JSON-formatierte Zeichenfolge umwandeln. Das folgende Codeausschnitt ruft mehrere Attribute auf oberster Ebene und verschachtelte Attribute ab und druckt die Ergebnisse im JSON-Format.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210)
.withProjectionExpression("VendorInfo.V01, Title, Price");
Item item = table.getItem(spec);
System.out.println(item.toJSON());
```
Die Ausgabe sieht wie folgt aus.
```
{"VendorInfo":{"V01":{"Name":"Acme Books","Offices":["Seattle"]}},"Price":30,"Title":"Book 210 Title"}
```
## Batch Write: Einfügen und Löschen mehrerer Elemente
*Batch Write* bezieht sich auf das Einfügen und Löschen mehrerer Elemente in einem Batch. Die `batchWriteItem`-Methode ermöglicht Ihnen das Einfügen und Löschen von mehreren Elementen aus einer oder mehreren Tabellen anhand eines einzigen Aufrufs. Im Folgenden finden Sie die Schritte zum Einfügen oder Löschen mehrerer Elemente mithilfe der AWS SDK für Java Dokument-API.
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `TableWriteItems`-Klasse, die alle Einfügen- und Löschen-Operationen für eine Tabelle beschreibt. Wenn Sie mit einer einzigen BatchWrite-Operation in mehrere Tabellen schreiben möchten, müssen Sie eine `TableWriteItems`-Instance pro Tabelle erstellen.
1. Rufen Sie die `batchWriteItem`-Methode auf, indem Sie das bzw. die `TableWriteItems`-Objekt(e) bereitstellen, das/die Sie im vorangegangenen Schritt erstellt haben.
1. Verarbeiten Sie die Antwort. Überprüfen Sie, ob in der Antwort nicht verarbeitete Anforderungselemente zurückgegeben wurden. Dies kann der Fall sein, wenn Sie das Kontingent für den bereitgestellten Durchsatz erreichen oder ein anderer vorübergehender Fehler auftritt. Außerdem begrenzt DynamoDB die Anforderungsgröße und die Anzahl der Vorgänge, die Sie in einer Anforderung angeben können. Wenn Sie diese Limits überschreiten, wird die Anforderung von DynamoDB abgelehnt. Weitere Informationen finden Sie unter [Kontingente in Amazon DynamoDB](ServiceQuotas.md).
Im folgenden Java-Codebeispiel werden die vorherigen Schritte veranschaulicht. Das folgende Beispiel führt eine `batchWriteItem`-Operation für zwei Tabellen durch: `Forum` und `Thread`. Die entsprechenden `TableWriteItems`-Objekte definieren die folgenden Aktionen:
+ Einfügen eines Elements in die `Forum`-Tabelle
+ Einfügen und Löschen eines Elements in der `Thread`-Tabelle
Der Code ruft dann `batchWriteItem` auf, um die Operation durchzuführen.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableWriteItems forumTableWriteItems = new TableWriteItems("Forum")
.withItemsToPut(
new Item()
.withPrimaryKey("Name", "Amazon RDS")
.withNumber("Threads", 0));
TableWriteItems threadTableWriteItems = new TableWriteItems("Thread")
.withItemsToPut(
new Item()
.withPrimaryKey("ForumName","Amazon RDS","Subject","Amazon RDS Thread 1")
.withHashAndRangeKeysToDelete("ForumName","Some partition key value", "Amazon S3", "Some sort key value");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
// Code for checking unprocessed items is omitted in this example
```
Ein funktionierendes Beispiel finden Sie unter [Beispiel: Batch-Schreibvorgang mit der AWS SDK für Java Dokument-API](batch-operation-document-api-java.md#JavaDocumentAPIBatchWrite).
## Batch Get: Abrufen mehrerer Elemente
Die `batchGetItem`-Methode ermöglicht Ihnen das Abrufen mehrerer Elemente aus einer oder mehreren Tabellen. Um ein einzelnes Element abzurufen, können Sie die `getItem`-Methode verwenden.
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `TableKeysAndAttributes`-Klasse, die eine Liste der Primärschlüsselwerte beschreibt, die von einer Tabelle abgerufen werden sollen. Wenn Sie mit einer einzigen BatchGet-Operation aus mehreren Tabellen lesen möchten, müssen Sie eine `TableKeysAndAttributes`-Instance pro Tabelle erstellen.
1. Rufen Sie die `batchGetItem`-Methode auf, indem Sie das bzw. die `TableKeysAndAttributes`-Objekt(e) bereitstellen, das/die Sie im vorangegangenen Schritt erstellt haben.
Im folgenden Java-Codebeispiel werden die vorherigen Schritte veranschaulicht. In dem Beispiel werden zwei Elemente aus der `Forum`-Tabelle und drei Elemente aus der `Thread`-Tabelle abgerufen.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject",
"Amazon DynamoDB","DynamoDB Thread 1",
"Amazon DynamoDB","DynamoDB Thread 2",
"Amazon S3","S3 Thread 1");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(
forumTableKeysAndAttributes, threadTableKeysAndAttributes);
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item);
}
}
```
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie bei Verwendung von `batchGetItem` auch optionale Parameter angeben. Beispielsweise können Sie einen `ProjectionExpression` mit jedem `TableKeysAndAttributes`, das Sie definieren, bereitstellen. So können Sie die Attribute angeben, die aus der Tabelle abgerufen werden sollen.
Im folgenden C\$1-Codebeispiel werden zwei Elemente aus der `Forum`-Tabelle abgerufen. Der Parameter `withProjectionExpression` gibt an, dass nur das Attribut `Threads` abgerufen werden soll.
**Example**
```
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes("Forum")
.withProjectionExpression("Threads");
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes);
```
## Aktualisieren eines Elements
Die `updateItem`-Methode eines `Table`-Objekts kann vorhandene Attributwerte aktualisieren, neue Attribute hinzuzufügen oder Attribute aus einem vorhandenen Element löschen.
Die `updateItem`-Methode verhält sich wie folgt:
+ Wenn kein Element vorhanden ist (kein Element in der Tabelle mit dem angegebenen Primärschlüssel), fügt `updateItem` der Tabelle ein neues Element hinzu.
+ Wenn ein Element vorhanden ist, führt `updateItem` die Aktualisierung wie vom `UpdateExpression`-Parameter angegeben aus.
**Anmerkung**
Es ist auch möglich, ein Element mit `putItem` zu "aktualisieren". Wenn Sie z. B. `putItem` aufrufen, um der Tabelle ein Element hinzuzufügen, aber bereits ein Element mit dem angegebenen Primärschlüssel vorhanden ist, wird das gesamte Element von `putItem` ersetzt. Wenn Attribute in dem vorhandenen Element nicht in der Eingabe angegeben sind, werden diese Attribute von `putItem` aus dem Element entfernt.
Im Allgemeinen empfehlen wir, `updateItem` immer dann zu verwenden, wenn Sie Elementattribute ändern möchten. Die `updateItem`-Methode ändert nur die Elementattribute, die Sie in der Eingabe angeben. Die anderen Attribute im Element bleiben unverändert.
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `Table`-Klasse, um die Tabelle zu repräsentieren, mit der Sie arbeiten möchten.
1. Rufen Sie die `updateTable`-Methode für die `Table`-Instance auf. Sie müssen den Primärschlüssel des abzurufenden Elements und einen `UpdateExpression` angeben, der die zu ändernden Attribute beschreibt und mitteilt, wie diese geändert werden sollen.
Im folgenden Java-Codebeispiel werden die vorherigen Aufgaben veranschaulicht. Das Beispiel aktualisiert ein Buchelement in der `ProductCatalog`-Tabelle. Es wird ein neuer Autor zum Satz der `Authors` hinzugefügt und das vorhandene `ISBN`-Attribut wird gelöscht. Darüber hinaus wird auch der Preis um eins gesenkt.
Im `ExpressionAttributeValues` wird eine `UpdateExpression`-Zuordnung verwendet. Die Platzhalter `:val1` und `:val2` werden zur Laufzeit durch die tatsächlichen Werte für `Authors` und `Price` ersetzt.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#A", "Authors");
expressionAttributeNames.put("#P", "Price");
expressionAttributeNames.put("#I", "ISBN");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1",
new HashSet(Arrays.asList("Author YY","Author ZZ")));
expressionAttributeValues.put(":val2", 1); //Price
UpdateItemOutcome outcome = table.updateItem(
"Id", // key attribute name
101, // key attribute value
"add #A :val1 set #P = #P - :val2 remove #I", // UpdateExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie auch optionale Parameter für die `updateItem`-Methode angeben, z. B. eine Bedingung, die erfüllt werden muss, damit die Aktualisierung erfolgt. Wenn die von Ihnen angegebene Bedingung nicht erfüllt ist, wird AWS SDK für Java eine `ConditionalCheckFailedException` ausgelöst. Beim folgenden Java-Codebeispiel wird der Preis eines Buchelements bedingungsabhängig auf 25 erhöht. Das Beispiel zeigt einen `ConditionExpression`, der besagt, dass der Preis nur aktualisiert werden soll, wenn der vorhandene Preis 20 lautet.
**Example**
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#P", "Price");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1", 25); // update Price to 25...
expressionAttributeValues.put(":val2", 20); //...but only if existing Price is 20
UpdateItemOutcome outcome = table.updateItem(
new PrimaryKey("Id",101),
"set #P = :val1", // UpdateExpression
"#P = :val2", // ConditionExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Unteilbarer Zähler
Sie können `updateItem` verwenden, um einen unteilbaren Zähler zu implementieren, mit dem der Wert eines bestehenden Attributs erhöht oder verringert wird, ohne andere Schreibanforderungen zu beeinflussen. Zum Erhöhen eines unteilbaren Zählers verwenden Sie einen `UpdateExpression` mit einer `set`-Aktion, um einem vorhandenen Attribut vom Typ `Number` einen numerischen Wert hinzuzufügen.
Das folgende Codebeispiel zeigt diesen Vorgang und erhöht das Attribut `Quantity` um eins. Es zeigt auch die Verwendung des Parameters `ExpressionAttributeNames` in einem `UpdateExpression`.
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#p", "PageCount");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", 1);
UpdateItemOutcome outcome = table.updateItem(
"Id", 121,
"set #p = #p + :val",
expressionAttributeNames,
expressionAttributeValues);
```
## Löschen eines Elements
Die `deleteItem`-Methode löscht ein Element aus einer Tabelle. Sie müssen den Primärschlüssel des Elements bereitstellen, das Sie löschen möchten.
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance des `DynamoDB`-Clients.
1. Rufen Sie die `deleteItem`-Methode durch Angabe des Schlüssels des Elements auf, das Sie löschen möchten.
Das folgende Java-Codebeispiel veranschaulicht diese Vorgehensweisen.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
DeleteItemOutcome outcome = table.deleteItem("Id", 101);
```
### Angeben eines optionalen Parameters
Sie können für `deleteItem` optionale Parameter angeben. Das folgende Java-Codebeispiel enthält einen `ConditionExpression`, der besagt, dass ein Buchelement im `InPublication` nur dann gelöscht werden darf, wenn das Buch nicht mehr veröffentlicht wird (das Attribut `ProductCatalog` ist False).
**Example**
```
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", false);
DeleteItemOutcome outcome = table.deleteItem("Id",103,
"InPublication = :val",
null, // ExpressionAttributeNames - not used in this example
expressionAttributeValues);
```
# Beispiel: CRUD-Operationen mit der AWS SDK für Java Dokument-API
Das folgende Codebeispiel veranschaulicht CRUD-Operationen für ein Amazon-DynamoDB-Element. In dem Beispiel wird ein Element erstellt, abgerufen, es werden verschiedene Aktualisierungen durchgeführt und es wird schließlich gelöscht.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
**Anmerkung**
In diesem Codebeispiel wird davon ausgegangen, dass Sie bereits Daten für Ihr Konto in DynamoDB geladen haben, indem Sie die Anweisungen im [Erstellen von Tabellen und Laden von Daten für Codebeispiele in DynamoDB](SampleData.md)-Abschnitt befolgen.
step-by-stepAnweisungen zur Ausführung des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
public class DocumentAPIItemCRUDExample {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "ProductCatalog";
public static void main(String[] args) throws IOException {
createItems();
retrieveItem();
// Perform various updates.
updateMultipleAttributes();
updateAddNewAttribute();
updateExistingAttributeConditionally();
// Delete the item.
deleteItem();
}
private static void createItems() {
Table table = dynamoDB.getTable(tableName);
try {
Item item = new Item().withPrimaryKey("Id", 120).withString("Title", "Book 120 Title")
.withString("ISBN", "120-1111111111")
.withStringSet("Authors", new HashSet(Arrays.asList("Author12", "Author22")))
.withNumber("Price", 20).withString("Dimensions", "8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", false).withString("ProductCategory", "Book");
table.putItem(item);
item = new Item().withPrimaryKey("Id", 121).withString("Title", "Book 121 Title")
.withString("ISBN", "121-1111111111")
.withStringSet("Authors", new HashSet(Arrays.asList("Author21", "Author 22")))
.withNumber("Price", 20).withString("Dimensions", "8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);
} catch (Exception e) {
System.err.println("Create items failed.");
System.err.println(e.getMessage());
}
}
private static void retrieveItem() {
Table table = dynamoDB.getTable(tableName);
try {
Item item = table.getItem("Id", 120, "Id, ISBN, Title, Authors", null);
System.out.println("Printing item after retrieving it....");
System.out.println(item.toJSONPretty());
} catch (Exception e) {
System.err.println("GetItem failed.");
System.err.println(e.getMessage());
}
}
private static void updateAddNewAttribute() {
Table table = dynamoDB.getTable(tableName);
try {
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 121)
.withUpdateExpression("set #na = :val1").withNameMap(new NameMap().with("#na", "NewAttribute"))
.withValueMap(new ValueMap().withString(":val1", "Some value"))
.withReturnValues(ReturnValue.ALL_NEW);
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after adding new attribute...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Failed to add new attribute in " + tableName);
System.err.println(e.getMessage());
}
}
private static void updateMultipleAttributes() {
Table table = dynamoDB.getTable(tableName);
try {
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)
.withUpdateExpression("add #a :val1 set #na=:val2")
.withNameMap(new NameMap().with("#a", "Authors").with("#na", "NewAttribute"))
.withValueMap(
new ValueMap().withStringSet(":val1", "Author YY", "Author ZZ").withString(":val2",
"someValue"))
.withReturnValues(ReturnValue.ALL_NEW);
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after multiple attribute update...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Failed to update multiple attributes in " + tableName);
System.err.println(e.getMessage());
}
}
private static void updateExistingAttributeConditionally() {
Table table = dynamoDB.getTable(tableName);
try {
// Specify the desired price (25.00) and also the condition (price =
// 20.00)
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)
.withReturnValues(ReturnValue.ALL_NEW).withUpdateExpression("set #p = :val1")
.withConditionExpression("#p = :val2").withNameMap(new NameMap().with("#p", "Price"))
.withValueMap(new ValueMap().withNumber(":val1", 25).withNumber(":val2", 20));
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after conditional update to new attribute...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Error updating item in " + tableName);
System.err.println(e.getMessage());
}
}
private static void deleteItem() {
Table table = dynamoDB.getTable(tableName);
try {
DeleteItemSpec deleteItemSpec = new DeleteItemSpec().withPrimaryKey("Id", 120)
.withConditionExpression("#ip = :val").withNameMap(new NameMap().with("#ip", "InPublication"))
.withValueMap(new ValueMap().withBoolean(":val", false)).withReturnValues(ReturnValue.ALL_OLD);
DeleteItemOutcome outcome = table.deleteItem(deleteItemSpec);
// Check the response.
System.out.println("Printing item that was deleted...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Error deleting item in " + tableName);
System.err.println(e.getMessage());
}
}
}
```
# Beispiel: Batch-Operationen mithilfe der AWS SDK für Java Dokument-API
Dieser Abschnitt enthält Beispiele für Batch-Write- und Batch-Abruf-Operationen in Amazon DynamoDB mithilfe der AWS SDK für Java Document API.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
**Topics**
+ [Beispiel: Batch-Schreibvorgang mit der AWS SDK für Java Dokument-API](#JavaDocumentAPIBatchWrite)
+ [Beispiel: Batch-Abruf-Vorgang mit der AWS SDK für Java Dokument-API](#JavaDocumentAPIBatchGet)
## Beispiel: Batch-Schreibvorgang mit der AWS SDK für Java Dokument-API
Das folgende Java-Beispielcode verwendet die `batchWriteItem`-Methode zur Durchführung der folgenden Operationen zum Einfügen und Löschen:
+ Einfügen eines Elements in die `Forum`-Tabelle
+ Einfügen und Löschen eines Elements aus der `Thread`-Tabelle
Bei der Erstellung Ihrer BatchWrite-Anforderung können Sie eine beliebige Anzahl von Einfüge- und Lösch-Anforderungen angeben. `batchWriteItem` begrenzt jedoch die Größe einer BatchWrite-Anforderung sowie die Anzahl der Einfüge- und Löschoperationen in einer einzelnen BatchWrite-Operation. Wenn Ihre Anforderung diese Grenzwerte überschreitet, wird sie abgelehnt. Wenn die Tabelle nicht über ausreichend bereitgestellten Durchsatz für diese Anforderung verfügt, werden nicht verarbeitete Anforderungselemente in der Antwort zurückgegeben.
Im folgenden Beispiel wird die Antwort auf unverarbeitete Anforderungselemente überprüft. Liegen unverarbeitete Elemente vor, wird der Vorgang wiederholt und die `batchWriteItem`-Anforderung mit unverarbeiteten Elementen wird erneut gesendet. Wenn Sie die Beispiele in dieser Anleitung befolgt haben, sollten Sie die Tabellen `Forum` und `Thread` bereits erstellt haben. Sie können diese Tabellen auch programmgesteuert erstellen und auf die gleiche Weise Beispieldaten hochladen. Weitere Informationen finden Sie unter [Erstellen von Beispieltabellen und Hochladen von Daten mit dem AWS SDK für Java](AppendixSampleDataCodeJava.md).
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchWriteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableWriteItems;
import com.amazonaws.services.dynamodbv2.model.WriteRequest;
public class DocumentAPIBatchWrite {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String forumTableName = "Forum";
static String threadTableName = "Thread";
public static void main(String[] args) throws IOException {
writeMultipleItemsBatchWrite();
}
private static void writeMultipleItemsBatchWrite() {
try {
// Add a new item to Forum
TableWriteItems forumTableWriteItems = new TableWriteItems(forumTableName) // Forum
.withItemsToPut(new Item().withPrimaryKey("Name", "Amazon RDS").withNumber("Threads", 0));
// Add a new item, and delete an existing item, from Thread
// This table has a partition key and range key, so need to specify
// both of them
TableWriteItems threadTableWriteItems = new TableWriteItems(threadTableName)
.withItemsToPut(
new Item().withPrimaryKey("ForumName", "Amazon RDS", "Subject", "Amazon RDS Thread 1")
.withString("Message", "ElastiCache Thread 1 message")
.withStringSet("Tags", new HashSet(Arrays.asList("cache", "in-memory"))))
.withHashAndRangeKeysToDelete("ForumName", "Subject", "Amazon S3", "S3 Thread 100");
System.out.println("Making the request.");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
do {
// Check for unprocessed keys which could happen if you exceed
// provisioned throughput
Map> unprocessedItems = outcome.getUnprocessedItems();
if (outcome.getUnprocessedItems().size() == 0) {
System.out.println("No unprocessed items found");
} else {
System.out.println("Retrieving the unprocessed items");
outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems);
}
} while (outcome.getUnprocessedItems().size() > 0);
} catch (Exception e) {
System.err.println("Failed to retrieve items: ");
e.printStackTrace(System.err);
}
}
}
```
## Beispiel: Batch-Abruf-Vorgang mit der AWS SDK für Java Dokument-API
Das folgende Java-Codebeispiel verwendet die `batchGetItem`-Methode zum Abrufen mehrerer Elemente aus den Tabellen `Forum` und `Thread`. Die `BatchGetItemRequest` gibt die Tabellennamen sowie eine Liste der Schlüssel für jedes abzurufende Element an. In dem Beispiel wird die Antwort durch Drucken der abgerufenen Elemente verarbeitet.
**Anmerkung**
In diesem Codebeispiel wird davon ausgegangen, dass Sie bereits Daten für Ihr Konto in DynamoDB geladen haben, indem Sie die Anweisungen im [Erstellen von Tabellen und Laden von Daten für Codebeispiele in DynamoDB](SampleData.md)-Abschnitt befolgen.
step-by-stepAnweisungen zur Ausführung des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchGetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableKeysAndAttributes;
import com.amazonaws.services.dynamodbv2.model.KeysAndAttributes;
public class DocumentAPIBatchGet {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String forumTableName = "Forum";
static String threadTableName = "Thread";
public static void main(String[] args) throws IOException {
retrieveMultipleItemsBatchGet();
}
private static void retrieveMultipleItemsBatchGet() {
try {
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
// Add a partition key
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name", "Amazon S3", "Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
// Add a partition key and a sort key
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject", "Amazon DynamoDB",
"DynamoDB Thread 1", "Amazon DynamoDB", "DynamoDB Thread 2", "Amazon S3", "S3 Thread 1");
System.out.println("Making the request.");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes,
threadTableKeysAndAttributes);
Map unprocessed = null;
do {
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List
- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item.toJSONPretty());
}
}
// Check for unprocessed keys which could happen if you exceed
// provisioned
// throughput or reach the limit on response size.
unprocessed = outcome.getUnprocessedKeys();
if (unprocessed.isEmpty()) {
System.out.println("No unprocessed keys found");
} else {
System.out.println("Retrieving the unprocessed keys");
outcome = dynamoDB.batchGetItemUnprocessed(unprocessed);
}
} while (!unprocessed.isEmpty());
} catch (Exception e) {
System.err.println("Failed to retrieve items.");
System.err.println(e.getMessage());
}
}
}
```
# Beispiel: Umgang mit binären Typattributen mithilfe der AWS SDK für Java Dokument-API
Das folgende Java-Codebeispiel veranschaulicht die Verarbeitung von Attributen des Typs Binärzahl. Bei dem Beispiel wird der `Reply`-Tabelle ein Element hinzugefügt. Das Element enthält ein Binärtypattribut (`ExtendedMessage`), in dem komprimierte Daten gespeichert sind. Daraufhin wird das Element abgerufen und es werden alle Attributwerte gedruckt. Zur Veranschaulichung wird in dem Beispiel die `GZIPOutputStream`-Klasse verwendet, um einen Beispiel-Stream zu komprimieren und dem `ExtendedMessage`-Attribut zuzuweisen. Wenn das Binärattribut abgerufen wird, wird es mit der `GZIPInputStream`-Klasse dekomprimiert.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
Wenn Sie die Schritte im Abschnitt [Erstellen von Tabellen und Laden von Daten für Codebeispiele in DynamoDB](SampleData.md) befolgt haben, sollten Sie die `Reply`-Tabelle bereits erstellt haben. Sie können diese Tabelle auch programmgesteuert erstellen. Weitere Informationen finden Sie unter [Erstellen von Beispieltabellen und Hochladen von Daten mit dem AWS SDK für Java](AppendixSampleDataCodeJava.md).
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.GetItemSpec;
public class DocumentAPIItemBinaryExample {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "Reply";
static SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
public static void main(String[] args) throws IOException {
try {
// Format the primary key values
String threadId = "Amazon DynamoDB#DynamoDB Thread 2";
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String replyDateTime = dateFormatter.format(new Date());
// Add a new reply with a binary attribute type
createItem(threadId, replyDateTime);
// Retrieve the reply with a binary attribute type
retrieveItem(threadId, replyDateTime);
// clean up by deleting the item
deleteItem(threadId, replyDateTime);
} catch (Exception e) {
System.err.println("Error running the binary attribute type example: " + e);
e.printStackTrace(System.err);
}
}
public static void createItem(String threadId, String replyDateTime) throws IOException {
Table table = dynamoDB.getTable(tableName);
// Craft a long message
String messageInput = "Long message to be compressed in a lengthy forum reply";
// Compress the long message
ByteBuffer compressedMessage = compressString(messageInput.toString());
table.putItem(new Item().withPrimaryKey("Id", threadId).withString("ReplyDateTime", replyDateTime)
.withString("Message", "Long message follows").withBinary("ExtendedMessage", compressedMessage)
.withString("PostedBy", "User A"));
}
public static void retrieveItem(String threadId, String replyDateTime) throws IOException {
Table table = dynamoDB.getTable(tableName);
GetItemSpec spec = new GetItemSpec().withPrimaryKey("Id", threadId, "ReplyDateTime", replyDateTime)
.withConsistentRead(true);
Item item = table.getItem(spec);
// Uncompress the reply message and print
String uncompressed = uncompressString(ByteBuffer.wrap(item.getBinary("ExtendedMessage")));
System.out.println("Reply message:\n" + " Id: " + item.getString("Id") + "\n" + " ReplyDateTime: "
+ item.getString("ReplyDateTime") + "\n" + " PostedBy: " + item.getString("PostedBy") + "\n"
+ " Message: "
+ item.getString("Message") + "\n" + " ExtendedMessage (uncompressed): " + uncompressed + "\n");
}
public static void deleteItem(String threadId, String replyDateTime) {
Table table = dynamoDB.getTable(tableName);
table.deleteItem("Id", threadId, "ReplyDateTime", replyDateTime);
}
private static ByteBuffer compressString(String input) throws IOException {
// Compress the UTF-8 encoded String into a byte[]
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream os = new GZIPOutputStream(baos);
os.write(input.getBytes("UTF-8"));
os.close();
baos.close();
byte[] compressedBytes = baos.toByteArray();
// The following code writes the compressed bytes to a ByteBuffer.
// A simpler way to do this is by simply calling
// ByteBuffer.wrap(compressedBytes);
// However, the longer form below shows the importance of resetting the
// position of the buffer
// back to the beginning of the buffer if you are writing bytes directly
// to it, since the SDK
// will consider only the bytes after the current position when sending
// data to DynamoDB.
// Using the "wrap" method automatically resets the position to zero.
ByteBuffer buffer = ByteBuffer.allocate(compressedBytes.length);
buffer.put(compressedBytes, 0, compressedBytes.length);
buffer.position(0); // Important: reset the position of the ByteBuffer
// to the beginning
return buffer;
}
private static String uncompressString(ByteBuffer input) throws IOException {
byte[] bytes = input.array();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPInputStream is = new GZIPInputStream(bais);
int chunkSize = 1024;
byte[] buffer = new byte[chunkSize];
int length = 0;
while ((length = is.read(buffer, 0, chunkSize)) != -1) {
baos.write(buffer, 0, length);
}
String result = new String(baos.toByteArray(), "UTF-8");
is.close();
baos.close();
bais.close();
return result;
}
}
```
# Arbeiten mit Elementen: .NET
Sie können die AWS SDK für .NET Low-Level-API verwenden, um typische Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge (CRUD) für ein Element in einer Tabelle durchzuführen. Nachfolgend sind die üblichen Schritte zum Ausführen von CRUD-Operationen mit der .NET-Low-Level-API ausführen:
1. Erstellen einer Instance der `AmazonDynamoDBClient`-Klasse (Client).
1. Geben Sie die für die Operation spezifischen, erforderlichen Parameter in einem entsprechenden Anforderungsobjekt an.
Verwenden Sie z. B. das `PutItemRequest`-Anforderungsobjekt zum Hochladen eines Elements und das `GetItemRequest`-Anforderungsobjekt, wenn Sie ein vorhandenes Element abrufen.
Mit dem Anforderungsobjekt können Sie sowohl die erforderlichen als auch die optionalen Parameter angeben.
1. Führen Sie die vom Client bereitgestellte, geeignete Methode aus, indem Sie das Anforderungsobjekt, das Sie im vorhergehenden Schritt erstellt haben, übergeben.
Der `AmazonDynamoDBClient`-Client bietet die Methoden `PutItem`, `GetItem`, `UpdateItem` und `DeleteItem` für die CRUD-Operationen.
**Topics**
+ [Einfügen eines Elements](#PutItemLowLevelAPIDotNet)
+ [Abrufen eines Elements](#GetItemLowLevelDotNET)
+ [Aktualisieren eines Elements](#UpdateItemLowLevelDotNet)
+ [Unteilbarer Zähler](#AtomicCounterLowLevelDotNet)
+ [Löschen eines Elements](#DeleteMidLevelDotNet)
+ [Batch Write: Einfügen und Löschen mehrerer Elemente](#BatchWriteLowLevelDotNet)
+ [Batch Get: Abrufen mehrerer Elemente](#BatchGetLowLevelDotNet)
+ [Beispiel: CRUD-Operationen unter Verwendung der AWS SDK für .NET Low-Level-API](LowLevelDotNetItemsExample.md)
+ [Beispiel: Batch-Operationen mit der AWS SDK für .NET Low-Level-API](batch-operation-lowlevel-dotnet.md)
+ [Beispiel: Umgang mit binären Attributen mithilfe der AWS SDK für .NET Low-Level-API](LowLevelDotNetBinaryTypeExample.md)
## Einfügen eines Elements
Mit der `PutItem`-Methode wird ein Element in eine Tabelle hochgeladen. Wenn das Element bereits vorhanden ist, wird das ganze Element ersetzt.
**Anmerkung**
Anstatt das gesamte Element zu ersetzen und nur spezifische Attribute zu aktualisieren, können Sie die Methode `UpdateItem` verwenden. Weitere Informationen finden Sie unter [Aktualisieren eines Elements](#UpdateItemLowLevelDotNet).
Im Folgenden finden Sie die Schritte zum Hochladen eines Elements mithilfe der .NET SDK-API auf niedriger Ebene:
1. Erstellen Sie eine Instance der `AmazonDynamoDBClient`-Klasse.
1. Stellen Sie die erforderlichen Parameter bereit, in dem Sie eine Instance der `PutItemRequest`-Klasse erstellen.
Um für ein Element eine PUT-Operation auszuführen, müssen Sie den Tabellennamen und das Element angeben.
1. Führen Sie die `PutItem`-Methode aus, indem Sie das `PutItemRequest`-Objekt bereitstellen, das Sie im vorherigen Schritt erstellt haben.
Im folgenden C\$1-Codebeispiel werden die vorherigen Schritte veranschaulicht. Das Beispiel lädt ein Element in die `ProductCatalog`-Tabelle hoch.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue { N = "201" }},
{ "Title", new AttributeValue { S = "Book 201 Title" }},
{ "ISBN", new AttributeValue { S = "11-11-11-11" }},
{ "Price", new AttributeValue { S = "20.00" }},
{
"Authors",
new AttributeValue
{ SS = new List{"Author1", "Author2"} }
}
}
};
client.PutItem(request);
```
Im vorherigen Beispiel laden Sie ein Buchelement mit den Attributen `Id`, `Title`, `ISBN` und `Authors` hoch. Beachten Sie, dass `Id` ein Attribut vom Typ Zahl ist. Alle anderen Attribute sind vom Typ Zeichenfolge. Autoren ist eine `String`-Einstellung.
### Angeben eines optionalen Parameters
Sie können mit dem `PutItemRequest`-Objekt auch optionale Parameter angeben, wie im folgenden C\$1-Beispiel dargestellt. Das Beispiel gibt die folgenden optionalen Parameter an:
+ `ExpressionAttributeNames`, `ExpressionAttributeValues` und `ConditionExpression` geben an, dass das Element nur ersetzt werden kann, wenn das vorhandene Element das Attribut "ISBN" mit einem spezifischen Wert besitzt.
+ Mit dem Parameter `ReturnValues` wird das alte Element in der Antwort angefordert.
**Example**
```
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue { N = "104" }},
{ "Title", new AttributeValue { S = "Book 104 Title" }},
{ "ISBN", new AttributeValue { S = "444-4444444444" }},
{ "Authors",
new AttributeValue { SS = new List{"Author3"}}}
},
// Optional parameters.
ExpressionAttributeNames = new Dictionary()
{
{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary()
{
{":isbn",new AttributeValue {S = "444-4444444444"}}
},
ConditionExpression = "#I = :isbn"
};
var response = client.PutItem(request);
```
Weitere Informationen finden Sie unter [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).
## Abrufen eines Elements
Die `GetItem`-Methode ruft ein Element ab.
**Anmerkung**
Um mehrere Elemente abzurufen, können Sie die `BatchGetItem`-Methode verwenden. Weitere Informationen finden Sie unter [Batch Get: Abrufen mehrerer Elemente](#BatchGetLowLevelDotNet).
Im Folgenden werden die Schritte zum Abrufen eines vorhandenen Elements mithilfe des AWS SDK für .NET -Low-Level-API beschrieben.
1. Erstellen Sie eine Instance der `AmazonDynamoDBClient`-Klasse.
1. Stellen Sie die erforderlichen Parameter bereit, in dem Sie eine Instance der `GetItemRequest`-Klasse erstellen.
Zum Abrufen eines Elements müssen Sie den Tabellennamen und den Primärschlüssel des Elements angeben.
1. Führen Sie die `GetItem`-Methode aus, indem Sie das `GetItemRequest`-Objekt bereitstellen, das Sie im vorherigen Schritt erstellt haben.
Im folgenden C\$1-Codebeispiel werden die vorherigen Schritte veranschaulicht. Das Beispiel ruft ein Objekt aus der `ProductCatalog`-Tabelle ab.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
};
var response = client.GetItem(request);
// Check the response.
var result = response.GetItemResult;
var attributeMap = result.Item; // Attribute list in the response.
```
### Angeben eines optionalen Parameters
Sie können mit dem `GetItemRequest`-Objekt auch optionale Parameter angeben, wie im folgenden C\$1-Beispiel dargestellt. Das Beispiel gibt die folgenden optionalen Parameter an:
+ `ProjectionExpression` Parameter, um die abzurufenden Attribute anzugeben.
+ `ConsistentRead` Parameter zum Ausführen eines Strongly-Consistent-Lesevorgangs. Weitere Informationen zur Lesekonsistenz finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
// Optional parameters.
ProjectionExpression = "Id, ISBN, Title, Authors",
ConsistentRead = true
};
var response = client.GetItem(request);
// Check the response.
var result = response.GetItemResult;
var attributeMap = result.Item;
```
Weitere Informationen finden Sie unter [GetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).
## Aktualisieren eines Elements
Mit der `UpdateItem`-Methode wird ein bestehendes Element aktualisiert, wenn es vorhanden ist. Sie können die `UpdateItem`-Operation verwenden, um vorhandene Attributwerte zu aktualisieren, der vorhandenen Sammlung neue Attribute hinzuzufügen oder Attribute aus der vorhandenen Sammlung zu löschen. Wenn das Element, das den bestimmten Primärschlüssel besitzt, nicht gefunden wird, wird ein neues Element hinzugefügt.
Die `UpdateItem`-Operation verwendet folgende Leitlinien:
+ Wenn das Element nicht vorhanden ist, fügt `UpdateItem` ein neues Element hinzu, indem der in der Eingabe angegebene Primärschlüssel genutzt wird.
+ Wenn das Element vorhanden ist, wendet `UpdateItem` die Aktualisierung wie folgt an:
+ Ersetzt die vorhandenen Attributwerte durch die Werte in der Aktualisierung.
+ Wenn das Attribut, das Sie in der Eingabe angegeben haben, nicht vorhanden ist, wird dem Element ein neues Attribut hinzugefügt.
+ Wenn das Eingabeattribut Null ist, wird das Attribut gelöscht, sofern es vorhanden ist.
+ Wenn Sie `ADD` für die Aktion `Action` verwenden, können Sie einem vorhandenen Satz (Zeichenfolgen- oder Zahlensatz) Werte hinzufügen oder mathematisch addieren (unter Verwendung einer positiven Zahl) bzw. von dem vorhandenen numerischen Attributwert subtrahieren (unter Verwendung einer negativen Zahl).
**Anmerkung**
Die `PutItem`-Operation kann auch eine Aktualisierung durchführen. Weitere Informationen finden Sie unter [Einfügen eines Elements](#PutItemLowLevelAPIDotNet). Wenn Sie z. B. `PutItem` aufrufen, um ein Element hochzuladen, und der Primärschlüssel vorhanden ist, ersetzt die `PutItem`-Operation das gesamte Element. Wenn das vorhandene Element Attribute entiert und diese Attribute nicht in der Eingabe angegeben sind, werden diese Attribute vom `PutItem`-Vorgang gelöscht. Jedoch aktualisiert `UpdateItem` lediglich die angegebenen Eingabeattribute. Alle anderen vorhandenen Attribute dieses Elements bleiben unverändert.
Im Folgenden werden die Schritte zum Aktualisieren eines vorhandenen Elements mithilfe der Low-Level-.NET.SDK-API beschrieben.
1. Erstellen Sie eine Instance der `AmazonDynamoDBClient`-Klasse.
1. Stellen Sie die erforderlichen Parameter bereit, in dem Sie eine Instance der `UpdateItemRequest`-Klasse erstellen.
Dies ist das Anforderungsobjekt, in dem Sie alle Aktualisierungen beschreiben, z. B. Attribute hinzufügen, vorhandene Attribute aktualisieren oder Attribute löschen. Um ein vorhandenes Attribut zu löschen, geben Sie den Attributnamen mit Nullwert an.
1. Führen Sie die `UpdateItem`-Methode aus, indem Sie das `UpdateItemRequest`-Objekt bereitstellen, das Sie im vorherigen Schritt erstellt haben.
Im folgenden C\$1-Codebeispiel werden die vorherigen Schritte veranschaulicht. Im Beispiel wird ein Buchelement in der `ProductCatalog`-Tabelle aktualisiert. Es fügt der `Authors`-Auflistung einen neuen Autor hinzu und löscht das vorhandene `ISBN`-Attribut. Darüber hinaus wird auch der Preis um eins gesenkt.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new UpdateItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
ExpressionAttributeNames = new Dictionary()
{
{"#A", "Authors"},
{"#P", "Price"},
{"#NA", "NewAttribute"},
{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary()
{
{":auth",new AttributeValue { SS = {"Author YY","Author ZZ"}}},
{":p",new AttributeValue {N = "1"}},
{":newattr",new AttributeValue {S = "someValue"}},
},
// This expression does the following:
// 1) Adds two new authors to the list
// 2) Reduces the price
// 3) Adds a new attribute to the item
// 4) Removes the ISBN attribute from the item
UpdateExpression = "ADD #A :auth SET #P = #P - :p, #NA = :newattr REMOVE #I"
};
var response = client.UpdateItem(request);
```
### Angeben eines optionalen Parameters
Sie können auch optionale Parameter mithilfe des `UpdateItemRequest`-Objekts bereitstellen, wie im folgenden C\$1-Beispiel gezeigt. Folgende optionale Parameter werden angegeben:
+ `ExpressionAttributeValues` und `ConditionExpression`, um festzulegen, dass der Preis nur aktualisiert werden kann, wenn er momentan 20,00 beträgt.
+ Der Parameter `ReturnValues` zum Anfordern des aktualisierten Elements in der Antwort.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new UpdateItemRequest
{
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
// Update price only if the current price is 20.00.
ExpressionAttributeNames = new Dictionary()
{
{"#P", "Price"}
},
ExpressionAttributeValues = new Dictionary()
{
{":newprice",new AttributeValue {N = "22"}},
{":currprice",new AttributeValue {N = "20"}}
},
UpdateExpression = "SET #P = :newprice",
ConditionExpression = "#P = :currprice",
TableName = tableName,
ReturnValues = "ALL_NEW" // Return all the attributes of the updated item.
};
var response = client.UpdateItem(request);
```
Weitere Informationen finden Sie unter [UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).
## Unteilbarer Zähler
Sie können `updateItem` verwenden, um einen unteilbaren Zähler zu implementieren, mit dem der Wert eines bestehenden Attributs erhöht oder verringert wird, ohne andere Schreibanforderungen zu beeinflussen. Um einen Atomzähler zu aktualisieren, verwenden Sie `updateItem` mit einem Attribut vom Typ `Number` im Parameter `UpdateExpression` und `ADD` als `Action`.
Das folgende Codebeispiel zeigt diesen Vorgang und erhöht das Attribut `Quantity` um eins.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new UpdateItemRequest
{
Key = new Dictionary() { { "Id", new AttributeValue { N = "121" } } },
ExpressionAttributeNames = new Dictionary()
{
{"#Q", "Quantity"}
},
ExpressionAttributeValues = new Dictionary()
{
{":incr",new AttributeValue {N = "1"}}
},
UpdateExpression = "SET #Q = #Q + :incr",
TableName = tableName
};
var response = client.UpdateItem(request);
```
## Löschen eines Elements
Die `DeleteItem`-Methode löscht ein Element aus einer Tabelle.
Im Folgenden werden die Schritte zum Löschen eines Elements mithilfe der .NET SDK-Low-Level-API beschrieben.
1. Erstellen Sie eine Instance der `AmazonDynamoDBClient`-Klasse.
1. Stellen Sie die erforderlichen Parameter bereit, in dem Sie eine Instance der `DeleteItemRequest`-Klasse erstellen.
Zum Löschen eines Elements sind der Tabellenname und der Primärschlüssel des Elements erforderlich.
1. Führen Sie die `DeleteItem`-Methode aus, indem Sie das `DeleteItemRequest`-Objekt bereitstellen, das Sie im vorherigen Schritt erstellt haben.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "201" } } },
};
var response = client.DeleteItem(request);
```
### Angeben eines optionalen Parameters
Sie können mit dem `DeleteItemRequest`-Objekt auch optionale Parameter angeben, wie im folgenden C\$1-Beispiel dargestellt. Folgende optionale Parameter werden angegeben:
+ `ExpressionAttributeValues`und `ConditionExpression` um anzugeben, dass das Buchelement nur gelöscht werden kann, wenn es nicht mehr veröffentlicht wird (der InPublication Attributwert ist falsch).
+ Der Parameter `ReturnValues` zum Anfordern des gelöschten Elements in der Antwort.
**Example**
```
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "201" } } },
// Optional parameters.
ReturnValues = "ALL_OLD",
ExpressionAttributeNames = new Dictionary()
{
{"#IP", "InPublication"}
},
ExpressionAttributeValues = new Dictionary()
{
{":inpub",new AttributeValue {BOOL = false}}
},
ConditionExpression = "#IP = :inpub"
};
var response = client.DeleteItem(request);
```
Weitere Informationen finden Sie unter [DeleteItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).
## Batch Write: Einfügen und Löschen mehrerer Elemente
*Batch Write* bezieht sich auf das Einfügen und Löschen mehrerer Elemente in einem Batch. Die `BatchWriteItem`-Methode ermöglicht Ihnen das Einfügen und Löschen von mehreren Elementen aus einer oder mehreren Tabellen anhand eines einzigen Aufrufs. Im Folgenden werden die Schritte zum Abrufen mehrerer Elemente mithilfe der .NET SDK-Low-Level-API beschrieben.
1. Erstellen Sie eine Instance der `AmazonDynamoDBClient`-Klasse.
1. Beschreiben Sie alle Put- und Delete-Operationen, indem Sie eine Instance der `BatchWriteItemRequest`-Klasse erstellen.
1. Führen Sie die `BatchWriteItem`-Methode aus, indem Sie das `BatchWriteItemRequest`-Objekt bereitstellen, das Sie im vorherigen Schritt erstellt haben.
1. Verarbeiten Sie die Antwort. Überprüfen Sie, ob in der Antwort nicht verarbeitete Anforderungselemente zurückgegeben wurden. Dies kann der Fall sein, wenn Sie das Kontingent für den bereitgestellten Durchsatz erreichen oder ein anderer vorübergehender Fehler auftritt. Außerdem begrenzt DynamoDB die Anforderungsgröße und die Anzahl der Vorgänge, die Sie in einer Anforderung angeben können. Wenn Sie diese Limits überschreiten, wird die Anforderung von DynamoDB abgelehnt. Weitere Informationen finden Sie unter [BatchWriteItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html).
Im folgenden C\$1-Codebeispiel werden die vorherigen Schritte veranschaulicht. Das Beispiel erstellt eine `BatchWriteItemRequest` zum Ausführen der folgenden Schreibvorgänge:
+ Einfügen eines Elements in die `Forum`-Tabelle
+ Einfügen und Löschen eines Elements in der `Thread`-Tabelle.
Der Code führt `BatchWriteItem` aus, um einen Batchvorgang auszuführen.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string table1Name = "Forum";
string table2Name = "Thread";
var request = new BatchWriteItemRequest
{
RequestItems = new Dictionary>
{
{
table1Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "Name", new AttributeValue { S = "Amazon S3 forum" } },
{ "Threads", new AttributeValue { N = "0" }}
}
}
}
}
} ,
{
table2Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "ForumName", new AttributeValue { S = "Amazon S3 forum" } },
{ "Subject", new AttributeValue { S = "My sample question" } },
{ "Message", new AttributeValue { S = "Message Text." } },
{ "KeywordTags", new AttributeValue { SS = new List { "Amazon S3", "Bucket" } } }
}
}
},
new WriteRequest
{
DeleteRequest = new DeleteRequest
{
Key = new Dictionary()
{
{ "ForumName", new AttributeValue { S = "Some forum name" } },
{ "Subject", new AttributeValue { S = "Some subject" } }
}
}
}
}
}
}
};
response = client.BatchWriteItem(request);
```
Ein funktionierendes Beispiel finden Sie unter [Beispiel: Batch-Operationen mit der AWS SDK für .NET Low-Level-API](batch-operation-lowlevel-dotnet.md).
## Batch Get: Abrufen mehrerer Elemente
Die `BatchGetItem`-Methode ermöglicht Ihnen das Abrufen mehrerer Elemente aus einer oder mehreren Tabellen.
**Anmerkung**
Um ein einzelnes Element abzurufen, können Sie die `GetItem`-Methode verwenden.
Im Folgenden werden die Schritte zum Abrufen mehrerer Elemente mithilfe der AWS SDK für .NET -Low-Level-API beschrieben.
1. Erstellen Sie eine Instance der `AmazonDynamoDBClient`-Klasse.
1. Stellen Sie die erforderlichen Parameter bereit, in dem Sie eine Instance der `BatchGetItemRequest`-Klasse erstellen.
Zum Abrufen mehrerer Elemente, sind der Tabellenname und eine Liste der Primärschlüsselwerte erforderlich.
1. Führen Sie die `BatchGetItem`-Methode aus, indem Sie das `BatchGetItemRequest`-Objekt bereitstellen, das Sie im vorherigen Schritt erstellt haben.
1. Verarbeiten Sie die Antwort. Überprüfen Sie, ob nicht verarbeitete Schlüssel vorhanden sind. Dies kann der Fall sein, wenn Sie das Kontingent für den bereitgestellten Durchsatz erreichen oder ein anderer vorübergehender Fehler auftritt.
Im folgenden C\$1-Codebeispiel werden die vorherigen Schritte veranschaulicht. Das Beispiel ruft Elemente aus zwei Tabellen, `Forum` und `Thread`, ab. Die Anforderung gibt zwei Elemente in der Tabelle `Forum` und drei Elemente in der Tabelle `Thread` an. Die Antwort enthält Elemente aus beiden Tabellen. Der Code zeigt, wie Sie die Antwort verarbeiten können.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string table1Name = "Forum";
string table2Name = "Thread";
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List>()
{
new Dictionary()
{
{ "Name", new AttributeValue { S = "DynamoDB" } }
},
new Dictionary()
{
{ "Name", new AttributeValue { S = "Amazon S3" } }
}
}
}
},
{
table2Name,
new KeysAndAttributes
{
Keys = new List>()
{
new Dictionary()
{
{ "ForumName", new AttributeValue { S = "DynamoDB" } },
{ "Subject", new AttributeValue { S = "DynamoDB Thread 1" } }
},
new Dictionary()
{
{ "ForumName", new AttributeValue { S = "DynamoDB" } },
{ "Subject", new AttributeValue { S = "DynamoDB Thread 2" } }
},
new Dictionary()
{
{ "ForumName", new AttributeValue { S = "Amazon S3" } },
{ "Subject", new AttributeValue { S = "Amazon S3 Thread 1" } }
}
}
}
}
}
};
var response = client.BatchGetItem(request);
// Check the response.
var result = response.BatchGetItemResult;
var responses = result.Responses; // The attribute list in the response.
var table1Results = responses[table1Name];
Console.WriteLine("Items in table {0}" + table1Name);
foreach (var item1 in table1Results.Items)
{
PrintItem(item1);
}
var table2Results = responses[table2Name];
Console.WriteLine("Items in table {1}" + table2Name);
foreach (var item2 in table2Results.Items)
{
PrintItem(item2);
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error.
Dictionary unprocessedKeys = result.UnprocessedKeys;
foreach (KeyValuePair pair in unprocessedKeys)
{
Console.WriteLine(pair.Key, pair.Value);
}
```
### Angeben eines optionalen Parameters
Sie können mit dem `BatchGetItemRequest`-Objekt auch optionale Parameter angeben, wie im folgenden C\$1-Beispiel dargestellt. Im Beispiel werden zwei Elemente aus der `Forum` Tabelle abgerufen. Folgende optionale Parameter werden angegeben:
+ `ProjectionExpression` Parameter, um die abzurufenden Attribute anzugeben.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string table1Name = "Forum";
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List>()
{
new Dictionary()
{
{ "Name", new AttributeValue { S = "DynamoDB" } }
},
new Dictionary()
{
{ "Name", new AttributeValue { S = "Amazon S3" } }
}
}
},
// Optional - name of an attribute to retrieve.
ProjectionExpression = "Title"
}
}
};
var response = client.BatchGetItem(request);
```
Weitere Informationen finden Sie unter [BatchGetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchGetItem.html).
# Beispiel: CRUD-Operationen unter Verwendung der AWS SDK für .NET Low-Level-API
Das folgende C\$1-Codebeispiel veranschaulicht CRUD-Operationen für ein Amazon-DynamoDB-Element. Das Beispiel fügt der Tabelle `ProductCatalog` ein Element hinzu, ruft es ab, führt verschiedene Aktualisierungen aus und löscht schließlich das Element. Wenn Sie diese Tabelle nicht erstellt haben, können Sie sie auch programmgesteuert erstellen. Weitere Informationen finden Sie unter [Erstellen von Beispieltabellen und Hochladen von Daten mit dem AWS SDK für .NET](AppendixSampleDataCodeDotNET.md).
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter. [.NET-Codebeispiele](CodeSamples.DotNet.md)
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class LowLevelItemCRUDExample
{
private static string tableName = "ProductCatalog";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
CreateItem();
RetrieveItem();
// Perform various updates.
UpdateMultipleAttributes();
UpdateExistingAttributeConditionally();
// Delete item.
DeleteItem();
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
}
private static void CreateItem()
{
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
}},
{ "Title", new AttributeValue {
S = "Book 201 Title"
}},
{ "ISBN", new AttributeValue {
S = "11-11-11-11"
}},
{ "Authors", new AttributeValue {
SS = new List{"Author1", "Author2" }
}},
{ "Price", new AttributeValue {
N = "20.00"
}},
{ "Dimensions", new AttributeValue {
S = "8.5x11.0x.75"
}},
{ "InPublication", new AttributeValue {
BOOL = false
} }
}
};
client.PutItem(request);
}
private static void RetrieveItem()
{
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
ProjectionExpression = "Id, ISBN, Title, Authors",
ConsistentRead = true
};
var response = client.GetItem(request);
// Check the response.
var attributeList = response.Item; // attribute list in the response.
Console.WriteLine("\nPrinting item after retrieving it ............");
PrintItem(attributeList);
}
private static void UpdateMultipleAttributes()
{
var request = new UpdateItemRequest
{
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
// Perform the following updates:
// 1) Add two new authors to the list
// 1) Set a new attribute
// 2) Remove the ISBN attribute
ExpressionAttributeNames = new Dictionary()
{
{"#A","Authors"},
{"#NA","NewAttribute"},
{"#I","ISBN"}
},
ExpressionAttributeValues = new Dictionary()
{
{":auth",new AttributeValue {
SS = {"Author YY", "Author ZZ"}
}},
{":new",new AttributeValue {
S = "New Value"
}}
},
UpdateExpression = "ADD #A :auth SET #NA = :new REMOVE #I",
TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);
// Check the response.
var attributeList = response.Attributes; // attribute list in the response.
// print attributeList.
Console.WriteLine("\nPrinting item after multiple attribute update ............");
PrintItem(attributeList);
}
private static void UpdateExistingAttributeConditionally()
{
var request = new UpdateItemRequest
{
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
ExpressionAttributeNames = new Dictionary()
{
{"#P", "Price"}
},
ExpressionAttributeValues = new Dictionary()
{
{":newprice",new AttributeValue {
N = "22.00"
}},
{":currprice",new AttributeValue {
N = "20.00"
}}
},
// This updates price only if current price is 20.00.
UpdateExpression = "SET #P = :newprice",
ConditionExpression = "#P = :currprice",
TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);
// Check the response.
var attributeList = response.Attributes; // attribute list in the response.
Console.WriteLine("\nPrinting item after updating price value conditionally ............");
PrintItem(attributeList);
}
private static void DeleteItem()
{
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
// Return the entire item as it appeared before the update.
ReturnValues = "ALL_OLD",
ExpressionAttributeNames = new Dictionary()
{
{"#IP", "InPublication"}
},
ExpressionAttributeValues = new Dictionary()
{
{":inpub",new AttributeValue {
BOOL = false
}}
},
ConditionExpression = "#IP = :inpub"
};
var response = client.DeleteItem(request);
// Check the response.
var attributeList = response.Attributes; // Attribute list in the response.
// Print item.
Console.WriteLine("\nPrinting item that was just deleted ............");
PrintItem(attributeList);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]")
);
}
Console.WriteLine("************************************************");
}
}
}
```
# Beispiel: Batch-Operationen mit der AWS SDK für .NET Low-Level-API
**Topics**
+ [Beispiel: Batch-Schreibvorgang mit der AWS SDK für .NET Low-Level-API](#batch-write-low-level-dotnet)
+ [Beispiel: Batch-Abruf-Vorgang mit der AWS SDK für .NET Low-Level-API](#LowLevelDotNetBatchGet)
Dieser Abschnitt enthält Beispiele für Batchvorgänge, *Batch-Schreibvorgänge* und *Batch-Get*, die Amazon DynamoDB unterstützt.
## Beispiel: Batch-Schreibvorgang mit der AWS SDK für .NET Low-Level-API
Das folgende C\$1-Codebeispiel verwendet die `BatchWriteItem`-Methode für die folgenden Operationen zum Einfügen und Löschen:
+ Einfügen eines Elements in die `Forum`-Tabelle
+ Einfügen und Löschen eines Elements aus der `Thread`-Tabelle
Bei der Erstellung Ihrer BatchWrite-Anforderung können Sie eine beliebige Anzahl von Einfüge- und Lösch-Anforderungen angeben. DynamoDB `BatchWriteItem` begrenzt jedoch die Größe einer Batch-Schreibanforderung und die Anzahl der Put- und Delete-Vorgänge in einem einzelnen Batch-Schreibvorgang. Weitere Informationen finden Sie unter [BatchWriteItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html). Wenn Ihre Anforderung diese Grenzwerte überschreitet, wird sie abgelehnt. Wenn die Tabelle nicht über ausreichend bereitgestellten Durchsatz für diese Anforderung verfügt, werden nicht verarbeitete Anforderungselemente in der Antwort zurückgegeben.
Im folgenden Beispiel wird die Antwort auf unverarbeitete Anforderungselemente überprüft. Liegen unverarbeitete Elemente vor, wird der Vorgang wiederholt und die `BatchWriteItem`-Anforderung mit unverarbeiteten Elementen wird erneut gesendet. Sie können diese Beispieltabellen auch erstellen und Beispieldaten programmgesteuert hochladen. Weitere Informationen finden Sie unter [Erstellen von Beispieltabellen und Hochladen von Daten mit dem AWS SDK für .NET](AppendixSampleDataCodeDotNET.md).
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[.NET-Codebeispiele](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelBatchWrite
{
private static string table1Name = "Forum";
private static string table2Name = "Thread";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
TestBatchWrite();
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
private static void TestBatchWrite()
{
var request = new BatchWriteItemRequest
{
ReturnConsumedCapacity = "TOTAL",
RequestItems = new Dictionary>
{
{
table1Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "Name", new AttributeValue {
S = "S3 forum"
} },
{ "Threads", new AttributeValue {
N = "0"
}}
}
}
}
}
},
{
table2Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "ForumName", new AttributeValue {
S = "S3 forum"
} },
{ "Subject", new AttributeValue {
S = "My sample question"
} },
{ "Message", new AttributeValue {
S = "Message Text."
} },
{ "KeywordTags", new AttributeValue {
SS = new List { "S3", "Bucket" }
} }
}
}
},
new WriteRequest
{
// For the operation to delete an item, if you provide a primary key value
// that does not exist in the table, there is no error, it is just a no-op.
DeleteRequest = new DeleteRequest
{
Key = new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Some partition key value"
} },
{ "Subject", new AttributeValue {
S = "Some sort key value"
} }
}
}
}
}
}
}
};
CallBatchWriteTillCompletion(request);
}
private static void CallBatchWriteTillCompletion(BatchWriteItemRequest request)
{
BatchWriteItemResponse response;
int callCount = 0;
do
{
Console.WriteLine("Making request");
response = client.BatchWriteItem(request);
callCount++;
// Check the response.
var tableConsumedCapacities = response.ConsumedCapacity;
var unprocessed = response.UnprocessedItems;
Console.WriteLine("Per-table consumed capacity");
foreach (var tableConsumedCapacity in tableConsumedCapacities)
{
Console.WriteLine("{0} - {1}", tableConsumedCapacity.TableName, tableConsumedCapacity.CapacityUnits);
}
Console.WriteLine("Unprocessed");
foreach (var unp in unprocessed)
{
Console.WriteLine("{0} - {1}", unp.Key, unp.Value.Count);
}
Console.WriteLine();
// For the next iteration, the request will have unprocessed items.
request.RequestItems = unprocessed;
} while (response.UnprocessedItems.Count > 0);
Console.WriteLine("Total # of batch write API calls made: {0}", callCount);
}
}
}
```
## Beispiel: Batch-Abruf-Vorgang mit der AWS SDK für .NET Low-Level-API
Im folgenden C\$1-Codebeispiel wird die `BatchGetItem` Methode zum Abrufen mehrerer Elemente aus den `Forum`- und `Thread`-Tabellen in Amazon DynamoDB verwendet. Die `BatchGetItemRequest` gibt die Tabellennamen sowie eine Liste der Primärschlüssel für jede Tabelle an. In dem Beispiel wird die Antwort durch Drucken der abgerufenen Elemente verarbeitet.
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[.NET-Codebeispiele](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelBatchGet
{
private static string table1Name = "Forum";
private static string table2Name = "Thread";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
RetrieveMultipleItemsBatchGet();
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
private static void RetrieveMultipleItemsBatchGet()
{
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List >()
{
new Dictionary()
{
{ "Name", new AttributeValue {
S = "Amazon DynamoDB"
} }
},
new Dictionary()
{
{ "Name", new AttributeValue {
S = "Amazon S3"
} }
}
}
}},
{
table2Name,
new KeysAndAttributes
{
Keys = new List >()
{
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 1"
} }
},
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 2"
} }
},
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon S3"
} },
{ "Subject", new AttributeValue {
S = "S3 Thread 1"
} }
}
}
}
}
}
};
BatchGetItemResponse response;
do
{
Console.WriteLine("Making request");
response = client.BatchGetItem(request);
// Check the response.
var responses = response.Responses; // Attribute list in the response.
foreach (var tableResponse in responses)
{
var tableResults = tableResponse.Value;
Console.WriteLine("Items retrieved from table {0}", tableResponse.Key);
foreach (var item1 in tableResults)
{
PrintItem(item1);
}
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error.
Dictionary unprocessedKeys = response.UnprocessedKeys;
foreach (var unprocessedTableKeys in unprocessedKeys)
{
// Print table name.
Console.WriteLine(unprocessedTableKeys.Key);
// Print unprocessed primary keys.
foreach (var key in unprocessedTableKeys.Value.Keys)
{
PrintItem(key);
}
}
request.RequestItems = unprocessedKeys;
} while (response.UnprocessedKeys.Count > 0);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]")
);
}
Console.WriteLine("************************************************");
}
}
}
```
# Beispiel: Umgang mit binären Attributen mithilfe der AWS SDK für .NET Low-Level-API
Das folgende C\$1-Codebeispiel veranschaulicht den Umgang mit Attributen des Typs Binärwert. Bei dem Beispiel wird der `Reply`-Tabelle ein Element hinzugefügt. Das Element enthält ein Binärtypattribut (`ExtendedMessage`), in dem komprimierte Daten gespeichert sind. Daraufhin wird das Element abgerufen und es werden alle Attributwerte gedruckt. Zur Veranschaulichung verwendet das Beispiel die `GZipStream`-Klasse, um einen Beispiel-Stream zu komprimieren und ihn dem Attribut `ExtendedMessage` hinzuzufügen, und dekomprimiert den Stream beim Drucken des Attributwerts.
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[.NET-Codebeispiele](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelItemBinaryExample
{
private static string tableName = "Reply";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
// Reply table primary key.
string replyIdPartitionKey = "Amazon DynamoDB#DynamoDB Thread 1";
string replyDateTimeSortKey = Convert.ToString(DateTime.UtcNow);
try
{
CreateItem(replyIdPartitionKey, replyDateTimeSortKey);
RetrieveItem(replyIdPartitionKey, replyDateTimeSortKey);
// Delete item.
DeleteItem(replyIdPartitionKey, replyDateTimeSortKey);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
private static void CreateItem(string partitionKey, string sortKey)
{
MemoryStream compressedMessage = ToGzipMemoryStream("Some long extended message to compress.");
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue {
S = partitionKey
}},
{ "ReplyDateTime", new AttributeValue {
S = sortKey
}},
{ "Subject", new AttributeValue {
S = "Binary type "
}},
{ "Message", new AttributeValue {
S = "Some message about the binary type"
}},
{ "ExtendedMessage", new AttributeValue {
B = compressedMessage
}}
}
};
client.PutItem(request);
}
private static void RetrieveItem(string partitionKey, string sortKey)
{
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
},
ConsistentRead = true
};
var response = client.GetItem(request);
// Check the response.
var attributeList = response.Item; // attribute list in the response.
Console.WriteLine("\nPrinting item after retrieving it ............");
PrintItem(attributeList);
}
private static void DeleteItem(string partitionKey, string sortKey)
{
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
}
};
var response = client.DeleteItem(request);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]") +
(value.B == null ? "" : "B=[" + FromGzipMemoryStream(value.B) + "]")
);
}
Console.WriteLine("************************************************");
}
private static MemoryStream ToGzipMemoryStream(string value)
{
MemoryStream output = new MemoryStream();
using (GZipStream zipStream = new GZipStream(output, CompressionMode.Compress, true))
using (StreamWriter writer = new StreamWriter(zipStream))
{
writer.Write(value);
}
return output;
}
private static string FromGzipMemoryStream(MemoryStream stream)
{
using (GZipStream zipStream = new GZipStream(stream, CompressionMode.Decompress))
using (StreamReader reader = new StreamReader(zipStream))
{
return reader.ReadToEnd();
}
}
}
}
```