As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# UpdateItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem"></a>

O documento de mapeamento de `UpdateItem` solicitações permite que você peça ao AWS AppSync resolvedor do DynamoDB que faça uma `UpdateItem` solicitação ao DynamoDB e especifique o seguinte:
+ A chave do item no DynamoDB
+ Uma expressão de atualização que descreve como atualizar o item no DynamoDB
+ Condições para que a operação seja bem-sucedida

O documento de mapeamento `UpdateItem` possui a seguinte estrutura:

```
{
    "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
}
```

Os campos são definidos da seguinte forma:

## UpdateItem campos
<a name="updateitem-list"></a>

### UpdateItem lista de campos
<a name="updateitem-list-col"></a>

 **`version`**   
As versões de definição de modelo `2017-02-28` e `2018-05-29` são compatíveis atualmente. Este valor é obrigatório.

 **`operation`**   
A operação do DynamoDB para execução. Para executar a operação `UpdateItem` do DynamoDB, ela deve ser definida como `UpdateItem`. Este valor é obrigatório.

 **`key`**   
A chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (mapeamento da solicitação)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Este valor é obrigatório.

 **`update`**   
A seção `update` permite especificar uma expressão de atualização que descreve como atualizar o item no DynamoDB. Para obter mais informações sobre como escrever expressões de atualização, consulte a documentação do [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Esta seção é obrigatória.  
A seção `update` tem três componentes:    
** `expression` **  
A expressão de atualização. Este valor é obrigatório.  
** `expressionNames` **  
As substituições para espaços reservados de *nome* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de nome usado em `expression` e o valor deve ser uma string que corresponde ao nome do atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados em `expression`.  
** `expressionValues` **  
As substituições para espaços reservados de *valor* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de valor usado na `expression` e o valor deve ser um valor digitado. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Isso deve ser especificado. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de valor do atributo da expressão usados em `expression`.

 **`condition`**   
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, a solicitação `UpdateItem` atualizará as entradas existentes independentemente do estado atual. Para obter mais informações sobre as condições, consulte [Expressões de condição](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Este valor é opcional.

 **`_version`**   
Um valor numérico que representa a versão conhecida mais recente de um item. Este valor é opcional. Esse campo é usado para *Detecção de conflitos* e só é compatível com fontes de dados versionadas.

**`customPartitionKey`**  
Quando ativado, esse valor de string modifica o formato dos `ds_pk` registros `ds_sk` e usados pela tabela de sincronização delta quando o controle de versão é ativado (para obter mais informações, consulte [Detecção e sincronização de conflitos no Guia](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) do *AWS AppSync desenvolvedor*). Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. Esse campo é opcional.

**`populateIndexFields`**  
Um valor booleano que, quando ativado **com `customPartitionKey`**, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`. Para obter mais informações, consulte [Detecção e sincronização de conflitos](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) no *Guia do desenvolvedor do AWS AppSync *. Esse campo é opcional.

O item atualizado no DynamoDB é automaticamente convertido nos tipos primitivos GraphQL e JSON e está disponível no contexto de mapeamento (`$context.result`).

Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md).

Para obter mais informações sobre os modelos de mapeamento da resposta, consulte [Visão geral do modelo de mapeamento do resolvedor](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Exemplo 1
<a name="id3"></a>

Veja a seguir um modelo de mapeamento para uma mutação do GraphQL `upvote(id: ID!)`.

Nesse exemplo, um item no DynamoDB tem seus campos `upvotes` e `version` incrementados por 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 }
        }
    }
}
```

## Exemplo 2
<a name="id4"></a>

Veja a seguir um modelo de mapeamento para uma mutação do GraphQL `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)`.

Esse é um exemplo complexo que inspeciona os argumentos e gera dinamicamente a expressão de atualização que inclui apenas os argumentos que foram fornecidos pelo cliente. Por exemplo, se `title` e `author` são omitidos, eles não são atualizados. Se um argumento for especificado, mas o seu valor for `null`, esse campo é excluído do objeto no DynamoDB. Finalmente, a operação tem uma condição, que verifica se o item que está atualmente no DynamoDB tem o campo `version` definido como `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)
        }
    }
}
```

Para obter mais informações sobre a API `UpdateItem` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).