toDynamoDB toString utenze toNumber utenze toBinary utenze toBoolean utenze toNull utenze toList utenze toMap utenze Utilità S3Object

Helper DynamoDB in $util.dynamodb

Nota

Ora supportiamo principalmente il runtime APPSYNC _JS e la relativa documentazione. Valuta la possibilità di utilizzare il runtime APPSYNC _JS e le relative guide qui.

$util.dynamodbcontiene metodi di supporto che semplificano la scrittura e la lettura dei dati su Amazon DynamoDB, come la mappatura e la formattazione automatiche dei tipi. Questi metodi sono progettati per mappare automaticamente i tipi e gli elenchi primitivi nel formato di input DynamoDB corretto, che è uno dei formati. Map { "TYPE" : VALUE }

Ad esempio, in precedenza, un modello di mappatura delle richieste per creare un nuovo elemento in DynamoDB avrebbe potuto avere il seguente aspetto:


{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : { "S" : "$util.autoId()" }
    },
    "attributeValues" : {
         "title" : { "S" : $util.toJson($ctx.args.title) },
         "author" : { "S" : $util.toJson($ctx.args.author) },
         "version" : { "N", $util.toJson($ctx.args.version) }
    }
}

Per aggiungere campi all'oggetto sarebbe stato necessario aggiornare la query GraphQL nello schema, nonché il modello di mappatura della richiesta. Tuttavia, ora possiamo ristrutturare il nostro modello di mappatura delle richieste in modo che raccolga automaticamente i nuovi campi aggiunti nel nostro schema e li aggiunga a DynamoDB con i tipi corretti:


{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : $util.dynamodb.toDynamoDBJson($util.autoId())
    },
    "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}

Nell'esempio precedente, utilizziamo l'$util.dynamodb.toDynamoDBJson(...)helper per prendere automaticamente l'id generato e convertirlo nella rappresentazione DynamoDB di un attributo stringa. Quindi prendiamo tutti gli argomenti e li convertiamo nelle loro rappresentazioni DynamoDB e li inviamo nel campo attributeValues del modello.

Ogni helper ha due versioni: una versione che restituisce un oggetto (ad esempio,$util.dynamodb.toString(...)) e una versione che restituisce l'oggetto come JSON stringa (ad esempio,). $util.dynamodb.toStringJson(...) Nell'esempio precedente, abbiamo utilizzato la versione che restituisce i dati come JSON stringa. Se vuoi modificare l'oggetto prima che venga usato nel modello, puoi scegliere di restituire invece un oggetto, come illustrato di seguito:


{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : $util.dynamodb.toDynamoDBJson($util.autoId())
    },

    #set( $myFoo = $util.dynamodb.toMapValues($ctx.args) )
    #set( $myFoo.version = $util.dynamodb.toNumber(1) )
    #set( $myFoo.timestamp = $util.dynamodb.toString($util.time.nowISO8601()))

    "attributeValues" : $util.toJson($myFoo)
}

Nell'esempio precedente, restituiamo gli argomenti convertiti come mappa anziché come JSON stringa, quindi aggiungiamo i timestamp campi version and prima di inviarli definitivamente al attributeValues campo nel modello che utilizza$util.toJson(...).

La JSON versione di ciascuno degli helper equivale a inserire la versione non esistente. JSON $util.toJson(...) Ad esempio, le istruzioni seguenti sono identiche:


$util.toStringJson("Hello, World!")
$util.toJson($util.toString("Hello, World!"))

toDynamoDB

$util.dynamodb.toDynamoDB(Object) : Map

Strumento generale di conversione degli oggetti per DynamoDB che converte gli oggetti di input nella rappresentazione DynamoDB appropriata. Rappresenta alcuni tipi in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.

Esempio di stringa


Input:      $util.dynamodb.toDynamoDB("foo")
Output:     { "S" : "foo" }

Esempio di numero


Input:      $util.dynamodb.toDynamoDB(12345)
Output:     { "N" : 12345 }

Esempio booleano


Input:      $util.dynamodb.toDynamoDB(true)
Output:     { "BOOL" : true }

Esempio di elenco


Input:      $util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output:     {
               "L" : [
                   { "S" : "foo" },
                   { "N" : 123 },
                   {
                       "M" : {
                           "bar" : { "S" : "baz" }
                       }
                   }
               ]
           }

Esempio di mappa


Input:      $util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output:     {
               "M" : {
                   "foo"  : { "S" : "bar" },
                   "baz"  : { "N" : 1234 },
                   "beep" : {
                       "L" : [
                           { "S" : "boop" }
                       ]
                   }
               }
           }

$util.dynamodb.toDynamoDBJson(Object) : String

Uguale a$util.dynamodb.toDynamoDB(Object) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toString utenze

$util.dynamodb.toString(String) : String

Converte una stringa di input nel formato stringa DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toString("foo")
Output:     { "S" : "foo" }

$util.dynamodb.toStringJson(String) : Map

Uguale a$util.dynamodb.toString(String) : String, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

$util.dynamodb.toStringSet(List<String>) : Map

Converte un elenco con stringhe nel formato del set di stringhe DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output:     { "SS" : [ "foo", "bar", "baz" ] }

$util.dynamodb.toStringSetJson(List<String>) : String

Uguale a$util.dynamodb.toStringSet(List<String>) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toNumber utenze

$util.dynamodb.toNumber(Number) : Map

Converte un numero nel formato numerico DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toNumber(12345)
Output:     { "N" : 12345 }

$util.dynamodb.toNumberJson(Number) : String

Uguale a$util.dynamodb.toNumber(Number) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

$util.dynamodb.toNumberSet(List<Number>) : Map

Converte un elenco di numeri nel formato del set di numeri DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output:     { "NS" : [ 1, 23, 4.56 ] }

$util.dynamodb.toNumberSetJson(List<Number>) : String

Uguale a$util.dynamodb.toNumberSet(List<Number>) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toBinary utenze

$util.dynamodb.toBinary(String) : Map

Converte i dati binari codificati come stringa base64 in formato binario DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toBinary("foo")
Output:     { "B" : "foo" }

$util.dynamodb.toBinaryJson(String) : String

Uguale a$util.dynamodb.toBinary(String) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

$util.dynamodb.toBinarySet(List<String>) : Map

Converte un elenco di dati binari codificati come stringhe base64 in formato set binario DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output:     { "BS" : [ "foo", "bar", "baz" ] }

$util.dynamodb.toBinarySetJson(List<String>) : String

Uguale a$util.dynamodb.toBinarySet(List<String>) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toBoolean utenze

$util.dynamodb.toBoolean(Boolean) : Map

Converte un booleano nel formato booleano DynamoDB appropriato. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toBoolean(true)
Output:     { "BOOL" : true }

$util.dynamodb.toBooleanJson(Boolean) : String

Uguale a$util.dynamodb.toBoolean(Boolean) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toNull utenze

$util.dynamodb.toNull() : Map

Restituisce un valore null nel formato null di DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toNull()
Output:     { "NULL" : null }

$util.dynamodb.toNullJson() : String

Uguale a$util.dynamodb.toNull() : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toList utenze

$util.dynamodb.toList(List) : Map

Converte un elenco di oggetti nel formato elenco DynamoDB. Ogni elemento dell'elenco viene inoltre convertito nel formato DynamoDB appropriato. Rappresenta alcuni oggetti nidificati in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output:     {
               "L" : [
                   { "S" : "foo" },
                   { "N" : 123 },
                   {
                       "M" : {
                           "bar" : { "S" : "baz" }
                       }
                   }
               ]
           }

$util.dynamodb.toListJson(List) : String

Uguale a$util.dynamodb.toList(List) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

toMap utenze

$util.dynamodb.toMap(Map) : Map

Converte una mappa nel formato di mappa DynamoDB. Ogni valore nella mappa viene inoltre convertito nel formato DynamoDB appropriato. Rappresenta alcuni oggetti nidificati in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output:     {
               "M" : {
                   "foo"  : { "S" : "bar" },
                   "baz"  : { "N" : 1234 },
                   "beep" : {
                       "L" : [
                           { "S" : "boop" }
                       ]
                   }
               }
           }

$util.dynamodb.toMapJson(Map) : String

Uguale a$util.dynamodb.toMap(Map) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

$util.dynamodb.toMapValues(Map) : Map

Crea una copia della mappa in cui ogni valore è stato convertito nel formato DynamoDB appropriato. Rappresenta alcuni oggetti nidificati in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS").


Input:      $util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output:     {
               "foo"  : { "S" : "bar" },
               "baz"  : { "N" : 1234 },
               "beep" : {
                   "L" : [
                       { "S" : "boop" }
                   ]
               }
           }

Nota

Questo è leggermente diverso dal fatto che restituisce solo il contenuto del valore dell'attributo DynamoDB, ma non l'intero valore dell'attributo $util.dynamodb.toMap(Map) : Map stesso. Ad esempio, le istruzioni seguenti sono identiche:


$util.dynamodb.toMapValues($map)
$util.dynamodb.toMap($map).get("M")

$util.dynamodb.toMapValuesJson(Map) : String

Uguale a$util.dynamodb.toMapValues(Map) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

Utilità S3Object

$util.dynamodb.toS3Object(String key, String bucket, String region) : Map

Converte la chiave, il bucket e la regione nella rappresentazione dell'oggetto DynamoDB S3. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toS3Object("foo", "bar", region = "baz")
Output:     { "S" : "{ \"s3\" : { \"key\" : \"foo", \"bucket\" : \"bar", \"region\" : \"baz" } }" }

$util.dynamodb.toS3ObjectJson(String key, String bucket, String region) : String

Uguale a$util.dynamodb.toS3Object(String key, String bucket, String region) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map

Converte la chiave, il bucket, la regione e la versione opzionale nella rappresentazione dell'oggetto DynamoDB S3. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB.


Input:      $util.dynamodb.toS3Object("foo", "bar", "baz", "beep")
Output:     { "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" }

$util.dynamodb.toS3ObjectJson(String key, String bucket, String region, String version) : String

Uguale a$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map, ma restituisce il valore dell'attributo DynamoDB come JSON stringa codificata.

$util.dynamodb.fromS3ObjectJson(String) : Map

Accetta il valore stringa di un oggetto DynamoDB S3 e restituisce una mappa che contiene la chiave, il bucket, la regione e la versione opzionale.


Input:      $util.dynamodb.fromS3ObjectJson({ "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" })
Output:     { "key" : "foo", "bucket" : "bar", "region" : "baz", "version" : "beep" }

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Aiutanti di mappe in $util.map

RDSAiutanti Amazon in $util.rds