vers DynamoDB Utilitaires ToString Utils ToNumber Utilitaires ToBinary Utilitaires ToBoolean Utilitaires ToNull Utilitaires ToList Utilitaires TomaP Utilitaires de l'objet S3

Assistants DynamoDB dans $util.dynamodb

Note

Nous prenons désormais principalement en charge le runtime APPSYNC_JS et sa documentation. Pensez à utiliser le runtime APPSYNC_JS et ses guides ici.

$util.dynamodbcontient des méthodes d'assistance qui facilitent l'écriture et la lecture de données dans Amazon DynamoDB, telles que le mappage automatique des types et le formatage. Ces méthodes sont conçues pour mapper automatiquement les types primitifs et les listes au format d'entrée DynamoDB approprié, qui est Map un des formats. { "TYPE" : VALUE }

Par exemple, auparavant, un modèle de mappage de demandes pour créer un nouvel élément dans DynamoDB aurait pu ressembler à ceci :


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

Si nous voulions ajouter des champs à l'objet, nous devrions mettre à jour la requête GraphQL dans le schéma, ainsi que le modèle de mappage de demande. Cependant, nous pouvons désormais restructurer notre modèle de mappage des demandes afin qu'il récupère automatiquement les nouveaux champs ajoutés dans notre schéma et les ajoute à DynamoDB avec les types appropriés :


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

Dans l'exemple précédent, nous utilisons l'$util.dynamodb.toDynamoDBJson(...)assistant pour prendre automatiquement l'identifiant généré et le convertir en représentation DynamoDB d'un attribut de chaîne. Nous prenons ensuite tous les arguments, les convertissons en leurs représentations DynamoDB et les affichons dans attributeValues le champ du modèle.

Chaque assistant possède deux versions : une version qui renvoie un objet (par exemple, $util.dynamodb.toString(...)) et une version qui renvoie l'objet en tant que chaîne JSON (par exemple, $util.dynamodb.toStringJson(...)). Dans l'exemple précédent, nous avons utilisé la version qui renvoie les données sous la forme d'une chaîne JSON. Si vous souhaitez manipuler l'objet avant qu'il ne soit utilisé dans le modèle, vous pouvez choisir à la place de renvoyer un objet :


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

Dans l'exemple précédent, nous retournons les arguments convertis comme map au lieu d'une chaîne JSON, ajoutons les champs version et timestamp avant de les exporter vers le champ attributeValues du modèle à l'aide de $util.toJson(...).

La version JSON de chacun des assistants est équivalente à l'encapsulage de la version autre que la version JSON dans $util.toJson(...). Par exemple, les instructions suivantes sont exactement identiques :


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

vers DynamoDB

$util.dynamodb.toDynamoDB(Object) : Map

Outil général de conversion d'objets pour DynamoDB qui convertit les objets d'entrée en une représentation DynamoDB appropriée. La façon dont il représente certains types est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.

Exemple de chaîne


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

Exemple de numéro


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

Exemple booléen


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

Exemple de liste


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

Exemple de carte


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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toDynamoDB(Object) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires ToString

$util.dynamodb.toString(String) : String

Convertit une chaîne d'entrée au format de chaîne DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

$util.dynamodb.toStringJson(String) : Map

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toString(String) : String, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

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

Convertit une liste contenant des chaînes au format de jeu de chaînes DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toStringSet(List<String>) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utils ToNumber

$util.dynamodb.toNumber(Number) : Map

Convertit un nombre au format numérique DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

$util.dynamodb.toNumberJson(Number) : String

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toNumber(Number) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

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

Convertit une liste de nombres au format d'ensemble de numéros DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toNumberSet(List<Number>) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires ToBinary

$util.dynamodb.toBinary(String) : Map

Convertit les données binaires codées sous forme de chaîne base64 au format binaire DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

$util.dynamodb.toBinaryJson(String) : String

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toBinary(String) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

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

Convertit une liste de données binaires codées sous forme de chaînes base64 au format d'ensemble binaire DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toBinarySet(List<String>) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires ToBoolean

$util.dynamodb.toBoolean(Boolean) : Map

Convertit un booléen au format booléen DynamoDB approprié. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

$util.dynamodb.toBooleanJson(Boolean) : String

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toBoolean(Boolean) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires ToNull

$util.dynamodb.toNull() : Map

Renvoie une valeur nulle au format DynamoDB nul. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

$util.dynamodb.toNullJson() : String

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toNull() : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires ToList

$util.dynamodb.toList(List) : Map

Convertit une liste d'objets au format de liste DynamoDB. Chaque élément de la liste est également converti au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.


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

$util.dynamodb.toListJson(List) : String

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toList(List) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires TomaP

$util.dynamodb.toMap(Map) : Map

Convertit une carte au format de carte DynamoDB. Chaque valeur de la carte est également convertie au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut 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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toMap(Map) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

$util.dynamodb.toMapValues(Map) : Map

Crée une copie de la carte dans laquelle chaque valeur a été convertie au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »).


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

Note

Cela est légèrement différent $util.dynamodb.toMap(Map) : Map car il renvoie uniquement le contenu de la valeur d'attribut DynamoDB, mais pas la valeur d'attribut complète elle-même. Par exemple, les instructions suivantes sont exactement identiques :


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

$util.dynamodb.toMapValuesJson(Map) : String

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toMapValues(Map) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

Utilitaires de l'objet S3

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

Convertit la clé, le compartiment et la région en représentation de l'objet DynamoDB S3. Cela renvoie un objet qui décrit la valeur de l'attribut 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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toS3Object(String key, String bucket, String region) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

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

Convertit la clé, le compartiment, la région et la version facultative en représentation de l'objet DynamoDB S3. Cela renvoie un objet qui décrit la valeur de l'attribut 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

Identique à la valeur de l'attribut DynamoDB$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

$util.dynamodb.fromS3ObjectJson(String) : Map

Accepte la valeur de chaîne d'un objet DynamoDB S3 et renvoie une carte contenant la clé, le compartiment, la région et la version facultative.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Assistants cartographiques dans $util.map

Assistants Amazon RDS dans $util.rds