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.
# AWS AppSync Referenz zur Resolver-Mapping-Vorlage für DynamoDB
**Anmerkung**
Wir unterstützen jetzt hauptsächlich die APPSYNC\$1JS-Laufzeit und ihre Dokumentation. [Bitte erwägen Sie, die APPSYNC\$1JS-Laufzeit und ihre Anleitungen hier zu verwenden.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)
Mit der AWS AppSync DynamoDB-Funktion können Sie [GraphQL](https://graphql.org) verwenden, um Daten in vorhandenen Amazon DynamoDB-Tabellen in Ihrem Konto zu speichern und abzurufen, indem Sie eine eingehende GraphQL-Anfrage einem DynamoDB-Aufruf zuordnen und dann die DynamoDB-Antwort wieder GraphQL zuordnen. In diesem Abschnitt werden die Anforderungs- und Antworthandler für unterstützte DynamoDB-Operationen beschrieben:
+ [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.html)- Mit der GetItem Anfrage können Sie die DynamoDB-Funktion anweisen, eine GetItem Anfrage an DynamoDB zu stellen, und Sie können den Schlüssel des Elements in DynamoDB angeben und angeben, ob ein konsistenter Lesevorgang verwendet werden soll oder nicht.
+ [ PutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.html)- Mit dem PutItem Anforderungszuordnungsdokument können Sie die DynamoDB-Funktion anweisen, eine PutItem Anfrage an DynamoDB zu stellen, und Sie können den Schlüssel des Elements in DynamoDB, den vollständigen Inhalt des Elements (bestehend aus Schlüssel und AttributeValues) und Bedingungen für den Erfolg des Vorgangs angeben.
+ [ UpdateItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.html)- Mit der UpdateItem Anforderung können Sie die DynamoDB-Funktion anweisen, eine UpdateItem Anfrage an DynamoDB zu stellen, und Sie können den Schlüssel des Elements in DynamoDB, einen Aktualisierungsausdruck, der beschreibt, wie das Element in DynamoDB aktualisiert wird, und die Bedingungen für den Erfolg des Vorgangs angeben.
+ [ DeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.html)- Mit der DeleteItem Anfrage können Sie die DynamoDB-Funktion anweisen, eine DeleteItem Anfrage an DynamoDB zu stellen, und Sie können den Schlüssel des Elements in DynamoDB und die Bedingungen für den Erfolg des Vorgangs angeben.
+ [Abfrage](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-query.html) — Mit dem Query-Anforderungsobjekt können Sie den DynamoDB-Resolver anweisen, eine Abfrageanforderung an DynamoDB zu stellen, und Sie können den Schlüsselausdruck, den zu verwendenden Index, zusätzliche Filter, die Anzahl der zurückzugebenden Elemente, die Verwendung konsistenter Lesevorgänge, die Abfragerichtung (vorwärts oder rückwärts) und Paginierungstoken angeben.
+ [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-scan.html) — Mit der Scananforderung können Sie die DynamoDB-Funktion anweisen, eine Scananforderung an DynamoDB zu stellen, und Sie können einen Filter angeben, um Ergebnisse auszuschließen, welcher Index verwendet werden soll, wie viele Elemente zurückgegeben werden sollen, ob konsistente Lesevorgänge, Paginierungstoken und parallel Scans verwendet werden sollen.
+ [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-sync.html) — Mit dem Sync-Anforderungsobjekt können Sie alle Ergebnisse aus einer DynamoDB-Tabelle abrufen und anschließend nur die Daten empfangen, die seit Ihrer letzten Abfrage geändert wurden (die Delta-Updates). Synchronisierungsanforderungen können nur an versionierte DynamoDB-Datenquellen gestellt werden. Sie können einen Filter angeben, um Ergebnisse, die Anzahl der zurückzugebenden Elemente, die Paginierungstoken und den Zeitpunkt, an dem Ihr letzter Synchronisierungsvorgang gestartet wurde, auszuschließen.
+ [ BatchGetItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-get-item.html)- Mit dem BatchGetItem Anforderungsobjekt können Sie die DynamoDB-Funktion anweisen, eine BatchGetItem Anforderung an DynamoDB zu stellen, um mehrere Elemente abzurufen, möglicherweise über mehrere Tabellen hinweg. Für dieses Anforderungsobjekt müssen Sie die Tabellennamen angeben, aus denen die Elemente abgerufen werden sollen, und die Schlüssel der Elemente, die aus jeder Tabelle abgerufen werden sollen.
+ [ BatchDeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-delete-item.html)- Mit dem BatchDeleteItem Anforderungsobjekt können Sie die DynamoDB-Funktion anweisen, eine BatchWriteItem Anforderung an DynamoDB zu stellen, um mehrere Elemente zu löschen, möglicherweise über mehrere Tabellen hinweg. Für dieses Anforderungsobjekt müssen Sie die Tabellennamen angeben, aus denen die Elemente gelöscht werden sollen, und die Schlüssel der Elemente, die aus jeder Tabelle gelöscht werden sollen.
+ [ BatchPutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-put-item.html)- Mit dem BatchPutItem Anforderungsobjekt können Sie die DynamoDB-Funktion anweisen, eine BatchWriteItem Anforderung an DynamoDB zu stellen, um mehrere Elemente zu platzieren, möglicherweise in mehreren Tabellen. Für dieses Anforderungsobjekt müssen Sie die Tabellennamen angeben, in die die Elemente eingefügt werden sollen, und die vollständigen Elemente, die in jede Tabelle eingefügt werden sollen.
+ [ TransactGetItems ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transact-get-items.html)- Mit dem TransactGetItems Anforderungsobjekt können Sie die DynamoDB-Funktion anweisen, eine TransactGetItems Anforderung an DynamoDB zu stellen, um mehrere Elemente abzurufen, möglicherweise über mehrere Tabellen hinweg. Für dieses Anforderungsobjekt müssen Sie den Tabellennamen jedes Anforderungselements angeben, aus dem das Element abgerufen werden soll, und den Schlüssel jedes Anforderungselements, das aus jeder Tabelle abgerufen werden soll.
+ [ TransactWriteItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-write-items.html)- Mit dem TransactWriteItems Anforderungsobjekt können Sie die DynamoDB-Funktion anweisen, eine TransactWriteItems Anforderung an DynamoDB zu stellen, um mehrere Elemente zu schreiben, möglicherweise in mehrere Tabellen. Für dieses Anforderungsobjekt müssen Sie den Zieltabellennamen jedes Anforderungselements, die Operation jedes auszuführenden Anforderungselements und den Schlüssel jedes zu schreibenden Anforderungselements angeben.
+ [Typsystem (Anforderungszuordnung)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.html) — Erfahren Sie mehr darüber, wie DynamoDB-Typisierung in Anfragen integriert AWS AppSync wird.
+ [Typsystem (Antwortzuordnung)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.html) — Erfahren Sie mehr darüber, wie DynamoDB-Typen in einer Antwortnutzlast automatisch in GraphQL oder JSON konvertiert werden.
+ [Filter](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-filter.html) — Erfahren Sie mehr über Filter für Abfrage- und Scanvorgänge.
+ [Bedingungsausdrücke](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.html) — Erfahren Sie mehr über Bedingungsausdrücke für PutItem UpdateItem, und DeleteItem Operationen.
+ [Ausdrücke für Transaktionsbedingungen](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.html) — Erfahren Sie mehr über Bedingungsausdrücke für TransactWriteItems Operationen.
+ [Projektionen](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-projections.html) — Erfahren Sie mehr darüber, wie Sie Attribute bei Lesevorgängen angeben.
# GetItem
Mit dem `GetItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `GetItem` Anfrage an DynamoDB zu stellen, und Sie können Folgendes angeben:
+ Der Schlüssel des Elements in DynamoDB
+ Ob ein Consistent-Lesevorgang verwendet wird oder nicht
Das `GetItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"foo" : ... typed value,
"bar" : ... typed value
},
"consistentRead" : true,
"projection" : {
...
}
}
```
Die Felder sind wie folgt definiert:
## GetItem Felder
### GetItem Liste der Felder
**`version`**
Die Version der Vorlagedefinition. Aktuell werden `2017-02-28` und `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
**`operation`**
Der DynamoDB DynamoDB-Vorgang. Um die `GetItem`-DynamoDB-Operation durchzuführen, muss diese auf `GetItem` gesetzt sein. Dieser Wert ist erforderlich.
**`key`**
Der Schlüssel des Elements in DynamoDB. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dieser Wert ist erforderlich.
**`consistentRead`**
Ob ein stark konsistenter Lesevorgang mit DynamoDB durchgeführt werden soll oder nicht. Dieser Schritt ist optional und standardmäßig auf `false` gesetzt.
**`projection`**
Eine Projektion, die verwendet wird, um die Attribute anzugeben, die von der DynamoDB-Operation zurückgegeben werden sollen. [Weitere Informationen zu Projektionen finden Sie unter Projektionen.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Dies ist ein optionales Feld.
Das von DynamoDB zurückgegebene Element wird automatisch in primitive GraphQL- und JSON-Typen konvertiert und ist im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Beispiel
Das folgende Beispiel ist eine Zuordnungsvorlage für eine GraphQL-Abfrage`getThing(foo: String!, bar: String!)`:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
"bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
},
"consistentRead" : true
}
```
Weitere Informationen zur DynamoDB `GetItem`-API finden Sie in der [DynamoDB API-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).
# PutItem
Mit dem `PutItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `PutItem` Anfrage an DynamoDB zu stellen, und Sie können Folgendes angeben:
+ Der Schlüssel des Elements in DynamoDB
+ Der vollständige Inhalt des Elements (bestehend aus `key` und `attributeValues`)
+ Bedingungen, damit die Operation erfolgreich ausgeführt werden kann
Das `PutItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "PutItem",
"customPartitionKey" : "foo",
"populateIndexFields" : boolean value,
"key": {
"foo" : ... typed value,
"bar" : ... typed value
},
"attributeValues" : {
"baz" : ... typed value
},
"condition" : {
...
},
"_version" : 1
}
```
Die Felder sind wie folgt definiert:
## PutItem Felder
### PutItem Liste der Felder
**`version`**
Die Version der Vorlagedefinition. Aktuell werden `2017-02-28` und `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
**`operation`**
Der DynamoDB DynamoDB-Vorgang. Um die `PutItem`-DynamoDB-Operation durchzuführen, muss diese auf `PutItem` gesetzt sein. Dieser Wert ist erforderlich.
**`key`**
Der Schlüssel des Elements in DynamoDB. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dieser Wert ist erforderlich.
**`attributeValues`**
Der Rest der Attribute des Elements, die in DynamoDB gespeichert werden sollen. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dies ist ein optionales Feld.
**`condition`**
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Wenn keine Bedingung angegeben ist, überschreibt die `PutItem`-Anforderung alle vorhandenen Einträge für dieses Element. Weitere Informationen zu Bedingungen finden Sie unter [Bedingungsausdrücke](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Dieser Wert ist optional.
**`_version`**
Ein numerischer Wert, der die neueste bekannte Version eines Elements darstellt. Dieser Wert ist optional. Dieses Feld wird für die *Konflikterkennung* verwendet und nur für versionsgesteuerte Datenquellen unterstützt.
**`customPartitionKey`**
Wenn diese Option aktiviert ist, ändert dieser Zeichenfolgenwert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Synchronisierungstabelle verwendet werden, wenn die Versionierung aktiviert wurde (weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*). Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert. Dies ist ein optionales Feld.
**`populateIndexFields`**
Ein boolescher Wert, der, wenn er **zusammen mit dem** aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten `gsi_ds_pk` und`gsi_ds_sk`. Weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*. Dies ist ein optionales Feld.
Das in DynamoDB geschriebene Element wird automatisch in primitive GraphQL- und JSON-Typen konvertiert und ist im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Beispiel 1
Das folgende Beispiel ist eine Mapping-Vorlage für eine GraphQL-Mutation`updateThing(foo: String!, bar: String!, name: String!, version: Int!)`.
Wenn kein Element mit dem angegebenen Schlüssel vorhanden ist, wird es erstellt. Wenn ein Element mit dem angegebenen Schlüssel bereits vorhanden ist, wird es überschrieben.
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key": {
"foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
"bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
},
"attributeValues" : {
"name" : $util.dynamodb.toDynamoDBJson($ctx.args.name),
"version" : $util.dynamodb.toDynamoDBJson($ctx.args.version)
}
}
```
## Beispiel 2
Das folgende Beispiel ist eine Mapping-Vorlage für eine GraphQL-Mutation`updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)`.
In diesem Beispiel wird überprüft, ob für das Element, das sich derzeit in DynamoDB befindet, das `version` Feld auf gesetzt ist. `expectedVersion`
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key": {
"foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
"bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
},
"attributeValues" : {
"name" : $util.dynamodb.toDynamoDBJson($ctx.args.name),
#set( $newVersion = $context.arguments.expectedVersion + 1 )
"version" : $util.dynamodb.toDynamoDBJson($newVersion)
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : $util.dynamodb.toDynamoDBJson($expectedVersion)
}
}
}
```
Weitere Informationen zur DynamoDB `PutItem`-API finden Sie in der [DynamoDB API-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).
# UpdateItem
Mit dem `UpdateItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `UpdateItem` Anfrage an DynamoDB zu stellen, und Sie können Folgendes angeben:
+ Der Schlüssel des Elements in DynamoDB
+ Ein Aktualisierungsausdruck, der beschreibt, wie das Element in DynamoDB aktualisiert wird
+ Bedingungen, damit die Operation erfolgreich ausgeführt werden kann
Das `UpdateItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "UpdateItem",
"customPartitionKey" : "foo",
"populateIndexFields" : boolean value,
"key": {
"foo" : ... typed value,
"bar" : ... typed value
},
"update" : {
"expression" : "someExpression",
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
}
},
"condition" : {
...
},
"_version" : 1
}
```
Die Felder sind wie folgt definiert:
## UpdateItem Felder
### UpdateItem Liste der Felder
**`version`**
Die Version der Vorlagedefinition. Aktuell werden `2017-02-28` und `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
**`operation`**
Der DynamoDB DynamoDB-Vorgang. Um die `UpdateItem`-DynamoDB-Operation durchzuführen, muss diese auf `UpdateItem` gesetzt sein. Dieser Wert ist erforderlich.
**`key`**
Der Schlüssel des Elements in DynamoDB. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Hinweise zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Dieser Wert ist erforderlich.
**`update`**
`update`In diesem Abschnitt können Sie einen Aktualisierungsausdruck angeben, der beschreibt, wie das Element in DynamoDB aktualisiert wird. Weitere Informationen zum Schreiben von Aktualisierungsausdrücken finden Sie in der [DynamoDB-Dokumentation UpdateExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Dieser Abschnitt ist erforderlich.
Der `update`-Abschnitt enthält drei Komponenten:
** `expression` **
Den Aktualisierungsausdruck. Dieser Wert ist erforderlich.
** `expressionNames` **
Die Ersetzungen für Platzhalter der *Namen* von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Namensplatzhalter`expression`, der in der verwendet wird, und der Wert muss eine Zeichenfolge sein, die dem Attributnamen des Elements in DynamoDB entspricht. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Namen von Ausdrucksattributen gefüllt sein, die im `expression` verwendet werden.
** `expressionValues` **
Die Ersetzungen für Platzhalter der *Werte* von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Wertplatzhalter, der im `expression` verwendet wird, und der Wert muss ein typisierter Wert sein. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)Anforderungszuordnung). Dieser muss angegeben werden. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Werte von Ausdrucksattributen gefüllt sein, die im `expression` verwendet werden.
**`condition`**
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Wenn keine Bedingung angegeben ist, aktualisiert die `UpdateItem`-Anforderung jeden vorhandenen Eintrag unabhängig vom aktuellen Status. Weitere Informationen zu Bedingungen finden Sie unter [Bedingungsausdrücke](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Dieser Wert ist optional.
**`_version`**
Ein numerischer Wert, der die neueste bekannte Version eines Elements darstellt. Dieser Wert ist optional. Dieses Feld wird für die *Konflikterkennung* verwendet und nur für versionsgesteuerte Datenquellen unterstützt.
**`customPartitionKey`**
Wenn diese Option aktiviert ist, ändert dieser Zeichenfolgenwert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Synchronisierungstabelle verwendet werden, wenn die Versionierung aktiviert wurde (weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*). Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert. Dies ist ein optionales Feld.
**`populateIndexFields`**
Ein boolescher Wert, der, wenn er **zusammen mit dem** aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten `gsi_ds_pk` und`gsi_ds_sk`. Weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*. Dies ist ein optionales Feld.
Das in DynamoDB aktualisierte Element wird automatisch in primitive GraphQL- und JSON-Typen konvertiert und ist im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Beispiel 1
Das folgende Beispiel ist eine Mapping-Vorlage für die GraphQL-Mutation`upvote(id: ID!)`.
In diesem Beispiel werden die `version` Felder `upvotes` und eines Elements in DynamoDB um 1 erhöht.
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"update" : {
"expression" : "ADD #votefield :plusOne, version :plusOne",
"expressionNames" : {
"#votefield" : "upvotes"
},
"expressionValues" : {
":plusOne" : { "N" : 1 }
}
}
}
```
## Beispiel 2
Das folgende Beispiel ist eine Mapping-Vorlage für eine GraphQL-Mutation`updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)`.
Hierbei handelt es sich um ein komplexes Beispiel, das die Argumente prüft und den Aktualisierungsausdruck dynamisch generiert, der nur die Argumente enthält, die vom Client bereitgestellt wurden. Beispiel: Wenn `title` und `author` nicht angegeben werden, werden sie nicht aktualisiert. Wenn ein Argument angegeben ist, sein Wert jedoch angegeben ist`null`, wird dieses Feld aus dem Objekt in DynamoDB gelöscht. Schließlich hat der Vorgang eine Bedingung, die überprüft, ob für das Element, das sich derzeit in DynamoDB befindet, das `version` Feld wie folgt gesetzt ist: `expectedVersion`
```
{
"version" : "2017-02-28",
"operation" : "UpdateItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
## Set up some space to keep track of things we're updating **
#set( $expNames = {} )
#set( $expValues = {} )
#set( $expSet = {} )
#set( $expAdd = {} )
#set( $expRemove = [] )
## Increment "version" by 1 **
$!{expAdd.put("version", ":newVersion")}
$!{expValues.put(":newVersion", { "N" : 1 })}
## Iterate through each argument, skipping "id" and "expectedVersion" **
#foreach( $entry in $context.arguments.entrySet() )
#if( $entry.key != "id" && $entry.key != "expectedVersion" )
#if( (!$entry.value) && ("$!{entry.value}" == "") )
## If the argument is set to "null", then remove that attribute from the item in DynamoDB **
#set( $discard = ${expRemove.add("#${entry.key}")} )
$!{expNames.put("#${entry.key}", "$entry.key")}
#else
## Otherwise set (or update) the attribute on the item in DynamoDB **
$!{expSet.put("#${entry.key}", ":${entry.key}")}
$!{expNames.put("#${entry.key}", "$entry.key")}
#if( $entry.key == "ups" || $entry.key == "downs" )
$!{expValues.put(":${entry.key}", { "N" : $entry.value })}
#else
$!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })}
#end
#end
#end
#end
## Start building the update expression, starting with attributes we're going to SET **
#set( $expression = "" )
#if( !${expSet.isEmpty()} )
#set( $expression = "SET" )
#foreach( $entry in $expSet.entrySet() )
#set( $expression = "${expression} ${entry.key} = ${entry.value}" )
#if ( $foreach.hasNext )
#set( $expression = "${expression}," )
#end
#end
#end
## Continue building the update expression, adding attributes we're going to ADD **
#if( !${expAdd.isEmpty()} )
#set( $expression = "${expression} ADD" )
#foreach( $entry in $expAdd.entrySet() )
#set( $expression = "${expression} ${entry.key} ${entry.value}" )
#if ( $foreach.hasNext )
#set( $expression = "${expression}," )
#end
#end
#end
## Continue building the update expression, adding attributes we're going to REMOVE **
#if( !${expRemove.isEmpty()} )
#set( $expression = "${expression} REMOVE" )
#foreach( $entry in $expRemove )
#set( $expression = "${expression} ${entry}" )
#if ( $foreach.hasNext )
#set( $expression = "${expression}," )
#end
#end
#end
## Finally, write the update expression into the document, along with any expressionNames and expressionValues **
"update" : {
"expression" : "${expression}"
#if( !${expNames.isEmpty()} )
,"expressionNames" : $utils.toJson($expNames)
#end
#if( !${expValues.isEmpty()} )
,"expressionValues" : $utils.toJson($expValues)
#end
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : $util.dynamodb.toDynamoDBJson($ctx.args.expectedVersion)
}
}
}
```
Weitere Informationen zur DynamoDB `UpdateItem`-API finden Sie in der [DynamoDB API-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).
# DeleteItem
Mit dem `DeleteItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `DeleteItem` Anfrage an DynamoDB zu stellen, und Sie können Folgendes angeben:
+ Der Schlüssel des Elements in DynamoDB
+ Bedingungen, damit die Operation erfolgreich ausgeführt werden kann
Das `DeleteItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "DeleteItem",
"customPartitionKey" : "foo",
"populateIndexFields" : boolean value,
"key": {
"foo" : ... typed value,
"bar" : ... typed value
},
"condition" : {
...
},
"_version" : 1
}
```
Die Felder sind wie folgt definiert:
## DeleteItem Felder
### DeleteItem Liste der Felder
** `version` **
Die Version der Vorlagedefinition. Aktuell werden `2017-02-28` und `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `DeleteItem`-DynamoDB-Operation durchzuführen, muss diese auf `DeleteItem` gesetzt sein. Dieser Wert ist erforderlich.
** `key` **
Der Schlüssel des Elements in DynamoDB. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Hinweise zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Dieser Wert ist erforderlich.
** `condition` **
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Wenn keine Bedingung angegeben ist, löscht die `DeleteItem`-Anforderung ein Element unabhängig vom aktuellen Status. Weitere Informationen zu Bedingungen finden Sie unter [Bedingungsausdrücke](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Dieser Wert ist optional.
** `_version` **
Ein numerischer Wert, der die neueste bekannte Version eines Elements darstellt. Dieser Wert ist optional. Dieses Feld wird für die *Konflikterkennung* verwendet und nur für versionsgesteuerte Datenquellen unterstützt.
**`customPartitionKey`**
Wenn diese Option aktiviert ist, ändert dieser Zeichenfolgenwert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Synchronisierungstabelle verwendet werden, wenn die Versionierung aktiviert wurde (weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*). Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert. Dies ist ein optionales Feld.
**`populateIndexFields`**
Ein boolescher Wert, der, wenn er **zusammen mit dem** aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten `gsi_ds_pk` und`gsi_ds_sk`. Weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*. Dies ist ein optionales Feld.
Das aus DynamoDB gelöschte Element wird automatisch in primitive GraphQL- und JSON-Typen konvertiert und ist im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Beispiel 1
Das folgende Beispiel ist eine Mapping-Vorlage für eine GraphQL-Mutation`deleteItem(id: ID!)`. Wenn ein Element mit dieser ID vorhanden ist, wird es gelöscht.
```
{
"version" : "2017-02-28",
"operation" : "DeleteItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
}
}
```
## Beispiel 2
Das folgende Beispiel ist eine Mapping-Vorlage für eine GraphQL-Mutation`deleteItem(id: ID!, expectedVersion: Int!)`. Wenn ein Element mit dieser ID vorhanden ist, wird es nur dann gelöscht, wenn das `version`-Feld auf `expectedVersion` gesetzt ist:
```
{
"version" : "2017-02-28",
"operation" : "DeleteItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"condition" : {
"expression" : "attribute_not_exists(id) OR version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : $util.dynamodb.toDynamoDBJson($expectedVersion)
}
}
}
```
Weitere Informationen zur DynamoDB `DeleteItem`-API finden Sie in der [DynamoDB API-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).
# Query
Mit dem `Query` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `Query` Anfrage an DynamoDB zu stellen, und Sie können Folgendes angeben:
+ Schlüsselausdruck
+ Welcher Index verwendet werden soll
+ Jeder zusätzliche Filter
+ Wie viele Elemente zurückgegeben werden sollen
+ Ob Consistent-Lesevorgänge verwendet werden sollen
+ Abfragerichtung (vorwärts oder rückwärts)
+ Paginierungs-Token
Das `Query`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2017-02-28",
"operation" : "Query",
"query" : {
"expression" : "some expression",
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
}
},
"index" : "fooIndex",
"nextToken" : "a pagination token",
"limit" : 10,
"scanIndexForward" : true,
"consistentRead" : false,
"select" : "ALL_ATTRIBUTES" | "ALL_PROJECTED_ATTRIBUTES" | "SPECIFIC_ATTRIBUTES",
"filter" : {
...
},
"projection" : {
...
}
}
```
Die Felder sind wie folgt definiert:
## Felder abfragen
### Liste der Abfragefelder
** `version` **
Die Version der Vorlagedefinition. Aktuell werden `2017-02-28` und `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `Query`-DynamoDB-Operation durchzuführen, muss diese auf `Query` gesetzt sein. Dieser Wert ist erforderlich.
** `query` **
`query`In diesem Abschnitt können Sie einen Schlüsselbedingungsausdruck angeben, der beschreibt, welche Elemente aus DynamoDB abgerufen werden sollen. Weitere Informationen zum Schreiben von Ausdrücken für Schlüsselbedingungen finden Sie in der [DynamoDB-Dokumentation KeyConditions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html). Dieser Abschnitt muss angegeben werden.
** `expression` **
Der Abfrageausdruck. Dieses Feld muss angegeben werden.
** `expressionNames` **
Die Ersetzungen für Platzhalter der *Namen* von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Namensplatzhalter`expression`, der in der verwendet wird, und der Wert muss eine Zeichenfolge sein, die dem Attributnamen des Elements in DynamoDB entspricht. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Namen von Ausdrucksattributen gefüllt sein, die im `expression` verwendet werden.
** `expressionValues` **
Die Ersetzungen für Platzhalter der *Werte* von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Wertplatzhalter, der im `expression` verwendet wird, und der Wert muss ein typisierter Wert sein. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)Anforderungszuordnung). Dieser Wert ist erforderlich. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Werte von Ausdrucksattributen gefüllt sein, die im `expression` verwendet werden.
** `filter` **
Ein zusätzlicher Filter, der für das Filtern der Ergebnisse von DynamoDB verwendet werden kann, bevor sie zurückgegeben werden. Weitere Informationen zu Filtern finden Sie unter [Filter](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Dies ist ein optionales Feld.
** `index` **
Der Name des abzufragenden Indexes. Der DynamoDB-Abfragevorgang ermöglicht es Ihnen, zusätzlich zum Primärschlüsselindex auch lokale sekundäre Indizes und globale sekundäre Indizes nach einem Hashschlüssel zu durchsuchen. Falls angegeben, weist dies DynamoDB an, den angegebenen Index abzufragen. Wenn nicht angegeben, wird der Primärschlüsselindex abgefragt.
** `nextToken` **
Das Paginierungs-Token für die Fortsetzung einer früheren Abfrage. Dieses wäre von einer vorherigen Abfrage erhalten worden. Dies ist ein optionales Feld.
** `limit` **
Die maximale Anzahl der auszuwertenden Elemente (nicht notwendigerweise die Anzahl der übereinstimmenden Elemente). Dies ist ein optionales Feld.
** `scanIndexForward` **
Ein boolescher Wert, der angibt, ob vorwärts oder rückwärts abgefragt werden soll. Dieses Feld ist optional und standardmäßig auf `true` gesetzt.
** `consistentRead` **
Ein boolescher Wert, der angibt, ob bei der Abfrage von DynamoDB konsistente Lesevorgänge verwendet werden sollen. Dieses Feld ist optional und standardmäßig auf `false` gesetzt.
** `select` **
Standardmäßig gibt der AWS AppSync DynamoDB-Resolver nur Attribute zurück, die in den Index projiziert werden. Wenn weitere Attribute erforderlich sind, kann dieses Feld festgelegt werden. Dies ist ein optionales Feld. Die unterstützten Werte sind:
** `ALL_ATTRIBUTES` **
Gibt alle Elementattribute aus der angegebenen Tabelle oder dem Index zurück. Wenn Sie einen lokalen sekundären Index abfragen, ruft DynamoDB für jedes übereinstimmende Element im Index das gesamte Element aus der übergeordneten Tabelle ab. Wenn der Index konfiguriert ist, um alle Elementattribute zu projizieren, können Sie alle Daten aus dem lokalen sekundären Index erhalten und das Abrufen ist nicht erforderlich.
** `ALL_PROJECTED_ATTRIBUTES` **
Nur bei der Abfrage eines Indexes erlaubt. Ruft alle Attribute ab, die in den Index projiziert wurden. Wenn der Index konfiguriert ist, um alle Attribute zu projizieren, entspricht dieser Rückgabewert der Angabe von `ALL_ATTRIBUTES`.
**`SPECIFIC_ATTRIBUTES`**
Gibt nur die in den s aufgeführten Attribute zurück. `projection` `expression` Dieser Rückgabewert entspricht der Angabe `projection` von 's' `expression` ohne Angabe eines Werts für`Select`.
**`projection`**
Eine Projektion, die verwendet wird, um die Attribute anzugeben, die von der DynamoDB-Operation zurückgegeben werden sollen. [Weitere Informationen zu Projektionen finden Sie unter Projektionen.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Dies ist ein optionales Feld.
Die Ergebnisse von DynamoDB werden automatisch in primitive GraphQL- und JSON-Typen konvertiert und sind im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
Die Ergebnisse weisen die folgende Struktur auf:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
Die Felder sind wie folgt definiert:
** `items` **
Eine Liste mit den von der DynamoDB-Abfrage zurückgegebenen Elementen.
** `nextToken` **
Wenn es mehr Ergebnisse geben könnte, enthält `nextToken` ein Paginierungs-Token, das in einer anderen Anfrage verwendet werden kann. Beachten Sie, dass das von DynamoDB zurückgegebene Paginierungstoken AWS AppSync verschlüsselt und verschleiert wird. Damit sickern Daten aus Ihren Tabellen nicht versehentlich an den Aufrufer durch. Beachten Sie auch, dass diese Paginierungs-Token nicht über verschiedene Resolver verwendet werden können.
** `scannedCount` **
Die Anzahl der Elemente, die mit dem Abfragebedingungsausdruck übereinstimmten, bevor ein Filterausdruck (falls vorhanden) angewendet wurde.
## Beispiel
Das folgende Beispiel ist eine Zuordnungsvorlage für eine GraphQL-Abfrage`getPosts(owner: ID!)`.
In diesem Beispiel wird ein globaler sekundärer Index in einer Tabelle abgefragt, um alle Beiträge im Besitz der angegebenen ID zurückzugeben.
```
{
"version" : "2017-02-28",
"operation" : "Query",
"query" : {
"expression" : "ownerId = :ownerId",
"expressionValues" : {
":ownerId" : $util.dynamodb.toDynamoDBJson($context.arguments.owner)
}
},
"index" : "owner-index"
}
```
Weitere Informationen zur DynamoDB `Query`-API finden Sie in der [DynamoDB API-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html).
# Scan
Mit dem `Scan` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `Scan` Anfrage an DynamoDB zu stellen, und Sie können Folgendes angeben:
+ Ein Filter zum Ausschließen von Ergebnissen
+ Welcher Index verwendet werden soll
+ Wie viele Elemente zurückgegeben werden sollen
+ Ob Consistent-Lesevorgänge verwendet werden sollen
+ Paginierungs-Token
+ Parallele Scans
Das `Scan`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"index" : "fooIndex",
"limit" : 10,
"consistentRead" : false,
"nextToken" : "aPaginationToken",
"totalSegments" : 10,
"segment" : 1,
"filter" : {
...
},
"projection" : {
...
}
}
```
Die Felder sind wie folgt definiert:
## Felder scannen
### Liste der Felder scannen
** `version` **
Die Version der Vorlagedefinition. Aktuell werden `2017-02-28` und `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `Scan`-DynamoDB-Operation durchzuführen, muss diese auf `Scan` gesetzt sein. Dieser Wert ist erforderlich.
** `filter` **
Ein Filter, mit dem die Ergebnisse aus DynamoDB gefiltert werden können, bevor sie zurückgegeben werden. Weitere Informationen zu Filtern finden Sie unter [Filter](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Dies ist ein optionales Feld.
** `index` **
Der Name des abzufragenden Indexes. Der DynamoDB-Abfragevorgang ermöglicht es Ihnen, zusätzlich zum Primärschlüsselindex auch lokale sekundäre Indizes und globale sekundäre Indizes nach einem Hashschlüssel zu durchsuchen. Falls angegeben, weist dies DynamoDB an, den angegebenen Index abzufragen. Wenn nicht angegeben, wird der Primärschlüsselindex abgefragt.
** `limit` **
Die maximale Anzahl der zu einem bestimmten Zeitpunkt auszuwertenden Elemente. Dies ist ein optionales Feld.
** `consistentRead` **
Ein boolescher Wert, der angibt, ob bei der Abfrage von DynamoDB konsistente Lesevorgänge verwendet werden sollen. Dieses Feld ist optional und standardmäßig auf `false` gesetzt.
** `nextToken` **
Das Paginierungs-Token für die Fortsetzung einer früheren Abfrage. Dieses wäre von einer vorherigen Abfrage erhalten worden. Dies ist ein optionales Feld.
** `select` **
Standardmäßig gibt der AWS AppSync DynamoDB-Resolver nur die Attribute zurück, die in den Index projiziert wurden. Wenn weitere Attribute erforderlich sind, kann dieses Feld festgelegt werden. Dies ist ein optionales Feld. Die unterstützten Werte sind:
** `ALL_ATTRIBUTES` **
Gibt alle Elementattribute aus der angegebenen Tabelle oder dem Index zurück. Wenn Sie einen lokalen sekundären Index abfragen, ruft DynamoDB für jedes übereinstimmende Element im Index das gesamte Element aus der übergeordneten Tabelle ab. Wenn der Index konfiguriert ist, um alle Elementattribute zu projizieren, können Sie alle Daten aus dem lokalen sekundären Index erhalten und das Abrufen ist nicht erforderlich.
** `ALL_PROJECTED_ATTRIBUTES` **
Nur bei der Abfrage eines Indexes erlaubt. Ruft alle Attribute ab, die in den Index projiziert wurden. Wenn der Index konfiguriert ist, um alle Attribute zu projizieren, entspricht dieser Rückgabewert der Angabe von `ALL_ATTRIBUTES`.
**`SPECIFIC_ATTRIBUTES`**
Gibt nur die in den s aufgeführten Attribute zurück. `projection` `expression` Dieser Rückgabewert entspricht der Angabe `projection` von 's' `expression` ohne Angabe eines Werts für`Select`.
** `totalSegments` **
Die Anzahl der Segmente zum Partitionieren der Tabelle, wenn ein paralleler Scan durchgeführt wird. Dieses Feld ist optional, muss aber angegeben werden, wenn `segment` angegeben ist.
** `segment` **
Das Tabellensegment in dieser Operation beim Durchführen eines parallelen Scans. Dieses Feld ist optional, muss aber angegeben werden, wenn `totalSegments` angegeben ist.
**`projection`**
Eine Projektion, die verwendet wird, um die Attribute anzugeben, die von der DynamoDB-Operation zurückgegeben werden sollen. [Weitere Informationen zu Projektionen finden Sie unter Projektionen.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Dies ist ein optionales Feld.
Die vom DynamoDB-Scan zurückgegebenen Ergebnisse werden automatisch in primitive GraphQL- und JSON-Typen konvertiert und sind im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
Die Ergebnisse weisen die folgende Struktur auf:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
Die Felder sind wie folgt definiert:
** `items` **
Eine Liste mit den vom DynamoDB-Scan zurückgegebenen Elementen.
** `nextToken` **
Falls es mehr Ergebnisse gibt, `nextToken` enthält sie ein Paginierungstoken, das Sie in einer anderen Anfrage verwenden können. AWS AppSync verschlüsselt und verschleiert das von DynamoDB zurückgegebene Paginierungstoken. Damit sickern Daten aus Ihren Tabellen nicht versehentlich an den Aufrufer durch. Diese Paginierungs-Tokens können nicht über verschiedene Resolver hinweg verwendet werden.
** `scannedCount` **
Die Anzahl der Elemente, die von DynamoDB abgerufen wurden, bevor ein Filterausdruck (falls vorhanden) angewendet wurde.
## Beispiel 1
Das folgende Beispiel ist eine Zuordnungsvorlage für die GraphQL-Abfrage:`allPosts`.
In diesem Beispiel werden alle Einträge in der Tabelle zurückgegeben.
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
## Beispiel 2
Das folgende Beispiel ist eine Zuordnungsvorlage für die GraphQL-Abfrage:`postsMatching(title: String!)`.
In diesem Beispiel werden alle Einträge in der Tabelle zurückgegeben, bei denen der Titel mit dem `title`-Argument beginnt.
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"filter" : {
"expression" : "begins_with(title, :title)",
"expressionValues" : {
":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
},
}
}
```
Weitere Informationen zur DynamoDB `Scan`-API finden Sie in der [DynamoDB API-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html).
# Synchronisierung
Mit dem `Sync` Anforderungszuordnungsdokument können Sie alle Ergebnisse aus einer DynamoDB-Tabelle abrufen und anschließend nur die Daten empfangen, die seit Ihrer letzten Abfrage geändert wurden (die Delta-Updates). `Sync`Anfragen können nur an versionierte DynamoDB-Datenquellen gestellt werden. Sie können Folgendes angeben:
+ Ein Filter zum Ausschließen von Ergebnissen
+ Wie viele Elemente zurückgegeben werden sollen
+ Paginierungstoken
+ Wann Ihre letzte `Sync`-Operation gestartet wurde
Das `Sync`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "Sync",
"basePartitionKey": "Base Tables PartitionKey",
"deltaIndexName": "delta-index-name",
"limit" : 10,
"nextToken" : "aPaginationToken",
"lastSync" : 1550000000000,
"filter" : {
...
}
}
```
Die Felder sind wie folgt definiert:
## Felder synchronisieren
### Liste der Felder synchronisieren
** `version` **
Die Version der Vorlagendefinition. Derzeit wird nur `2018-05-29` unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `Sync`--Operation durchzuführen, muss diese auf `Sync` gesetzt sein. Dieser Wert ist erforderlich.
** `filter` **
Ein Filter, mit dem die Ergebnisse aus DynamoDB gefiltert werden können, bevor sie zurückgegeben werden. Weitere Informationen zu Filtern finden Sie unter [Filter](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Dies ist ein optionales Feld.
** `limit` **
Die maximale Anzahl der zu einem bestimmten Zeitpunkt auszuwertenden Elemente. Dies ist ein optionales Feld. Wenn nicht angegeben, wird das Standardlimit auf `100` Elemente festgelegt. Der maximale Wert für dieses Feld ist `1000` Elemente.
** `nextToken` **
Das Paginierungs-Token für die Fortsetzung einer früheren Abfrage. Dieses wäre von einer vorherigen Abfrage erhalten worden. Dies ist ein optionales Feld.
** `lastSync` **
Der Moment, in Epochenmillisekunden, an dem die letzte erfolgreiche `Sync`-Operation gestartet wurde. Wenn angegeben, werden nur Elemente zurückgegeben, die sich nach `lastSync` geändert haben. Dieses Feld ist optional und sollte nur ausgefüllt werden, nachdem alle Seiten von einem ersten `Sync`-Vorgang abgerufen wurden. Wenn nicht angegeben, werden Ergebnisse aus der *Basis*-Tabelle zurückgegeben, andernfalls werden Ergebnisse aus der *Delta*-Tabelle zurückgegeben.
**`basePartitionKey`**
Der Partitionsschlüssel der *Basistabelle*, der bei der Ausführung eines `Sync` Vorgangs verwendet wird. In diesem Feld kann eine `Sync` Operation ausgeführt werden, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet. Dies ist ein optionales Feld.
**`deltaIndexName`**
Der für die `Sync` Operation verwendete Index. Dieser Index ist erforderlich, um einen `Sync` Vorgang für die gesamte Delta-Speichertabelle zu aktivieren, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet. Die `Sync` Operation wird auf der GSI (erstellt am `gsi_ds_pk` und`gsi_ds_sk`) ausgeführt. Dies ist ein optionales Feld.
Die von der DynamoDB-Synchronisierung zurückgegebenen Ergebnisse werden automatisch in primitive GraphQL- und JSON-Typen konvertiert und sind im Mapping-Kontext () verfügbar. `$context.result`
Weitere Informationen zur DynamoDB-Typkonvertierung finden Sie unter [Typsystem (Antwortzuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)).
Weitere Informationen zu Vorlagen für die Antwortzuweisung finden Sie unter Übersicht über [Resolver-Mapping-Vorlagen](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
Die Ergebnisse weisen die folgende Struktur auf:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10,
startedAt = 1550000000000
}
```
Die Felder sind wie folgt definiert:
** `items` **
Eine Liste mit den Elementen, die von der Synchronisierung zurückgegeben wurden.
** `nextToken` **
Falls es möglicherweise mehr Ergebnisse gibt, `nextToken` enthält es ein Paginierungstoken, das Sie in einer anderen Anfrage verwenden können. AWS AppSync verschlüsselt und verschleiert das von DynamoDB zurückgegebene Paginierungstoken. Damit sickern Daten aus Ihren Tabellen nicht versehentlich an den Aufrufer durch. Diese Paginierungs-Tokens können nicht über verschiedene Resolver hinweg verwendet werden.
** `scannedCount` **
Die Anzahl der Elemente, die von DynamoDB abgerufen wurden, bevor ein Filterausdruck (falls vorhanden) angewendet wurde.
** `startedAt` **
Der Moment, in Epochenmillisekunden, an dem der Synchronisierungsvorgang gestartet wurde, den Sie lokal speichern und in einer anderen Anforderung als `lastSync`-Argument verwenden können. Wenn ein Paginierungstoken in der Anforderung enthalten war, entspricht dieser Wert dem Wert, der von der Anforderung für die erste Ergebnisseite zurückgegeben wird.
## Beispiel
Das folgende Beispiel ist eine Zuordnungsvorlage für die GraphQL-Abfrage:`syncPosts(nextToken: String, lastSync: AWSTimestamp)`.
Wenn in diesem Beispiel `lastSync` weggelassen wird, werden alle Einträge in der Basistabelle zurückgegeben. Wenn `lastSync` angegeben wird, werden nur die Einträge in der Delta-Synchronisationstabelle zurückgegeben, die sich seit `lastSync` geändert haben.
```
{
"version" : "2018-05-29",
"operation" : "Sync",
"limit": 100,
"nextToken": $util.toJson($util.defaultIfNull($ctx.args.nextToken, null)),
"lastSync": $util.toJson($util.defaultIfNull($ctx.args.lastSync, null))
}
```
# BatchGetItem
Mit dem `BatchGetItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `BatchGetItem` Anforderung an DynamoDB zu stellen, um mehrere Elemente abzurufen, möglicherweise über mehrere Tabellen hinweg. Für diese Anforderungsvorlage müssen Sie Folgendes angeben:
+ Die Namen der Tabellen, aus denen die Elemente abgerufen werden sollen.
+ Die Schlüssel der Elemente, die aus den einzelnen Tabellen abgerufen werden sollen.
Es gelten die DynamoDB `BatchGetItem`-Grenzwerte, und es kann **kein Bedingungsausdruck** bereitgestellt werden.
Das `BatchGetItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "BatchGetItem",
"tables" : {
"table1": {
"keys": [
## Item to retrieve Key
{
"foo" : ... typed value,
"bar" : ... typed value
},
## Item2 to retrieve Key
{
"foo" : ... typed value,
"bar" : ... typed value
}
],
"consistentRead": true|false,
"projection" : {
...
}
},
"table2": {
"keys": [
## Item3 to retrieve Key
{
"foo" : ... typed value,
"bar" : ... typed value
},
## Item4 to retrieve Key
{
"foo" : ... typed value,
"bar" : ... typed value
}
],
"consistentRead": true|false,
"projection" : {
...
}
}
}
}
```
Die Felder sind wie folgt definiert:
## BatchGetItem Felder
### BatchGetItem Liste der Felder
** `version` **
Die Version der Vorlagendefinition. Nur `2018-05-29` wird unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `BatchGetItem`-DynamoDB-Operation durchzuführen, muss diese auf `BatchGetItem` gesetzt sein. Dieser Wert ist erforderlich.
** `tables` **
Die DynamoDB-Tabellen, aus denen die Elemente abgerufen werden sollen. Der Wert ist eine Zuweisung, in der Tabellennamen als Schlüssel der Zuweisung angegeben werden. Mindestens eine Tabelle muss angegeben werden. Dieser `tables`-Wert ist erforderlich.
** `keys` **
Liste der DynamoDB-Schlüssel, die den Primärschlüssel der abzurufenden Elemente darstellen. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)).
** `consistentRead` **
Ob bei der Ausführung eines *GetItem*Vorgangs ein konsistenter Lesevorgang verwendet werden soll. Dieser Wert ist optional und ist standardmäßig *false*.
**`projection`**
Eine Projektion, die verwendet wird, um die Attribute anzugeben, die von der DynamoDB-Operation zurückgegeben werden sollen. [Weitere Informationen zu Projektionen finden Sie unter Projektionen.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Dies ist ein optionales Feld.
Beachten Sie Folgendes:
+ Wenn ein Element nicht aus der Tabelle abgerufen wurde, enthält der Datenblock für diese Tabelle ein *null*-Element.
+ Die Aufrufergebnisse werden nach Tabelle sortiert, basierend auf der Reihenfolge, in der sie in der Vorlage für die Anforderungszuweisung bereitgestellt wurden.
+ Jeder `Get` Befehl in a `BatchGetItem` ist atomar, ein Batch kann jedoch teilweise verarbeitet werden. Wenn ein Stapel aufgrund eines Fehlers teilweise verarbeitet wird, werden die nicht verarbeiteten Schlüssel als Teil des Aufrufergebnisses im Block *unprocessedKeys* zurückgegeben.
+ `BatchGetItem` ist auf 100 Schlüssel beschränkt.
Für das folgende Beispiel für eine Anforderungszuweisungsvorlage gilt:
```
{
"version": "2018-05-29",
"operation": "BatchGetItem",
"tables": {
"authors": [
{
"author_id": {
"S": "a1"
}
},
],
"posts": [
{
"author_id": {
"S": "a1"
},
"post_id": {
"S": "p2"
}
}
],
}
}
```
Das in `$ctx.result` verfügbare Aufrufergebnis sieht wie folgt aus:
```
{
"data": {
"authors": [null],
"posts": [
# Was retrieved
{
"author_id": "a1",
"post_id": "p2",
"post_title": "title",
"post_description": "description",
}
]
},
"unprocessedKeys": {
"authors": [
# This item was not processed due to an error
{
"author_id": "a1"
}
],
"posts": []
}
}
```
`$ctx.error` enthält die Einzelheiten zu dem Fehler. Die Schlüssel **data**, **unprocessedKeys** sowie die einzelnen Tabellenschlüssel, die in der Zuweisungsvorlage für die Anforderung bereitgestellt wurden, sind garantiert im Aufrufergebnis vorhanden. Elemente, die gelöscht wurden, befinden sich im Block **data**. Elemente, die nicht verarbeitet wurden, werden im Datenblock mit *null* markiert und im Block **unprocessedKeys** platziert.
Ein vollständigeres Beispiel AppSync finden Sie im DynamoDB Batch-Tutorial mit diesem [Tutorial: DynamoDB-Batch-Resolver](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch).
# BatchDeleteItem
Mit dem `BatchDeleteItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `BatchWriteItem` Anforderung an DynamoDB zu stellen, um mehrere Elemente zu löschen, möglicherweise über mehrere Tabellen hinweg. Für diese Anforderungsvorlage müssen Sie Folgendes angeben:
+ Die Namen der Tabellen, aus denen die Elemente gelöscht werden sollen.
+ Die Schlüssel der Elemente, die aus den einzelnen Tabellen gelöscht werden sollen.
Es gelten die DynamoDB `BatchWriteItem`-Grenzwerte, und es kann **kein Bedingungsausdruck** bereitgestellt werden.
Das `BatchDeleteItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "BatchDeleteItem",
"tables" : {
"table1": [
## Item to delete Key
{
"foo" : ... typed value,
"bar" : ... typed value
},
## Item2 to delete Key
{
"foo" : ... typed value,
"bar" : ... typed value
}],
"table2": [
## Item3 to delete Key
{
"foo" : ... typed value,
"bar" : ... typed value
},
## Item4 to delete Key
{
"foo" : ... typed value,
"bar" : ... typed value
}],
}
}
```
Die Felder sind wie folgt definiert:
## BatchDeleteItem Felder
### BatchDeleteItem Liste der Felder
** `version` **
Die Version der Vorlagendefinition. Nur `2018-05-29` wird unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `BatchDeleteItem`-DynamoDB-Operation durchzuführen, muss diese auf `BatchDeleteItem` gesetzt sein. Dieser Wert ist erforderlich.
** `tables` **
Die DynamoDB-Tabellen, aus denen die Elemente gelöscht werden sollen. Jede Tabelle ist eine Liste von DynamoDB-Schlüsseln, die den Primärschlüssel der zu löschenden Elemente darstellen. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Mindestens eine Tabelle muss angegeben werden. Der `tables` Wert ist erforderlich.
Beachten Sie Folgendes:
+ Im Gegensatz zum `DeleteItem`-Vorgang wird nicht das vollständig gelöschte Element in der Antwort zurückgegeben. Nur der übergebene Schlüssel wird zurückgegeben.
+ Wenn ein Element nicht aus der Tabelle gelöscht wurde, enthält der Datenblock für diese Tabelle ein *null*-Element.
+ Die Aufrufergebnisse werden nach Tabelle sortiert, basierend auf der Reihenfolge, in der sie in der Anforderungszuordnungsvorlage bereitgestellt wurden.
+ Jeder `Delete` Befehl in a `BatchDeleteItem` ist atomar. Ein Stapel kann jedoch teilweise verarbeitet werden. Wenn ein Stapel aufgrund eines Fehlers teilweise verarbeitet wird, werden die nicht verarbeiteten Schlüssel als Teil des Aufrufergebnisses im Block *unprocessedKeys* zurückgegeben.
+ `BatchDeleteItem` ist auf 25 Schlüssel beschränkt.
+ Dieser Vorgang **wird nicht** unterstützt, wenn er zusammen mit der Konflikterkennung verwendet wird. Wenn Sie beide gleichzeitig verwenden, kann dies zu einem Fehler führen.
Für das folgende Beispiel für eine Anforderungszuweisungsvorlage gilt:
```
{
"version": "2018-05-29",
"operation": "BatchDeleteItem",
"tables": {
"authors": [
{
"author_id": {
"S": "a1"
}
},
],
"posts": [
{
"author_id": {
"S": "a1"
},
"post_id": {
"S": "p2"
}
}
],
}
}
```
Das in `$ctx.result` verfügbare Aufrufergebnis sieht wie folgt aus:
```
{
"data": {
"authors": [null],
"posts": [
# Was deleted
{
"author_id": "a1",
"post_id": "p2"
}
]
},
"unprocessedKeys": {
"authors": [
# This key was not processed due to an error
{
"author_id": "a1"
}
],
"posts": []
}
}
```
`$ctx.error` enthält die Einzelheiten zu dem Fehler. Die Schlüssel **data**, **unprocessedKeys** sowie die einzelnen Tabellenschlüssel, die in der Zuweisungsvorlage für die Anforderung bereitgestellt wurden, sind garantiert im Aufrufergebnis vorhanden. Elemente, die gelöscht wurden, befinden sich im Block **data**. Elemente, die nicht verarbeitet wurden, werden im Datenblock mit *null* markiert und im Block **unprocessedKeys** platziert.
Ein vollständigeres Beispiel AppSync finden Sie im DynamoDB Batch-Tutorial mit diesem [Tutorial: DynamoDB-Batch-Resolver](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch).
# BatchPutItem
Mit dem `BatchPutItem` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `BatchWriteItem` Anforderung an DynamoDB zu stellen, um mehrere Elemente zu platzieren, möglicherweise in mehreren Tabellen. Für diese Anforderungsvorlage müssen Sie Folgendes angeben:
+ Die Namen der Tabellen, in denen die Elemente abgelegt werden sollen.
+ Die vollständigen Elemente, die in jeder Tabelle abgelegt werden sollen
Es gelten die DynamoDB `BatchWriteItem`-Grenzwerte, und es kann **kein Bedingungsausdruck** bereitgestellt werden.
Das `BatchPutItem`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version" : "2018-05-29",
"operation" : "BatchPutItem",
"tables" : {
"table1": [
## Item to put
{
"foo" : ... typed value,
"bar" : ... typed value
},
## Item2 to put
{
"foo" : ... typed value,
"bar" : ... typed value
}],
"table2": [
## Item3 to put
{
"foo" : ... typed value,
"bar" : ... typed value
},
## Item4 to put
{
"foo" : ... typed value,
"bar" : ... typed value
}],
}
}
```
Die Felder sind wie folgt definiert:
## BatchPutItem Felder
### BatchPutItem Liste der Felder
** `version` **
Die Version der Vorlagendefinition. Nur `2018-05-29` wird unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `BatchPutItem`-DynamoDB-Operation durchzuführen, muss diese auf `BatchPutItem` gesetzt sein. Dieser Wert ist erforderlich.
** `tables` **
Die DynamoDB-Tabellen, in die die Elemente eingefügt werden sollen. Jeder Tabelleneintrag stellt eine Liste von DynamoDB-Elementen dar, die für diese spezielle Tabelle eingefügt werden sollen. Mindestens eine Tabelle muss angegeben werden. Dieser Wert ist erforderlich.
Beachten Sie Folgendes:
+ Bei Erfolg werden die vollständig eingefügten Elemente in der Antwort zurückgegeben.
+ Wenn ein Element nicht in die Tabelle eingefügt wurde, wird im Datenblock für diese Tabelle ein *null*-Element angezeigt.
+ Die eingefügten Elemente werden nach Tabelle sortiert, basierend auf der Reihenfolge, in der sie in der Anforderungszuordnungsvorlage bereitgestellt wurden.
+ Jeder `Put` Befehl in a `BatchPutItem` ist atomar, ein Batch kann jedoch teilweise verarbeitet werden. Wenn ein Stapel aufgrund eines Fehlers teilweise verarbeitet wird, werden die nicht verarbeiteten Schlüssel als Teil des Aufrufergebnisses im Block *unprocessedKeys* zurückgegeben.
+ `BatchPutItem` ist auf 25 Elemente beschränkt.
+ Dieser Vorgang **wird nicht** unterstützt, wenn er zusammen mit der Konflikterkennung verwendet wird. Wenn Sie beide gleichzeitig verwenden, kann dies zu einem Fehler führen.
Für das folgende Beispiel für eine Anforderungszuweisungsvorlage gilt:
```
{
"version": "2018-05-29",
"operation": "BatchPutItem",
"tables": {
"authors": [
{
"author_id": {
"S": "a1"
},
"author_name": {
"S": "a1_name"
}
},
],
"posts": [
{
"author_id": {
"S": "a1"
},
"post_id": {
"S": "p2"
},
"post_title": {
"S": "title"
}
}
],
}
}
```
Das in `$ctx.result` verfügbare Aufrufergebnis sieht wie folgt aus:
```
{
"data": {
"authors": [
null
],
"posts": [
# Was inserted
{
"author_id": "a1",
"post_id": "p2",
"post_title": "title"
}
]
},
"unprocessedItems": {
"authors": [
# This item was not processed due to an error
{
"author_id": "a1",
"author_name": "a1_name"
}
],
"posts": []
}
}
```
`$ctx.error` enthält die Einzelheiten zu dem Fehler. Die Schlüssel **data**, **unprocessedItems** sowie die einzelnen Tabellenschlüssel, die in der Zuweisungsvorlage für die Anforderung bereitgestellt wurden, sind garantiert im Aufrufergebnis vorhanden. Elemente, die eingefügt wurden, befinden sich im Block **data**. Elemente, die nicht verarbeitet wurden, werden im Datenblock mit *null* markiert und im Block **unprocessedItems** platziert.
Ein vollständigeres Beispiel AppSync finden Sie im DynamoDB Batch-Tutorial mit diesem [Tutorial: DynamoDB-Batch-Resolver](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch).
# TransactGetItems
Mit dem `TransactGetItems` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `TransactGetItems` Anforderung an DynamoDB zu stellen, um mehrere Elemente abzurufen, möglicherweise über mehrere Tabellen hinweg. Für diese Anforderungsvorlage müssen Sie Folgendes angeben:
+ Der Tabellenname jedes Anforderungselements, von dem das Element abgerufen werden soll
+ Der Schlüssel jedes Anforderungselements, das aus jeder Tabelle abgerufen werden soll
Es gelten die DynamoDB `TransactGetItems`-Grenzwerte, und es kann **kein Bedingungsausdruck** bereitgestellt werden.
Das `TransactGetItems`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version": "2018-05-29",
"operation": "TransactGetItems",
"transactItems": [
## First request item
{
"table": "table1",
"key": {
"foo": ... typed value,
"bar": ... typed value
},
"projection" : {
...
}
},
## Second request item
{
"table": "table2",
"key": {
"foo": ... typed value,
"bar": ... typed value
},
"projection" : {
...
}
}
]
}
```
Die Felder sind wie folgt definiert:
## TransactGetItems Felder
### TransactGetItems Liste der Felder
** `version` **
Die Version der Vorlagendefinition. Nur `2018-05-29` wird unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `TransactGetItems`-DynamoDB-Operation durchzuführen, muss diese auf `TransactGetItems` gesetzt sein. Dieser Wert ist erforderlich.
** `transactItems` **
Die einzuschließenden Anforderungselemente. Der Wert ist ein Array von Anforderungselementen. Es muss mindestens ein Anforderungselement angegeben werden. Dieser `transactItems`-Wert ist erforderlich.
** `table` **
Die DynamoDB-Tabelle, aus der das Element abgerufen werden soll. Der Wert ist eine Zeichenfolge des Tabellennamens. Dieser `table`-Wert ist erforderlich.
** `key` **
Der DynamoDB-Schlüssel, der den Primärschlüssel des abzurufenden Elements darstellt. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)).
**`projection`**
Eine Projektion, die verwendet wird, um die Attribute anzugeben, die von der DynamoDB-Operation zurückgegeben werden sollen. [Weitere Informationen zu Projektionen finden Sie unter Projektionen.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Dies ist ein optionales Feld.
Beachten Sie Folgendes:
+ Wenn eine Transaktion erfolgreich ist, entspricht die Reihenfolge der abgerufenen Elemente im `items`-Block der Reihenfolge der Anforderungselemente.
+ Transaktionen werden in irgendeiner all-or-nothing Weise ausgeführt. Wenn ein Anforderungselement einen Fehler verursacht, wird die gesamte Transaktion nicht ausgeführt, und Fehlerdetails werden zurückgegeben.
+ Ein Anforderungselement, das nicht abgerufen werden kann, ist kein Fehler. Stattdessen erscheint ein *Null*-Element im *Elemente*-Block an der entsprechenden Position.
+ Wenn der Fehler einer Transaktion lautet *TransactionCanceledException*, wird der `cancellationReasons` Block aufgefüllt. Die Reihenfolge der Stornierungsgründe im `cancellationReasons`-Block ist die gleiche wie die Reihenfolge der Anforderungselemente.
+ `TransactGetItems`ist auf 100 Anfrageelemente begrenzt.
Für das folgende Beispiel für eine Anforderungszuweisungsvorlage gilt:
```
{
"version": "2018-05-29",
"operation": "TransactGetItems",
"transactItems": [
## First request item
{
"table": "posts",
"key": {
"post_id": {
"S": "p1"
}
}
},
## Second request item
{
"table": "authors",
"key": {
"author_id": {
"S": a1
}
}
}
]
}
```
Wenn die Transaktion erfolgreich ist und nur das erste angeforderte Element abgerufen wird, ist das Aufrufergebnis in `$ctx.result` wie folgt verfügbar:
```
{
"items": [
{
// Attributes of the first requested item
"post_id": "p1",
"post_title": "title",
"post_description": "description"
},
// Could not retrieve the second requested item
null,
],
"cancellationReasons": null
}
```
Wenn die Transaktion *TransactionCanceledException*aufgrund des ersten Anforderungselements fehlschlägt, `$ctx.result` ist das Aufrufergebnis wie folgt verfügbar:
```
{
"items": null,
"cancellationReasons": [
{
"type":"Sample error type",
"message":"Sample error message"
},
{
"type":"None",
"message":"None"
}
]
}
```
`$ctx.error` enthält die Einzelheiten zu dem Fehler. Die Schlüssel-**Elemente** und **Stornierungsgründe** sind garantiert in `$ctx.result` vorhanden.
Ein vollständigeres Beispiel AppSync finden Sie im DynamoDB-Transaktions-Tutorial mit diesem [Tutorial: DynamoDB-Transaktionsauflösungen](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).
# TransactWriteItems
Mit dem `TransactWriteItems` Anforderungszuordnungsdokument können Sie den AWS AppSync DynamoDB-Resolver anweisen, eine `TransactWriteItems` Anforderung an DynamoDB zu stellen, um mehrere Elemente zu schreiben, möglicherweise in mehrere Tabellen. Für diese Anforderungsvorlage müssen Sie Folgendes angeben:
+ Der Name der Zieltabelle jedes Anforderungselements
+ Der Vorgang jedes auszuführenden Anforderungselements. Es gibt vier Arten von Operationen, die unterstützt werden:,, und *PutItem*UpdateItem*DeleteItem*ConditionCheck****
+ Der Schlüssel jedes zu schreibenden Anforderungselements
Es gelten die DynamoDB `TransactWriteItems`-Grenzwerte.
Das `TransactWriteItems`-Zuweisungsdokument weist die folgende Struktur auf:
```
{
"version": "2018-05-29",
"operation": "TransactWriteItems",
"transactItems": [
{
"table": "table1",
"operation": "PutItem",
"key": {
"foo": ... typed value,
"bar": ... typed value
},
"attributeValues": {
"baz": ... typed value
},
"condition": {
"expression": "someExpression",
"expressionNames": {
"#foo": "foo"
},
"expressionValues": {
":bar": ... typed value
},
"returnValuesOnConditionCheckFailure": true|false
}
},
{
"table":"table2",
"operation": "UpdateItem",
"key": {
"foo": ... typed value,
"bar": ... typed value
},
"update": {
"expression": "someExpression",
"expressionNames": {
"#foo": "foo"
},
"expressionValues": {
":bar": ... typed value
}
},
"condition": {
"expression": "someExpression",
"expressionNames": {
"#foo":"foo"
},
"expressionValues": {
":bar": ... typed value
},
"returnValuesOnConditionCheckFailure": true|false
}
},
{
"table": "table3",
"operation": "DeleteItem",
"key":{
"foo": ... typed value,
"bar": ... typed value
},
"condition":{
"expression": "someExpression",
"expressionNames": {
"#foo": "foo"
},
"expressionValues": {
":bar": ... typed value
},
"returnValuesOnConditionCheckFailure": true|false
}
},
{
"table": "table4",
"operation": "ConditionCheck",
"key":{
"foo": ... typed value,
"bar": ... typed value
},
"condition":{
"expression": "someExpression",
"expressionNames": {
"#foo": "foo"
},
"expressionValues": {
":bar": ... typed value
},
"returnValuesOnConditionCheckFailure": true|false
}
}
]
}
```
## TransactWriteItems Felder
### TransactWriteItems Liste der Felder
**Die Felder sind wie folgt definiert:**
** `version` **
Die Version der Vorlagendefinition. Nur `2018-05-29` wird unterstützt. Dieser Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `TransactWriteItems`-DynamoDB-Operation durchzuführen, muss diese auf `TransactWriteItems` gesetzt sein. Dieser Wert ist erforderlich.
** `transactItems` **
Die einzuschließenden Anforderungselemente. Der Wert ist ein Array von Anforderungselementen. Es muss mindestens ein Anforderungselement angegeben werden. Dieser `transactItems`-Wert ist erforderlich.
Für `PutItem` sind die Felder wie folgt definiert:
** `table` **
Die DynamoDB-Zieltabelle. Der Wert ist eine Zeichenfolge des Tabellennamens. Dieser `table`-Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `PutItem`-DynamoDB-Operation durchzuführen, muss diese auf `PutItem` gesetzt sein. Dieser Wert ist erforderlich.
** `key` **
Der DynamoDB-Schlüssel, der den Primärschlüssel des einzufügenden Elements darstellt. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dieser Wert ist erforderlich.
** `attributeValues` **
Der Rest der Attribute des Elements, die in DynamoDB gespeichert werden sollen. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dies ist ein optionales Feld.
** `condition` **
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Wenn keine Bedingung angegeben ist, überschreibt die `PutItem`-Anforderung alle vorhandenen Einträge für dieses Element. Sie können angeben, ob das vorhandene Element zurückgerufen werden soll, wenn die Bedingungsprüfung fehlschlägt. Weitere Informationen zu Transaktionsbedingungen finden Sie unter Ausdrücke für [Transaktionsbedingungen](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Dieser Wert ist optional.
Für `UpdateItem` sind die Felder wie folgt definiert:
** `table` **
Die zu aktualisierende DynamoDB-Tabelle. Der Wert ist eine Zeichenfolge des Tabellennamens. Dieser `table`-Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `UpdateItem`-DynamoDB-Operation durchzuführen, muss diese auf `UpdateItem` gesetzt sein. Dieser Wert ist erforderlich.
** `key` **
Der DynamoDB-Schlüssel, der den Primärschlüssel des zu aktualisierenden Elements darstellt. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dieser Wert ist erforderlich.
** `update` **
`update`In diesem Abschnitt können Sie einen Aktualisierungsausdruck angeben, der beschreibt, wie das Element in DynamoDB aktualisiert wird. Weitere Informationen zum Schreiben von Aktualisierungsausdrücken finden Sie in der [DynamoDB-Dokumentation UpdateExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Dieser Abschnitt ist erforderlich.
** `condition` **
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Wenn keine Bedingung angegeben ist, aktualisiert die `UpdateItem`-Anforderung jeden vorhandenen Eintrag unabhängig vom aktuellen Status. Sie können angeben, ob das vorhandene Element zurückgerufen werden soll, wenn die Bedingungsprüfung fehlschlägt. [Weitere Informationen zu Transaktionsbedingungen finden Sie unter Ausdrücke für Transaktionsbedingungen.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Dieser Wert ist optional.
Für `DeleteItem` sind die Felder wie folgt definiert:
** `table` **
Die DynamoDB-Tabelle, in der das Element gelöscht werden soll. Der Wert ist eine Zeichenfolge des Tabellennamens. Dieser `table`-Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `DeleteItem`-DynamoDB-Operation durchzuführen, muss diese auf `DeleteItem` gesetzt sein. Dieser Wert ist erforderlich.
** `key` **
Der DynamoDB-Schlüssel, der den Primärschlüssel des zu löschenden Elements darstellt. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dieser Wert ist erforderlich.
** `condition` **
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Wenn keine Bedingung angegeben ist, löscht die `DeleteItem`-Anforderung ein Element unabhängig vom aktuellen Status. Sie können angeben, ob das vorhandene Element zurückgerufen werden soll, wenn die Bedingungsprüfung fehlschlägt. Weitere Informationen zu Transaktionsbedingungen finden Sie unter Ausdrücke für [Transaktionsbedingungen](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Dieser Wert ist optional.
Für `ConditionCheck` sind die Felder wie folgt definiert:
** `table` **
Die DynamoDB-Tabelle, in der der Zustand überprüft werden soll. Der Wert ist eine Zeichenfolge des Tabellennamens. Dieser `table`-Wert ist erforderlich.
** `operation` **
Der DynamoDB DynamoDB-Vorgang. Um die `ConditionCheck`-DynamoDB-Operation durchzuführen, muss diese auf `ConditionCheck` gesetzt sein. Dieser Wert ist erforderlich.
** `key` **
Der DynamoDB-Schlüssel, der den Primärschlüssel des Artikels zur Zustandsprüfung darstellt. DynamoDB-Elemente können je nach Tabellenstruktur einen einzelnen Hashschlüssel oder einen Hashschlüssel und einen Sortierschlüssel haben. Weitere Informationen zur Angabe eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuordnung](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Dieser Wert ist erforderlich.
** `condition` **
Eine Bedingung, um zu bestimmen, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Status des Objekts, das sich bereits in DynamoDB befindet. Sie können angeben, ob das vorhandene Element zurückgerufen werden soll, wenn die Bedingungsprüfung fehlschlägt. Weitere Informationen zu Transaktionsbedingungen finden Sie unter Ausdrücke für [Transaktionsbedingungen](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Dieser Wert ist erforderlich.
Beachten Sie Folgendes:
+ Nur Schlüssel von Anforderungselementen werden in der Antwort zurückgegeben, wenn diese erfolgreich ist. Die Reihenfolge der Schlüssel entspricht der Reihenfolge der Anforderungselemente.
+ Transaktionen werden auf irgendeine Weise ausgeführt. all-or-nothing Wenn ein Anforderungselement einen Fehler verursacht, wird die gesamte Transaktion nicht ausgeführt, und Fehlerdetails werden zurückgegeben.
+ Es können keine zwei Anforderungselemente auf dasselbe Element ausgerichtet werden. Andernfalls führen sie zu *TransactionCanceledException*Fehlern.
+ Wenn der Fehler einer Transaktion vorliegt *TransactionCanceledException*, wird der `cancellationReasons` Block aufgefüllt. Wenn die Bedingungsprüfung eines Anforderungselements fehlschlägt **und** Sie nicht `returnValuesOnConditionCheckFailure` als `false` angegeben haben, wird das in der Tabelle vorhandene Element `item` an der entsprechenden Position des `cancellationReasons`-Blocks abgerufen und gespeichert.
+ `TransactWriteItems`ist auf 100 Anfrageelemente begrenzt.
+ Dieser Vorgang **wird nicht** unterstützt, wenn er zusammen mit der Konflikterkennung verwendet wird. Wenn Sie beide gleichzeitig verwenden, kann dies zu einem Fehler führen.
Für das folgende Beispiel für eine Anforderungszuweisungsvorlage gilt:
```
{
"version": "2018-05-29",
"operation": "TransactWriteItems",
"transactItems": [
{
"table": "posts",
"operation": "PutItem",
"key": {
"post_id": {
"S": "p1"
}
},
"attributeValues": {
"post_title": {
"S": "New title"
},
"post_description": {
"S": "New description"
}
},
"condition": {
"expression": "post_title = :post_title",
"expressionValues": {
":post_title": {
"S": "Expected old title"
}
}
}
},
{
"table":"authors",
"operation": "UpdateItem",
"key": {
"author_id": {
"S": "a1"
},
},
"update": {
"expression": "SET author_name = :author_name",
"expressionValues": {
":author_name": {
"S": "New name"
}
}
},
}
]
}
```
Wenn die Transaktion erfolgreich ist, ist das Aufrufergebnis in `$ctx.result` wie folgt verfügbar:
```
{
"keys": [
// Key of the PutItem request
{
"post_id": "p1",
},
// Key of the UpdateItem request
{
"author_id": "a1"
}
],
"cancellationReasons": null
}
```
Wenn die Transaktion aufgrund eines Fehlers bei der Zustandsprüfung der `PutItem` Anfrage fehlschlägt, `$ctx.result` ist das Aufrufergebnis wie folgt verfügbar:
```
{
"keys": null,
"cancellationReasons": [
{
"item": {
"post_id": "p1",
"post_title": "Actual old title",
"post_description": "Old description"
},
"type": "ConditionCheckFailed",
"message": "The condition check failed."
},
{
"type": "None",
"message": "None"
}
]
}
```
`$ctx.error` enthält die Einzelheiten zu dem Fehler. Die Schlüssel **keys** und **cancellationReasons** sind garantiert in `$ctx.result` vorhanden.
Ein vollständigeres Beispiel AppSync finden Sie im DynamoDB-Transaktions-Tutorial mit diesem [Tutorial: DynamoDB-Transaktionsauflösungen](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).
# Geben Sie System ein (Zuordnung anfordern)
Wenn Sie den AWS AppSync DynamoDB-Resolver zum Aufrufen Ihrer DynamoDB-Tabellen verwenden, AWS AppSync muss der Typ jedes Werts bekannt sein, der in diesem Aufruf verwendet werden soll. Dies liegt daran, dass DynamoDB mehr Typprimitive unterstützt als GraphQL oder JSON (z. B. Sets und Binärdaten). AWS AppSync benötigt einige Hinweise bei der Übersetzung zwischen GraphQL und DynamoDB, andernfalls müsste es einige Annahmen darüber treffen, wie Daten in Ihrer Tabelle strukturiert sind.
[Weitere Informationen zu DynamoDB-Datentypen finden Sie in der Dokumentation zu [DynamoDB-Datentypdeskriptoren und Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors).](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes)
Ein DynamoDB-Wert wird durch ein JSON-Objekt dargestellt, das ein einzelnes Schlüssel-Wert-Paar enthält. Der Schlüssel gibt den DynamoDB-Typ an, und der Wert gibt den Wert selbst an. Im folgenden Beispiel gibt der Schlüssel `S` an, dass der Wert eine Zeichenfolge und der Wert `identifier` selbst ein Zeichenfolgewert ist.
```
{ "S" : "identifier" }
```
Beachten Sie, dass das JSON-Objekt nicht mehr als ein Schlüssel-Wert-Paar haben kann. Wenn mehr als ein Schlüssel-Wert-Paar angegeben wird, wird das Zuweisungsdokument für Anforderungen nicht analysiert.
Ein DynamoDB-Wert wird überall in einem Anforderungszuordnungsdokument verwendet, wo Sie einen Wert angeben müssen. Zu den Stellen, an denen Sie dies durchführen müssen, gehören: die Abschnitte `key` und `attributeValue` und der Bereich `expressionValues` von Ausdrucksabschnitten. Im folgenden Beispiel `identifier` wird der DynamoDB-Zeichenkettenwert dem `id` Feld in einem `key` Abschnitt zugewiesen (möglicherweise in einem `GetItem` Anforderungszuordnungsdokument).
```
"key" : {
"id" : { "S" : "identifier" }
}
```
**Unterstützte Typen**
AWS AppSync unterstützt die folgenden DynamoDB-Skalar-, Dokument- und Satztypen:
**Zeichenfolgetyp `S` **
Ein einzelner Zeichenfolgewert. Ein DynamoDB-Zeichenkettenwert wird wie folgt bezeichnet:
```
{ "S" : "some string" }
```
Eine Verwendungsbeispiel ist:
```
"key" : {
"id" : { "S" : "some string" }
}
```
**Zeichenfolgesatztyp `SS` **
Ein Satz von Zeichenfolgewerten. Ein DynamoDB String Set-Wert wird wie folgt bezeichnet:
```
{ "SS" : [ "first value", "second value", ... ] }
```
Eine Verwendungsbeispiel ist:
```
"attributeValues" : {
"phoneNumbers" : { "SS" : [ "+1 555 123 4567", "+1 555 234 5678" ] }
}
```
**Zahlentyp `N` **
Ein einzelner numerischer Wert. Ein DynamoDB-Zahlenwert wird wie folgt bezeichnet:
```
{ "N" : 1234 }
```
Eine Verwendungsbeispiel ist:
```
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
}
```
**Zahlensatztyp `NS` **
Ein Satz von Zahlenwerten. Ein DynamoDB Number Set-Wert wird wie folgt bezeichnet:
```
{ "NS" : [ 1, 2.3, 4 ... ] }
```
Eine Verwendungsbeispiel ist:
```
"attributeValues" : {
"sensorReadings" : { "NS" : [ 67.8, 12.2, 70 ] }
}
```
**Binärtyp `B` **
Ein Binärwert. Ein DynamoDB-Binärwert wird wie folgt bezeichnet:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
Beachten Sie, dass der Wert tatsächlich eine Zeichenfolge ist, wobei die Zeichenfolge die Base64-kodierte Darstellung der Binärdaten ist. AWS AppSync dekodiert diese Zeichenfolge wieder in ihren Binärwert, bevor sie an DynamoDB gesendet wird. AWS AppSync verwendet das Base64-Dekodierungsschema, wie es in RFC 2045 definiert ist: Jedes Zeichen, das nicht im Base64-Alphabet vorkommt, wird ignoriert.
Eine Verwendungsbeispiel ist:
```
"attributeValues" : {
"binaryMessage" : { "B" : "SGVsbG8sIFdvcmxkIQo=" }
}
```
**Binärsatztyp `BS` **
Ein Satz von Binärwerten. Ein DynamoDB Binary Set-Wert wird wie folgt bezeichnet:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
Beachten Sie, dass der Wert tatsächlich eine Zeichenfolge ist, wobei die Zeichenfolge die Base64-kodierte Darstellung der Binärdaten ist. AWS AppSync dekodiert diese Zeichenfolge wieder in ihren Binärwert, bevor sie an DynamoDB gesendet wird. AWS AppSync verwendet das Base64-Dekodierungsschema, wie es in RFC 2045 definiert ist: Jedes Zeichen, das nicht im Base64-Alphabet vorkommt, wird ignoriert.
Eine Verwendungsbeispiel ist:
```
"attributeValues" : {
"binaryMessages" : { "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ] }
}
```
**Boolescher Typ `BOOL` **
Ein Boolescher Wert Ein boolescher DynamoDB-Wert wird wie folgt bezeichnet:
```
{ "BOOL" : true }
```
Beachten Sie, dass nur `true` und `false` gültige Werte sind.
Eine Verwendungsbeispiel ist:
```
"attributeValues" : {
"orderComplete" : { "BOOL" : false }
}
```
**Listentyp `L` **
Eine Liste aller anderen unterstützten DynamoDB-Werte. Ein DynamoDB-Listenwert wird wie folgt gekennzeichnet:
```
{ "L" : [ ... ] }
```
Beachten Sie, dass es sich bei dem Wert um einen zusammengesetzten Wert handelt, wobei die Liste null oder mehr aller unterstützten DynamoDB-Werte (einschließlich anderer Listen) enthalten kann. Die Liste kann auch eine Mischung aus verschiedenen Typen enthalten.
Eine Verwendungsbeispiel ist:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
**Zuordnungstyp `M` **
Stellt eine ungeordnete Sammlung von Schlüssel-Wert-Paaren anderer unterstützter DynamoDB-Werte dar. Ein DynamoDB-Zuordnungswert wird wie folgt bezeichnet:
```
{ "M" : { ... } }
```
Beachten Sie, dass eine Zuordnung null oder mehrere Schlüssel-Wert-Paare enthalten kann. Der Schlüssel muss eine Zeichenfolge sein, und der Wert kann ein beliebiger unterstützter DynamoDB-Wert sein (einschließlich anderer Maps). Die Zuordnung kann auch eine Mischung aus verschiedenen Typen enthalten.
Eine Verwendungsbeispiel ist:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
**Null-Typ `NULL` **
Ein Null-Wert. Ein DynamoDB-Null-Wert wird wie folgt bezeichnet:
```
{ "NULL" : null }
```
Eine Verwendungsbeispiel ist:
```
"attributeValues" : {
"phoneNumbers" : { "NULL" : null }
}
```
Weitere Informationen zu den einzelnen Typen finden Sie in der [DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html).
# Geben Sie System ein (Antwortzuordnung)
Wenn Sie eine Antwort von DynamoDB erhalten, konvertiert sie AWS AppSync automatisch in primitive GraphQL- und JSON-Typen. Jedes Attribut in DynamoDB wird dekodiert und im Antwortzuordnungskontext zurückgegeben.
Wenn DynamoDB beispielsweise Folgendes zurückgibt:
```
{
"id" : { "S" : "1234" },
"name" : { "S" : "Nadia" },
"age" : { "N" : 25 }
}
```
Dann konvertiert der AWS AppSync DynamoDB-Resolver es in GraphQL- und JSON-Typen wie folgt:
```
{
"id" : "1234",
"name" : "Nadia",
"age" : 25
}
```
In diesem Abschnitt wird erklärt, wie die folgenden DynamoDB-Skalar-, Dokument- und Satztypen AWS AppSync konvertiert werden:
**Zeichenfolgetyp `S` **
Ein einzelner Zeichenfolgewert. Ein DynamoDB-Zeichenkettenwert wird als Zeichenfolge zurückgegeben.
Beispiel: DynamoDB hat den folgenden DynamoDB-Zeichenkettenwert zurückgegeben:
```
{ "S" : "some string" }
```
AWS AppSync konvertiert ihn in eine Zeichenfolge:
```
"some string"
```
**Zeichenfolgesatztyp `SS` **
Ein Satz von Zeichenfolgewerten. Ein DynamoDB String Set-Wert wird als eine Liste von Zeichenketten zurückgegeben.
Beispiel: DynamoDB hat den folgenden DynamoDB String Set-Wert zurückgegeben:
```
{ "SS" : [ "first value", "second value", ... ] }
```
AWS AppSync konvertiert ihn in eine Liste von Zeichenketten:
```
[ "+1 555 123 4567", "+1 555 234 5678" ]
```
**Zahlentyp `N` **
Ein einzelner numerischer Wert. Ein DynamoDB-Zahlenwert wird als Zahl zurückgegeben.
Beispiel: DynamoDB hat den folgenden DynamoDB-Zahlenwert zurückgegeben:
```
{ "N" : 1234 }
```
AWS AppSync wandelt ihn in eine Zahl um:
```
1234
```
**Zahlensatztyp `NS` **
Ein Satz von Zahlenwerten. Ein DynamoDB Number Set-Wert wird als eine Liste von Zahlen zurückgegeben.
Beispiel: DynamoDB hat den folgenden DynamoDB Number Set-Wert zurückgegeben:
```
{ "NS" : [ 67.8, 12.2, 70 ] }
```
AWS AppSync wandelt ihn in eine Liste von Zahlen um:
```
[ 67.8, 12.2, 70 ]
```
**Binärtyp `B` **
Ein Binärwert. Ein DynamoDB-Binärwert wird als Zeichenfolge zurückgegeben, die die Base64-Darstellung dieses Werts enthält.
Wenn DynamoDB beispielsweise den folgenden DynamoDB-Binärwert zurückgegeben hat:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
AWS AppSync konvertiert ihn in eine Zeichenfolge, die die Base64-Darstellung des Werts enthält:
```
"SGVsbG8sIFdvcmxkIQo="
```
Beachten Sie, dass die Binärdaten im Base64-Codierungsschema codiert werden, wie in [RFC 4648](https://tools.ietf.org/html/rfc4648) und [RFC 2045](https://tools.ietf.org/html/rfc2045) angegeben.
**Binärsatztyp `BS` **
Ein Satz von Binärwerten. Ein DynamoDB Binary Set-Wert wird als eine Liste von Zeichenketten zurückgegeben, die die Base64-Darstellung der Werte enthalten.
Beispiel: DynamoDB hat den folgenden DynamoDB Binary Set-Wert zurückgegeben:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
AWS AppSync konvertiert ihn in eine Liste von Zeichenketten, die die Base64-Darstellung der Werte enthalten:
```
[ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ]
```
Beachten Sie, dass die Binärdaten im Base64-Codierungsschema codiert werden, wie in [RFC 4648](https://tools.ietf.org/html/rfc4648) und [RFC 2045](https://tools.ietf.org/html/rfc2045) angegeben.
**Boolescher Typ `BOOL` **
Ein Boolescher Wert Ein boolescher DynamoDB-Wert wird als boolescher Wert zurückgegeben.
Wenn DynamoDB beispielsweise den folgenden booleschen DynamoDB-Wert zurückgegeben hat:
```
{ "BOOL" : true }
```
AWS AppSync wandelt ihn in einen booleschen Wert um:
```
true
```
**Listentyp `L` **
Eine Liste aller anderen unterstützten DynamoDB-Werte. Ein DynamoDB-Listenwert wird als Werteliste zurückgegeben, wobei jeder innere Wert ebenfalls konvertiert wird.
Wenn DynamoDB beispielsweise den folgenden DynamoDB-Listenwert zurückgegeben hat:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
AWS AppSync konvertiert ihn in eine Liste von konvertierten Werten:
```
[ "A string value", 1, [ "Another string value", "Even more string values!" ] ]
```
**Zuordnungstyp `M` **
Eine key/value Sammlung aller anderen unterstützten DynamoDB-Werte. Ein DynamoDB-Zuordnungswert wird als JSON-Objekt zurückgegeben, wobei jeder Wert auch konvertiert key/value wird.
Wenn DynamoDB beispielsweise den folgenden DynamoDB-Zuordnungswert zurückgegeben hat:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
AWS AppSync konvertiert ihn in ein JSON-Objekt:
```
{
"someString" : "A string value",
"someNumber" : 1,
"stringSet" : [ "Another string value", "Even more string values!" ]
}
```
**Null-Typ `NULL` **
Ein Null-Wert.
Beispiel: DynamoDB hat den folgenden DynamoDB-Null-Wert zurückgegeben:
```
{ "NULL" : null }
```
AWS AppSync wandelt ihn in einen Nullwert um:
```
null
```
# Filter
Wenn Sie Objekte in DynamoDB mithilfe der `Scan` Operationen `Query` und abfragen, können Sie optional a angeben, `filter` das die Ergebnisse auswertet und nur die gewünschten Werte zurückgibt.
Der Filterzuweisungsbereich eines `Query`- oder `Scan`-Zuweisungsdokuments weist die folgende Struktur auf:
```
"filter" : {
"expression" : "filter expression"
"expressionNames" : {
"#name" : "name",
},
"expressionValues" : {
":value" : ... typed value
},
}
```
Die Felder sind wie folgt definiert:
** `expression` **
Der Abfrageausdruck. Weitere Informationen zum Schreiben von Filterausdrücken finden Sie in der Dokumentation zu DynamoDB QueryFilter und [https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html). Dieses Feld muss angegeben werden.
** `expressionNames` **
Die Ersetzungen für Platzhalter der *Namen* von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Namensplatzhalter, der in der `expression` verwendet wird. Der Wert muss eine Zeichenfolge sein, die dem Attributnamen des Elements in DynamoDB entspricht. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Namen von Ausdrucksattributen gefüllt sein, die im `expression` verwendet werden.
** `expressionValues` **
Die Ersetzungen für Platzhalter der *Werte* von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Wertplatzhalter, der im `expression` verwendet wird, und der Wert muss ein typisierter Wert sein. Weitere Informationen zum Angeben eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuweisung)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Dieser muss angegeben werden. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Werte von Ausdrucksattributen gefüllt sein, die im `expression` verwendet werden.
## Beispiel
Das folgende Beispiel ist ein Filterabschnitt für eine Mapping-Vorlage, in dem aus DynamoDB abgerufene Einträge nur zurückgegeben werden, wenn der Titel mit dem `title` Argument beginnt.
```
"filter" : {
"expression" : "begins_with(#title, :title)",
"expressionNames" : {
"#title" : "title"
},
"expressionValues" : {
":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
}
}
```
# Bedingungsausdrücke
Wenn Sie Objekte in DynamoDB mithilfe der Operationen,, und `DeleteItem` DynamoDB mutieren `PutItem``UpdateItem`, können Sie optional einen Bedingungsausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird.
Der AWS AppSync DynamoDB-Resolver ermöglicht die Angabe eines Bedingungsausdrucks in `PutItem``UpdateItem`, und `DeleteItem` fordert Mapping-Dokumente an sowie eine Strategie, die befolgt werden kann, wenn die Bedingung fehlschlägt und das Objekt nicht aktualisiert wurde.
## Beispiel 1
Das folgende `PutItem`-Zuweisungsdokument enthält keinen Bedingungsausdruck. Dadurch wird ein Element in DynamoDB platziert, auch wenn ein Element mit demselben Schlüssel bereits vorhanden ist, wodurch das vorhandene Element überschrieben wird.
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
}
}
```
## Beispiel 2
Das folgende `PutItem` Zuordnungsdokument enthält einen Bedingungsausdruck, der nur dann den Erfolg des Vorgangs ermöglicht, wenn ein Element mit demselben Schlüssel *nicht* in DynamoDB vorhanden ist.
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
},
"condition" : {
"expression" : "attribute_not_exists(id)"
}
}
```
Wenn die Zustandsprüfung fehlschlägt, gibt der AWS AppSync DynamoDB-Resolver standardmäßig einen Fehler für die Mutation zurück. Der AWS AppSync DynamoDB-Resolver bietet jedoch einige zusätzliche Funktionen, mit denen Entwickler einige häufig auftretende Grenzfälle bewältigen können:
+ Wenn der AWS AppSync DynamoDB-Resolver feststellen kann, dass der aktuelle Wert in DynamoDB dem gewünschten Ergebnis entspricht, behandelt er den Vorgang so, als ob er trotzdem erfolgreich gewesen wäre.
+ Anstatt einen Fehler zurückzugeben, können Sie den Resolver so konfigurieren, dass er eine benutzerdefinierte Lambda-Funktion aufruft, um zu entscheiden, wie der AWS AppSync DynamoDB-Resolver den Fehler behandeln soll.
Diese werden im Abschnitt [Handling a Condition Check Failure](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling) detaillierter beschrieben.
Weitere Informationen zu DynamoDB-Bedingungsausdrücken finden Sie in der [ ConditionExpressions DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html).
## Angabe einer Bedingung
Die Zuweisungsdokumente der `PutItem`- `UpdateItem`- und `DeleteItem`-Anforderung erlauben das Angeben eines optionalen `condition`-Abschnitts. Wenn nicht angegeben, wird keine Bedingungsprüfung ausgeführt. Wenn angegeben, muss die Bedingung wahr sein, damit die Operation erfolgreich ausgeführt werden kann.
Ein `condition`-Abschnitt weist die folgende Struktur auf:
```
"condition" : {
"expression" : "someExpression"
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
},
"equalsIgnore" : [ "version" ],
"consistentRead" : true,
"conditionalCheckFailedHandler" : {
"strategy" : "Custom",
"lambdaArn" : "arn:..."
}
}
```
Die folgenden Felder geben die Bedingung an:
** `expression` **
Der Aktualisierungsausdruck selbst. Weitere Informationen zum Schreiben von Bedingungsausdrücken finden Sie in der [DynamoDB-Dokumentation ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Dieses Feld muss angegeben werden.
** `expressionNames` **
Die Ersetzungen für Platzhalter für Ausdrucksattributnamen in der Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Namensplatzhalter, der im *Ausdruck* verwendet wird, und der Wert muss eine Zeichenfolge sein, die dem Attributnamen des Elements in DynamoDB entspricht. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Namen von Ausdrucksattributen gefüllt sein, die im *Ausdruck* verwendet werden.
** `expressionValues` **
Die Ersetzungen für Platzhalter der Werte von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Wertplatzhalter, der im Ausdruck verwendet wird, und der Wert muss ein typisierter Wert sein. Weitere Informationen zum Angeben eines „typisierten Werts“ finden Sie unter [Typsystem (Anforderungszuweisung)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Dieser muss angegeben werden. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Werte von Ausdrucksattributen gefüllt sein, die im Ausdruck verwendet werden.
Die verbleibenden Felder teilen dem AWS AppSync DynamoDB-Resolver mit, wie er mit einem Fehler bei der Zustandsprüfung umgehen soll:
** `equalsIgnore` **
Wenn eine Zustandsprüfung bei der Verwendung des `PutItem` Vorgangs fehlschlägt, vergleicht der AWS AppSync DynamoDB-Resolver das Element, das sich derzeit in DynamoDB befindet, mit dem Element, das er zu schreiben versucht hat. Wenn sie identisch sind, wird die Operation behandelt, als wäre sie trotzdem erfolgreich ausgeführt worden. Sie können das `equalsIgnore` Feld verwenden, um eine Liste von Attributen anzugeben, die bei diesem Vergleich ignoriert AWS AppSync werden sollen. Wenn der einzige Unterschied beispielsweise ein `version` Attribut war, wird der Vorgang so behandelt, als ob er erfolgreich war. Dies ist ein optionales Feld.
** `consistentRead` **
Wenn eine Zustandsprüfung fehlschlägt, AWS AppSync wird der aktuelle Wert des Elements mithilfe eines stark konsistenten Lesevorgangs von DynamoDB abgerufen. Sie können dieses Feld verwenden, um den AWS AppSync DynamoDB-Resolver anzuweisen, stattdessen einen eventuell konsistenten Lesevorgang zu verwenden. Dieses Feld ist optional und standardmäßig auf `true` gesetzt.
** `conditionalCheckFailedHandler` **
In diesem Abschnitt können Sie angeben, wie der AWS AppSync DynamoDB-Resolver einen Fehler bei der Zustandsprüfung behandelt, nachdem er den aktuellen Wert in DynamoDB mit dem erwarteten Ergebnis verglichen hat. Dieser Abschnitt ist optional. Wenn nicht angegeben, wird standardmäßig eine Strategie von `Reject` verwendet.
** `strategy` **
Die Strategie, die der AWS AppSync DynamoDB-Resolver verfolgt, nachdem er den aktuellen Wert in DynamoDB mit dem erwarteten Ergebnis verglichen hat. Dieses Feld ist erforderlich und besitzt die folgenden möglichen Werte:
** `Reject` **
Die Mutation schlägt fehl und der GraphQL-Antwort wird ein Fehler hinzugefügt.
** `Custom` **
Der AWS AppSync DynamoDB-Resolver ruft eine benutzerdefinierte Lambda-Funktion auf, um zu entscheiden, wie mit dem Fehler bei der Zustandsprüfung umgegangen werden soll. Wenn die `strategy` auf `Custom` gesetzt ist, muss das `lambdaArn`-Feld den ARN der aufzurufenden Lambda-Funktion enthalten.
** `lambdaArn` **
Der ARN der aufzurufenden Lambda-Funktion, die bestimmt, wie der AWS AppSync DynamoDB-Resolver mit dem Fehler bei der Zustandsprüfung umgehen soll. Dieses Feld muss nur angegeben werden, wenn `strategy` auf `Custom` festgelegt ist. Weitere Informationen zur Verwendung dieser Funktion finden Sie unter [Umgang mit einem Bedingungsausdrucksfehler](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).
## Behandlung eines Fehlers bei der Zustandsprüfung
Wenn eine Zustandsprüfung fehlschlägt, gibt der AWS AppSync DynamoDB-Resolver standardmäßig einen Fehler für die Mutation und den aktuellen Wert des Objekts in DynamoDB zurück. Der AWS AppSync DynamoDB-Resolver bietet jedoch einige zusätzliche Funktionen, mit denen Entwickler einige häufig auftretende Grenzfälle bewältigen können:
+ Wenn der AWS AppSync DynamoDB-Resolver feststellen kann, dass der aktuelle Wert in DynamoDB dem gewünschten Ergebnis entspricht, behandelt er den Vorgang so, als ob er trotzdem erfolgreich gewesen wäre.
+ Anstatt einen Fehler zurückzugeben, können Sie den Resolver so konfigurieren, dass er eine benutzerdefinierte Lambda-Funktion aufruft, um zu entscheiden, wie der AWS AppSync DynamoDB-Resolver den Fehler behandeln soll.
Das Flussdiagramm für diesen Prozess ist:
![\[Flowchart showing process for transforming requests with mutation attempts and value checks.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/DynamoDB-condition-check-failure-handling.png)
### Es wird geprüft, ob das gewünschte Ergebnis vorliegt
Wenn die Zustandsprüfung fehlschlägt, führt der AWS AppSync DynamoDB-Resolver eine `GetItem` DynamoDB-Anforderung aus, um den aktuellen Wert des Elements von DynamoDB abzurufen. Standardmäßig wird ein Strongly Consistent-Lesevorgang verwendet, jedoch kann dies mit dem `consistentRead`-Feld im `condition`-Block konfiguriert werden, und mit dem erwarteten Ergebnis verglichen:
+ Für den `PutItem` Vorgang vergleicht der AWS AppSync DynamoDB-Resolver den aktuellen Wert mit dem Wert, den er zu schreiben versucht hat, und schließt alle unter aufgelisteten Attribute aus dem Vergleich `equalsIgnore` aus. Wenn die Elemente identisch sind, wird der Vorgang als erfolgreich behandelt und das Element zurückgegeben, das von DynamoDB abgerufen wurde. Andernfalls wird die konfigurierte Strategie verfolgt.
Beispiel: Wenn das Zuweisungsdokument der `PutItem`-Anforderung wie folgt ausgesehen hat:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
},
"attributeValues" : {
"name" : { "S" : "Steve" },
"version" : { "N" : 2 }
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
},
"equalsIgnore": [ "version" ]
}
}
```
Und das Element, das sich derzeit in DynamoDB befindet, wie folgt ausgesehen hat:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
Der AWS AppSync DynamoDB-Resolver würde das Element, das er schreiben wollte, mit dem aktuellen Wert vergleichen und feststellen, dass der einzige Unterschied das `version` Feld ist. Da er jedoch so konfiguriert ist, dass er das `version` Feld ignoriert, behandelt er den Vorgang als erfolgreich und gibt das Element zurück, das von DynamoDB abgerufen wurde.
+ Für den `DeleteItem` Vorgang überprüft der AWS AppSync DynamoDB-Resolver, ob ein Element von DynamoDB zurückgegeben wurde. Wenn kein Element zurückgegeben wurde, behandelt er die Operation als erfolgreich. Andernfalls wird die konfigurierte Strategie verfolgt.
+ Für den `UpdateItem` Vorgang verfügt der AWS AppSync DynamoDB-Resolver nicht über genügend Informationen, um festzustellen, ob das Element, das sich derzeit in DynamoDB befindet, dem erwarteten Ergebnis entspricht, und folgt daher der konfigurierten Strategie.
Wenn der aktuelle Status des Objekts in DynamoDB vom erwarteten Ergebnis abweicht, folgt der AWS AppSync DynamoDB-Resolver der konfigurierten Strategie, entweder die Mutation zurückzuweisen oder eine Lambda-Funktion aufzurufen, um zu bestimmen, was als Nächstes zu tun ist.
### Wir folgen der Strategie „Ablehnen“
Wenn die `Reject` Strategie befolgt wird, gibt der AWS AppSync DynamoDB-Resolver einen Fehler für die Mutation zurück.
Angenommen, Sie haben folgende Mutationsanforderung:
```
mutation {
updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
Name
theVersion
}
}
```
Wenn das von DynamoDB zurückgegebene Element wie folgt aussieht:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
Und die Antwortzuweisungsvorlage wie folgt aussieht:
```
{
"id" : $util.toJson($context.result.id),
"Name" : $util.toJson($context.result.name),
"theVersion" : $util.toJson($context.result.version)
}
```
Die GraphQL-Antwort sieht wie folgt aus:
```
{
"data": null,
"errors": [
{
"message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
"errorType": "DynamoDB:ConditionalCheckFailedException",
...
}
]
}
```
Beachten Sie auch, dass, wenn bei einer erfolgreichen Mutation alle Felder im zurückgegebenen Objekt von anderen Resolvern ausgefüllt werden, diese nicht auf den Resolver angewendet werden, wenn das Objekt im `error`-Abschnitt zurückgegeben wird.
### Folgen Sie der „benutzerdefinierten“ Strategie
Wenn die `Custom` Strategie befolgt wird, ruft der AWS AppSync DynamoDB-Resolver eine Lambda-Funktion auf, um zu entscheiden, was als Nächstes zu tun ist. Die Lambda-Funktion wählt eine der folgenden Optionen aus:
+ Die Mutation `reject`. Dadurch wird der AWS AppSync DynamoDB-Resolver angewiesen`Reject`, sich wie bei der konfigurierten Strategie zu verhalten und einen Fehler für die Mutation und den aktuellen Wert des Objekts in DynamoDB zurückzugeben, wie im vorherigen Abschnitt beschrieben.
+ Die Mutation `discard`. Dadurch wird der AWS AppSync DynamoDB-Resolver angewiesen, den Fehler bei der Zustandsprüfung stillschweigend zu ignorieren und den Wert in DynamoDB zurückzugeben.
+ Die Mutation `retry`. Dadurch wird der AWS AppSync DynamoDB-Resolver angewiesen, die Mutation mit einem neuen Anforderungszuordnungsdokument erneut zu versuchen.
**Die Lambda-Aufrufanforderung**
Der AWS AppSync DynamoDB-Resolver ruft die Lambda-Funktion auf, die in der angegeben ist. `lambdaArn` Er verwendet die gleiche `service-role-arn`-Konfiguration für die Datenquelle. Die Nutzlast des Aufrufs hat die folgende Struktur:
```
{
"arguments": { ... },
"requestMapping": {... },
"currentValue": { ... },
"resolver": { ... },
"identity": { ... }
}
```
Die Felder sind wie folgt definiert:
** `arguments` **
Die Argumente aus der GraphQL-Mutation. Diese entsprechen den Argumente, die dem Zuweisungsdokument der Anforderung in `$context.arguments` zur Verfügung stehen.
** `requestMapping` **
Das Zuweisungsdokument der Anforderung für diese Operation.
** `currentValue` **
Der aktuelle Wert des Objekts in DynamoDB.
** `resolver` **
Informationen über den Resolver AWS AppSync .
** `identity` **
Informationen über den Aufrufer. Diese entsprechen den Identitätsinformationen, die dem Zuweisungsdokument der Anforderung in `$context.identity` zur Verfügung stehen.
Ein vollständiges Beispiel für die Nutzlast:
```
{
"arguments": {
"id": "1",
"name": "Steve",
"expectedVersion": 1
},
"requestMapping": {
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
},
"attributeValues" : {
"name" : { "S" : "Steve" },
"version" : { "N" : 2 }
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
},
"equalsIgnore": [ "version" ]
}
},
"currentValue": {
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
},
"resolver": {
"tableName": "People",
"awsRegion": "us-west-2",
"parentType": "Mutation",
"field": "updatePerson",
"outputType": "Person"
},
"identity": {
"accountId": "123456789012",
"sourceIp": "x.x.x.x",
"user": "AIDAAAAAAAAAAAAAAAAAA",
"userArn": "arn:aws:iam::123456789012:user/appsync"
}
}
```
**Die Lambda-Aufrufantwort**
Die Lambda-Funktion kann die Nutzlast des Aufrufs untersuchen und jede Geschäftslogik anwenden, um zu entscheiden, wie der AWS AppSync DynamoDB-Resolver mit dem Fehler umgehen soll. Es gibt drei Optionen für den Umgang mit dem Bedingungsprüfungsfehler:
+ Die Mutation `reject`. Die Antwortnutzlast für diese Option muss diese Struktur aufweisen:
```
{
"action": "reject"
}
```
Dadurch wird der AWS AppSync DynamoDB-Resolver angewiesen`Reject`, sich wie bei der konfigurierten Strategie zu verhalten und einen Fehler für die Mutation und den aktuellen Wert des Objekts in DynamoDB zurückzugeben, wie im obigen Abschnitt beschrieben.
+ Die Mutation `discard`. Die Antwortnutzlast für diese Option muss diese Struktur aufweisen:
```
{
"action": "discard"
}
```
Dadurch wird der AWS AppSync DynamoDB-Resolver angewiesen, den Fehler bei der Zustandsprüfung stillschweigend zu ignorieren und den Wert in DynamoDB zurückzugeben.
+ Die Mutation `retry`. Die Antwortnutzlast für diese Option muss diese Struktur aufweisen:
```
{
"action": "retry",
"retryMapping": { ... }
}
```
Dadurch wird der AWS AppSync DynamoDB-Resolver angewiesen, die Mutation mit einem neuen Anforderungszuordnungsdokument erneut zu versuchen. Die Struktur des `retryMapping` Abschnitts hängt vom DynamoDB-Vorgang ab und ist eine Teilmenge des vollständigen Anforderungszuordnungsdokuments für diesen Vorgang.
Für `PutItem` weist der `retryMapping`-Abschnitt die folgende Struktur auf. Eine Beschreibung des `attributeValues` Felds finden Sie unter. [PutItem](aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.md)
```
{
"attributeValues": { ... },
"condition": {
"equalsIgnore" = [ ... ],
"consistentRead" = true
}
}
```
Für `UpdateItem` weist der `retryMapping`-Abschnitt die folgende Struktur auf. Eine Beschreibung des `update` Abschnitts finden Sie unter [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md).
```
{
"update" : {
"expression" : "someExpression"
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
}
},
"condition": {
"consistentRead" = true
}
}
```
Für `DeleteItem` weist der `retryMapping`-Abschnitt die folgende Struktur auf.
```
{
"condition": {
"consistentRead" = true
}
}
```
Es ist nicht möglich, eine andere Operation oder einen anderen Schlüssel anzugeben. Der AWS AppSync DynamoDB-Resolver erlaubt nur Wiederholungen derselben Operation für dasselbe Objekt. Beachten Sie auch, dass der Abschnitt `condition` nicht zulässt, dass ein `conditionalCheckFailedHandler` angegeben wird. Schlägt der Wiederholungsversuch fehl, folgt der AWS AppSync DynamoDB-Resolver der Strategie. `Reject`
Hier sehen Sie ein Beispiel für eine Lambda-Funktion zum Umgang mit einer fehlgeschlagenen `PutItem`-Anforderung. Die Geschäftslogik prüft, wer den Aufruf ausgeführt hat. Wenn es von erstellt wurde`jeffTheAdmin`, wiederholt es die Anfrage und aktualisiert das `version` und `expectedVersion` aus dem Element, das sich derzeit in DynamoDB befindet. Andernfalls wird die Mutation ablehnt.
```
exports.handler = (event, context, callback) => {
console.log("Event: "+ JSON.stringify(event));
// Business logic goes here.
var response;
if ( event.identity.user == "jeffTheAdmin" ) {
response = {
"action" : "retry",
"retryMapping" : {
"attributeValues" : event.requestMapping.attributeValues,
"condition" : {
"expression" : event.requestMapping.condition.expression,
"expressionValues" : event.requestMapping.condition.expressionValues
}
}
}
response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version
} else {
response = { "action" : "reject" }
}
console.log("Response: "+ JSON.stringify(response))
callback(null, response)
};
```
# Ausdrücke für Transaktionsbedingungen
Transaktionsbedingungsausdrücke sind in Anforderungszuweisungsvorlagen aller vier Arten von Operationen in `TransactWriteItems`, nämlich `PutItem`, `DeleteItem`, `UpdateItem` und `ConditionCheck` verfügbar.
Für `PutItem` `DeleteItem``UpdateItem`, und ist der Ausdruck für die Transaktionsbedingung optional. Für `ConditionCheck` ist der Ausdruck der Transaktionsbedingung erforderlich.
## Beispiel 1
Das folgende `DeleteItem`-Transaktionszuweisungsdokument weist keinen Bedingungsausdruck auf. Infolgedessen wird das Element in DynamoDB gelöscht.
```
{
"version": "2018-05-29",
"operation": "TransactWriteItems",
"transactItems": [
{
"table": "posts",
"operation": "DeleteItem",
"key": {
"id": { "S" : "1" }
}
}
]
}
```
## Beispiel 2
Das folgende `DeleteItem` Transaktions-Mapping-Dokument enthält einen Ausdruck für eine Transaktionsbedingung, mit dem der Vorgang nur dann erfolgreich ausgeführt werden kann, wenn der Autor dieses Beitrags einem bestimmten Namen entspricht.
```
{
"version": "2018-05-29",
"operation": "TransactWriteItems",
"transactItems": [
{
"table": "posts",
"operation": "DeleteItem",
"key": {
"id": { "S" : "1" }
}
"condition": {
"expression": "author = :author",
"expressionValues": {
":author": { "S" : "Chunyan" }
}
}
}
]
}
```
Wenn die Bedingungsprüfung fehlschlägt, führt dies zu `TransactionCanceledException`, und die Fehlerdetails werden in `$ctx.result.cancellationReasons` zurückgegeben. Beachten Sie, dass standardmäßig das alte Element in DynamoDB zurückgegeben wird, bei dem die Zustandsprüfung fehlgeschlagen ist. `$ctx.result.cancellationReasons`
## Angabe einer Bedingung
Die Zuweisungsdokumente der `PutItem`- `UpdateItem`- und `DeleteItem`-Anforderung erlauben das Angeben eines optionalen `condition`-Abschnitts. Wenn nicht angegeben, wird keine Bedingungsprüfung ausgeführt. Wenn angegeben, muss die Bedingung wahr sein, damit die Operation erfolgreich ausgeführt werden kann. Der `ConditionCheck` muss einen `condition`-Abschnitt haben, der angegeben werden soll. Die Bedingung muss erfüllt sein, damit die gesamte Transaktion erfolgreich ist.
Ein `condition`-Abschnitt weist die folgende Struktur auf:
```
"condition": {
"expression": "someExpression",
"expressionNames": {
"#foo": "foo"
},
"expressionValues": {
":bar": ... typed value
},
"returnValuesOnConditionCheckFailure": false
}
```
Die folgenden Felder geben die Bedingung an:
** `expression` **
Der Aktualisierungsausdruck selbst. Weitere Informationen zum Schreiben von Bedingungsausdrücken finden Sie in der [DynamoDB-Dokumentation ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Dieses Feld muss angegeben werden.
** `expressionNames` **
Die Ersetzungen für Platzhalter für Ausdrucksattributnamen in der Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Namensplatzhalter, der im *Ausdruck* verwendet wird, und der Wert muss eine Zeichenfolge sein, die dem Attributnamen des Elements in DynamoDB entspricht. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Namen von Ausdrucksattributen gefüllt sein, die im *Ausdruck* verwendet werden.
** `expressionValues` **
Die Ersetzungen für Platzhalter der Werte von Ausdrucksattributen in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Wertplatzhalter, der im Ausdruck verwendet wird, und der Wert muss ein typisierter Wert sein. Weitere Informationen zum Angeben eines „typisierten Werts“ finden Sie unter „Typsystem (Anforderungszuweisung)“. Dieser muss angegeben werden. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter der Werte von Ausdrucksattributen gefüllt sein, die im Ausdruck verwendet werden.
** `returnValuesOnConditionCheckFailure` **
Geben Sie an, ob das Element in DynamoDB zurückgeholt werden soll, wenn eine Zustandsprüfung fehlschlägt. Das abgerufene Element befindet sich in `$ctx.result.cancellationReasons[$index].item`, wobei der `$index` Index des Anforderungselements ist, durch das die Bedingungsprüfung fehlgeschlagen ist. Dieser Wert ist standardmäßig auf true gesetzt.
# Projektionen
Wenn Sie Objekte in DynamoDB mithilfe der `TransactGetItems` Operationen`GetItem`,`Scan`, `Query``BatchGetItem`, und lesen, können Sie optional eine Projektion angeben, die die gewünschten Attribute identifiziert. Die Projektion hat die folgende Struktur, die Filtern ähnelt:
```
"projection" : {
"expression" : "projection expression"
"expressionNames" : {
"#name" : "name",
}
}
```
Die Felder sind wie folgt definiert:
**`expression`**
Der Projektionsausdruck, der eine Zeichenfolge ist. Zum Abrufen eines einzelnen Attributs geben Sie seinen Namen an. Bei mehreren Attributen müssen die Namen durch Kommas getrennte Werte sein. Weitere Informationen zum Schreiben von Projektionsausdrücken finden Sie in der Dokumentation zu [DynamoDB-Projektionsausdrücken](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html). Dies ist ein Pflichtfeld.
**`expressionNames`**
Die Ersetzungen für Platzhalter für *Ausdrucksattributnamen* in Form von Schlüssel-Wert-Paaren. Der Schlüssel entspricht einem Namensplatzhalter, der in der `expression` verwendet wird. Der Wert muss eine Zeichenfolge sein, die dem Attributnamen des Elements in DynamoDB entspricht. Dieses Feld ist optional und sollte nur mit Ersetzungen für Platzhalter für Ausdrucksattributnamen gefüllt werden, die in der verwendet werden. `expression` Weitere Informationen zu `expressionNames` finden Sie in der [DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html).
## Beispiel 1
Das folgende Beispiel ist ein Projektionsabschnitt für eine VTL-Mapping-Vorlage, in der nur die Attribute `author` und von DynamoDB zurückgegeben `id` werden:
```
"projection" : {
"expression" : "#author, id",
"expressionNames" : {
"#author" : "author"
}
}
```
**Tipp**
Sie können mit [\$1context.info auf Ihren GraphQL-Anforderungsauswahlsatz zugreifen. selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html#aws-appsync-resolver-context-reference-info). In diesem Feld können Sie Ihren Projektionsausdruck Ihren Anforderungen entsprechend dynamisch gestalten.
**Anmerkung**
Bei der Verwendung von Projektionsausdrücken mit den `Scan` Operationen `Query` und `select` muss der Wert für sein`SPECIFIC_ATTRIBUTES`. Weitere Informationen finden Sie in der [DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html#DDB-Query-request-Select).