Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS AppSync riferimento al modello di mappatura dei resolver per DynamoDB
**Nota**
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)
La funzione AWS AppSync DynamoDB ti consente di utilizzare [GraphQL](https://graphql.org) per archiviare e recuperare dati nelle tabelle Amazon DynamoDB esistenti nel tuo account mappando una richiesta GraphQL in entrata in una chiamata DynamoDB e quindi mappando la risposta DynamoDB a GraphQL. Questa sezione descrive i gestori di richieste e risposte per le operazioni DynamoDB supportate:
+ [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.html)- La GetItem richiesta consente di indicare alla funzione DynamoDB di effettuare una GetItem richiesta a DynamoDB e di specificare la chiave dell'elemento in DynamoDB e se utilizzare o meno una lettura coerente.
+ [ PutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.html)- Il documento di mappatura della PutItem richiesta consente di indicare alla funzione DynamoDB di PutItem effettuare una richiesta a DynamoDB e di specificare la chiave dell'elemento in DynamoDB, il contenuto completo dell'elemento (composto da key e attributeValues) e le condizioni per il successo dell'operazione.
+ [ UpdateItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.html)- La UpdateItem richiesta consente di indicare alla funzione DynamoDB di effettuare una UpdateItem richiesta a DynamoDB e consente di specificare la chiave dell'elemento in DynamoDB, un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB e le condizioni per il successo dell'operazione.
+ [ DeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.html)- La DeleteItem richiesta consente di indicare alla funzione DynamoDB di effettuare una DeleteItem richiesta a DynamoDB e di specificare la chiave dell'elemento in DynamoDB e le condizioni per il successo dell'operazione.
+ [Query](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-query.html): l'oggetto Query request consente di indicare al resolver DynamoDB di effettuare una richiesta Query a DynamoDB e di specificare l'espressione chiave, l'indice da utilizzare, i filtri aggiuntivi, il numero di elementi da restituire, se utilizzare letture coerenti, la direzione della query (avanti o indietro) e i token di impaginazione.
+ [Scansione](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-scan.html): la richiesta Scan consente di indicare alla funzione DynamoDB di effettuare una richiesta di scansione a DynamoDB e di specificare un filtro per escludere i risultati, quale indice utilizzare, quanti elementi restituire, se utilizzare letture coerenti, token di impaginazione e scansioni parallele.
+ [Sincronizzazione](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-sync.html): l'oggetto di richiesta di sincronizzazione consente di recuperare tutti i risultati da una tabella DynamoDB e quindi ricevere solo i dati modificati dall'ultima query (gli aggiornamenti delta). Le richieste di sincronizzazione possono essere effettuate solo su sorgenti dati DynamoDB con versione. È possibile specificare un filtro per escludere i risultati, il numero di elementi da restituire, i token di paginazione e quando è stata avviata l'ultima operazione di sincronizzazione.
+ [ BatchGetItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-get-item.html)- L'oggetto BatchGetItem request consente di indicare alla funzione DynamoDB di effettuare una BatchGetItem richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare i nomi delle tabelle da cui recuperare gli elementi e le chiavi degli elementi da recuperare da ciascuna tabella.
+ [ BatchDeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-delete-item.html)- L'oggetto BatchDeleteItem request consente di indicare alla funzione DynamoDB di fare una BatchWriteItem richiesta a DynamoDB per eliminare più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare i nomi delle tabelle da cui eliminare gli elementi e le chiavi degli elementi da eliminare da ciascuna tabella.
+ [ BatchPutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-put-item.html)- L'oggetto BatchPutItem request consente di indicare alla funzione DynamoDB di fare una BatchWriteItem richiesta a DynamoDB per inserire più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare i nomi delle tabelle in cui inserire gli elementi e gli elementi completi da inserire in ogni tabella.
+ [ TransactGetItems ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transact-get-items.html)- L'oggetto TransactGetItems request consente di indicare alla funzione DynamoDB di effettuare una TransactGetItems richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare il nome della tabella di ogni elemento della richiesta da cui recuperare l'elemento e la chiave di ogni elemento della richiesta da recuperare da ogni tabella.
+ [ TransactWriteItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-write-items.html)- L'oggetto TransactWriteItems request consente di indicare alla funzione DynamoDB di TransactWriteItems richiedere a DynamoDB di scrivere più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare il nome della tabella di destinazione di ogni elemento della richiesta, l'operazione di ogni elemento della richiesta da eseguire e la chiave di ogni elemento della richiesta da scrivere.
+ [Sistema dei tipi (mappatura delle richieste)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.html): scopri di più su come la digitazione DynamoDB è integrata nelle richieste. AWS AppSync
+ [Sistema di tipi (mappatura delle risposte)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.html): scopri di più su come i tipi DynamoDB vengono convertiti automaticamente in GraphQL o JSON in un payload di risposta.
+ [Filtri](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-filter.html): scopri di più sui filtri per le operazioni di interrogazione e scansione.
+ [Espressioni](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.html) condizionali: scopri di più sulle espressioni di PutItem condizione e DeleteItem sulle operazioni. UpdateItem
+ [Espressioni delle condizioni delle transazioni](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.html): ulteriori informazioni sulle espressioni di condizione per TransactWriteItems le operazioni.
+ [Proiezioni](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-projections.html): ulteriori informazioni su come specificare gli attributi nelle operazioni di lettura.
# GetItem
Il documento di mappatura delle `GetItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `GetItem` richiesta a DynamoDB e consente di specificare:
+ La chiave dell'elemento in DynamoDB
+ Se utilizzare una lettura consistente o no
Il documento di mappatura `GetItem` ha la seguente struttura:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"foo" : ... typed value,
"bar" : ... typed value
},
"consistentRead" : true,
"projection" : {
...
}
}
```
I campi sono definiti come segue:
## GetItem campi
### GetItem elenco dei campi
**`version`**
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.
**`operation`**
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `GetItem` DynamoDB, il valore deve essere impostato su `GetItem`. Questo valore è obbligatorio.
**`key`**
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.
**`consistentRead`**
Se eseguire o meno una lettura fortemente coerente con DynamoDB. Si tratta di un'opzione facoltativa, impostata di default su `false`.
**`projection`**
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.
L'elemento restituito da DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Esempio
L'esempio seguente è un modello di mappatura per una query `getThing(foo: String!, bar: String!)` GraphQL:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
"bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
},
"consistentRead" : true
}
```
Per ulteriori informazioni sull'API `GetItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).
# PutItem
Il documento di mappatura delle `PutItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `PutItem` richiesta a DynamoDB e consente di specificare quanto segue:
+ La chiave dell'elemento in DynamoDB
+ L'intero contenuto della voce (costituita da `key` e `attributeValues`)
+ Condizioni per la riuscita dell'operazione
Il documento di mappatura `PutItem` ha la seguente struttura:
```
{
"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
}
```
I campi sono definiti come segue:
## PutItem campi
### PutItem elenco dei campi
**`version`**
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.
**`operation`**
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `PutItem` DynamoDB, il valore deve essere impostato su `PutItem`. Questo valore è obbligatorio.
**`key`**
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.
**`attributeValues`**
Gli altri attributi della voce da inserir in DynamoDB. Per ulteriori informazioni su come specificare un «valore digitato», vedete [Type system (request](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) mapping). Questo campo è facoltativo.
**`condition`**
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `PutItem` sovrascrive qualsiasi valore esistente per quella voce. Per ulteriori informazioni sulle condizioni, vedere Espressioni di [condizione](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Questo valore è facoltativo.
**`_version`**
Valore numerico che rappresenta l'ultima versione nota di un elemento. Questo valore è facoltativo. Questo campo viene utilizzato per il *rilevamento dei conflitti* ed è supportato solo nelle origini dati con versione.
**`customPartitionKey`**
Se abilitato, questo valore di stringa modifica il formato dei `ds_pk` record `ds_sk` and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato (per ulteriori informazioni, consulta [Conflict detection and sync](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella *AWS AppSync Developer Guide*). Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. Questo campo è facoltativo.
**`populateIndexFields`**
Un valore booleano che, se abilitato **insieme** a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne `gsi_ds_pk` and`gsi_ds_sk`. Per ulteriori informazioni, consulta [Rilevamento e sincronizzazione dei conflitti](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella Guida per gli *AWS AppSync sviluppatori*. Questo campo è facoltativo.
L'elemento scritto in DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Esempio 1
L'esempio seguente è un modello di mappatura per una mutazione `updateThing(foo: String!, bar: String!, name: String!, version: Int!)` GraphQL.
Se non esiste alcuna voce con la chiave specificata, viene creata. Se esiste, viene sovrascritta.
```
{
"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)
}
}
```
## Esempio 2
L'esempio seguente è un modello di mappatura per una mutazione `updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)` GraphQL.
Questo esempio verifica che l'elemento attualmente in DynamoDB abbia `version` il campo impostato su. `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)
}
}
}
```
Per ulteriori informazioni sull'API `PutItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).
# UpdateItem
Il documento di mappatura delle `UpdateItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `UpdateItem` richiesta a DynamoDB e consente di specificare quanto segue:
+ La chiave dell'elemento in DynamoDB
+ Un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB
+ Condizioni per la riuscita dell'operazione
Il documento di mappatura `UpdateItem` ha la seguente struttura:
```
{
"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
}
```
I campi sono definiti come segue:
## UpdateItem campi
### UpdateItem elenco dei campi
**`version`**
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.
**`operation`**
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `UpdateItem` DynamoDB, il valore deve essere impostato su `UpdateItem`. Questo valore è obbligatorio.
**`key`**
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. [Per ulteriori informazioni sulla specificazione di un «valore digitato», consulta Sistema di tipi (mappatura delle richieste).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Questo valore è obbligatorio.
**`update`**
La `update` sezione consente di specificare un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB. Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Questa sezione è obbligatoria.
La sezione `update` ha tre componenti:
** `expression` **
L'espressione di aggiornamento. Questo valore è obbligatorio.
** `expressionNames` **
Le sostituzioni per i segnaposto dell'attributo di espressione *name* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato in`expression`, e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in `expression`.
** `expressionValues` **
Le sostituzioni per i segnaposto dell'attributo di espressione *value* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato in `expression`, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Type system](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) (request mapping). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate in `expression`.
**`condition`**
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `UpdateItem` aggiorna qualsiasi valore esistente, indipendentemente dal suo stato attuale. Per ulteriori informazioni sulle condizioni, vedere Espressioni di [condizione](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Questo valore è facoltativo.
**`_version`**
Valore numerico che rappresenta l'ultima versione nota di un elemento. Questo valore è facoltativo. Questo campo viene utilizzato per il *rilevamento dei conflitti* ed è supportato solo nelle origini dati con versione.
**`customPartitionKey`**
Se abilitato, questo valore di stringa modifica il formato dei `ds_pk` record `ds_sk` and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato (per ulteriori informazioni, consulta [Conflict detection and sync](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella *AWS AppSync Developer Guide*). Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. Questo campo è facoltativo.
**`populateIndexFields`**
Un valore booleano che, se abilitato **insieme** a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne `gsi_ds_pk` and`gsi_ds_sk`. Per ulteriori informazioni, consulta [Rilevamento e sincronizzazione dei conflitti](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella Guida per gli *AWS AppSync sviluppatori*. Questo campo è facoltativo.
L'elemento aggiornato in DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Esempio 1
L'esempio seguente è un modello di mappatura per la mutazione `upvote(id: ID!)` GraphQL.
In questo esempio, un elemento in DynamoDB ha i `upvotes` suoi campi `version` e incrementati di 1.
```
{
"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 }
}
}
}
```
## Esempio 2
L'esempio seguente è un modello di mappatura per una mutazione `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)` GraphQL.
Si tratta di un esempio complesso che verifica gli argomenti e genera dinamicamente l'espressione di aggiornamento in cui sono inclusi solo gli argomenti forniti dal client. Ad esempio, se `title` e `author` vengono omessi, non vengono aggiornati. Se viene specificato un argomento ma il suo valore è`null`, quel campo viene eliminato dall'oggetto in DynamoDB. Infine, l'operazione ha una condizione, che verifica se l'elemento attualmente in DynamoDB ha `version` il campo impostato su: `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)
}
}
}
```
Per ulteriori informazioni sull'API `UpdateItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).
# DeleteItem
Il documento di mappatura delle `DeleteItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `DeleteItem` richiesta a DynamoDB e consente di specificare quanto segue:
+ La chiave dell'elemento in DynamoDB
+ Condizioni per la riuscita dell'operazione
Il documento di mappatura `DeleteItem` ha la seguente struttura:
```
{
"version" : "2018-05-29",
"operation" : "DeleteItem",
"customPartitionKey" : "foo",
"populateIndexFields" : boolean value,
"key": {
"foo" : ... typed value,
"bar" : ... typed value
},
"condition" : {
...
},
"_version" : 1
}
```
I campi sono definiti come segue:
## DeleteItem campi
### DeleteItem elenco dei campi
** `version` **
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `DeleteItem` DynamoDB, il valore deve essere impostato su `DeleteItem`. Questo valore è obbligatorio.
** `key` **
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. [Per ulteriori informazioni sulla specificazione di un «valore digitato», consulta Sistema di tipi (mappatura delle richieste).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Questo valore è obbligatorio.
** `condition` **
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `DeleteItem` elimina la voce indipendentemente dal suo stato attuale. [Per ulteriori informazioni sulle condizioni, vedere Espressioni di condizione.](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md) Questo valore è facoltativo.
** `_version` **
Valore numerico che rappresenta l'ultima versione nota di un elemento. Questo valore è facoltativo. Questo campo viene utilizzato per il *rilevamento dei conflitti* ed è supportato solo nelle origini dati con versione.
**`customPartitionKey`**
Se abilitato, questo valore di stringa modifica il formato dei `ds_pk` record `ds_sk` and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato (per ulteriori informazioni, consulta [Conflict detection and sync](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella *AWS AppSync Developer Guide*). Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. Questo campo è facoltativo.
**`populateIndexFields`**
Un valore booleano che, se abilitato **insieme** a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne `gsi_ds_pk` and`gsi_ds_sk`. Per ulteriori informazioni, consulta [Rilevamento e sincronizzazione dei conflitti](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella Guida per gli *AWS AppSync sviluppatori*. Questo campo è facoltativo.
L'elemento eliminato da DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Esempio 1
L'esempio seguente è un modello di mappatura per una mutazione `deleteItem(id: ID!)` GraphQL. Se esiste già una voce con questo ID, viene eliminata.
```
{
"version" : "2017-02-28",
"operation" : "DeleteItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
}
}
```
## Esempio 2
L'esempio seguente è un modello di mappatura per una mutazione `deleteItem(id: ID!, expectedVersion: Int!)` GraphQL. Se esiste già una voce con questo ID, viene eliminata, ma solo se il relativo campo `version` è impostato su `expectedVersion`:
```
{
"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)
}
}
}
```
Per ulteriori informazioni sull'API `DeleteItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).
# Query
Il documento di mappatura delle `Query` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `Query` richiesta a DynamoDB e consente di specificare quanto segue:
+ Espressione chiave
+ Indice da utilizzare
+ Eventuali filtri aggiuntivi
+ Numero di voci da restituire
+ Se utilizzare letture consistenti
+ Direzione della query (avanti o indietro)
+ Token di paginazione
Il documento di mappatura `Query` ha la seguente struttura:
```
{
"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" : {
...
}
}
```
I campi sono definiti come segue:
## Campi di interrogazione
### Elenco dei campi di interrogazione
** `version` **
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `Query` DynamoDB, il valore deve essere impostato su `Query`. Questo valore è obbligatorio.
** `query` **
La `query` sezione consente di specificare un'espressione di condizione chiave che descrive quali elementi recuperare da DynamoDB. Per ulteriori informazioni su come scrivere espressioni di condizioni chiave, consulta la documentazione di [ KeyConditions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html). Questa sezione deve essere specificata.
** `expression` **
L'espressione della query. Questo campo deve essere specificato.
** `expressionNames` **
Le sostituzioni per i segnaposto dell'attributo di espressione *name* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato in`expression`, e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in `expression`.
** `expressionValues` **
Le sostituzioni per i segnaposto dell'attributo di espressione *value* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato in `expression`, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Type system](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) (request mapping). Questo valore è obbligatorio. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate in `expression`.
** `filter` **
Un ulteriore filtro che può essere utilizzato per filtrare i risultati da DynamoDB prima che siano restituiti. Per ulteriori informazioni sui filtri, consulta [Filtri](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Questo campo è facoltativo.
** `index` **
Nome dell'indice su cui eseguire una query. L'operazione di interrogazione DynamoDB consente di eseguire la scansione degli indici secondari locali e degli indici secondari globali oltre all'indice della chiave primaria alla ricerca di una chiave hash. Se specificato, indica a DynamoDB di interrogare l'indice specificato. Se omesso, la query viene eseguita sull'indice primario della chiave.
** `nextToken` **
Il token di paginazione utilizzato per continuare una query precedente, dalla quale deve essere ottenuto. Questo campo è facoltativo.
** `limit` **
Il numero massimo di item da valutare (non necessariamente il numero di item corrispondenti). Questo campo è facoltativo.
** `scanIndexForward` **
Un valore booleano che indica se la query deve essere eseguita in avanti o indietro. Si tratta di un campo facoltativo, impostato di default su `true`.
** `consistentRead` **
Un booleano che indica se utilizzare letture coerenti quando si esegue una query su DynamoDB. Si tratta di un campo facoltativo, impostato di default su `false`.
** `select` **
Per impostazione predefinita, il AWS AppSync resolver DynamoDB restituisce solo gli attributi proiettati nell'indice. Se sono necessari più attributi, puoi impostare questo campo. Questo campo è facoltativo. I valori supportati sono:
** `ALL_ATTRIBUTES` **
Restituisce tutti gli attributi della voce nella tabella o nell'indice specificati. Se si esegue una query su un indice secondario locale, DynamoDB recupera l'intero elemento dalla tabella principale per ogni elemento corrispondente nell'indice. Se l'indice è configurato per proiettare tutti gli attributi della voce, è possibile ottenere tutti i dati dall'indice secondario locale, senza necessità di recupero.
** `ALL_PROJECTED_ATTRIBUTES` **
Consentito solo durante l'esecuzione di una query su un indice. Recupera tutti gli attributi proiettati nell'indice. Se la configurazione dell'indice prevede che vi siano proiettati tutti gli attributi, il valore che restituisce è uguale a quello dato da `ALL_ATTRIBUTES`.
**`SPECIFIC_ATTRIBUTES`**
Restituisce solo gli attributi elencati negli. `projection` `expression` Questo valore restituito equivale a specificare i `projection` `expression` senza specificare alcun valore per. `Select`
**`projection`**
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.
I risultati di DynamoDB vengono convertiti automaticamente in tipi primitivi GraphQL e JSON e sono disponibili nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
I risultati hanno la struttura seguente:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
I campi sono definiti come segue:
** `items` **
Un elenco contenente gli elementi restituiti dalla query DynamoDB.
** `nextToken` **
Se è possibile che ci siano altri risultati, `nextToken` contiene un token di paginazione utilizzabile in un'altra richiesta. Nota che AWS AppSync crittografa e offusca il token di impaginazione restituito da DynamoDB. In questo modo si evita che i dati della tabella siano inavvertitamente divulgati all'intermediario. Inoltre, i token di paginazione non possono essere utilizzati con più resolver diversi.
** `scannedCount` **
Il numero di voci corrispondenti all'espressione di condizione della query prima dell'applicazione di un'espressione di filtro (se presente).
## Esempio
L'esempio seguente è un modello di mappatura per una query `getPosts(owner: ID!)` GraphQL.
In questo esempio, un indice secondario globale in una tabella viene interrogato per restituire tutti i post di proprietà dell'ID specificato.
```
{
"version" : "2017-02-28",
"operation" : "Query",
"query" : {
"expression" : "ownerId = :ownerId",
"expressionValues" : {
":ownerId" : $util.dynamodb.toDynamoDBJson($context.arguments.owner)
}
},
"index" : "owner-index"
}
```
Per ulteriori informazioni sull'API `Query` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html).
# Scan
Il documento di mappatura delle `Scan` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `Scan` richiesta a DynamoDB e consente di specificare quanto segue:
+ Un filtro per escludere i risultati
+ Indice da utilizzare
+ Numero di voci da restituire
+ Se utilizzare letture consistenti
+ Token di paginazione
+ Scansioni parallele
Il documento di mappatura `Scan` ha la seguente struttura:
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"index" : "fooIndex",
"limit" : 10,
"consistentRead" : false,
"nextToken" : "aPaginationToken",
"totalSegments" : 10,
"segment" : 1,
"filter" : {
...
},
"projection" : {
...
}
}
```
I campi sono definiti come segue:
## Scansiona i campi
### Elenco dei campi di scansione
** `version` **
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `Scan` DynamoDB, il valore deve essere impostato su `Scan`. Questo valore è obbligatorio.
** `filter` **
Un filtro che può essere utilizzato per filtrare i risultati di DynamoDB prima che vengano restituiti. Per ulteriori informazioni sui filtri, consulta [Filtri](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Questo campo è facoltativo.
** `index` **
Nome dell'indice su cui eseguire una query. L'operazione di interrogazione DynamoDB consente di eseguire la scansione degli indici secondari locali e degli indici secondari globali oltre all'indice della chiave primaria alla ricerca di una chiave hash. Se specificato, indica a DynamoDB di interrogare l'indice specificato. Se omesso, la query viene eseguita sull'indice primario della chiave.
** `limit` **
Numero massimo di elementi da valutare in una sola volta. Questo campo è facoltativo.
** `consistentRead` **
Un valore booleano che indica se utilizzare letture coerenti quando si esegue una query su DynamoDB. Si tratta di un campo facoltativo, impostato di default su `false`.
** `nextToken` **
Il token di paginazione utilizzato per continuare una query precedente, dalla quale deve essere ottenuto. Questo campo è facoltativo.
** `select` **
Per impostazione predefinita, il AWS AppSync resolver DynamoDB restituisce solo gli attributi proiettati nell'indice. Se sono necessari più attributi, è possibile impostare questo campo. Questo campo è facoltativo. I valori supportati sono:
** `ALL_ATTRIBUTES` **
Restituisce tutti gli attributi della voce nella tabella o nell'indice specificati. Se si esegue una query su un indice secondario locale, DynamoDB recupera l'intero elemento dalla tabella principale per ogni elemento corrispondente nell'indice. Se l'indice è configurato per proiettare tutti gli attributi della voce, è possibile ottenere tutti i dati dall'indice secondario locale, senza necessità di recupero.
** `ALL_PROJECTED_ATTRIBUTES` **
Consentito solo durante l'esecuzione di una query su un indice. Recupera tutti gli attributi proiettati nell'indice. Se la configurazione dell'indice prevede che vi siano proiettati tutti gli attributi, il valore che restituisce è uguale a quello dato da `ALL_ATTRIBUTES`.
**`SPECIFIC_ATTRIBUTES`**
Restituisce solo gli attributi elencati negli. `projection` `expression` Questo valore restituito equivale a specificare i `projection` `expression` senza specificare alcun valore per. `Select`
** `totalSegments` **
Il numero di segmenti in cui partizionare la tabella durante una scansione parallela. Questo campo è facoltativo, ma deve essere specificato se è specificato anche `segment`.
** `segment` **
Il segmento della tabella in questa operazione quando si esegue una scansione parallela. Questo campo è facoltativo, ma deve essere specificato se è specificato anche `totalSegments`.
**`projection`**
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.
I risultati restituiti dalla scansione DynamoDB vengono convertiti automaticamente in tipi primitivi GraphQL e JSON e sono disponibili nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
I risultati hanno la struttura seguente:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
I campi sono definiti come segue:
** `items` **
Un elenco contenente gli elementi restituiti dalla scansione DynamoDB.
** `nextToken` **
Se potrebbero esserci più risultati, `nextToken` contiene un token di impaginazione che puoi utilizzare in un'altra richiesta. AWS AppSync crittografa e offusca il token di impaginazione restituito da DynamoDB. In questo modo si evita che i dati della tabella siano inavvertitamente divulgati all'intermediario. Inoltre, questi token di paginazione non possono essere utilizzati con più resolver diversi.
** `scannedCount` **
Il numero di elementi recuperati da DynamoDB prima dell'applicazione di un'espressione di filtro (se presente).
## Esempio 1
L'esempio seguente è un modello di mappatura per la query GraphQL:. `allPosts`
In questo esempio, vengono restituite tutte le voci della tabella.
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
## Esempio 2
L'esempio seguente è un modello di mappatura per la query GraphQL:. `postsMatching(title: String!)`
In questo esempio, vengono restituite tutte le voci della tabella il cui titolo inizia con l'argomento `title`.
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"filter" : {
"expression" : "begins_with(title, :title)",
"expressionValues" : {
":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
},
}
}
```
Per ulteriori informazioni sull'API `Scan` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html).
# Sync
Il documento di mappatura della `Sync` richiesta consente di recuperare tutti i risultati da una tabella DynamoDB e quindi ricevere solo i dati modificati dall'ultima query (gli aggiornamenti delta). `Sync`le richieste possono essere inoltrate solo a sorgenti dati DynamoDB con versione. È possibile specificare quanto segue:
+ Un filtro per escludere i risultati
+ Numero di voci da restituire
+ Token di paginazione
+ Quando è stata avviata l'ultima operazione `Sync`
Il documento di mappatura `Sync` ha la seguente struttura:
```
{
"version" : "2018-05-29",
"operation" : "Sync",
"basePartitionKey": "Base Tables PartitionKey",
"deltaIndexName": "delta-index-name",
"limit" : 10,
"nextToken" : "aPaginationToken",
"lastSync" : 1550000000000,
"filter" : {
...
}
}
```
I campi sono definiti come segue:
## Sincronizza campi
### Elenco dei campi di sincronizzazione
** `version` **
La versione di definizione del modello. Al momento è supportato soltanto `2018-05-29`. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `Sync`, il valore deve essere impostato su `Sync`. Questo valore è obbligatorio.
** `filter` **
Un filtro che può essere utilizzato per filtrare i risultati di DynamoDB prima che vengano restituiti. Per ulteriori informazioni sui filtri, consulta [Filtri](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Questo campo è facoltativo.
** `limit` **
Numero massimo di elementi da valutare in una sola volta. Questo campo è facoltativo. Se omesso, il limite predefinito sarà impostato su `100` elementi. Il valore massimo per questo campo è `1000` articoli.
** `nextToken` **
Il token di paginazione utilizzato per continuare una query precedente, dalla quale deve essere ottenuto. Questo campo è facoltativo.
** `lastSync` **
Il momento, in millisecondi dall'epoca, in cui è iniziata l'ultima operazione `Sync` riuscita. Se specificato, vengono restituiti solo gli elementi che sono stati modificati dopo `lastSync`. Questo campo è facoltativo e deve essere compilato solo dopo aver recuperato tutte le pagine da un' operazione `Sync` iniziale. Se omesso, i risultati della tabella *Base* verranno restituiti, altrimenti verranno restituiti i risultati della tabella *Delta*.
**`basePartitionKey`**
La chiave di partizione della tabella *Base* utilizzata durante l'esecuzione di un'operazione. `Sync` Questo campo consente di eseguire un'`Sync`operazione quando la tabella utilizza una chiave di partizione personalizzata. Questo campo è opzionale.
**`deltaIndexName`**
L'indice utilizzato per l'operazione. `Sync` Questo indice è necessario per abilitare un'`Sync`operazione sull'intera tabella delta store quando la tabella utilizza una chiave di partizione personalizzata. L'`Sync`operazione verrà eseguita sul GSI (creato su `gsi_ds_pk` and`gsi_ds_sk`). Questo campo è facoltativo.
I risultati restituiti dalla sincronizzazione DynamoDB vengono convertiti automaticamente in tipi primitivi GraphQL e JSON e sono disponibili nel contesto di mappatura (). `$context.result`
Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).
Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
I risultati hanno la struttura seguente:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10,
startedAt = 1550000000000
}
```
I campi sono definiti come segue:
** `items` **
Un elenco contenente le voci restituite dalla sincronizzazione.
** `nextToken` **
Se potrebbero esserci più risultati, `nextToken` contiene un token di impaginazione che puoi utilizzare in un'altra richiesta. AWS AppSync crittografa e offusca il token di impaginazione restituito da DynamoDB. In questo modo si evita che i dati della tabella siano inavvertitamente divulgati all'intermediario. Inoltre, questi token di paginazione non possono essere utilizzati con più resolver diversi.
** `scannedCount` **
Il numero di elementi recuperati da DynamoDB prima dell'applicazione di un'espressione di filtro (se presente).
** `startedAt` **
Il momento, in millisecondi dall'epoca, in cui è iniziata l'operazione di sincronizzazione che è possibile memorizzare localmente e utilizzare in un'altra richiesta come argomento `lastSync`. Se un token di paginazione è stato incluso nella richiesta, questo valore sarà lo stesso di quello restituito dalla richiesta per la prima pagina di risultati.
## Esempio
L'esempio seguente è un modello di mappatura per la query GraphQL:. `syncPosts(nextToken: String, lastSync: AWSTimestamp)`
In questo esempio, se `lastSync` viene omesso, vengono restituite tutte le voci nella tabella di base. Se `lastSync` viene fornito, vengono restituite solo le voci nella tabella di sincronizzazione delta che sono state modificate dal momento in cui sono state sincronizzate `lastSync`.
```
{
"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
Il documento di mappatura delle `BatchGetItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `BatchGetItem` richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ I nomi delle tabelle da cui recuperare le voci
+ Le chiavi delle voci da recuperare da ciascuna tabella
Si applicano i limiti `BatchGetItem` di DynamoDB e non si può inserire **alcuna espressione di condizione**.
Il documento di mappatura `BatchGetItem` ha la seguente struttura:
```
{
"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" : {
...
}
}
}
}
```
I campi sono definiti come segue:
## BatchGetItem campi
### BatchGetItem elenco dei campi
** `version` **
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `BatchGetItem` DynamoDB, il valore deve essere impostato su `BatchGetItem`. Questo valore è obbligatorio.
** `tables` **
Le tabelle DynamoDB da cui recuperare gli elementi. Il valore è una mappa in cui i nomi delle tabelle sono specificati come chiavi della mappa. Occorre specificare almeno una tabella. Questo valore `tables` è obbligatorio.
** `keys` **
Elenco di chiavi DynamoDB che rappresentano la chiave primaria degli elementi da recuperare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)).
** `consistentRead` **
Se utilizzare una lettura coerente durante l'esecuzione di un'*GetItem*operazione. Questo valore è opzionale e l'impostazione predefinita è *false*.
**`projection`**
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.
Aspetti da ricordare:
+ Se una voce non è stata recuperata dalla tabella, un elemento *null* compare nel blocco di dati relativo a quella tabella.
+ I risultati delle chiamate vengono ordinati per tabella, in base all'ordine in cui sono stati forniti all'interno del modello di mappatura della richiesta.
+ Ogni `Get` comando all'interno di a `BatchGetItem` è atomico, tuttavia un batch può essere parzialmente elaborato. Se un batch viene elaborato parzialmente a causa di un errore, le chiavi non elaborate vengono restituite nell'ambito del risultato dell'invocazione all'interno del blocco *unprocessedKeys*.
+ `BatchGetItem` ha un limite di 100 chiavi.
Per il seguente esempio di modello di mappatura della richiesta:
```
{
"version": "2018-05-29",
"operation": "BatchGetItem",
"tables": {
"authors": [
{
"author_id": {
"S": "a1"
}
},
],
"posts": [
{
"author_id": {
"S": "a1"
},
"post_id": {
"S": "p2"
}
}
],
}
}
```
Il risultato dell'invocazione disponibile in `$ctx.result` è il seguente:
```
{
"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": []
}
}
```
Il messaggio `$ctx.error` contiene dettagli relativi all'errore. Le chiavi **dati**, **unprocessedKeys** e ogni chiave di tabella disponibile nel modello di mappatura della richiesta sono sicuramente presenti nel risultato dell'invocazione. Le voci eliminate compaiono nel blocco **dati**. Le voci non elaborate vengono contrassegnate come *null* all'interno del blocco dati e vengono inserite nel blocco **unprocessedKeys**.
Per un esempio più completo, segui il tutorial su DynamoDB Batch [con AppSync questo Tutorial: DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch) batch resolvers.
# BatchDeleteItem
Il documento di mappatura delle `BatchDeleteItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `BatchWriteItem` richiesta a DynamoDB per eliminare più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ I nomi delle tabelle da cui eliminare le voci
+ Le chiavi delle voci da eliminare da ciascuna tabella
Si applicano i limiti `BatchWriteItem` di DynamoDB e non si può inserire **alcuna espressione di condizione**.
Il documento di mappatura `BatchDeleteItem` ha la seguente struttura:
```
{
"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
}],
}
}
```
I campi sono definiti come segue:
## BatchDeleteItem campi
### BatchDeleteItem elenco dei campi
** `version` **
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `BatchDeleteItem` DynamoDB, il valore deve essere impostato su `BatchDeleteItem`. Questo valore è obbligatorio.
** `tables` **
Le tabelle DynamoDB da cui eliminare gli elementi. Ogni tabella è un elenco di chiavi DynamoDB che rappresentano la chiave primaria degli elementi da eliminare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Occorre specificare almeno una tabella. Il `tables` valore è obbligatorio.
Aspetti da ricordare:
+ A differenza dell'operazione `DeleteItem`, nella risposta non viene restituita la voce completamente eliminata. Viene restituita solo la chiave passata.
+ Se una voce non è stata eliminata dalla tabella, un elemento *null* compare nel blocco di dati relativo a quella tabella.
+ I risultati delle chiamate vengono ordinati per tabella, in base all'ordine in cui sono stati forniti all'interno del modello di mappatura della richiesta.
+ Ogni `Delete` comando all'interno di a è atomico. `BatchDeleteItem` Tuttavia, un batch può essere parzialmente elaborato. Se un batch viene elaborato parzialmente a causa di un errore, le chiavi non elaborate vengono restituite nell'ambito del risultato dell'invocazione all'interno del blocco *unprocessedKeys*.
+ `BatchDeleteItem` ha un limite di 25 chiavi.
+ Questa operazione **non è** supportata se utilizzata con il rilevamento dei conflitti. L'utilizzo di entrambi allo stesso tempo può causare un errore.
Per il seguente esempio di modello di mappatura della richiesta:
```
{
"version": "2018-05-29",
"operation": "BatchDeleteItem",
"tables": {
"authors": [
{
"author_id": {
"S": "a1"
}
},
],
"posts": [
{
"author_id": {
"S": "a1"
},
"post_id": {
"S": "p2"
}
}
],
}
}
```
Il risultato dell'invocazione disponibile in `$ctx.result` è il seguente:
```
{
"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": []
}
}
```
Il messaggio `$ctx.error` contiene dettagli relativi all'errore. Le chiavi **dati**, **unprocessedKeys** e ogni chiave di tabella disponibile nel modello di mappatura della richiesta sono sicuramente presenti nel risultato dell'invocazione. Le voci eliminate sono presenti nel blocco di **dati**. Le voci non elaborate vengono contrassegnate come *null* all'interno del blocco dati e vengono inserite nel blocco **unprocessedKeys**.
Per un esempio più completo, segui il tutorial su DynamoDB Batch [con AppSync questo Tutorial: DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch) batch resolvers.
# BatchPutItem
Il documento di mappatura delle `BatchPutItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di fare una `BatchWriteItem` richiesta a DynamoDB per inserire più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ I nomi delle tabelle in cui inserire le voci
+ Le voci complete da inserire in ciascuna tabella
Si applicano i limiti `BatchWriteItem` di DynamoDB e non si può inserire **alcuna espressione di condizione**.
Il documento di mappatura `BatchPutItem` ha la seguente struttura:
```
{
"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
}],
}
}
```
I campi sono definiti come segue:
## BatchPutItem campi
### BatchPutItem elenco dei campi
** `version` **
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `BatchPutItem` DynamoDB, il valore deve essere impostato su `BatchPutItem`. Questo valore è obbligatorio.
** `tables` **
Le tabelle DynamoDB in cui inserire gli elementi. Ogni voce della tabella rappresenta un elenco di elementi DynamoDB da inserire per questa tabella specifica. Occorre specificare almeno una tabella. Questo valore è obbligatorio.
Aspetti da ricordare:
+ Se l'operazione va a buon fine, nella risposta vengono restituite le voci inserite completamente.
+ Se una voce non è stata inserita nella tabella, un elemento *null* viene visualizzato nel blocco di dati relativo a quella tabella.
+ Gli elementi inseriti vengono ordinati per tabella, in base all'ordine in cui sono stati forniti all'interno del modello di mappatura della richiesta.
+ Ogni `Put` comando all'interno di a `BatchPutItem` è atomico, tuttavia un batch può essere parzialmente elaborato. Se un batch viene elaborato parzialmente a causa di un errore, le chiavi non elaborate vengono restituite nell'ambito del risultato dell'invocazione all'interno del blocco *unprocessedKeys*.
+ `BatchPutItem` ha un limite di 25 voci.
+ Questa operazione **non è** supportata se utilizzata con il rilevamento dei conflitti. L'utilizzo di entrambi allo stesso tempo può causare un errore.
Per il seguente esempio di modello di mappatura della richiesta:
```
{
"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"
}
}
],
}
}
```
Il risultato dell'invocazione disponibile in `$ctx.result` è il seguente:
```
{
"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": []
}
}
```
Il messaggio `$ctx.error` contiene dettagli relativi all'errore. Le chiavi **dati**, **unprocessedItems** e ogni chiave di tabella disponibile nel modello di mappatura della richiesta sono sicuramente presenti nel risultato dell'invocazione. Le voci inserite si trovano nel blocco di **dati**. Le voci non elaborate vengono contrassegnate come *null* all'interno del blocco dati e vengono inserite nel blocco **unprocessedItems**.
Per un esempio più completo, segui il tutorial su DynamoDB Batch [con AppSync questo Tutorial: DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch) batch resolvers.
# TransactGetItems
Il documento di mappatura delle `TransactGetItems` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `TransactGetItems` richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ Il nome della tabella di ogni elemento di richiesta da cui recuperare l'elemento
+ La chiave di ogni elemento di richiesta da recuperare da ogni tabella
Si applicano i limiti `TransactGetItems` di DynamoDB e non si può inserire **alcuna espressione di condizione**.
Il documento di mappatura `TransactGetItems` ha la seguente struttura:
```
{
"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" : {
...
}
}
]
}
```
I campi sono definiti come segue:
## TransactGetItems campi
### TransactGetItems elenco dei campi
** `version` **
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `TransactGetItems` DynamoDB, il valore deve essere impostato su `TransactGetItems`. Questo valore è obbligatorio.
** `transactItems` **
Gli elementi di richiesta da includere. Il valore è un array di elementi di richiesta. Deve essere fornito almeno un elemento di richiesta. Questo valore `transactItems` è obbligatorio.
** `table` **
La tabella DynamoDB da cui recuperare l'elemento. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.
** `key` **
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da recuperare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)).
**`projection`**
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.
Aspetti da ricordare:
+ Se una transazione ha esito positivo, l'ordine degli elementi recuperati nel blocco `items` sarà lo stesso dell'ordine degli elementi della richiesta.
+ Le transazioni vengono eseguite in qualche modo. all-or-nothing Se un elemento di richiesta causa un errore, l'intera transazione non viene eseguita e vengono restituiti i dettagli dell'errore.
+ Un elemento di richiesta che non può essere recuperato non è un errore. Invece, un elemento *null* appare nel blocco *elementi* nella posizione corrispondente.
+ Se l'errore di una transazione è *TransactionCanceledException*, il `cancellationReasons` blocco verrà popolato. L'ordine dei motivi di annullamento nel blocco `cancellationReasons` è lo stesso dell'ordine degli elementi della richiesta.
+ `TransactGetItems`è limitato a 100 articoli richiesti.
Per il seguente esempio di modello di mappatura della richiesta:
```
{
"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
}
}
}
]
}
```
Se la transazione ha esito positivo e viene recuperato solo il primo elemento richiesto, il risultato della chiamata disponibile `$ctx.result` è il seguente:
```
{
"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
}
```
Se la transazione fallisce a *TransactionCanceledException*causa del primo elemento della richiesta, il risultato della chiamata disponibile in `$ctx.result` è il seguente:
```
{
"items": null,
"cancellationReasons": [
{
"type":"Sample error type",
"message":"Sample error message"
},
{
"type":"None",
"message":"None"
}
]
}
```
Il messaggio `$ctx.error` contiene dettagli relativi all'errore. La presenza delle chiavi **items** e **cancellationReasons** è garantita in `$ctx.result`.
Per un esempio più completo, segui il tutorial sulle transazioni di DynamoDB AppSync con questo [Tutorial: risolutori di transazioni DynamoDB](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).
# TransactWriteItems
Il documento di mappatura delle `TransactWriteItems` richieste consente di indicare al AWS AppSync resolver DynamoDB di `TransactWriteItems` richiedere a DynamoDB di scrivere più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ Il nome della tabella di destinazione di ogni elemento di richiesta
+ L'operazione di ogni elemento di richiesta da eseguire. Sono supportati quattro tipi di operazioni:,, e *PutItem*UpdateItem*DeleteItem*ConditionCheck****
+ La chiave di ogni elemento di richiesta da scrivere
Si applicano i limiti `TransactWriteItems` DynamoDB.
Il documento di mappatura `TransactWriteItems` ha la seguente struttura:
```
{
"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 campi
### TransactWriteItems elenco dei campi
**I campi sono definiti come segue:**
** `version` **
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `TransactWriteItems` DynamoDB, il valore deve essere impostato su `TransactWriteItems`. Questo valore è obbligatorio.
** `transactItems` **
Gli elementi di richiesta da includere. Il valore è un array di elementi di richiesta. Deve essere fornito almeno un elemento di richiesta. Questo valore `transactItems` è obbligatorio.
Per `PutItem`, i campi sono definiti come segue:
** `table` **
La tabella DynamoDB di destinazione. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `PutItem` DynamoDB, il valore deve essere impostato su `PutItem`. Questo valore è obbligatorio.
** `key` **
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da inserire. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.
** `attributeValues` **
Gli altri attributi della voce da inserir in DynamoDB. Per ulteriori informazioni su come specificare un «valore digitato», vedete [Type system (request](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) mapping). Questo campo è facoltativo.
** `condition` **
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `PutItem` sovrascrive qualsiasi valore esistente per quella voce. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è facoltativo.
Per `UpdateItem`, i campi sono definiti come segue:
** `table` **
La tabella DynamoDB da aggiornare. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `UpdateItem` DynamoDB, il valore deve essere impostato su `UpdateItem`. Questo valore è obbligatorio.
** `key` **
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da aggiornare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.
** `update` **
La `update` sezione consente di specificare un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB. Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Questa sezione è obbligatoria.
** `condition` **
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `UpdateItem` aggiorna qualsiasi valore esistente, indipendentemente dal suo stato attuale. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è facoltativo.
Per `DeleteItem`, i campi sono definiti come segue:
** `table` **
La tabella DynamoDB in cui eliminare l'elemento. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `DeleteItem` DynamoDB, il valore deve essere impostato su `DeleteItem`. Questo valore è obbligatorio.
** `key` **
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da eliminare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.
** `condition` **
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `DeleteItem` elimina la voce indipendentemente dal suo stato attuale. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è facoltativo.
Per `ConditionCheck`, i campi sono definiti come segue:
** `table` **
La tabella DynamoDB in cui controllare la condizione. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.
** `operation` **
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `ConditionCheck` DynamoDB, il valore deve essere impostato su `ConditionCheck`. Questo valore è obbligatorio.
** `key` **
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento per il controllo delle condizioni. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.
** `condition` **
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è obbligatorio.
Aspetti da ricordare:
+ Solo le chiavi degli elementi della richiesta vengono restituite nella risposta, in caso di esito positivo. L'ordine delle chiavi sarà lo stesso dell'ordine degli elementi della richiesta.
+ Le transazioni vengono eseguite in qualsiasi modo. all-or-nothing Se un elemento di richiesta causa un errore, l'intera transazione non viene eseguita e vengono restituiti i dettagli dell'errore.
+ Nessun elemento di richiesta può scegliere come target lo stesso elemento. Altrimenti causeranno *TransactionCanceledException*errori.
+ Se l'errore di una transazione è *TransactionCanceledException*, il `cancellationReasons` blocco verrà popolato. Se il controllo delle condizioni di un elemento di richiesta fallisce **e** non è stato specificato `returnValuesOnConditionCheckFailure` come `false`, l'elemento esistente nella tabella viene recuperato e memorizzato in `item` nella posizione corrispondente del blocco `cancellationReasons`.
+ `TransactWriteItems`è limitato a 100 articoli richiesti.
+ Questa operazione **non è** supportata se utilizzata con il rilevamento dei conflitti. L'utilizzo di entrambi allo stesso tempo può causare un errore.
Per il seguente esempio di modello di mappatura della richiesta:
```
{
"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"
}
}
},
}
]
}
```
Se la transazione ha esito positivo, il risultato della chiamata disponibile in `$ctx.result` è il seguente:
```
{
"keys": [
// Key of the PutItem request
{
"post_id": "p1",
},
// Key of the UpdateItem request
{
"author_id": "a1"
}
],
"cancellationReasons": null
}
```
Se la transazione fallisce a causa del fallimento del controllo delle condizioni della `PutItem` richiesta, il risultato della chiamata disponibile in `$ctx.result` è il seguente:
```
{
"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"
}
]
}
```
Il messaggio `$ctx.error` contiene dettagli relativi all'errore. La presenza delle chiavi **keys** e **cancellationReasons** è garantita in `$ctx.result`.
Per un esempio più completo, segui il tutorial sulle transazioni di DynamoDB AppSync con questo [Tutorial: risolutori di transazioni DynamoDB](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).
# Sistema di tipi (mappatura delle richieste)
Quando si utilizza il AWS AppSync resolver DynamoDB per chiamare le AWS AppSync tabelle DynamoDB, è necessario conoscere il tipo di ogni valore da utilizzare in quella chiamata. Questo perché DynamoDB supporta più primitive di tipo rispetto a GraphQL o JSON (come set e dati binari). AWS AppSync necessita di alcuni suggerimenti per la traduzione tra GraphQL e DynamoDB, altrimenti dovrebbe formulare alcune ipotesi su come i dati sono strutturati nella tabella.
[Per ulteriori informazioni sui tipi di dati DynamoDB, consulta i descrittori dei tipi di dati e la documentazione sui tipi di dati di [DynamoDB](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)
Un valore DynamoDB è rappresentato da un oggetto JSON contenente una singola coppia chiave-valore. La chiave specifica il tipo DynamoDB e il valore specifica il valore stesso. In questo esempio, la chiave `S` indica che il valore è una stringa e il valore `identifier` è il valore della stringa stessa.
```
{ "S" : "identifier" }
```
L'oggetto JSON non può contenere più di una coppia chiave-valore. In caso contrario, il documento di mappatura della richiesta non viene analizzato.
Un valore DynamoDB viene utilizzato ovunque in un documento di mappatura delle richieste in cui è necessario specificare un valore. ad esempio nelle sezioni `key` e `attributeValue`, nonché nella sezione `expressionValues` delle sezioni delle espressioni. Nell'esempio seguente, il `identifier` valore String di DynamoDB viene assegnato al campo in una sezione (magari in `key` `GetItem` un documento di mappatura `id` della richiesta).
```
"key" : {
"id" : { "S" : "identifier" }
}
```
**Tipi supportati**
AWS AppSync supporta i seguenti tipi di scalari, documenti e set di DynamoDB:
**`S` (tipo String) **
Un singolo valore di stringa. Un valore di stringa DynamoDB è indicato da:
```
{ "S" : "some string" }
```
Un esempio di utilizzo è:
```
"key" : {
"id" : { "S" : "some string" }
}
```
**`SS` (tipo String set) **
Un set di valori di stringa. Un valore DynamoDB String Set è indicato da:
```
{ "SS" : [ "first value", "second value", ... ] }
```
Un esempio di utilizzo è:
```
"attributeValues" : {
"phoneNumbers" : { "SS" : [ "+1 555 123 4567", "+1 555 234 5678" ] }
}
```
**`N` (tipo Number) **
Un singolo valore numerico. Un valore numerico di DynamoDB è indicato da:
```
{ "N" : 1234 }
```
Un esempio di utilizzo è:
```
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
}
```
**`NS` (tipo Number set) **
Un set di valori numerici. Un valore del DynamoDB Number Set è indicato da:
```
{ "NS" : [ 1, 2.3, 4 ... ] }
```
Un esempio di utilizzo è:
```
"attributeValues" : {
"sensorReadings" : { "NS" : [ 67.8, 12.2, 70 ] }
}
```
**`B` (tipo Binary) **
Un valore binario. Un valore binario di DynamoDB è indicato da:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
Nota che il valore è in realtà una stringa, dove la stringa è la rappresentazione codificata in base64 dei dati binari. AWS AppSync decodifica nuovamente questa stringa nel suo valore binario prima di inviarla a DynamoDB. AWS AppSync utilizza lo schema di decodifica base64 come definito da RFC 2045: qualsiasi carattere che non sia nell'alfabeto base64 viene ignorato.
Un esempio di utilizzo è:
```
"attributeValues" : {
"binaryMessage" : { "B" : "SGVsbG8sIFdvcmxkIQo=" }
}
```
**`BS` (tipo Binary set) **
Un set di valori binari. Un valore del set binario di DynamoDB è indicato da:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
Nota che il valore è in realtà una stringa, dove la stringa è la rappresentazione codificata in base64 dei dati binari. AWS AppSync decodifica nuovamente questa stringa nel suo valore binario prima di inviarla a DynamoDB. AWS AppSync utilizza lo schema di decodifica base64 come definito da RFC 2045: qualsiasi carattere che non sia nell'alfabeto base64 viene ignorato.
Un esempio di utilizzo è:
```
"attributeValues" : {
"binaryMessages" : { "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ] }
}
```
**`BOOL` (tipo Boolean) **
Un valore booleano. Un valore booleano di DynamoDB è indicato da:
```
{ "BOOL" : true }
```
Solo i valori `true` e `false` sono validi.
Un esempio di utilizzo è:
```
"attributeValues" : {
"orderComplete" : { "BOOL" : false }
}
```
**`L` (tipo List) **
Un elenco di qualsiasi altro valore DynamoDB supportato. Un valore di DynamoDB List è indicato da:
```
{ "L" : [ ... ] }
```
Nota che il valore è un valore composto, in cui l'elenco può contenere zero o più di qualsiasi valore DynamoDB supportato (inclusi altri elenchi). L'elenco può anche contenere una combinazione di diversi tipi.
Un esempio di utilizzo è:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
**`M` (tipo Map) **
Rappresenta una raccolta non ordinata di coppie chiave-valore di altri valori DynamoDB supportati. Un valore di DynamoDB Map è indicato da:
```
{ "M" : { ... } }
```
Una mappa può contenere zero o più coppie chiave-valore. La chiave deve essere una stringa e il valore può essere qualsiasi valore DynamoDB supportato (incluse altre mappe). La mappa può anche contenere una combinazione di diversi tipi.
Un esempio di utilizzo è:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
**`NULL` (tipo Null) **
Un valore nullo. Un valore Null di DynamoDB è indicato da:
```
{ "NULL" : null }
```
Un esempio di utilizzo è:
```
"attributeValues" : {
"phoneNumbers" : { "NULL" : null }
}
```
Per ulteriori informazioni su ciascun tipo, consulta la [documentazione di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html).
# Sistema di tipi (mappatura delle risposte)
Quando riceve una risposta da DynamoDB AWS AppSync , la converte automaticamente in tipi primitivi GraphQL e JSON. Ogni attributo in DynamoDB viene decodificato e restituito nel contesto di mappatura delle risposte.
Ad esempio, se DynamoDB restituisce quanto segue:
```
{
"id" : { "S" : "1234" },
"name" : { "S" : "Nadia" },
"age" : { "N" : 25 }
}
```
Quindi il resolver AWS AppSync DynamoDB lo converte nei tipi GraphQL e JSON come:
```
{
"id" : "1234",
"name" : "Nadia",
"age" : 25
}
```
Questa sezione spiega come AWS AppSync convertire i seguenti tipi di scalari, documenti e set di DynamoDB:
**`S` (tipo String) **
Un singolo valore di stringa. Un valore DynamoDB String viene restituito come stringa.
Ad esempio, se DynamoDB ha restituito il seguente valore DynamoDB String:
```
{ "S" : "some string" }
```
AWS AppSync lo converte in una stringa:
```
"some string"
```
**`SS` (tipo String set) **
Un set di valori di stringa. Un valore DynamoDB String Set viene restituito come elenco di stringhe.
Ad esempio, se DynamoDB ha restituito il seguente valore DynamoDB String Set:
```
{ "SS" : [ "first value", "second value", ... ] }
```
AWS AppSync lo converte in un elenco di stringhe:
```
[ "+1 555 123 4567", "+1 555 234 5678" ]
```
**`N` (tipo Number) **
Un singolo valore numerico. Un valore numerico di DynamoDB viene restituito come numero.
Ad esempio, se DynamoDB ha restituito il seguente valore numerico di DynamoDB:
```
{ "N" : 1234 }
```
AWS AppSync lo converte in un numero:
```
1234
```
**`NS` (tipo Number set) **
Un set di valori numerici. Un valore del set di numeri di DynamoDB viene restituito come elenco di numeri.
Ad esempio, se DynamoDB ha restituito il seguente valore del DynamoDB Number Set:
```
{ "NS" : [ 67.8, 12.2, 70 ] }
```
AWS AppSync lo converte in un elenco di numeri:
```
[ 67.8, 12.2, 70 ]
```
**`B` (tipo Binary) **
Un valore binario. Un valore binario di DynamoDB viene restituito come stringa contenente la rappresentazione in base64 di quel valore.
Ad esempio, se DynamoDB ha restituito il seguente valore binario di DynamoDB:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
AWS AppSync lo converte in una stringa contenente la rappresentazione in base64 del valore:
```
"SGVsbG8sIFdvcmxkIQo="
```
I dati binari vengono codificati nello schema di codifica base64 secondo quanto specificato negli standard [RFC 4648](https://tools.ietf.org/html/rfc4648) e [RFC 2045](https://tools.ietf.org/html/rfc2045).
**`BS` (tipo Binary set) **
Un set di valori binari. Un valore del set binario di DynamoDB viene restituito come elenco di stringhe contenenti la rappresentazione in base64 dei valori.
Ad esempio, se DynamoDB ha restituito il seguente valore di DynamoDB Binary Set:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
AWS AppSync lo converte in un elenco di stringhe contenenti la rappresentazione in base64 dei valori:
```
[ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ]
```
I dati binari vengono codificati nello schema di codifica base64 secondo quanto specificato negli standard [RFC 4648](https://tools.ietf.org/html/rfc4648) e [RFC 2045](https://tools.ietf.org/html/rfc2045).
**`BOOL` (tipo Boolean) **
Un valore booleano. Un valore booleano DynamoDB viene restituito come booleano.
Ad esempio, se DynamoDB ha restituito il seguente valore booleano di DynamoDB:
```
{ "BOOL" : true }
```
AWS AppSync lo converte in booleano:
```
true
```
**`L` (tipo List) **
Un elenco di qualsiasi altro valore DynamoDB supportato. Un valore DynamoDB List viene restituito come elenco di valori, in cui viene convertito anche ogni valore interno.
Ad esempio, se DynamoDB ha restituito il seguente valore di DynamoDB List:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
AWS AppSync lo converte in un elenco di valori convertiti:
```
[ "A string value", 1, [ "Another string value", "Even more string values!" ] ]
```
**`M` (tipo Map) **
Una key/value raccolta di qualsiasi altro valore DynamoDB supportato. Un valore della mappa DynamoDB viene restituito come oggetto JSON, dove key/value ogni valore viene anche convertito.
Ad esempio, se DynamoDB ha restituito il seguente valore di DynamoDB Map:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
AWS AppSync lo converte in un oggetto JSON:
```
{
"someString" : "A string value",
"someNumber" : 1,
"stringSet" : [ "Another string value", "Even more string values!" ]
}
```
**`NULL` (tipo Null) **
Un valore nullo.
Ad esempio, se DynamoDB ha restituito il seguente valore Null di DynamoDB:
```
{ "NULL" : null }
```
AWS AppSync lo converte in un valore nullo:
```
null
```
# Filtri
Quando si eseguono interrogazioni su oggetti in DynamoDB utilizzando `Query` le operazioni `Scan` and, è possibile facoltativamente specificare `filter` un valore che valuti i risultati e restituisca solo i valori desiderati.
La sezione di mappatura dei filtri di un documento di mappatura di `Query` o `Scan` ha la seguente struttura:
```
"filter" : {
"expression" : "filter expression"
"expressionNames" : {
"#name" : "name",
},
"expressionValues" : {
":value" : ... typed value
},
}
```
I campi sono definiti come segue:
** `expression` **
L'espressione della query. Per ulteriori informazioni su come scrivere espressioni di filtro, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html) [e QueryFilter ScanFilter](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html) DynamoDB. Questo campo deve essere specificato.
** `expressionNames` **
Le sostituzioni per i segnaposto dell'attributo di espressione *name* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto nome utilizzato in `expression`. Il valore deve essere una stringa che corrisponde al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in `expression`.
** `expressionValues` **
Le sostituzioni per i segnaposto dell'attributo di espressione *value* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato in `expression`, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un "valore tipizzato", consulta [Sistema di tipi (mappatura della richiesta)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate in `expression`.
## Esempio
L'esempio seguente è una sezione filtro per un modello di mappatura, in cui le voci recuperate da DynamoDB vengono restituite solo se il titolo inizia con l'argomento. `title`
```
"filter" : {
"expression" : "begins_with(#title, :title)",
"expressionNames" : {
"#title" : "title"
},
"expressionValues" : {
":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
}
}
```
# Espressioni di condizione
Quando modificate gli oggetti in DynamoDB utilizzando le operazioni`PutItem`, e `DeleteItem` DynamoDB`UpdateItem`, potete facoltativamente specificare un'espressione di condizione che controlli se la richiesta deve avere successo o meno, in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione.
Il AWS AppSync resolver DynamoDB consente di specificare `PutItem` un'espressione di condizione `DeleteItem` e richiedere documenti di mappatura`UpdateItem`, nonché una strategia da seguire se la condizione fallisce e l'oggetto non è stato aggiornato.
## Esempio 1
Il seguente documento di mappatura `PutItem` non contiene un'espressione di condizione. Di conseguenza, inserisce un elemento in DynamoDB anche se esiste già un elemento con la stessa chiave, sovrascrivendo così l'elemento esistente.
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
}
}
```
## Esempio 2
Il seguente documento di `PutItem` mappatura contiene un'espressione di condizione che consente il successo dell'operazione solo se un elemento con la stessa chiave *non* esiste in DynamoDB.
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
},
"condition" : {
"expression" : "attribute_not_exists(id)"
}
}
```
Per impostazione predefinita, se il controllo delle condizioni fallisce, il resolver AWS AppSync DynamoDB restituisce un errore per la mutazione. Tuttavia, il AWS AppSync resolver DynamoDB offre alcune funzionalità aggiuntive per aiutare gli sviluppatori a gestire alcuni casi limite comuni:
+ Se AWS AppSync il resolver DynamoDB è in grado di determinare che il valore corrente in DynamoDB corrisponde al risultato desiderato, considera l'operazione come se fosse riuscita comunque.
+ Invece di restituire un errore, puoi configurare il resolver per richiamare una funzione Lambda personalizzata per decidere come il resolver DynamoDB deve gestire AWS AppSync l'errore.
Queste vengono descritte in dettaglio nella sezione [Gestione di un errore nel controllo della condizione](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).
[Per ulteriori informazioni sulle espressioni delle condizioni di DynamoDB, consulta la documentazione di DynamoDB. ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html)
## Specificare una condizione
I documenti di mappatura della richiesta `PutItem`, `UpdateItem` e `DeleteItem` consentono tutti di specificare una sezione facoltativa `condition`. Se omessa, non vengono eseguiti controlli di condizione. Se specificata, la condizione deve essere soddisfatta perché l'operazione abbia esito positivo.
Una sezione `condition` ha la seguente struttura:
```
"condition" : {
"expression" : "someExpression"
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
},
"equalsIgnore" : [ "version" ],
"consistentRead" : true,
"conditionalCheckFailedHandler" : {
"strategy" : "Custom",
"lambdaArn" : "arn:..."
}
}
```
I seguenti campi specificano la condizione:
** `expression` **
L'espressione di aggiornamento in sé. Per ulteriori informazioni su come scrivere espressioni di condizione, consulta la documentazione di [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Questo campo deve essere specificato.
** `expressionNames` **
Le sostituzioni per i segnaposto dell'attributo di espressione name, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato nell'*espressione* e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in*expression*.
** `expressionValues` **
Le sostituzioni per i segnaposto del valore dell'attributo di espressione, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato nell'espressione, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un "valore tipizzato", consulta [Sistema di tipi (mappatura della richiesta)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate nell'espressione.
I campi rimanenti indicano al resolver AWS AppSync DynamoDB come gestire un errore di controllo delle condizioni:
** `equalsIgnore` **
Quando un controllo delle condizioni fallisce durante l'utilizzo dell'`PutItem`operazione, il resolver AWS AppSync DynamoDB confronta l'elemento attualmente in DynamoDB con l'elemento che ha cercato di scrivere. Se sono uguali, tratta l'operazione come se avesse avuto comunque esito positivo. È possibile utilizzare il `equalsIgnore` campo per specificare un elenco di attributi da ignorare quando si esegue il AWS AppSync confronto. Ad esempio, se l'unica differenza era un `version` attributo, considera l'operazione come se fosse riuscita. Questo campo è facoltativo.
** `consistentRead` **
Quando un controllo delle condizioni fallisce, AWS AppSync ottiene il valore corrente dell'elemento da DynamoDB utilizzando una lettura fortemente coerente. È possibile utilizzare questo campo per indicare al resolver AWS AppSync DynamoDB di utilizzare invece una lettura alla fine coerente. Si tratta di un campo facoltativo, impostato di default su `true`.
** `conditionalCheckFailedHandler` **
Questa sezione consente di specificare in che modo il resolver AWS AppSync DynamoDB tratta un errore di controllo delle condizioni dopo aver confrontato il valore corrente in DynamoDB con il risultato previsto. Questa sezione è facoltativa. Se omesso, la strategia predefinita è `Reject`.
** `strategy` **
La strategia adottata dal AWS AppSync resolver DynamoDB dopo aver confrontato il valore corrente in DynamoDB con il risultato previsto. Questo campo è obbligatorio e ha i seguenti possibili valori:
** `Reject` **
La mutazione fallisce e viene aggiunto un errore alla risposta GraphQL.
** `Custom` **
Il AWS AppSync resolver DynamoDB richiama una funzione Lambda personalizzata per decidere come gestire l'errore del controllo delle condizioni. Se `strategy` è impostato su `Custom`, il campo `lambdaArn` deve contenere l'ARN della funzione Lambda da invocare.
** `lambdaArn` **
L'ARN della funzione Lambda da richiamare che determina in che modo il resolver DynamoDB deve gestire l'errore del controllo delle AWS AppSync condizioni. Questo campo deve essere specificato solo se `strategy` è impostato su `Custom`. Per ulteriori informazioni su come utilizzare questa funzionalità, consulta [Gestione di un errore nel controllo della condizione](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).
## Gestione di un errore di controllo delle condizioni
Per impostazione predefinita, quando un controllo delle condizioni fallisce, il resolver AWS AppSync DynamoDB restituisce un errore per la mutazione e il valore corrente dell'oggetto in DynamoDB. Tuttavia, il AWS AppSync resolver DynamoDB offre alcune funzionalità aggiuntive per aiutare gli sviluppatori a gestire alcuni casi limite comuni:
+ Se AWS AppSync il resolver DynamoDB è in grado di determinare che il valore corrente in DynamoDB corrisponde al risultato desiderato, considera l'operazione come se fosse riuscita comunque.
+ Invece di restituire un errore, puoi configurare il resolver per richiamare una funzione Lambda personalizzata per decidere come il resolver DynamoDB deve gestire AWS AppSync l'errore.
Il diagramma di questo processo è il seguente:
![\[Flowchart showing process for transforming requests with mutation attempts and value checks.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/DynamoDB-condition-check-failure-handling.png)
### Verifica del risultato desiderato
Quando il controllo delle condizioni fallisce, il resolver AWS AppSync DynamoDB esegue `GetItem` una richiesta DynamoDB per ottenere il valore corrente dell'elemento da DynamoDB. Per impostazione predefinita, si utilizza una lettura fortemente consistente, ma è possibile intervenire sulla configurazione utilizzando il campo `consistentRead` del blocco `condition` e confrontandolo con il risultato previsto:
+ Per l'`PutItem`operazione, il AWS AppSync resolver DynamoDB confronta il valore corrente con quello che ha tentato di scrivere, escludendo dal confronto tutti gli attributi elencati. `equalsIgnore` Se gli elementi sono uguali, considera l'operazione come riuscita e restituisce l'elemento recuperato da DynamoDB. In caso contrario, viene seguita la strategia configurata.
Ad esempio, se il documento di mappatura della richiesta `PutItem` fosse simile al seguente:
```
{
"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" ]
}
}
```
E la voce attualmente inclusa in DynamoDB fosse simile alla seguente:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
Il AWS AppSync resolver DynamoDB confronta l'elemento che ha cercato di scrivere con il valore corrente, verifica che l'unica differenza è `version` il campo, ma poiché è configurato per ignorare il campo, considera `version` l'operazione come riuscita e restituisce l'elemento recuperato da DynamoDB.
+ Per l'`DeleteItem`operazione, il resolver AWS AppSync DynamoDB verifica che un elemento sia stato restituito da DynamoDB. Se nessuna voce è stata restituita, considera l'operazione riuscita. In caso contrario, viene seguita la strategia configurata.
+ Per l'`UpdateItem`operazione, il AWS AppSync resolver DynamoDB non dispone di informazioni sufficienti per determinare se l'elemento attualmente in DynamoDB corrisponde al risultato previsto e pertanto segue la strategia configurata.
Se lo stato corrente dell'oggetto in DynamoDB è diverso dal risultato previsto, il resolver AWS AppSync DynamoDB segue la strategia configurata, rifiutando la mutazione o richiamando una funzione Lambda per determinare cosa fare dopo.
### Seguendo la strategia di «rifiuto»
Quando si segue la `Reject` strategia, il resolver AWS AppSync DynamoDB restituisce un errore per la mutazione.
Ad esempio, partendo dalla richiesta di mutazione seguente:
```
mutation {
updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
Name
theVersion
}
}
```
Se l'elemento restituito da DynamoDB è simile al seguente:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
E il modello di mappatura della risposta fosse simile al seguente:
```
{
"id" : $util.toJson($context.result.id),
"Name" : $util.toJson($context.result.name),
"theVersion" : $util.toJson($context.result.version)
}
```
La risposta GraphQL ha il seguente aspetto:
```
{
"data": null,
"errors": [
{
"message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
"errorType": "DynamoDB:ConditionalCheckFailedException",
...
}
]
}
```
Inoltre, se i campi dell'oggetto restituito sono compilati da altri resolver in caso di successo della mutazione, tali campi non saranno risolti quando l'oggetto viene restituito nella sezione `error`.
### Seguendo la strategia «personalizzata»
Quando segue la `Custom` strategia, il resolver AWS AppSync DynamoDB richiama una funzione Lambda per decidere cosa fare dopo. La funzione Lambda sceglie una delle seguenti opzioni:
+ Rifiuto della mutazione (`reject`). Ciò indica al AWS AppSync resolver DynamoDB di comportarsi come se lo `Reject` fosse la strategia configurata, restituendo un errore per la mutazione e il valore corrente dell'oggetto in DynamoDB come descritto nella sezione precedente.
+ Rifiuto della mutazione (`discard`). Ciò indica al resolver AWS AppSync DynamoDB di ignorare silenziosamente l'errore del controllo delle condizioni e restituisce il valore in DynamoDB.
+ Rifiuto della mutazione (`retry`). Questo indica al resolver AWS AppSync DynamoDB di riprovare la mutazione con un nuovo documento di mappatura delle richieste.
**La richiesta di invocazione Lambda**
Il AWS AppSync resolver DynamoDB richiama la funzione Lambda specificata in. `lambdaArn` Utilizza lo stesso `service-role-arn` configurato per l'origine dati. Il payload dell'invocazione ha la seguente struttura:
```
{
"arguments": { ... },
"requestMapping": {... },
"currentValue": { ... },
"resolver": { ... },
"identity": { ... }
}
```
I campi sono definiti come segue:
** `arguments` **
Gli argomenti della mutazione GraphQL. Sono uguali agli argomenti disponibili per il documento di mappatura della richiesta in `$context.arguments`.
** `requestMapping` **
Il documento di mappatura della richiesta per questa operazione.
** `currentValue` **
Il valore corrente dell'oggetto in DynamoDB.
** `resolver` **
Informazioni sul resolver. AWS AppSync
** `identity` **
Informazioni sul chiamante. Sono uguali alle informazioni sull'identità disponibili per il documento di mappatura della richiesta in `$context.identity`.
Un esempio completo di payload:
```
{
"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"
}
}
```
**La risposta all'invocazione Lambda**
La funzione Lambda può ispezionare il payload di chiamata e applicare qualsiasi logica aziendale per decidere come il resolver DynamoDB deve gestire l'errore AWS AppSync . Sono disponibili tre opzioni per la gestione dell'errore nel controllo della condizione:
+ Rifiuto della mutazione (`reject`). Il payload di risposta per questa opzione deve avere questa struttura:
```
{
"action": "reject"
}
```
Ciò indica al AWS AppSync resolver DynamoDB di comportarsi come se la strategia configurata lo `Reject` fosse, restituendo un errore per la mutazione e il valore corrente dell'oggetto in DynamoDB, come descritto nella sezione precedente.
+ Rifiuto della mutazione (`discard`). Il payload di risposta per questa opzione deve avere questa struttura:
```
{
"action": "discard"
}
```
Ciò indica al resolver AWS AppSync DynamoDB di ignorare silenziosamente l'errore del controllo delle condizioni e restituisce il valore in DynamoDB.
+ Rifiuto della mutazione (`retry`). Il payload di risposta per questa opzione deve avere questa struttura:
```
{
"action": "retry",
"retryMapping": { ... }
}
```
Questo indica al resolver AWS AppSync DynamoDB di riprovare la mutazione con un nuovo documento di mappatura delle richieste. La struttura della `retryMapping` sezione dipende dall'operazione DynamoDB ed è un sottoinsieme del documento completo di mappatura delle richieste per quell'operazione.
Per `PutItem`, la sezione `retryMapping` ha la seguente struttura. Per una descrizione del campo, vedere. `attributeValues` [PutItem](aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.md)
```
{
"attributeValues": { ... },
"condition": {
"equalsIgnore" = [ ... ],
"consistentRead" = true
}
}
```
Per `UpdateItem`, la sezione `retryMapping` ha la seguente struttura. Per una descrizione della `update` sezione, vedere [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md).
```
{
"update" : {
"expression" : "someExpression"
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
}
},
"condition": {
"consistentRead" = true
}
}
```
Per `DeleteItem`, la sezione `retryMapping` ha la seguente struttura.
```
{
"condition": {
"consistentRead" = true
}
}
```
Non c'è modo di specificare operazioni o chiavi diverse su cui lavorare. Il AWS AppSync resolver DynamoDB consente solo di ripetere la stessa operazione sullo stesso oggetto. Inoltre, la sezione `condition` non consente di specificare un valore per `conditionalCheckFailedHandler`. Se il nuovo tentativo fallisce, il resolver AWS AppSync DynamoDB segue la strategia. `Reject`
Ecco un esempio di funzione Lambda per far fronte a una richiesta `PutItem` non riuscita. La logica di business osserva l'autore della chiamata. Se è stata effettuata da`jeffTheAdmin`, riprova la richiesta, aggiornando l'`version`and `expectedVersion` dall'elemento attualmente in DynamoDB. Altrimenti rifiuta la mutazione.
```
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)
};
```
# Espressioni relative alle condizioni delle transazioni
Le espressioni di condizione delle transazioni sono disponibili nei modelli di mappatura delle richieste di tutti e quattro i tipi di operazioni in `TransactWriteItems`, vale a dire `PutItem`, `DeleteItem`, `UpdateItem` e `ConditionCheck`.
Per`PutItem`, e `DeleteItem``UpdateItem`, l'espressione della condizione di transazione è facoltativa. Perché`ConditionCheck`, l'espressione della condizione della transazione è obbligatoria.
## Esempio 1
Il seguente documento di mappatura `DeleteItem` transazionale non dispone di un'espressione di condizione. Di conseguenza, elimina l'elemento in DynamoDB.
```
{
"version": "2018-05-29",
"operation": "TransactWriteItems",
"transactItems": [
{
"table": "posts",
"operation": "DeleteItem",
"key": {
"id": { "S" : "1" }
}
}
]
}
```
## Esempio 2
Il seguente documento di `DeleteItem` mappatura transazionale contiene un'espressione della condizione di transazione che consente l'esito positivo dell'operazione solo se l'autore di quel post è uguale a un determinato nome.
```
{
"version": "2018-05-29",
"operation": "TransactWriteItems",
"transactItems": [
{
"table": "posts",
"operation": "DeleteItem",
"key": {
"id": { "S" : "1" }
}
"condition": {
"expression": "author = :author",
"expressionValues": {
":author": { "S" : "Chunyan" }
}
}
}
]
}
```
Se il controllo della condizione fallisce, genera una `TransactionCanceledException` e il dettaglio dell'errore viene restituito in `$ctx.result.cancellationReasons`. Tieni presente che, per impostazione predefinita, verrà restituito il vecchio elemento in DynamoDB che ha impedito il controllo delle condizioni. `$ctx.result.cancellationReasons`
## Specificare una condizione
I documenti di mappatura della richiesta `PutItem`, `UpdateItem` e `DeleteItem` consentono tutti di specificare una sezione facoltativa `condition`. Se omessa, non vengono eseguiti controlli di condizione. Se specificata, la condizione deve essere soddisfatta perché l'operazione abbia esito positivo. Per `ConditionCheck` deve essere specificata una sezione `condition`. La condizione deve essere vera affinché l'intera transazione abbia esito positivo.
Una sezione `condition` ha la seguente struttura:
```
"condition": {
"expression": "someExpression",
"expressionNames": {
"#foo": "foo"
},
"expressionValues": {
":bar": ... typed value
},
"returnValuesOnConditionCheckFailure": false
}
```
I seguenti campi specificano la condizione:
** `expression` **
L'espressione di aggiornamento in sé. Per ulteriori informazioni su come scrivere espressioni di condizione, consulta la documentazione di [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Questo campo deve essere specificato.
** `expressionNames` **
Le sostituzioni per i segnaposto dell'attributo di espressione name, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato nell'*espressione* e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in*expression*.
** `expressionValues` **
Le sostituzioni per i segnaposto del valore dell'attributo di espressione, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato nell'espressione, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un "valore tipizzato", consulta Sistema di tipi (mappatura della richiesta). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate nell'espressione.
** `returnValuesOnConditionCheckFailure` **
Specificare se recuperare l'elemento in DynamoDB quando un controllo delle condizioni fallisce. L'elemento recuperato sarà in `$ctx.result.cancellationReasons[$index].item`, dove `$index` è l'indice dell'elemento richiesta che non ha superato il controllo della condizione. Il valore predefinito di questo valore è true.
# Proiezioni
Quando si leggono oggetti in DynamoDB utilizzando `GetItem` le operazioni`Scan`,, `Query``BatchGetItem`, `TransactGetItems` e,, è possibile specificare facoltativamente una proiezione che identifichi gli attributi desiderati. La proiezione ha la seguente struttura, simile ai filtri:
```
"projection" : {
"expression" : "projection expression"
"expressionNames" : {
"#name" : "name",
}
}
```
I campi sono definiti come segue:
**`expression`**
L'espressione di proiezione, che è una stringa. Per recuperare un singolo attributo, specificane il nome. Per più attributi, i nomi devono essere valori separati da virgole. Per ulteriori informazioni sulla scrittura di espressioni di proiezione, consulta la documentazione delle espressioni di proiezione [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html). Questo campo è obbligatorio.
**`expressionNames`**
Le sostituzioni degli attributi di espressione *chiamano* segnaposto sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto nome utilizzato in `expression`. Il valore deve essere una stringa che corrisponde al nome dell'attributo dell'elemento in DynamoDB. Questo campo è facoltativo e deve essere compilato solo con sostituzioni per i segnaposto dei nomi degli attributi di espressione utilizzati in. `expression` Per ulteriori informazioni`expressionNames`, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html).
## Esempio 1
L'esempio seguente è una sezione di proiezione per un modello di mappatura VTL in cui `id` vengono restituiti solo gli attributi `author` e da DynamoDB:
```
"projection" : {
"expression" : "#author, id",
"expressionNames" : {
"#author" : "author"
}
}
```
**Suggerimento**
[È possibile accedere al set di selezione delle richieste GraphQL utilizzando \$1context.info. selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html#aws-appsync-resolver-context-reference-info). Questo campo consente di inquadrare l'espressione di proiezione in modo dinamico in base alle proprie esigenze.
**Nota**
Quando si utilizzano espressioni di proiezione con le `Scan` operazioni `Query` and, il valore per `select` deve essere. `SPECIFIC_ATTRIBUTES` Per ulteriori informazioni, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html#DDB-Query-request-Select).