

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

El documento de mapeo de `UpdateItem` solicitudes le permite indicar al solucionador de AWS AppSync DynamoDB que realice `UpdateItem` una solicitud a DynamoDB y le permite especificar lo siguiente:
+ La clave del elemento de DynamoDB
+ Una expresión de actualización que describe cómo se actualiza el elemento de DynamoDB
+ Condiciones para que la operación se lleve a cabo correctamente.

El documento de mapeo de `UpdateItem` tiene la siguiente estructura:

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

Los campos se definen de la siguiente manera:

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

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

 **`version`**   
La versión de la definición de plantilla `2017-02-28` y `2018-05-29` se admiten actualmente. Este valor es obligatorio.

 **`operation`**   
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `UpdateItem`, este valor se debe establecer en `UpdateItem`. Este valor es obligatorio.

 **`key`**   
La clave del elemento de DynamoDB. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Este valor es obligatorio.

 **`update`**   
La sección `update` permite especificar una expresión de actualización que describe cómo se actualiza el elemento en DynamoDB. Para obtener más información sobre cómo escribir expresiones de actualización, consulte la documentación de [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Esta sección es obligatoria.  
La sección `update` tiene tres componentes:    
** `expression` **  
La expresión de actualización. Este valor es obligatorio.  
** `expressionNames` **  
Las sustituciones de los marcadores de posición de *nombre* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre usado en la `expression` y el valor tiene que ser una cadena que corresponda al nombre de atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de marcadores de posición de nombre de atributo de expresión que se usen en la `expression`.  
** `expressionValues` **  
Las sustituciones de los marcadores de posición de *valor* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de valor usado en la `expression` y el valor tiene que ser un valor con tipo. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Este valor debe especificarse. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de valor de atributo de expresión que se usen en la `expression`.

 **`condition`**   
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `UpdateItem` actualiza todas las entradas existentes independientemente de su estado actual. Para obtener más información sobre las condiciones, consulte [Expresiones de condición](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Este valor es opcional.

 **`_version`**   
Valor numérico que representa la última versión conocida de un elemento. Este valor es opcional. Este campo se utiliza para *detectar conflictos* y solo se admite en orígenes de datos con control de versiones.

**`customPartitionKey`**  
*Cuando está activado, este valor de cadena modifica el formato `ds_sk` y los `ds_pk` registros utilizados por la tabla de sincronización delta cuando se ha activado el control de versiones (para obtener más información, consulte [Detección de conflictos y sincronización](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) en la AWS AppSync Guía para desarrolladores).* Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`. Este campo es opcional.

**`populateIndexFields`**  
Valor booleano que, cuando se habilita **junto con la `customPartitionKey`**, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas `gsi_ds_pk` y `gsi_ds_sk`. Para obtener más información, consulte el artículo sobre [detección de conflictos y sincronización](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) en la *Guía para desarrolladores de AWS AppSync *. Este campo es opcional.

El elemento que se actualiza en DynamoDB se convierte automáticamente a los tipos primitivos de GraphQL y JSON, y está disponible en el contexto de mapeo (`$context.result`).

Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md).

Para obtener más información acerca de las plantillas de mapeo de respuesta, consulte [Información general sobre las plantillas de mapeo de solucionador](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

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

El siguiente ejemplo muestra una plantilla de mapeo de la mutación de GraphQL `upvote(id: ID!)`.

En este ejemplo, se han incrementado en 1 los campos `upvotes` y `version` de un elemento de DynamoDB.

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

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

El siguiente ejemplo muestra una plantilla de mapeo de una mutación de GraphQL `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)`.

Se trata de un ejemplo complejo que inspecciona los argumentos y genera de manera dinámica la expresión de actualización que solo incluye los argumentos que ha proporcionado el cliente. Por ejemplo, si se omiten `title` y `author`, no se actualizan. Si se especifica un argumento pero su valor es `null`, ese campo se elimina del objeto en DynamoDB. Por último, la operación tiene una condición que comprueba si el elemento que está actualmente en DynamoDB tiene el campo `version` establecido en `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 obtener más información sobre la API `UpdateItem` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).