UpdateItem

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

UpdateItem lista de campos

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). 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. 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). 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. 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 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 no Guia do AWS AppSync desenvolvedor. Esse campo é opcional.

O item atualizado no DynamoDB é automaticamente convertido em tipos GraphQL JSON e primitivos 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).

Para obter mais informações sobre os modelos de mapeamento da resposta, consulte Visão geral do modelo de mapeamento do resolvedor.

Exemplo 1

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

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 o DynamoDB, consulte a UpdateItem API documentação do DynamoDB. API