()
{
new KeySchemaElement
{
AttributeName = "year",
KeyType = KeyType.HASH,
},
new KeySchemaElement
{
AttributeName = "title",
KeyType = KeyType.RANGE,
},
},
BillingMode = BillingMode.PAY_PER_REQUEST,
});
// Wait until the table is ACTIVE and then report success.
Console.Write("Waiting for table to become active...");
var request = new DescribeTableRequest
{
TableName = response.TableDescription.TableName,
};
TableStatus status;
int sleepDuration = 2000;
do
{
Thread.Sleep(sleepDuration);
var describeTableResponse = await _amazonDynamoDB.DescribeTableAsync(request);
status = describeTableResponse.Table.TableStatus;
Console.Write(".");
}
while (status != "ACTIVE");
return status == TableStatus.ACTIVE;
}
catch (ResourceInUseException ex)
{
Console.WriteLine($"Table {tableName} already exists. {ex.Message}");
throw;
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine($"An Amazon DynamoDB error occurred while creating table {tableName}. {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred while creating table {tableName}. {ex.Message}");
throw;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/CreateTable)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/dynamodb#code-examples).
```
###############################################################################
# function dynamodb_create_table
#
# This function creates an Amazon DynamoDB table.
#
# Parameters:
# -n table_name -- The name of the table to create.
# -a attribute_definitions -- JSON file path of a list of attributes and their types.
# -k key_schema -- JSON file path of a list of attributes and their key types.
#
# Returns:
# 0 - If successful.
# 1 - If it fails.
###############################################################################
function dynamodb_create_table() {
local table_name attribute_definitions key_schema response
local option OPTARG # Required to use getopts command in a function.
#######################################
# Function usage explanation
#######################################
function usage() {
echo "function dynamodb_create_table"
echo "Creates an Amazon DynamoDB table with on-demand billing."
echo " -n table_name -- The name of the table to create."
echo " -a attribute_definitions -- JSON file path of a list of attributes and their types."
echo " -k key_schema -- JSON file path of a list of attributes and their key types."
echo ""
}
# Retrieve the calling parameters.
while getopts "n:a:k:h" option; do
case "${option}" in
n) table_name="${OPTARG}" ;;
a) attribute_definitions="${OPTARG}" ;;
k) key_schema="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$table_name" ]]; then
errecho "ERROR: You must provide a table name with the -n parameter."
usage
return 1
fi
if [[ -z "$attribute_definitions" ]]; then
errecho "ERROR: You must provide an attribute definitions json file path the -a parameter."
usage
return 1
fi
if [[ -z "$key_schema" ]]; then
errecho "ERROR: You must provide a key schema json file path the -k parameter."
usage
return 1
fi
iecho "Parameters:\n"
iecho " table_name: $table_name"
iecho " attribute_definitions: $attribute_definitions"
iecho " key_schema: $key_schema"
iecho ""
response=$(aws dynamodb create-table \
--table-name "$table_name" \
--attribute-definitions file://"$attribute_definitions" \
--billing-mode PAY_PER_REQUEST \
--key-schema file://"$key_schema" )
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports create-table operation failed.$response"
return 1
fi
return 0
}
```
Fonctions utilitaires utilisées dans cet exemple.
```
###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
if [[ $VERBOSE == true ]]; then
echo "$@"
fi
}
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
##############################################################################
# function aws_cli_error_log()
#
# This function is used to log the error messages from the AWS CLI.
#
# See https://docs.aws.amazon.com/cli/latest/topic/return-codes.html#cli-aws-help-return-codes.
#
# The function expects the following argument:
# $1 - The error code returned by the AWS CLI.
#
# Returns:
# 0: - Success.
#
##############################################################################
function aws_cli_error_log() {
local err_code=$1
errecho "Error code : $err_code"
if [ "$err_code" == 1 ]; then
errecho " One or more S3 transfers failed."
elif [ "$err_code" == 2 ]; then
errecho " Command line failed to parse."
elif [ "$err_code" == 130 ]; then
errecho " Process received SIGINT."
elif [ "$err_code" == 252 ]; then
errecho " Command syntax invalid."
elif [ "$err_code" == 253 ]; then
errecho " The system environment or configuration was invalid."
elif [ "$err_code" == 254 ]; then
errecho " The service returned an error."
elif [ "$err_code" == 255 ]; then
errecho " 255 is a catch-all error."
fi
return 0
}
```
+ Pour plus de détails sur l'API, voir [CreateTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/CreateTable)la section *Référence des AWS CLI commandes*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
//! Create an Amazon DynamoDB table.
/*!
\sa createTable()
\param tableName: Name for the DynamoDB table.
\param primaryKey: Primary key for the DynamoDB table.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::createTable(const Aws::String &tableName,
const Aws::String &primaryKey,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
std::cout << "Creating table " << tableName <<
" with a simple primary key: \"" << primaryKey << "\"." << std::endl;
Aws::DynamoDB::Model::CreateTableRequest request;
Aws::DynamoDB::Model::AttributeDefinition hashKey;
hashKey.SetAttributeName(primaryKey);
hashKey.SetAttributeType(Aws::DynamoDB::Model::ScalarAttributeType::S);
request.AddAttributeDefinitions(hashKey);
Aws::DynamoDB::Model::KeySchemaElement keySchemaElement;
keySchemaElement.WithAttributeName(primaryKey).WithKeyType(
Aws::DynamoDB::Model::KeyType::HASH);
request.AddKeySchema(keySchemaElement);
Aws::DynamoDB::Model::ProvisionedThroughput throughput;
throughput.WithReadCapacityUnits(5).WithWriteCapacityUnits(5);
request.SetProvisionedThroughput(throughput);
request.SetTableName(tableName);
const Aws::DynamoDB::Model::CreateTableOutcome &outcome = dynamoClient.CreateTable(
request);
if (outcome.IsSuccess()) {
std::cout << "Table \""
<< outcome.GetResult().GetTableDescription().GetTableName() <<
" created!" << std::endl;
}
else {
std::cerr << "Failed to create table: " << outcome.GetError().GetMessage()
<< std::endl;
return false;
}
return waitTableActive(tableName, dynamoClient);
}
```
Code qui attend que la table soit active.
```
//! Query a newly created DynamoDB table until it is active.
/*!
\sa waitTableActive()
\param waitTableActive: The DynamoDB table's name.
\param dynamoClient: A DynamoDB client.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::waitTableActive(const Aws::String &tableName,
const Aws::DynamoDB::DynamoDBClient &dynamoClient) {
// Repeatedly call DescribeTable until table is ACTIVE.
const int MAX_QUERIES = 20;
Aws::DynamoDB::Model::DescribeTableRequest request;
request.SetTableName(tableName);
int count = 0;
while (count < MAX_QUERIES) {
const Aws::DynamoDB::Model::DescribeTableOutcome &result = dynamoClient.DescribeTable(
request);
if (result.IsSuccess()) {
Aws::DynamoDB::Model::TableStatus status = result.GetResult().GetTable().GetTableStatus();
if (Aws::DynamoDB::Model::TableStatus::ACTIVE != status) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
else {
return true;
}
}
else {
std::cerr << "Error DynamoDB::waitTableActive "
<< result.GetError().GetMessage() << std::endl;
return false;
}
count++;
}
return false;
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/CreateTable)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour créer une table avec des balises**
L’exemple `create-table` suivant utilise les attributs et le schéma de clés spécifiés pour créer une table nommée `MusicCollection`. Cette table utilise le débit provisionné et est chiffrée au repos à l'aide de la clé CMK AWS détenue par défaut. La commande applique également une balise à la table, avec une clé `Owner` et une valeur `blueTeam`.
```
aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
--tags Key=Owner,Value=blueTeam
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 5
},
"TableSizeBytes": 0,
"TableName": "MusicCollection",
"TableStatus": "CREATING",
"KeySchema": [
{
"KeyType": "HASH",
"AttributeName": "Artist"
},
{
"KeyType": "RANGE",
"AttributeName": "SongTitle"
}
],
"ItemCount": 0,
"CreationDateTime": "2020-05-26T16:04:41.627000-07:00",
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 2 : pour créer une table en mode à la demande**
L’exemple suivant crée une table appelée `MusicCollection` en mode à la demande, plutôt qu’en mode débit provisionné. Cela est utile pour les tables dont les charges de travail sont imprévisibles.
```
aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--billing-mode PAY_PER_REQUEST
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "MusicCollection",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH"
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2020-05-27T11:44:10.807000-07:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 0,
"WriteCapacityUnits": 0
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"BillingModeSummary": {
"BillingMode": "PAY_PER_REQUEST"
}
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 3 : pour créer une table et la chiffrer à l’aide d’une clé CMK gérée par le client**
L’exemple suivant crée une table nommée `MusicCollection` et la chiffre à l’aide d’une clé CMK gérée par le client.
```
aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
--sse-specification Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-abcd-1234-a123-ab1234a1b234
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "MusicCollection",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH"
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2020-05-27T11:12:16.431000-07:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"SSEDescription": {
"Status": "ENABLED",
"SSEType": "KMS",
"KMSMasterKeyArn": "arn:aws:kms:us-west-2:123456789012:key/abcd1234-abcd-1234-a123-ab1234a1b234"
}
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 4 : pour créer une table avec un index secondaire local**
L’exemple suivant utilise les attributs et le schéma de clés spécifiés pour créer une table nommée `MusicCollection` avec un index local secondaire nommé `AlbumTitleIndex`.
```
aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S AttributeName=AlbumTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--local-secondary-indexes \
"[
{
\"IndexName\": \"AlbumTitleIndex\",
\"KeySchema\": [
{\"AttributeName\": \"Artist\",\"KeyType\":\"HASH\"},
{\"AttributeName\": \"AlbumTitle\",\"KeyType\":\"RANGE\"}
],
\"Projection\": {
\"ProjectionType\": \"INCLUDE\",
\"NonKeyAttributes\": [\"Genre\", \"Year\"]
}
}
]"
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "AlbumTitle",
"AttributeType": "S"
},
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "MusicCollection",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH"
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"LocalSecondaryIndexes": [
{
"IndexName": "AlbumTitleIndex",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH"
},
{
"AttributeName": "AlbumTitle",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"Genre",
"Year"
]
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
}
]
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 5 : pour créer une table avec un index secondaire global**
L’exemple suivant crée une table nommée `GameScores` avec un index secondaire global nommé `GameTitleIndex`. La table de base a une clé de partition `UserId` et une clé de tri `GameTitle`, vous permettant de trouver efficacement le meilleur score d’un utilisateur pour un jeu spécifique, tandis que l’index secondaire global (GSI) a une clé de partition `GameTitle` et une clé de tri `TopScore`, vous permettant de trouver rapidement le score le plus élevé pour un jeu particulier.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S AttributeName=TopScore,AttributeType=N \
--key-schema AttributeName=UserId,KeyType=HASH \
AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--global-secondary-indexes \
"[
{
\"IndexName\": \"GameTitleIndex\",
\"KeySchema\": [
{\"AttributeName\":\"GameTitle\",\"KeyType\":\"HASH\"},
{\"AttributeName\":\"TopScore\",\"KeyType\":\"RANGE\"}
],
\"Projection\": {
\"ProjectionType\":\"INCLUDE\",
\"NonKeyAttributes\":[\"UserId\"]
},
\"ProvisionedThroughput\": {
\"ReadCapacityUnits\": 10,
\"WriteCapacityUnits\": 5
}
}
]"
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "TopScore",
"AttributeType": "N"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2020-05-26T17:28:15.602000-07:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"GlobalSecondaryIndexes": [
{
"IndexName": "GameTitleIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "TopScore",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"UserId"
]
},
"IndexStatus": "CREATING",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameTitleIndex"
}
]
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 6 : pour créer une table avec plusieurs index secondaires globaux à la fois**
L’exemple suivant crée une table nommée `GameScores` avec deux index secondaires globaux. Les schémas GSI sont transmis via un fichier plutôt que sur la ligne de commande.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S AttributeName=TopScore,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--global-secondary-indexes file://gsi.json
```
Contenu de `gsi.json` :
```
[
{
"IndexName": "GameTitleIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "TopScore",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "ALL"
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
}
},
{
"IndexName": "GameDateIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "ALL"
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
]
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "Date",
"AttributeType": "S"
},
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "TopScore",
"AttributeType": "N"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2020-08-04T16:40:55.524000-07:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"GlobalSecondaryIndexes": [
{
"IndexName": "GameTitleIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "TopScore",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "ALL"
},
"IndexStatus": "CREATING",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameTitleIndex"
},
{
"IndexName": "GameDateIndex",
"KeySchema": [
{
"AttributeName": "GameTitle",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "ALL"
},
"IndexStatus": "CREATING",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
},
"IndexSizeBytes": 0,
"ItemCount": 0,
"IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameDateIndex"
}
]
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 7 : pour créer une table avec Streams activé**
L’exemple suivant crée une table appelée `GameScores` avec DynamoDB Streams activé. Les nouvelles et les anciennes images de chaque élément seront écrites dans le flux.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
--key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--stream-specification StreamEnabled=TRUE,StreamViewType=NEW_AND_OLD_IMAGES
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2020-05-27T10:49:34.056000-07:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"StreamSpecification": {
"StreamEnabled": true,
"StreamViewType": "NEW_AND_OLD_IMAGES"
},
"LatestStreamLabel": "2020-05-27T17:49:34.056",
"LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/2020-05-27T17:49:34.056"
}
}
```
Pour plus d’informations, consultez [Opérations de base pour les tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 8 : pour créer une table avec Keys-Only Stream activé**
L’exemple suivant crée une table appelée `GameScores` avec DynamoDB Streams activé. Seuls les attributs clés des éléments modifiés sont écrits dans le flux.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
--key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--stream-specification StreamEnabled=TRUE,StreamViewType=KEYS_ONLY
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2023-05-25T18:45:34.140000+00:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"StreamSpecification": {
"StreamEnabled": true,
"StreamViewType": "KEYS_ONLY"
},
"LatestStreamLabel": "2023-05-25T18:45:34.140",
"LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/2023-05-25T18:45:34.140",
"DeletionProtectionEnabled": false
}
}
```
Pour plus d’informations, consultez [Modifier la récupération de données pour DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 9 : pour créer une table à l’aide de la classe Standard Infrequent Access**
L’exemple suivant crée une table appelée `GameScores` et attribue la classe de table Standard-Infrequent Access (DynamoDB Standard-IA). Cette classe de table est optimisée pour le stockage, qui constitue le principal coût.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
--key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--table-class STANDARD_INFREQUENT_ACCESS
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2023-05-25T18:33:07.581000+00:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"TableClassSummary": {
"TableClass": "STANDARD_INFREQUENT_ACCESS"
},
"DeletionProtectionEnabled": false
}
}
```
Pour plus d’informations, consultez [Classes de tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 10 : pour créer une table avec la protection contre la suppression activée**
L’exemple suivant crée une table appelée `GameScores` et active la protection contre la suppression.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
--key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--deletion-protection-enabled
```
Sortie :
```
{
"TableDescription": {
"AttributeDefinitions": [
{
"AttributeName": "GameTitle",
"AttributeType": "S"
},
{
"AttributeName": "UserId",
"AttributeType": "S"
}
],
"TableName": "GameScores",
"KeySchema": [
{
"AttributeName": "UserId",
"KeyType": "HASH"
},
{
"AttributeName": "GameTitle",
"KeyType": "RANGE"
}
],
"TableStatus": "CREATING",
"CreationDateTime": "2023-05-25T23:02:17.093000+00:00",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 5
},
"TableSizeBytes": 0,
"ItemCount": 0,
"TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
"TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"DeletionProtectionEnabled": true
}
}
```
Pour plus d’informations, consultez [Utilisation de la protection contre la suppression](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeletionProtection) dans le *Guide du développeur Amazon DynamoDB*.
+ Pour plus de détails sur l'API, voir [CreateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-table.html)la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// TableBasics encapsulates the Amazon DynamoDB service actions used in the examples.
// It contains a DynamoDB service client that is used to act on the specified table.
type TableBasics struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// CreateMovieTable creates a DynamoDB table with a composite primary key defined as
// a string sort key named `title`, and a numeric partition key named `year`.
// This function uses NewTableExistsWaiter to wait for the table to be created by
// DynamoDB before it returns.
func (basics TableBasics) CreateMovieTable(ctx context.Context) (*types.TableDescription, error) {
var tableDesc *types.TableDescription
table, err := basics.DynamoDbClient.CreateTable(ctx, &dynamodb.CreateTableInput{
AttributeDefinitions: []types.AttributeDefinition{{
AttributeName: aws.String("year"),
AttributeType: types.ScalarAttributeTypeN,
}, {
AttributeName: aws.String("title"),
AttributeType: types.ScalarAttributeTypeS,
}},
KeySchema: []types.KeySchemaElement{{
AttributeName: aws.String("year"),
KeyType: types.KeyTypeHash,
}, {
AttributeName: aws.String("title"),
KeyType: types.KeyTypeRange,
}},
TableName: aws.String(basics.TableName),
BillingMode: types.BillingModePayPerRequest,
})
if err != nil {
log.Printf("Couldn't create table %v. Here's why: %v\n", basics.TableName, err)
} else {
waiter := dynamodb.NewTableExistsWaiter(basics.DynamoDbClient)
err = waiter.Wait(ctx, &dynamodb.DescribeTableInput{
TableName: aws.String(basics.TableName)}, 5*time.Minute)
if err != nil {
log.Printf("Wait for table exists failed. Here's why: %v\n", err)
}
tableDesc = table.TableDescription
log.Printf("Ccreating table test")
}
return tableDesc, err
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.CreateTable)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
```
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;
import software.amazon.awssdk.services.dynamodb.model.BillingMode;
import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest;
import software.amazon.awssdk.services.dynamodb.model.CreateTableResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableResponse;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement;
import software.amazon.awssdk.services.dynamodb.model.KeyType;
import software.amazon.awssdk.services.dynamodb.model.OnDemandThroughput;
import software.amazon.awssdk.services.dynamodb.model.ProvisionedThroughput;
import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;
import software.amazon.awssdk.services.dynamodb.waiters.DynamoDbWaiter;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CreateTable {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table to create (for example, Music3).
key - The key for the Amazon DynamoDB table (for example, Artist).
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
System.out.println("Creating an Amazon DynamoDB table " + tableName + " with a simple primary key: " + key);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
String result = createTable(ddb, tableName, key);
System.out.println("New table is " + result);
ddb.close();
}
public static String createTable(DynamoDbClient ddb, String tableName, String key) {
DynamoDbWaiter dbWaiter = ddb.waiter();
CreateTableRequest request = CreateTableRequest.builder()
.attributeDefinitions(AttributeDefinition.builder()
.attributeName(key)
.attributeType(ScalarAttributeType.S)
.build())
.keySchema(KeySchemaElement.builder()
.attributeName(key)
.keyType(KeyType.HASH)
.build())
.billingMode(BillingMode.PAY_PER_REQUEST) // DynamoDB automatically scales based on traffic.
.tableName(tableName)
.build();
String newTable;
try {
CreateTableResponse response = ddb.createTable(request);
DescribeTableRequest tableRequest = DescribeTableRequest.builder()
.tableName(tableName)
.build();
// Wait until the Amazon DynamoDB table is created.
WaiterResponse waiterResponse = dbWaiter.waitUntilTableExists(tableRequest);
waiterResponse.matched().response().ifPresent(System.out::println);
newTable = response.tableDescription().tableName();
return newTable;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return "";
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples).
```
import { CreateTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient({});
export const main = async () => {
const command = new CreateTableCommand({
TableName: "EspressoDrinks",
// For more information about data types,
// see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes and
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors
AttributeDefinitions: [
{
AttributeName: "DrinkName",
AttributeType: "S",
},
],
KeySchema: [
{
AttributeName: "DrinkName",
KeyType: "HASH",
},
],
BillingMode: "PAY_PER_REQUEST",
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/dynamodb-examples-using-tables.html#dynamodb-examples-using-tables-creating-a-table).
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/CreateTableCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/dynamodb#code-examples).
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the DynamoDB service object
var ddb = new AWS.DynamoDB({ apiVersion: "2012-08-10" });
var params = {
AttributeDefinitions: [
{
AttributeName: "CUSTOMER_ID",
AttributeType: "N",
},
{
AttributeName: "CUSTOMER_NAME",
AttributeType: "S",
},
],
KeySchema: [
{
AttributeName: "CUSTOMER_ID",
KeyType: "HASH",
},
{
AttributeName: "CUSTOMER_NAME",
KeyType: "RANGE",
},
],
ProvisionedThroughput: {
ReadCapacityUnits: 1,
WriteCapacityUnits: 1,
},
TableName: "CUSTOMER_LIST",
StreamSpecification: {
StreamEnabled: false,
},
};
// Call DynamoDB to create the table
ddb.createTable(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Table Created", data);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-examples-using-tables.html#dynamodb-examples-using-tables-creating-a-table).
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/CreateTable)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/dynamodb#code-examples).
```
suspend fun createNewTable(
tableNameVal: String,
key: String,
): String? {
val attDef =
AttributeDefinition {
attributeName = key
attributeType = ScalarAttributeType.S
}
val keySchemaVal =
KeySchemaElement {
attributeName = key
keyType = KeyType.Hash
}
val request =
CreateTableRequest {
attributeDefinitions = listOf(attDef)
keySchema = listOf(keySchemaVal)
billingMode = BillingMode.PayPerRequest
tableName = tableNameVal
}
DynamoDbClient.fromEnvironment { region = "us-east-1" }.use { ddb ->
var tableArn: String
val response = ddb.createTable(request)
ddb.waitUntilTableExists {
// suspend call
tableName = tableNameVal
}
tableArn = response.tableDescription!!.tableArn.toString()
println("Table $tableArn is ready")
return tableArn
}
}
```
+ Pour plus de détails sur l'API, consultez [CreateTable](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
Créer une table.
```
$tableName = "ddb_demo_table_$uuid";
$service->createTable(
$tableName,
[
new DynamoDBAttribute('year', 'N', 'HASH'),
new DynamoDBAttribute('title', 'S', 'RANGE')
]
);
public function createTable(string $tableName, array $attributes)
{
$keySchema = [];
$attributeDefinitions = [];
foreach ($attributes as $attribute) {
if (is_a($attribute, DynamoDBAttribute::class)) {
$keySchema[] = ['AttributeName' => $attribute->AttributeName, 'KeyType' => $attribute->KeyType];
$attributeDefinitions[] =
['AttributeName' => $attribute->AttributeName, 'AttributeType' => $attribute->AttributeType];
}
}
$this->dynamoDbClient->createTable([
'TableName' => $tableName,
'KeySchema' => $keySchema,
'AttributeDefinitions' => $attributeDefinitions,
'ProvisionedThroughput' => ['ReadCapacityUnits' => 10, 'WriteCapacityUnits' => 10],
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : Cet exemple crée une table nommée Thread dont la clé primaire est composée de « ForumName » (hachage de type de clé) et de « Subject » (plage de types de clés). Le schéma utilisé pour construire la table peut être redirigé vers chaque applet de commande comme indiqué ou spécifié à l’aide du paramètre -Schema.**
```
$schema = New-DDBTableSchema
$schema | Add-DDBKeySchema -KeyName "ForumName" -KeyDataType "S"
$schema | Add-DDBKeySchema -KeyName "Subject" -KeyType RANGE -KeyDataType "S"
$schema | New-DDBTable -TableName "Thread" -ReadCapacity 10 -WriteCapacity 5
```
**Sortie** :
```
AttributeDefinitions : {ForumName, Subject}
TableName : Thread
KeySchema : {ForumName, Subject}
TableStatus : CREATING
CreationDateTime : 10/28/2013 4:39:49 PM
ProvisionedThroughput : Amazon.DynamoDBv2.Model.ProvisionedThroughputDescription
TableSizeBytes : 0
ItemCount : 0
LocalSecondaryIndexes : {}
```
**Exemple 2 : Cet exemple crée une table nommée Thread dont la clé primaire est composée de « ForumName » (hachage de type de clé) et de « Subject » (plage de types de clés). Un index secondaire local est également défini. La clé de l'index secondaire local sera définie automatiquement à partir de la clé de hachage principale de la table (ForumName). Le schéma utilisé pour construire la table peut être redirigé vers chaque applet de commande comme indiqué ou spécifié à l’aide du paramètre -Schema.**
```
$schema = New-DDBTableSchema
$schema | Add-DDBKeySchema -KeyName "ForumName" -KeyDataType "S"
$schema | Add-DDBKeySchema -KeyName "Subject" -KeyDataType "S"
$schema | Add-DDBIndexSchema -IndexName "LastPostIndex" -RangeKeyName "LastPostDateTime" -RangeKeyDataType "S" -ProjectionType "keys_only"
$schema | New-DDBTable -TableName "Thread" -ReadCapacity 10 -WriteCapacity 5
```
**Sortie** :
```
AttributeDefinitions : {ForumName, LastPostDateTime, Subject}
TableName : Thread
KeySchema : {ForumName, Subject}
TableStatus : CREATING
CreationDateTime : 10/28/2013 4:39:49 PM
ProvisionedThroughput : Amazon.DynamoDBv2.Model.ProvisionedThroughputDescription
TableSizeBytes : 0
ItemCount : 0
LocalSecondaryIndexes : {LastPostIndex}
```
**Exemple 3 : Cet exemple montre comment utiliser un pipeline unique pour créer une table nommée Thread qui possède une clé primaire composée de « ForumName » (hachage de type de clé) et de « Subject » (plage de types de clés) et un index secondaire local. Les options Add- DDBKey Schema et Add- DDBIndex Schema créent un nouvel TableSchema objet pour vous si aucun objet n'est fourni par le pipeline ou le paramètre -Schema.**
```
New-DDBTableSchema |
Add-DDBKeySchema -KeyName "ForumName" -KeyDataType "S" |
Add-DDBKeySchema -KeyName "Subject" -KeyDataType "S" |
Add-DDBIndexSchema -IndexName "LastPostIndex" `
-RangeKeyName "LastPostDateTime" `
-RangeKeyDataType "S" `
-ProjectionType "keys_only" |
New-DDBTable -TableName "Thread" -ReadCapacity 10 -WriteCapacity 5
```
**Sortie** :
```
AttributeDefinitions : {ForumName, LastPostDateTime, Subject}
TableName : Thread
KeySchema : {ForumName, Subject}
TableStatus : CREATING
CreationDateTime : 10/28/2013 4:39:49 PM
ProvisionedThroughput : Amazon.DynamoDBv2.Model.ProvisionedThroughputDescription
TableSizeBytes : 0
ItemCount : 0
LocalSecondaryIndexes : {LastPostIndex}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/powershell/v4/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : Cet exemple crée une table nommée Thread dont la clé primaire est composée de « ForumName » (hachage de type de clé) et de « Subject » (plage de types de clés). Le schéma utilisé pour construire la table peut être redirigé vers chaque applet de commande comme indiqué ou spécifié à l’aide du paramètre -Schema.**
```
$schema = New-DDBTableSchema
$schema | Add-DDBKeySchema -KeyName "ForumName" -KeyDataType "S"
$schema | Add-DDBKeySchema -KeyName "Subject" -KeyType RANGE -KeyDataType "S"
$schema | New-DDBTable -TableName "Thread" -ReadCapacity 10 -WriteCapacity 5
```
**Sortie** :
```
AttributeDefinitions : {ForumName, Subject}
TableName : Thread
KeySchema : {ForumName, Subject}
TableStatus : CREATING
CreationDateTime : 10/28/2013 4:39:49 PM
ProvisionedThroughput : Amazon.DynamoDBv2.Model.ProvisionedThroughputDescription
TableSizeBytes : 0
ItemCount : 0
LocalSecondaryIndexes : {}
```
**Exemple 2 : Cet exemple crée une table nommée Thread dont la clé primaire est composée de « ForumName » (hachage de type de clé) et de « Subject » (plage de types de clés). Un index secondaire local est également défini. La clé de l'index secondaire local sera définie automatiquement à partir de la clé de hachage principale de la table (ForumName). Le schéma utilisé pour construire la table peut être redirigé vers chaque applet de commande comme indiqué ou spécifié à l’aide du paramètre -Schema.**
```
$schema = New-DDBTableSchema
$schema | Add-DDBKeySchema -KeyName "ForumName" -KeyDataType "S"
$schema | Add-DDBKeySchema -KeyName "Subject" -KeyDataType "S"
$schema | Add-DDBIndexSchema -IndexName "LastPostIndex" -RangeKeyName "LastPostDateTime" -RangeKeyDataType "S" -ProjectionType "keys_only"
$schema | New-DDBTable -TableName "Thread" -ReadCapacity 10 -WriteCapacity 5
```
**Sortie** :
```
AttributeDefinitions : {ForumName, LastPostDateTime, Subject}
TableName : Thread
KeySchema : {ForumName, Subject}
TableStatus : CREATING
CreationDateTime : 10/28/2013 4:39:49 PM
ProvisionedThroughput : Amazon.DynamoDBv2.Model.ProvisionedThroughputDescription
TableSizeBytes : 0
ItemCount : 0
LocalSecondaryIndexes : {LastPostIndex}
```
**Exemple 3 : Cet exemple montre comment utiliser un pipeline unique pour créer une table nommée Thread qui possède une clé primaire composée de « ForumName » (hachage de type de clé) et de « Subject » (plage de types de clés) et un index secondaire local. Les options Add- DDBKey Schema et Add- DDBIndex Schema créent un nouvel TableSchema objet pour vous si aucun objet n'est fourni par le pipeline ou le paramètre -Schema.**
```
New-DDBTableSchema |
Add-DDBKeySchema -KeyName "ForumName" -KeyDataType "S" |
Add-DDBKeySchema -KeyName "Subject" -KeyDataType "S" |
Add-DDBIndexSchema -IndexName "LastPostIndex" `
-RangeKeyName "LastPostDateTime" `
-RangeKeyDataType "S" `
-ProjectionType "keys_only" |
New-DDBTable -TableName "Thread" -ReadCapacity 10 -WriteCapacity 5
```
**Sortie** :
```
AttributeDefinitions : {ForumName, LastPostDateTime, Subject}
TableName : Thread
KeySchema : {ForumName, Subject}
TableStatus : CREATING
CreationDateTime : 10/28/2013 4:39:49 PM
ProvisionedThroughput : Amazon.DynamoDBv2.Model.ProvisionedThroughputDescription
TableSizeBytes : 0
ItemCount : 0
LocalSecondaryIndexes : {LastPostIndex}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/powershell/v5/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/dynamodb#code-examples).
Créez une table pour stocker des données vidéo.
```
class Movies:
"""Encapsulates an Amazon DynamoDB table of movie data.
Example data structure for a movie record in this table:
{
"year": 1999,
"title": "For Love of the Game",
"info": {
"directors": ["Sam Raimi"],
"release_date": "1999-09-15T00:00:00Z",
"rating": 6.3,
"plot": "A washed up pitcher flashes through his career.",
"rank": 4987,
"running_time_secs": 8220,
"actors": [
"Kevin Costner",
"Kelly Preston",
"John C. Reilly"
]
}
}
"""
def __init__(self, dyn_resource):
"""
:param dyn_resource: A Boto3 DynamoDB resource.
"""
self.dyn_resource = dyn_resource
# The table variable is set during the scenario in the call to
# 'exists' if the table exists. Otherwise, it is set by 'create_table'.
self.table = None
def create_table(self, table_name):
"""
Creates an Amazon DynamoDB table that can be used to store movie data.
The table uses the release year of the movie as the partition key and the
title as the sort key.
:param table_name: The name of the table to create.
:return: The newly created table.
"""
try:
self.table = self.dyn_resource.create_table(
TableName=table_name,
KeySchema=[
{"AttributeName": "year", "KeyType": "HASH"}, # Partition key
{"AttributeName": "title", "KeyType": "RANGE"}, # Sort key
],
AttributeDefinitions=[
{"AttributeName": "year", "AttributeType": "N"},
{"AttributeName": "title", "AttributeType": "S"},
],
BillingMode='PAY_PER_REQUEST',
)
self.table.wait_until_exists()
except ClientError as err:
logger.error(
"Couldn't create table %s. Here's why: %s: %s",
table_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return self.table
```
+ Pour plus de détails sur l'API, consultez [CreateTable](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/CreateTable)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/dynamodb#code-examples).
```
# Encapsulates an Amazon DynamoDB table of movie data.
class Scaffold
attr_reader :dynamo_resource, :table_name, :table
def initialize(table_name)
client = Aws::DynamoDB::Client.new(region: 'us-east-1')
@dynamo_resource = Aws::DynamoDB::Resource.new(client: client)
@table_name = table_name
@table = nil
@logger = Logger.new($stdout)
@logger.level = Logger::DEBUG
end
# Creates an Amazon DynamoDB table that can be used to store movie data.
# The table uses the release year of the movie as the partition key and the
# title as the sort key.
#
# @param table_name [String] The name of the table to create.
# @return [Aws::DynamoDB::Table] The newly created table.
def create_table(table_name)
@table = @dynamo_resource.create_table(
table_name: table_name,
key_schema: [
{ attribute_name: 'year', key_type: 'HASH' }, # Partition key
{ attribute_name: 'title', key_type: 'RANGE' } # Sort key
],
attribute_definitions: [
{ attribute_name: 'year', attribute_type: 'N' },
{ attribute_name: 'title', attribute_type: 'S' }
],
billing_mode: 'PAY_PER_REQUEST'
)
@dynamo_resource.client.wait_until(:table_exists, table_name: table_name)
@table
rescue Aws::DynamoDB::Errors::ServiceError => e
@logger.error("Failed create table #{table_name}:\n#{e.code}: #{e.message}")
raise
end
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/CreateTable)à la section *Référence des AWS SDK pour Ruby API*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn create_table(
client: &Client,
table: &str,
key: &str,
) -> Result {
let a_name: String = key.into();
let table_name: String = table.into();
let ad = AttributeDefinition::builder()
.attribute_name(&a_name)
.attribute_type(ScalarAttributeType::S)
.build()
.map_err(Error::BuildError)?;
let ks = KeySchemaElement::builder()
.attribute_name(&a_name)
.key_type(KeyType::Hash)
.build()
.map_err(Error::BuildError)?;
let create_table_response = client
.create_table()
.table_name(table_name)
.key_schema(ks)
.attribute_definitions(ad)
.billing_mode(BillingMode::PayPerRequest)
.send()
.await;
match create_table_response {
Ok(out) => {
println!("Added table {} with key {}", table, key);
Ok(out)
}
Err(e) => {
eprintln!("Got an error creating table:");
eprintln!("{}", e);
Err(Error::unhandled(e))
}
}
}
```
+ Pour plus de détails sur l'API, voir [CreateTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.create_table)la section de *référence de l'API AWS SDK for Rust*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/dyn#code-examples).
```
TRY.
DATA(lt_keyschema) = VALUE /aws1/cl_dynkeyschemaelement=>tt_keyschema(
( NEW /aws1/cl_dynkeyschemaelement( iv_attributename = 'year'
iv_keytype = 'HASH' ) )
( NEW /aws1/cl_dynkeyschemaelement( iv_attributename = 'title'
iv_keytype = 'RANGE' ) ) ).
DATA(lt_attributedefinitions) = VALUE /aws1/cl_dynattributedefn=>tt_attributedefinitions(
( NEW /aws1/cl_dynattributedefn( iv_attributename = 'year'
iv_attributetype = 'N' ) )
( NEW /aws1/cl_dynattributedefn( iv_attributename = 'title'
iv_attributetype = 'S' ) ) ).
" Adjust read/write capacities as desired.
DATA(lo_dynprovthroughput) = NEW /aws1/cl_dynprovthroughput(
iv_readcapacityunits = 5
iv_writecapacityunits = 5 ).
oo_result = lo_dyn->createtable(
it_keyschema = lt_keyschema
iv_tablename = iv_table_name
it_attributedefinitions = lt_attributedefinitions
io_provisionedthroughput = lo_dynprovthroughput ).
" Table creation can take some time. Wait till table exists before returning.
lo_dyn->get_waiter( )->tableexists(
iv_max_wait_time = 200
iv_tablename = iv_table_name ).
MESSAGE 'DynamoDB Table' && iv_table_name && 'created.' TYPE 'I'.
" This exception can happen if the table already exists.
CATCH /aws1/cx_dynresourceinuseex INTO DATA(lo_resourceinuseex).
DATA(lv_error) = |"{ lo_resourceinuseex->av_err_code }" - { lo_resourceinuseex->av_err_msg }|.
MESSAGE lv_error TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez [CreateTable](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/dynamodb#code-examples).
```
import AWSDynamoDB
///
/// Create a movie table in the Amazon DynamoDB data store.
///
private func createTable() async throws {
do {
guard let client = self.ddbClient else {
throw MoviesError.UninitializedClient
}
let input = CreateTableInput(
attributeDefinitions: [
DynamoDBClientTypes.AttributeDefinition(attributeName: "year", attributeType: .n),
DynamoDBClientTypes.AttributeDefinition(attributeName: "title", attributeType: .s)
],
billingMode: DynamoDBClientTypes.BillingMode.payPerRequest,
keySchema: [
DynamoDBClientTypes.KeySchemaElement(attributeName: "year", keyType: .hash),
DynamoDBClientTypes.KeySchemaElement(attributeName: "title", keyType: .range)
],
tableName: self.tableName
)
let output = try await client.createTable(input: input)
if output.tableDescription == nil {
throw MoviesError.TableNotFound
}
} catch {
print("ERROR: createTable:", dump(error))
throw error
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTable](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/createtable(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
Pour obtenir plus d’exemples avec DynamoDB, consultez [Exemples de code pour DynamoDB utilisant AWS SDKs](service_code_examples.md).
Une fois la nouvelle table créée, passez à l’ [Étape 2 : écrire des données dans une table DynamoDB](getting-started-step-2.md).
# Étape 2 : écrire des données dans une table DynamoDB
Dans cette étape, vous insérez plusieurs éléments dans la table `Music` que vous avez créée dans [Étape 1 : création d’une table dans DynamoDB](getting-started-step-1.md).
Pour plus d’informations sur les opérations d’écriture, consultez [Écriture d’un élément](WorkingWithItems.md#WorkingWithItems.WritingData).
## AWS Management Console
Suivez ces étapes pour écrire des données sur la table `Music` à l’aide de la console DynamoDB.
1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dans le volet de navigation de gauche, choisissez **Tables**.
1. Sur la page **Tables**, sélectionnez la table **Musique**.
1. Sélectionnez **Explorer les éléments de table**.
1. Dans la section **Éléments retournés**, choisissez **Créer un article**.
1. Sur la page **Créer un article**, procédez comme suit pour ajouter des éléments à la table :
1. Choisissez **Ajouter un nouvel attribut**, puis choisissez **Numéro**.
1. Dans Nom de l’attribut, entrez **Awards**.
1. Répétez cette procédure pour créer un **AlbumTitle** de type **Chaîne**.
1. Saisissez les valeurs suivantes pour votre élément :
1. Pour **Artist (Artiste)**, saisissez **No One You Know**.
1. Pour **SongTitle**, saisissez **Call Me Today**.
1. Pour **AlbumTitle**, saisissez **Somewhat Famous**.
1. Pour **Awards (Récompenses)**, saisissez **1**.
1. Choisissez **Créer un élément**.
1. Répétez cette procédure et créez un autre élément avec les valeurs suivantes :
1. Pour **Artist (Artiste)**, saisissez **Acme Band**.
1. Pour **SongTitle**entrer**Happy Day**.
1. Pour **AlbumTitle**, saisissez **Songs About Life**.
1. Pour **Awards (Récompenses)**, saisissez **10**.
1. Effectuez cette opération de nouveau pour créer un autre élément avec le même **Artist** (Artiste) qu’à l’étape précédente, mais avec des valeurs différentes pour les autres attributs :
1. Pour **Artist (Artiste)**, saisissez **Acme Band**.
1. Pour **SongTitle**entrer**PartiQL Rocks**.
1. Pour **AlbumTitle**, saisissez **Another Album Title**.
1. Pour **Awards (Récompenses)**, saisissez **8**.
## AWS CLI
L' AWS CLI exemple suivant crée plusieurs nouveaux éléments dans le `Music` tableau. Vous pouvez procéder via l’API DynamoDB ou [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL pour DynamoDB.
------
#### [ DynamoDB API ]
**Linux**
```
aws dynamodb put-item \
--table-name Music \
--item \
'{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Call Me Today"}, "AlbumTitle": {"S": "Somewhat Famous"}, "Awards": {"N": "1"}}'
aws dynamodb put-item \
--table-name Music \
--item \
'{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Howdy"}, "AlbumTitle": {"S": "Somewhat Famous"}, "Awards": {"N": "2"}}'
aws dynamodb put-item \
--table-name Music \
--item \
'{"Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}, "AlbumTitle": {"S": "Songs About Life"}, "Awards": {"N": "10"}}'
aws dynamodb put-item \
--table-name Music \
--item \
'{"Artist": {"S": "Acme Band"}, "SongTitle": {"S": "PartiQL Rocks"}, "AlbumTitle": {"S": "Another Album Title"}, "Awards": {"N": "8"}}'
```
**Windows CMD**
```
aws dynamodb put-item ^
--table-name Music ^
--item ^
"{\"Artist\": {\"S\": \"No One You Know\"}, \"SongTitle\": {\"S\": \"Call Me Today\"}, \"AlbumTitle\": {\"S\": \"Somewhat Famous\"}, \"Awards\": {\"N\": \"1\"}}"
aws dynamodb put-item ^
--table-name Music ^
--item ^
"{\"Artist\": {\"S\": \"No One You Know\"}, \"SongTitle\": {\"S\": \"Howdy\"}, \"AlbumTitle\": {\"S\": \"Somewhat Famous\"}, \"Awards\": {\"N\": \"2\"}}"
aws dynamodb put-item ^
--table-name Music ^
--item ^
"{\"Artist\": {\"S\": \"Acme Band\"}, \"SongTitle\": {\"S\": \"Happy Day\"}, \"AlbumTitle\": {\"S\": \"Songs About Life\"}, \"Awards\": {\"N\": \"10\"}}"
aws dynamodb put-item ^
--table-name Music ^
--item ^
"{\"Artist\": {\"S\": \"Acme Band\"}, \"SongTitle\": {\"S\": \"PartiQL Rocks\"}, \"AlbumTitle\": {\"S\": \"Another Album Title\"}, \"Awards\": {\"N\": \"8\"}}"
```
------
#### [ PartiQL for DynamoDB ]
**Linux**
```
aws dynamodb execute-statement --statement "INSERT INTO Music \
VALUE \
{'Artist':'No One You Know','SongTitle':'Call Me Today', 'AlbumTitle':'Somewhat Famous', 'Awards':'1'}"
aws dynamodb execute-statement --statement "INSERT INTO Music \
VALUE \
{'Artist':'No One You Know','SongTitle':'Howdy', 'AlbumTitle':'Somewhat Famous', 'Awards':'2'}"
aws dynamodb execute-statement --statement "INSERT INTO Music \
VALUE \
{'Artist':'Acme Band','SongTitle':'Happy Day', 'AlbumTitle':'Songs About Life', 'Awards':'10'}"
aws dynamodb execute-statement --statement "INSERT INTO Music \
VALUE \
{'Artist':'Acme Band','SongTitle':'PartiQL Rocks', 'AlbumTitle':'Another Album Title', 'Awards':'8'}"
```
**Windows CMD**
```
aws dynamodb execute-statement --statement "INSERT INTO Music VALUE {'Artist':'No One You Know','SongTitle':'Call Me Today', 'AlbumTitle':'Somewhat Famous', 'Awards':'1'}"
aws dynamodb execute-statement --statement "INSERT INTO Music VALUE {'Artist':'No One You Know','SongTitle':'Howdy', 'AlbumTitle':'Somewhat Famous', 'Awards':'2'}"
aws dynamodb execute-statement --statement "INSERT INTO Music VALUE {'Artist':'Acme Band','SongTitle':'Happy Day', 'AlbumTitle':'Songs About Life', 'Awards':'10'}"
aws dynamodb execute-statement --statement "INSERT INTO Music VALUE {'Artist':'Acme Band','SongTitle':'PartiQL Rocks', 'AlbumTitle':'Another Album Title', 'Awards':'8'}"
```
Pour plus d’informations sur l’écriture de données avec PartiQL, veuillez consulter [Instructions d’insertion de PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.insert.html).
------
Pour plus d’informations sur les types de données pris en charge dans DynamoDB, consultez [Types de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes).
Pour plus d’informations sur la façon de représenter les types de données DynamoDB dans JSON, consultez [Valeurs d’attributs](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_AttributeValue.html).
## AWS SDK
Les exemples de code suivants montrent comment écrire un élément dans une table DynamoDB à l'aide d'un SDK. AWS
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/DynamoDB#code-examples).
```
///
/// Adds a new item to the table.
///
/// A Movie object containing informtation for
/// the movie to add to the table.
/// The name of the table where the item will be added.
/// A Boolean value that indicates the results of adding the item.
public async Task PutItemAsync(Movie newMovie, string tableName)
{
try
{
var item = new Dictionary
{
["title"] = new AttributeValue { S = newMovie.Title },
["year"] = new AttributeValue { N = newMovie.Year.ToString() },
};
var request = new PutItemRequest
{
TableName = tableName,
Item = item,
};
await _amazonDynamoDB.PutItemAsync(request);
return true;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine($"Table {tableName} was not found. {ex.Message}");
return false;
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine($"An Amazon DynamoDB error occurred while putting item. {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred while putting item. {ex.Message}");
throw;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/PutItem)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/dynamodb#code-examples).
```
##############################################################################
# function dynamodb_put_item
#
# This function puts an item into a DynamoDB table.
#
# Parameters:
# -n table_name -- The name of the table.
# -i item -- Path to json file containing the item values.
#
# Returns:
# 0 - If successful.
# 1 - If it fails.
##############################################################################
function dynamodb_put_item() {
local table_name item response
local option OPTARG # Required to use getopts command in a function.
#######################################
# Function usage explanation
#######################################
function usage() {
echo "function dynamodb_put_item"
echo "Put an item into a DynamoDB table."
echo " -n table_name -- The name of the table."
echo " -i item -- Path to json file containing the item values."
echo ""
}
while getopts "n:i:h" option; do
case "${option}" in
n) table_name="${OPTARG}" ;;
i) item="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$table_name" ]]; then
errecho "ERROR: You must provide a table name with the -n parameter."
usage
return 1
fi
if [[ -z "$item" ]]; then
errecho "ERROR: You must provide an item with the -i parameter."
usage
return 1
fi
iecho "Parameters:\n"
iecho " table_name: $table_name"
iecho " item: $item"
iecho ""
iecho ""
response=$(aws dynamodb put-item \
--table-name "$table_name" \
--item file://"$item")
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports put-item operation failed.$response"
return 1
fi
return 0
}
```
Fonctions utilitaires utilisées dans cet exemple.
```
###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
if [[ $VERBOSE == true ]]; then
echo "$@"
fi
}
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
##############################################################################
# function aws_cli_error_log()
#
# This function is used to log the error messages from the AWS CLI.
#
# See https://docs.aws.amazon.com/cli/latest/topic/return-codes.html#cli-aws-help-return-codes.
#
# The function expects the following argument:
# $1 - The error code returned by the AWS CLI.
#
# Returns:
# 0: - Success.
#
##############################################################################
function aws_cli_error_log() {
local err_code=$1
errecho "Error code : $err_code"
if [ "$err_code" == 1 ]; then
errecho " One or more S3 transfers failed."
elif [ "$err_code" == 2 ]; then
errecho " Command line failed to parse."
elif [ "$err_code" == 130 ]; then
errecho " Process received SIGINT."
elif [ "$err_code" == 252 ]; then
errecho " Command syntax invalid."
elif [ "$err_code" == 253 ]; then
errecho " The system environment or configuration was invalid."
elif [ "$err_code" == 254 ]; then
errecho " The service returned an error."
elif [ "$err_code" == 255 ]; then
errecho " 255 is a catch-all error."
fi
return 0
}
```
+ Pour plus de détails sur l'API, voir [PutItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem)la section *Référence des AWS CLI commandes*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
//! Put an item in an Amazon DynamoDB table.
/*!
\sa putItem()
\param tableName: The table name.
\param artistKey: The artist key. This is the partition key for the table.
\param artistValue: The artist value.
\param albumTitleKey: The album title key.
\param albumTitleValue: The album title value.
\param awardsKey: The awards key.
\param awardsValue: The awards value.
\param songTitleKey: The song title key.
\param songTitleValue: The song title value.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::putItem(const Aws::String &tableName,
const Aws::String &artistKey,
const Aws::String &artistValue,
const Aws::String &albumTitleKey,
const Aws::String &albumTitleValue,
const Aws::String &awardsKey,
const Aws::String &awardsValue,
const Aws::String &songTitleKey,
const Aws::String &songTitleValue,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
Aws::DynamoDB::Model::PutItemRequest putItemRequest;
putItemRequest.SetTableName(tableName);
putItemRequest.AddItem(artistKey, Aws::DynamoDB::Model::AttributeValue().SetS(
artistValue)); // This is the hash key.
putItemRequest.AddItem(albumTitleKey, Aws::DynamoDB::Model::AttributeValue().SetS(
albumTitleValue));
putItemRequest.AddItem(awardsKey,
Aws::DynamoDB::Model::AttributeValue().SetS(awardsValue));
putItemRequest.AddItem(songTitleKey,
Aws::DynamoDB::Model::AttributeValue().SetS(songTitleValue));
const Aws::DynamoDB::Model::PutItemOutcome outcome = dynamoClient.PutItem(
putItemRequest);
if (outcome.IsSuccess()) {
std::cout << "Successfully added Item!" << std::endl;
}
else {
std::cerr << outcome.GetError().GetMessage() << std::endl;
return false;
}
return waitTableActive(tableName, dynamoClient);
}
```
Code qui attend que la table soit active.
```
//! Query a newly created DynamoDB table until it is active.
/*!
\sa waitTableActive()
\param waitTableActive: The DynamoDB table's name.
\param dynamoClient: A DynamoDB client.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::waitTableActive(const Aws::String &tableName,
const Aws::DynamoDB::DynamoDBClient &dynamoClient) {
// Repeatedly call DescribeTable until table is ACTIVE.
const int MAX_QUERIES = 20;
Aws::DynamoDB::Model::DescribeTableRequest request;
request.SetTableName(tableName);
int count = 0;
while (count < MAX_QUERIES) {
const Aws::DynamoDB::Model::DescribeTableOutcome &result = dynamoClient.DescribeTable(
request);
if (result.IsSuccess()) {
Aws::DynamoDB::Model::TableStatus status = result.GetResult().GetTable().GetTableStatus();
if (Aws::DynamoDB::Model::TableStatus::ACTIVE != status) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
else {
return true;
}
}
else {
std::cerr << "Error DynamoDB::waitTableActive "
<< result.GetError().GetMessage() << std::endl;
return false;
}
count++;
}
return false;
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour ajouter un élément à une table**
L'`put-item`exemple suivant ajoute un nouvel élément au *MusicCollection*tableau.
```
aws dynamodb put-item \
--table-name MusicCollection \
--item file://item.json \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Contenu de `item.json` :
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Greatest Hits"}
}
```
Sortie :
```
{
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
},
"ItemCollectionMetrics": {
"ItemCollectionKey": {
"Artist": {
"S": "No One You Know"
}
},
"SizeEstimateRangeGB": [
0.0,
1.0
]
}
}
```
Pour plus d’informations, consultez [Écriture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 2 : pour remplacer un élément d’une table sous certaines conditions**
L’exemple `put-item` suivant remplace un élément existant dans la table `MusicCollection` uniquement si celui-ci possède un attribut `AlbumTitle` dont la valeur est `Greatest Hits`. La commande renvoie la valeur précédente de l’élément.
```
aws dynamodb put-item \
--table-name MusicCollection \
--item file://item.json \
--condition-expression "#A = :A" \
--expression-attribute-names file://names.json \
--expression-attribute-values file://values.json \
--return-values ALL_OLD
```
Contenu de `item.json` :
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}
}
```
Contenu de `names.json` :
```
{
"#A": "AlbumTitle"
}
```
Contenu de `values.json` :
```
{
":A": {"S": "Greatest Hits"}
}
```
Sortie :
```
{
"Attributes": {
"AlbumTitle": {
"S": "Greatest Hits"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Call Me Today"
}
}
}
```
Si la clé existe déjà, vous devriez voir la sortie suivante :
```
A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.
```
Pour plus d’informations, consultez [Écriture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) dans le *Guide du développeur Amazon DynamoDB*.
+ Pour plus de détails sur l'API, voir [PutItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/put-item.html)la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// TableBasics encapsulates the Amazon DynamoDB service actions used in the examples.
// It contains a DynamoDB service client that is used to act on the specified table.
type TableBasics struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// AddMovie adds a movie the DynamoDB table.
func (basics TableBasics) AddMovie(ctx context.Context, movie Movie) error {
item, err := attributevalue.MarshalMap(movie)
if err != nil {
panic(err)
}
_, err = basics.DynamoDbClient.PutItem(ctx, &dynamodb.PutItemInput{
TableName: aws.String(basics.TableName), Item: item,
})
if err != nil {
log.Printf("Couldn't add item to table. Here's why: %v\n", err)
}
return err
}
```
Définissez une structure Movie utilisée dans cet exemple.
```
import (
"archive/zip"
"bytes"
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// Movie encapsulates data about a movie. Title and Year are the composite primary key
// of the movie in Amazon DynamoDB. Title is the sort key, Year is the partition key,
// and Info is additional data.
type Movie struct {
Title string `dynamodbav:"title"`
Year int `dynamodbav:"year"`
Info map[string]interface{} `dynamodbav:"info"`
}
// GetKey returns the composite primary key of the movie in a format that can be
// sent to DynamoDB.
func (movie Movie) GetKey() map[string]types.AttributeValue {
title, err := attributevalue.Marshal(movie.Title)
if err != nil {
panic(err)
}
year, err := attributevalue.Marshal(movie.Year)
if err != nil {
panic(err)
}
return map[string]types.AttributeValue{"title": title, "year": year}
}
// String returns the title, year, rating, and plot of a movie, formatted for the example.
func (movie Movie) String() string {
return fmt.Sprintf("%v\n\tReleased: %v\n\tRating: %v\n\tPlot: %v\n",
movie.Title, movie.Year, movie.Info["rating"], movie.Info["plot"])
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.PutItem)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
Met un élément dans un tableau en utilisant [DynamoDbClient](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/dynamodb/DynamoDbClient.html).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To place items into an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client. See the EnhancedPutItem example.
*/
public class PutItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table in which an item is placed (for example, Music3).
key - The key used in the Amazon DynamoDB table (for example, Artist).
keyval - The key value that represents the item to get (for example, Famous Band).
albumTitle - The Album title (for example, AlbumTitle).
AlbumTitleValue - The name of the album (for example, Songs About Life ).
Awards - The awards column (for example, Awards).
AwardVal - The value of the awards (for example, 10).
SongTitle - The song title (for example, SongTitle).
SongTitleVal - The value of the song title (for example, Happy Day).
**Warning** This program will place an item that you specify into a table!
""";
if (args.length != 9) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
String albumTitle = args[3];
String albumTitleValue = args[4];
String awards = args[5];
String awardVal = args[6];
String songTitle = args[7];
String songTitleVal = args[8];
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
putItemInTable(ddb, tableName, key, keyVal, albumTitle, albumTitleValue, awards, awardVal, songTitle,
songTitleVal);
System.out.println("Done!");
ddb.close();
}
public static void putItemInTable(DynamoDbClient ddb,
String tableName,
String key,
String keyVal,
String albumTitle,
String albumTitleValue,
String awards,
String awardVal,
String songTitle,
String songTitleVal) {
HashMap itemValues = new HashMap<>();
itemValues.put(key, AttributeValue.builder().s(keyVal).build());
itemValues.put(songTitle, AttributeValue.builder().s(songTitleVal).build());
itemValues.put(albumTitle, AttributeValue.builder().s(albumTitleValue).build());
itemValues.put(awards, AttributeValue.builder().s(awardVal).build());
PutItemRequest request = PutItemRequest.builder()
.tableName(tableName)
.item(itemValues)
.build();
try {
PutItemResponse response = ddb.putItem(request);
System.out.println(tableName + " was successfully updated. The request id is "
+ response.responseMetadata().requestId());
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples).
Cet exemple utilise le client de document pour simplifier l’utilisation d’éléments dans DynamoDB. Pour plus de détails sur l'API, voir [PutCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-lib-dynamodb/Class/PutCommand/).
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { PutCommand, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
export const main = async () => {
const command = new PutCommand({
TableName: "HappyAnimals",
Item: {
CommonName: "Shiba Inu",
},
});
const response = await docClient.send(command);
console.log(response);
return response;
};
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/PutItemCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/dynamodb#code-examples).
Insérez un élément dans la table.
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the DynamoDB service object
var ddb = new AWS.DynamoDB({ apiVersion: "2012-08-10" });
var params = {
TableName: "CUSTOMER_LIST",
Item: {
CUSTOMER_ID: { N: "001" },
CUSTOMER_NAME: { S: "Richard Roe" },
},
};
// Call DynamoDB to add the item to the table
ddb.putItem(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data);
}
});
```
Insérez un élément dans une table à l’aide du client de document DynamoDB.
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create DynamoDB document client
var docClient = new AWS.DynamoDB.DocumentClient({ apiVersion: "2012-08-10" });
var params = {
TableName: "TABLE",
Item: {
HASHKEY: VALUE,
ATTRIBUTE_1: "STRING_VALUE",
ATTRIBUTE_2: VALUE_2,
},
};
docClient.put(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-example-table-read-write.html#dynamodb-example-table-read-write-writing-an-item).
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/dynamodb#code-examples).
```
suspend fun putItemInTable(
tableNameVal: String,
key: String,
keyVal: String,
albumTitle: String,
albumTitleValue: String,
awards: String,
awardVal: String,
songTitle: String,
songTitleVal: String,
) {
val itemValues = mutableMapOf()
// Add all content to the table.
itemValues[key] = AttributeValue.S(keyVal)
itemValues[songTitle] = AttributeValue.S(songTitleVal)
itemValues[albumTitle] = AttributeValue.S(albumTitleValue)
itemValues[awards] = AttributeValue.S(awardVal)
val request =
PutItemRequest {
tableName = tableNameVal
item = itemValues
}
DynamoDbClient.fromEnvironment { region = "us-east-1" }.use { ddb ->
ddb.putItem(request)
println(" A new item was placed into $tableNameVal.")
}
}
```
+ Pour plus de détails sur l'API, consultez [PutItem](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
```
echo "What's the name of the last movie you watched?\n";
while (empty($movieName)) {
$movieName = testable_readline("Movie name: ");
}
echo "And what year was it released?\n";
$movieYear = "year";
while (!is_numeric($movieYear) || intval($movieYear) != $movieYear) {
$movieYear = testable_readline("Year released: ");
}
$service->putItem([
'Item' => [
'year' => [
'N' => "$movieYear",
],
'title' => [
'S' => $movieName,
],
],
'TableName' => $tableName,
]);
public function putItem(array $array)
{
$this->dynamoDbClient->putItem($array);
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : création d’un nouvel élément ou remplacement d’un élément existant par un nouvel élément.**
```
$item = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
AlbumTitle = 'Somewhat Famous'
Price = 1.94
Genre = 'Country'
CriticRating = 9.0
} | ConvertTo-DDBItem
Set-DDBItem -TableName 'Music' -Item $item
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/powershell/v4/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : création d’un nouvel élément ou remplacement d’un élément existant par un nouvel élément.**
```
$item = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
AlbumTitle = 'Somewhat Famous'
Price = 1.94
Genre = 'Country'
CriticRating = 9.0
} | ConvertTo-DDBItem
Set-DDBItem -TableName 'Music' -Item $item
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/powershell/v5/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/dynamodb#code-examples).
```
class Movies:
"""Encapsulates an Amazon DynamoDB table of movie data.
Example data structure for a movie record in this table:
{
"year": 1999,
"title": "For Love of the Game",
"info": {
"directors": ["Sam Raimi"],
"release_date": "1999-09-15T00:00:00Z",
"rating": 6.3,
"plot": "A washed up pitcher flashes through his career.",
"rank": 4987,
"running_time_secs": 8220,
"actors": [
"Kevin Costner",
"Kelly Preston",
"John C. Reilly"
]
}
}
"""
def __init__(self, dyn_resource):
"""
:param dyn_resource: A Boto3 DynamoDB resource.
"""
self.dyn_resource = dyn_resource
# The table variable is set during the scenario in the call to
# 'exists' if the table exists. Otherwise, it is set by 'create_table'.
self.table = None
def add_movie(self, title, year, plot, rating):
"""
Adds a movie to the table.
:param title: The title of the movie.
:param year: The release year of the movie.
:param plot: The plot summary of the movie.
:param rating: The quality rating of the movie.
"""
try:
self.table.put_item(
Item={
"year": year,
"title": title,
"info": {"plot": plot, "rating": Decimal(str(rating))},
}
)
except ClientError as err:
logger.error(
"Couldn't add movie %s to table %s. Here's why: %s: %s",
title,
self.table.name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Pour plus de détails sur l'API, consultez [PutItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/dynamodb#code-examples).
```
class DynamoDBBasics
attr_reader :dynamo_resource, :table
def initialize(table_name)
client = Aws::DynamoDB::Client.new(region: 'us-east-1')
@dynamo_resource = Aws::DynamoDB::Resource.new(client: client)
@table = @dynamo_resource.table(table_name)
end
# Adds a movie to the table.
#
# @param movie [Hash] The title, year, plot, and rating of the movie.
def add_item(movie)
@table.put_item(
item: {
'year' => movie[:year],
'title' => movie[:title],
'info' => { 'plot' => movie[:plot], 'rating' => movie[:rating] }
}
)
rescue Aws::DynamoDB::Errors::ServiceError => e
puts("Couldn't add movie #{title} to table #{@table.name}. Here's why:")
puts("\t#{e.code}: #{e.message}")
raise
end
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/PutItem)à la section *Référence des AWS SDK pour Ruby API*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn add_item(client: &Client, item: Item, table: &String) -> Result {
let user_av = AttributeValue::S(item.username);
let type_av = AttributeValue::S(item.p_type);
let age_av = AttributeValue::S(item.age);
let first_av = AttributeValue::S(item.first);
let last_av = AttributeValue::S(item.last);
let request = client
.put_item()
.table_name(table)
.item("username", user_av)
.item("account_type", type_av)
.item("age", age_av)
.item("first_name", first_av)
.item("last_name", last_av);
println!("Executing request [{request:?}] to add item...");
let resp = request.send().await?;
let attributes = resp.attributes().unwrap();
let username = attributes.get("username").cloned();
let first_name = attributes.get("first_name").cloned();
let last_name = attributes.get("last_name").cloned();
let age = attributes.get("age").cloned();
let p_type = attributes.get("p_type").cloned();
println!(
"Added user {:?}, {:?} {:?}, age {:?} as {:?} user",
username, first_name, last_name, age, p_type
);
Ok(ItemOut {
p_type,
age,
username,
first_name,
last_name,
})
}
```
+ Pour plus de détails sur l'API, voir [PutItem](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.put_item)la section de *référence de l'API AWS SDK for Rust*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/dyn#code-examples).
```
TRY.
DATA(lo_resp) = lo_dyn->putitem(
iv_tablename = iv_table_name
it_item = it_item ).
MESSAGE '1 row inserted into DynamoDB Table' && iv_table_name TYPE 'I'.
CATCH /aws1/cx_dyncondalcheckfaile00.
MESSAGE 'A condition specified in the operation could not be evaluated.' TYPE 'E'.
CATCH /aws1/cx_dynresourcenotfoundex.
MESSAGE 'The table or index does not exist' TYPE 'E'.
CATCH /aws1/cx_dyntransactconflictex.
MESSAGE 'Another transaction is using the item' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez [PutItem](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/dynamodb#code-examples).
```
import AWSDynamoDB
/// Add a movie specified as a `Movie` structure to the Amazon DynamoDB
/// table.
///
/// - Parameter movie: The `Movie` to add to the table.
///
func add(movie: Movie) async throws {
do {
guard let client = self.ddbClient else {
throw MoviesError.UninitializedClient
}
// Get a DynamoDB item containing the movie data.
let item = try await movie.getAsItem()
// Send the `PutItem` request to Amazon DynamoDB.
let input = PutItemInput(
item: item,
tableName: self.tableName
)
_ = try await client.putItem(input: input)
} catch {
print("ERROR: add movie:", dump(error))
throw error
}
}
///
/// Return an array mapping attribute names to Amazon DynamoDB attribute
/// values, representing the contents of the `Movie` record as a DynamoDB
/// item.
///
/// - Returns: The movie item as an array of type
/// `[Swift.String:DynamoDBClientTypes.AttributeValue]`.
///
func getAsItem() async throws -> [Swift.String:DynamoDBClientTypes.AttributeValue] {
// Build the item record, starting with the year and title, which are
// always present.
var item: [Swift.String:DynamoDBClientTypes.AttributeValue] = [
"year": .n(String(self.year)),
"title": .s(self.title)
]
// Add the `info` field with the rating and/or plot if they're
// available.
var details: [Swift.String:DynamoDBClientTypes.AttributeValue] = [:]
if (self.info.rating != nil || self.info.plot != nil) {
if self.info.rating != nil {
details["rating"] = .n(String(self.info.rating!))
}
if self.info.plot != nil {
details["plot"] = .s(self.info.plot!)
}
}
item["info"] = .m(details)
return item
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutItem](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/putitem(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
Pour obtenir plus d’exemples avec DynamoDB, consultez [Exemples de code pour DynamoDB utilisant AWS SDKs](service_code_examples.md).
Après avoir écrit des données dans votre table, passez à l’ [Étape 3 : lire des données à partir d’une table DynamoDB](getting-started-step-3.md).
# Étape 3 : lire des données à partir d’une table DynamoDB
Dans cette étape, vous relirez l’un des éléments que vous avez créé dans [Étape 2 : écrire des données dans une table DynamoDB](getting-started-step-2.md). Vous pouvez utiliser la console DynamoDB ou AWS CLI le pour lire un élément du `Music` tableau en spécifiant et. `Artist` `SongTitle`
Pour plus d’informations sur les opérations de lecture dans DynamoDB, consultez [Lecture d’un élément](WorkingWithItems.md#WorkingWithItems.ReadingData).
## AWS Management Console
Suivez ces étapes pour lire des données de la table `Music` à l’aide de la console DynamoDB.
1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dans le volet de navigation de gauche, choisissez **Tables**.
1. Sur la page **Tables**, sélectionnez la table **Musique**.
1. Sélectionnez **Explorer les éléments de table**.
1. Dans la section **Éléments retournés**, affichez la liste d’éléments stockés dans la table, triés par `Artist` et `SongTitle`. Le premier élément de la liste est celui avec l'**artiste** **Acme Band** et les **SongTitle****PartiQL Rocks**.
## AWS CLI
L' AWS CLI exemple suivant lit un élément à partir du`Music`. Vous pouvez procéder via l’API DynamoDB ou [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL pour DynamoDB.
------
#### [ DynamoDB API ]
**Note**
Le comportement par défaut pour DynamoDB est la lecture éventuellement cohérente. Le paramètre `consistent-read` est utilisé ci-dessous pour illustrer des lectures cohérentes fortes.
**Linux**
```
aws dynamodb get-item --consistent-read \
--table-name Music \
--key '{ "Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}}'
```
**Windows CMD**
```
aws dynamodb get-item --consistent-read ^
--table-name Music ^
--key "{\"Artist\": {\"S\": \"Acme Band\"}, \"SongTitle\": {\"S\": \"Happy Day\"}}"
```
L’utilisation de `get-item` renvoie l’exemple de résultat suivant.
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
}
}
```
------
#### [ PartiQL for DynamoDB ]
**Linux**
```
aws dynamodb execute-statement --statement "SELECT * FROM Music \
WHERE Artist='Acme Band' AND SongTitle='Happy Day'"
```
**Windows CMD**
```
aws dynamodb execute-statement --statement "SELECT * FROM Music WHERE Artist='Acme Band' AND SongTitle='Happy Day'"
```
L’utilisation de l’instruction PartiQL `Select` renvoie l’exemple de résultat suivant.
```
{
"Items": [
{
"AlbumTitle": {
"S": "Songs About Life"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
}
]
}
```
Pour plus d’informations sur la lecture de données avec PartiQL, consultez [Instructions de sélection de PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.SELECT.html).
------
## AWS SDK
Les exemples de code suivants montrent comment lire un élément d'une table DynamoDB à l'aide d'un SDK. AWS
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/DynamoDB#code-examples).
```
///
/// Gets information about an existing movie from the table.
///
/// A Movie object containing information about
/// the movie to retrieve.
/// The name of the table containing the movie.
/// A Dictionary object containing information about the item
/// retrieved.
public async Task> GetItemAsync(Movie newMovie, string tableName)
{
try
{
var key = new Dictionary
{
["title"] = new AttributeValue { S = newMovie.Title },
["year"] = new AttributeValue { N = newMovie.Year.ToString() },
};
var request = new GetItemRequest
{
Key = key,
TableName = tableName,
};
var response = await _amazonDynamoDB.GetItemAsync(request);
return response.Item;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine($"Table {tableName} was not found. {ex.Message}");
return new Dictionary();
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine($"An Amazon DynamoDB error occurred while getting item. {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred while getting item. {ex.Message}");
throw;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/GetItem)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/dynamodb#code-examples).
```
#############################################################################
# function dynamodb_get_item
#
# This function gets an item from a DynamoDB table.
#
# Parameters:
# -n table_name -- The name of the table.
# -k keys -- Path to json file containing the keys that identify the item to get.
# [-q query] -- Optional JMESPath query expression.
#
# Returns:
# The item as text output.
# And:
# 0 - If successful.
# 1 - If it fails.
############################################################################
function dynamodb_get_item() {
local table_name keys query response
local option OPTARG # Required to use getopts command in a function.
# ######################################
# Function usage explanation
#######################################
function usage() {
echo "function dynamodb_get_item"
echo "Get an item from a DynamoDB table."
echo " -n table_name -- The name of the table."
echo " -k keys -- Path to json file containing the keys that identify the item to get."
echo " [-q query] -- Optional JMESPath query expression."
echo ""
}
query=""
while getopts "n:k:q:h" option; do
case "${option}" in
n) table_name="${OPTARG}" ;;
k) keys="${OPTARG}" ;;
q) query="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$table_name" ]]; then
errecho "ERROR: You must provide a table name with the -n parameter."
usage
return 1
fi
if [[ -z "$keys" ]]; then
errecho "ERROR: You must provide a keys json file path the -k parameter."
usage
return 1
fi
if [[ -n "$query" ]]; then
response=$(aws dynamodb get-item \
--table-name "$table_name" \
--key file://"$keys" \
--output text \
--query "$query")
else
response=$(
aws dynamodb get-item \
--table-name "$table_name" \
--key file://"$keys" \
--output text
)
fi
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports get-item operation failed.$response"
return 1
fi
if [[ -n "$query" ]]; then
echo "$response" | sed "/^\t/s/\t//1" # Remove initial tab that the JMSEPath query inserts on some strings.
else
echo "$response"
fi
return 0
}
```
Fonctions utilitaires utilisées dans cet exemple.
```
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
##############################################################################
# function aws_cli_error_log()
#
# This function is used to log the error messages from the AWS CLI.
#
# See https://docs.aws.amazon.com/cli/latest/topic/return-codes.html#cli-aws-help-return-codes.
#
# The function expects the following argument:
# $1 - The error code returned by the AWS CLI.
#
# Returns:
# 0: - Success.
#
##############################################################################
function aws_cli_error_log() {
local err_code=$1
errecho "Error code : $err_code"
if [ "$err_code" == 1 ]; then
errecho " One or more S3 transfers failed."
elif [ "$err_code" == 2 ]; then
errecho " Command line failed to parse."
elif [ "$err_code" == 130 ]; then
errecho " Process received SIGINT."
elif [ "$err_code" == 252 ]; then
errecho " Command syntax invalid."
elif [ "$err_code" == 253 ]; then
errecho " The system environment or configuration was invalid."
elif [ "$err_code" == 254 ]; then
errecho " The service returned an error."
elif [ "$err_code" == 255 ]; then
errecho " 255 is a catch-all error."
fi
return 0
}
```
+ Pour plus de détails sur l'API, voir [GetItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/GetItem)la section *Référence des AWS CLI commandes*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
//! Get an item from an Amazon DynamoDB table.
/*!
\sa getItem()
\param tableName: The table name.
\param partitionKey: The partition key.
\param partitionValue: The value for the partition key.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::getItem(const Aws::String &tableName,
const Aws::String &partitionKey,
const Aws::String &partitionValue,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
Aws::DynamoDB::Model::GetItemRequest request;
// Set up the request.
request.SetTableName(tableName);
request.AddKey(partitionKey,
Aws::DynamoDB::Model::AttributeValue().SetS(partitionValue));
// Retrieve the item's fields and values.
const Aws::DynamoDB::Model::GetItemOutcome &outcome = dynamoClient.GetItem(request);
if (outcome.IsSuccess()) {
// Reference the retrieved fields/values.
const Aws::Map &item = outcome.GetResult().GetItem();
if (!item.empty()) {
// Output each retrieved field and its value.
for (const auto &i: item)
std::cout << "Values: " << i.first << ": " << i.second.GetS()
<< std::endl;
}
else {
std::cout << "No item found with the key " << partitionKey << std::endl;
}
}
else {
std::cerr << "Failed to get item: " << outcome.GetError().GetMessage();
}
return outcome.IsSuccess();
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/GetItem)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour lire un élément dans une table**
L’exemple `get-item` suivant récupère un élément de la table `MusicCollection`. La table possède une clé hash-and-range primaire (`Artist`et`SongTitle`), vous devez donc spécifier ces deux attributs. La commande demande également des informations sur la capacité de lecture consommée par l’opération.
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--return-consumed-capacity TOTAL
```
Contenu de `key.json` :
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Sortie :
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
Pour plus d’informations, consultez [Lecture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 2 : pour lire un élément en utilisant une lecture cohérente**
L’exemple suivant récupère un élément à partir de la table `MusicCollection` à l’aide de la lecture fortement cohérente.
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--consistent-read \
--return-consumed-capacity TOTAL
```
Contenu de `key.json` :
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Sortie :
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
}
}
```
Pour plus d’informations, consultez [Lecture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 3 : pour extraire des attributs spécifiques d’un élément**
L’exemple suivant utilise une expression de projection pour extraire uniquement trois attributs de l’élément souhaité.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "102"}}' \
--projection-expression "#T, #C, #P" \
--expression-attribute-names file://names.json
```
Contenu de `names.json` :
```
{
"#T": "Title",
"#C": "ProductCategory",
"#P": "Price"
}
```
Sortie :
```
{
"Item": {
"Price": {
"N": "20"
},
"Title": {
"S": "Book 102 Title"
},
"ProductCategory": {
"S": "Book"
}
}
}
```
Pour plus d’informations, consultez [Lecture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) dans le *Guide du développeur Amazon DynamoDB*.
+ Pour plus de détails sur l'API, voir [GetItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/get-item.html)la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// TableBasics encapsulates the Amazon DynamoDB service actions used in the examples.
// It contains a DynamoDB service client that is used to act on the specified table.
type TableBasics struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// GetMovie gets movie data from the DynamoDB table by using the primary composite key
// made of title and year.
func (basics TableBasics) GetMovie(ctx context.Context, title string, year int) (Movie, error) {
movie := Movie{Title: title, Year: year}
response, err := basics.DynamoDbClient.GetItem(ctx, &dynamodb.GetItemInput{
Key: movie.GetKey(), TableName: aws.String(basics.TableName),
})
if err != nil {
log.Printf("Couldn't get info about %v. Here's why: %v\n", title, err)
} else {
err = attributevalue.UnmarshalMap(response.Item, &movie)
if err != nil {
log.Printf("Couldn't unmarshal response. Here's why: %v\n", err)
}
}
return movie, err
}
```
Définissez une structure Movie utilisée dans cet exemple.
```
import (
"archive/zip"
"bytes"
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// Movie encapsulates data about a movie. Title and Year are the composite primary key
// of the movie in Amazon DynamoDB. Title is the sort key, Year is the partition key,
// and Info is additional data.
type Movie struct {
Title string `dynamodbav:"title"`
Year int `dynamodbav:"year"`
Info map[string]interface{} `dynamodbav:"info"`
}
// GetKey returns the composite primary key of the movie in a format that can be
// sent to DynamoDB.
func (movie Movie) GetKey() map[string]types.AttributeValue {
title, err := attributevalue.Marshal(movie.Title)
if err != nil {
panic(err)
}
year, err := attributevalue.Marshal(movie.Year)
if err != nil {
panic(err)
}
return map[string]types.AttributeValue{"title": title, "year": year}
}
// String returns the title, year, rating, and plot of a movie, formatted for the example.
func (movie Movie) String() string {
return fmt.Sprintf("%v\n\tReleased: %v\n\tRating: %v\n\tPlot: %v\n",
movie.Title, movie.Year, movie.Info["rating"], movie.Info["plot"])
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.GetItem)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
Récupère un élément d'une table à l'aide du DynamoDbClient.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To get an item from an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client, see the EnhancedGetItem example.
*/
public class GetItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table from which an item is retrieved (for example, Music3).\s
key - The key used in the Amazon DynamoDB table (for example, Artist).\s
keyval - The key value that represents the item to get (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
System.out.format("Retrieving item \"%s\" from \"%s\"\n", keyVal, tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
getDynamoDBItem(ddb, tableName, key, keyVal);
ddb.close();
}
public static void getDynamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap keyToGet = new HashMap<>();
keyToGet.put(key, AttributeValue.builder()
.s(keyVal)
.build());
GetItemRequest request = GetItemRequest.builder()
.key(keyToGet)
.tableName(tableName)
.build();
try {
// If there is no matching item, GetItem does not return any data.
Map returnedItem = ddb.getItem(request).item();
if (returnedItem.isEmpty())
System.out.format("No item found with the key %s!\n", key);
else {
Set keys = returnedItem.keySet();
System.out.println("Amazon DynamoDB table attributes: \n");
for (String key1 : keys) {
System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString());
}
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/GetItem)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples).
Cet exemple utilise le client de document pour simplifier l’utilisation d’éléments dans DynamoDB. Pour plus de détails sur l'API, voir [GetCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-lib-dynamodb/Class/GetCommand/).
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
export const main = async () => {
const command = new GetCommand({
TableName: "AngryAnimals",
Key: {
CommonName: "Shoebill",
},
});
const response = await docClient.send(command);
console.log(response);
return response;
};
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/GetItemCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/dynamodb#code-examples).
Obtenir un élément d’une table
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the DynamoDB service object
var ddb = new AWS.DynamoDB({ apiVersion: "2012-08-10" });
var params = {
TableName: "TABLE",
Key: {
KEY_NAME: { N: "001" },
},
ProjectionExpression: "ATTRIBUTE_NAME",
};
// Call DynamoDB to read the item from the table
ddb.getItem(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data.Item);
}
});
```
Obtenez un élément d’une table à l’aide du client de document DynamoDB.
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create DynamoDB document client
var docClient = new AWS.DynamoDB.DocumentClient({ apiVersion: "2012-08-10" });
var params = {
TableName: "EPISODES_TABLE",
Key: { KEY_NAME: VALUE },
};
docClient.get(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data.Item);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-example-dynamodb-utilities.html#dynamodb-example-document-client-get).
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/GetItem)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/dynamodb#code-examples).
```
suspend fun getSpecificItem(
tableNameVal: String,
keyName: String,
keyVal: String,
) {
val keyToGet = mutableMapOf()
keyToGet[keyName] = AttributeValue.S(keyVal)
val request =
GetItemRequest {
key = keyToGet
tableName = tableNameVal
}
DynamoDbClient.fromEnvironment { region = "us-east-1" }.use { ddb ->
val returnedItem = ddb.getItem(request)
val numbersMap = returnedItem.item
numbersMap?.forEach { key1 ->
println(key1.key)
println(key1.value)
}
}
}
```
+ Pour plus de détails sur l'API, consultez [GetItem](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
```
$movie = $service->getItemByKey($tableName, $key);
echo "\nThe movie {$movie['Item']['title']['S']} was released in {$movie['Item']['year']['N']}.\n";
public function getItemByKey(string $tableName, array $key)
{
return $this->dynamoDbClient->getItem([
'Key' => $key['Item'],
'TableName' => $tableName,
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : renvoie l'élément DynamoDB avec la clé de partition et la SongTitle clé de tri Artist.**
```
$key = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
} | ConvertTo-DDBItem
Get-DDBItem -TableName 'Music' -Key $key | ConvertFrom-DDBItem
```
**Sortie** :
```
Name Value
---- -----
Genre Country
SongTitle Somewhere Down The Road
Price 1.94
Artist No One You Know
CriticRating 9
AlbumTitle Somewhat Famous
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/powershell/v4/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : renvoie l'élément DynamoDB avec la clé de partition et la SongTitle clé de tri Artist.**
```
$key = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
} | ConvertTo-DDBItem
Get-DDBItem -TableName 'Music' -Key $key | ConvertFrom-DDBItem
```
**Sortie** :
```
Name Value
---- -----
Genre Country
SongTitle Somewhere Down The Road
Price 1.94
Artist No One You Know
CriticRating 9
AlbumTitle Somewhat Famous
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/powershell/v5/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/dynamodb#code-examples).
```
class Movies:
"""Encapsulates an Amazon DynamoDB table of movie data.
Example data structure for a movie record in this table:
{
"year": 1999,
"title": "For Love of the Game",
"info": {
"directors": ["Sam Raimi"],
"release_date": "1999-09-15T00:00:00Z",
"rating": 6.3,
"plot": "A washed up pitcher flashes through his career.",
"rank": 4987,
"running_time_secs": 8220,
"actors": [
"Kevin Costner",
"Kelly Preston",
"John C. Reilly"
]
}
}
"""
def __init__(self, dyn_resource):
"""
:param dyn_resource: A Boto3 DynamoDB resource.
"""
self.dyn_resource = dyn_resource
# The table variable is set during the scenario in the call to
# 'exists' if the table exists. Otherwise, it is set by 'create_table'.
self.table = None
def get_movie(self, title, year):
"""
Gets movie data from the table for a specific movie.
:param title: The title of the movie.
:param year: The release year of the movie.
:return: The data about the requested movie.
"""
try:
response = self.table.get_item(Key={"year": year, "title": title})
except ClientError as err:
logger.error(
"Couldn't get movie %s from table %s. Here's why: %s: %s",
title,
self.table.name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response["Item"]
```
+ Pour plus de détails sur l'API, consultez [GetItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/GetItem)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/dynamodb#code-examples).
```
class DynamoDBBasics
attr_reader :dynamo_resource, :table
def initialize(table_name)
client = Aws::DynamoDB::Client.new(region: 'us-east-1')
@dynamo_resource = Aws::DynamoDB::Resource.new(client: client)
@table = @dynamo_resource.table(table_name)
end
# Gets movie data from the table for a specific movie.
#
# @param title [String] The title of the movie.
# @param year [Integer] The release year of the movie.
# @return [Hash] The data about the requested movie.
def get_item(title, year)
@table.get_item(key: { 'year' => year, 'title' => title })
rescue Aws::DynamoDB::Errors::ServiceError => e
puts("Couldn't get movie #{title} (#{year}) from table #{@table.name}:\n")
puts("\t#{e.code}: #{e.message}")
raise
end
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/GetItem)à la section *Référence des AWS SDK pour Ruby API*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/dyn#code-examples).
```
TRY.
oo_item = lo_dyn->getitem(
iv_tablename = iv_table_name
it_key = it_key ).
DATA(lt_attr) = oo_item->get_item( ).
DATA(lo_title) = lt_attr[ key = 'title' ]-value.
DATA(lo_year) = lt_attr[ key = 'year' ]-value.
DATA(lo_rating) = lt_attr[ key = 'rating' ]-value.
MESSAGE 'Movie name is: ' && lo_title->get_s( )
&& 'Movie year is: ' && lo_year->get_n( )
&& 'Moving rating is: ' && lo_rating->get_n( ) TYPE 'I'.
CATCH /aws1/cx_dynresourcenotfoundex.
MESSAGE 'The table or index does not exist' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez [GetItem](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/dynamodb#code-examples).
```
import AWSDynamoDB
/// Return a `Movie` record describing the specified movie from the Amazon
/// DynamoDB table.
///
/// - Parameters:
/// - title: The movie's title (`String`).
/// - year: The movie's release year (`Int`).
///
/// - Throws: `MoviesError.ItemNotFound` if the movie isn't in the table.
///
/// - Returns: A `Movie` record with the movie's details.
func get(title: String, year: Int) async throws -> Movie {
do {
guard let client = self.ddbClient else {
throw MoviesError.UninitializedClient
}
let input = GetItemInput(
key: [
"year": .n(String(year)),
"title": .s(title)
],
tableName: self.tableName
)
let output = try await client.getItem(input: input)
guard let item = output.item else {
throw MoviesError.ItemNotFound
}
let movie = try Movie(withItem: item)
return movie
} catch {
print("ERROR: get:", dump(error))
throw error
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetItem](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/getitem(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
Pour obtenir plus d’exemples avec DynamoDB, consultez [Exemples de code pour DynamoDB utilisant AWS SDKs](service_code_examples.md).
Pour mettre à jour les données dans votre table, passez à l’ [Étape 4 : mettre à jour des données dans une table DynamoDB](getting-started-step-4.md).
# Étape 4 : mettre à jour des données dans une table DynamoDB
Dans cette étape, vous mettez à jour un élément que vous avez créé dans [Étape 2 : écrire des données dans une table DynamoDB](getting-started-step-2.md). Vous pouvez utiliser la console DynamoDB ou AWS CLI le pour mettre à jour un élément `AlbumTitle` du tableau en `Music` `Artist` spécifiant`SongTitle`, et en mettant à jour. `AlbumTitle`
Pour plus d’informations sur les opérations d’écriture, consultez [Écriture d’un élément](WorkingWithItems.md#WorkingWithItems.WritingData).
## AWS Management Console
Vous pouvez utiliser la console DynamoDB pour mettre à jour des données dans la table `Music`.
1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dans le volet de navigation de gauche, choisissez **Tables**.
1. Dans la liste de tables, choisissez la table **Music (Musique)**.
1. Sélectionnez **Explorer les éléments de table**.
1. Dans **Articles retournés**, pour la ligne d'articles avec **Acme Band** **Artist** et **Happy Day **SongTitle****, procédez comme suit :
1. Placez votre curseur sur le **AlbumTitle**titre **Songs About Life**.
1. Choisissez l’icône Modifier.
1. Dans la fenêtre contextuelle **Modifier la chaîne**, entrez **Songs of Twilight**.
1. Choisissez **Enregistrer**.
**Astuce**
Pour pouvez aussi, pour mettre à jour un élément, procéder comme suit dans la section **Articles retournés** :
Choisissez la rangée d'articles avec **l'artiste** **Acme Band** et **SongTitle****Happy Day.**
Dans la liste déroulante **Actions**, choisissez **Modifier l’élément**.
Pour entrer **AlbumTitle**, entrez**Songs of Twilight**.
Choisissez **Enregistrer et fermer**.
## AWS CLI
L' AWS CLI exemple suivant met à jour un élément du `Music` tableau. Vous pouvez procéder via l’API DynamoDB ou [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL pour DynamoDB.
------
#### [ DynamoDB API ]
**Linux**
```
aws dynamodb update-item \
--table-name Music \
--key '{ "Artist": {"S": "Acme Band"}, "SongTitle": {"S": "Happy Day"}}' \
--update-expression "SET AlbumTitle = :newval" \
--expression-attribute-values '{":newval":{"S":"Updated Album Title"}}' \
--return-values ALL_NEW
```
**Windows CMD**
```
aws dynamodb update-item ^
--table-name Music ^
--key "{\"Artist\": {\"S\": \"Acme Band\"}, \"SongTitle\": {\"S\": \"Happy Day\"}}" ^
--update-expression "SET AlbumTitle = :newval" ^
--expression-attribute-values "{\":newval\":{\"S\":\"Updated Album Title\"}}" ^
--return-values ALL_NEW
```
L’utilisation de `update-item` renvoie l’exemple de résultat suivant car `return-values ALL_NEW` a été spécifié.
```
{
"Attributes": {
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
}
}
```
------
#### [ PartiQL for DynamoDB ]
**Linux**
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AlbumTitle='Updated Album Title' \
WHERE Artist='Acme Band' AND SongTitle='Happy Day' \
RETURNING ALL NEW *"
```
**Windows CMD**
```
aws dynamodb execute-statement --statement "UPDATE Music SET AlbumTitle='Updated Album Title' WHERE Artist='Acme Band' AND SongTitle='Happy Day' RETURNING ALL NEW *"
```
L’utilisation de l’instruction `Update` renvoie l’exemple de résultat suivant car `RETURNING ALL NEW *` a été spécifié.
```
{
"Items": [
{
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
}
]
}
```
Pour plus d’informations sur la mise à jour des données avec PartiQL, consultez [Instructions de mise à jour de PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.update.html).
------
## AWS SDK
Les exemples de code suivants montrent comment mettre à jour un élément dans une table DynamoDB à l'aide d'un SDK. AWS
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/DynamoDB#code-examples).
```
///
/// Updates an existing item in the movies table.
///
/// A Movie object containing information for
/// the movie to update.
/// A MovieInfo object that contains the
/// information that will be changed.
/// The name of the table that contains the movie.
/// A Boolean value that indicates the success of the operation.
public async Task UpdateItemAsync(
Movie newMovie,
MovieInfo newInfo,
string tableName)
{
try
{
var key = new Dictionary
{
["title"] = new AttributeValue { S = newMovie.Title },
["year"] = new AttributeValue { N = newMovie.Year.ToString() },
};
var updates = new Dictionary
{
["info.plot"] = new AttributeValueUpdate
{
Action = AttributeAction.PUT,
Value = new AttributeValue { S = newInfo.Plot },
},
["info.rating"] = new AttributeValueUpdate
{
Action = AttributeAction.PUT,
Value = new AttributeValue { N = newInfo.Rank.ToString() },
},
};
var request = new UpdateItemRequest
{
AttributeUpdates = updates,
Key = key,
TableName = tableName,
};
await _amazonDynamoDB.UpdateItemAsync(request);
return true;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine($"Table {tableName} or item was not found. {ex.Message}");
return false;
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine($"An Amazon DynamoDB error occurred while updating item. {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred while updating item. {ex.Message}");
throw;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/UpdateItem)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/dynamodb#code-examples).
```
##############################################################################
# function dynamodb_update_item
#
# This function updates an item in a DynamoDB table.
#
#
# Parameters:
# -n table_name -- The name of the table.
# -k keys -- Path to json file containing the keys that identify the item to update.
# -e update expression -- An expression that defines one or more attributes to be updated.
# -v values -- Path to json file containing the update values.
#
# Returns:
# 0 - If successful.
# 1 - If it fails.
#############################################################################
function dynamodb_update_item() {
local table_name keys update_expression values response
local option OPTARG # Required to use getopts command in a function.
#######################################
# Function usage explanation
#######################################
function usage() {
echo "function dynamodb_update_item"
echo "Update an item in a DynamoDB table."
echo " -n table_name -- The name of the table."
echo " -k keys -- Path to json file containing the keys that identify the item to update."
echo " -e update expression -- An expression that defines one or more attributes to be updated."
echo " -v values -- Path to json file containing the update values."
echo ""
}
while getopts "n:k:e:v:h" option; do
case "${option}" in
n) table_name="${OPTARG}" ;;
k) keys="${OPTARG}" ;;
e) update_expression="${OPTARG}" ;;
v) values="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$table_name" ]]; then
errecho "ERROR: You must provide a table name with the -n parameter."
usage
return 1
fi
if [[ -z "$keys" ]]; then
errecho "ERROR: You must provide a keys json file path the -k parameter."
usage
return 1
fi
if [[ -z "$update_expression" ]]; then
errecho "ERROR: You must provide an update expression with the -e parameter."
usage
return 1
fi
if [[ -z "$values" ]]; then
errecho "ERROR: You must provide a values json file path the -v parameter."
usage
return 1
fi
iecho "Parameters:\n"
iecho " table_name: $table_name"
iecho " keys: $keys"
iecho " update_expression: $update_expression"
iecho " values: $values"
response=$(aws dynamodb update-item \
--table-name "$table_name" \
--key file://"$keys" \
--update-expression "$update_expression" \
--expression-attribute-values file://"$values")
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports update-item operation failed.$response"
return 1
fi
return 0
}
```
Fonctions utilitaires utilisées dans cet exemple.
```
###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
if [[ $VERBOSE == true ]]; then
echo "$@"
fi
}
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
##############################################################################
# function aws_cli_error_log()
#
# This function is used to log the error messages from the AWS CLI.
#
# See https://docs.aws.amazon.com/cli/latest/topic/return-codes.html#cli-aws-help-return-codes.
#
# The function expects the following argument:
# $1 - The error code returned by the AWS CLI.
#
# Returns:
# 0: - Success.
#
##############################################################################
function aws_cli_error_log() {
local err_code=$1
errecho "Error code : $err_code"
if [ "$err_code" == 1 ]; then
errecho " One or more S3 transfers failed."
elif [ "$err_code" == 2 ]; then
errecho " Command line failed to parse."
elif [ "$err_code" == 130 ]; then
errecho " Process received SIGINT."
elif [ "$err_code" == 252 ]; then
errecho " Command syntax invalid."
elif [ "$err_code" == 253 ]; then
errecho " The system environment or configuration was invalid."
elif [ "$err_code" == 254 ]; then
errecho " The service returned an error."
elif [ "$err_code" == 255 ]; then
errecho " 255 is a catch-all error."
fi
return 0
}
```
+ Pour plus de détails sur l'API, voir [UpdateItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/UpdateItem)la section *Référence des AWS CLI commandes*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
//! Update an Amazon DynamoDB table item.
/*!
\sa updateItem()
\param tableName: The table name.
\param partitionKey: The partition key.
\param partitionValue: The value for the partition key.
\param attributeKey: The key for the attribute to be updated.
\param attributeValue: The value for the attribute to be updated.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
/*
* The example code only sets/updates an attribute value. It processes
* the attribute value as a string, even if the value could be interpreted
* as a number. Also, the example code does not remove an existing attribute
* from the key value.
*/
bool AwsDoc::DynamoDB::updateItem(const Aws::String &tableName,
const Aws::String &partitionKey,
const Aws::String &partitionValue,
const Aws::String &attributeKey,
const Aws::String &attributeValue,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
// *** Define UpdateItem request arguments.
// Define TableName argument.
Aws::DynamoDB::Model::UpdateItemRequest request;
request.SetTableName(tableName);
// Define KeyName argument.
Aws::DynamoDB::Model::AttributeValue attribValue;
attribValue.SetS(partitionValue);
request.AddKey(partitionKey, attribValue);
// Construct the SET update expression argument.
Aws::String update_expression("SET #a = :valueA");
request.SetUpdateExpression(update_expression);
// Construct attribute name argument.
Aws::Map expressionAttributeNames;
expressionAttributeNames["#a"] = attributeKey;
request.SetExpressionAttributeNames(expressionAttributeNames);
// Construct attribute value argument.
Aws::DynamoDB::Model::AttributeValue attributeUpdatedValue;
attributeUpdatedValue.SetS(attributeValue);
Aws::Map expressionAttributeValues;
expressionAttributeValues[":valueA"] = attributeUpdatedValue;
request.SetExpressionAttributeValues(expressionAttributeValues);
// Update the item.
const Aws::DynamoDB::Model::UpdateItemOutcome &outcome = dynamoClient.UpdateItem(
request);
if (outcome.IsSuccess()) {
std::cout << "Item was updated" << std::endl;
} else {
std::cerr << outcome.GetError().GetMessage() << std::endl;
return false;
}
return waitTableActive(tableName, dynamoClient);
}
```
Code qui attend que la table soit active.
```
//! Query a newly created DynamoDB table until it is active.
/*!
\sa waitTableActive()
\param waitTableActive: The DynamoDB table's name.
\param dynamoClient: A DynamoDB client.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::waitTableActive(const Aws::String &tableName,
const Aws::DynamoDB::DynamoDBClient &dynamoClient) {
// Repeatedly call DescribeTable until table is ACTIVE.
const int MAX_QUERIES = 20;
Aws::DynamoDB::Model::DescribeTableRequest request;
request.SetTableName(tableName);
int count = 0;
while (count < MAX_QUERIES) {
const Aws::DynamoDB::Model::DescribeTableOutcome &result = dynamoClient.DescribeTable(
request);
if (result.IsSuccess()) {
Aws::DynamoDB::Model::TableStatus status = result.GetResult().GetTable().GetTableStatus();
if (Aws::DynamoDB::Model::TableStatus::ACTIVE != status) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
else {
return true;
}
}
else {
std::cerr << "Error DynamoDB::waitTableActive "
<< result.GetError().GetMessage() << std::endl;
return false;
}
count++;
}
return false;
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/UpdateItem)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour mettre à jour un élément dans une table**
L’exemple `update-item` suivant met à jour un élément dans la table `MusicCollection`. Il ajoute un nouvel attribut (`Year`) et modifie l’attribut `AlbumTitle`. Tous les attributs de l’élément, tels qu’ils apparaissent après la mise à jour, sont renvoyés dans la réponse.
```
aws dynamodb update-item \
--table-name MusicCollection \
--key file://key.json \
--update-expression "SET #Y = :y, #AT = :t" \
--expression-attribute-names file://expression-attribute-names.json \
--expression-attribute-values file://expression-attribute-values.json \
--return-values ALL_NEW \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Contenu de `key.json` :
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Contenu de `expression-attribute-names.json` :
```
{
"#Y":"Year", "#AT":"AlbumTitle"
}
```
Contenu de `expression-attribute-values.json` :
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
Sortie :
```
{
"Attributes": {
"AlbumTitle": {
"S": "Louder Than Ever"
},
"Awards": {
"N": "10"
},
"Artist": {
"S": "Acme Band"
},
"Year": {
"N": "2015"
},
"SongTitle": {
"S": "Happy Day"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 3.0
},
"ItemCollectionMetrics": {
"ItemCollectionKey": {
"Artist": {
"S": "Acme Band"
}
},
"SizeEstimateRangeGB": [
0.0,
1.0
]
}
}
```
Pour plus d’informations, consultez [Écriture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 2 : pour mettre à jour un élément sous certaines conditions**
L’exemple suivant met à jour un élément de la table `MusicCollection`, mais uniquement si l’élément existant ne possède pas encore d’attribut `Year`.
```
aws dynamodb update-item \
--table-name MusicCollection \
--key file://key.json \
--update-expression "SET #Y = :y, #AT = :t" \
--expression-attribute-names file://expression-attribute-names.json \
--expression-attribute-values file://expression-attribute-values.json \
--condition-expression "attribute_not_exists(#Y)"
```
Contenu de `key.json` :
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Contenu de `expression-attribute-names.json` :
```
{
"#Y":"Year",
"#AT":"AlbumTitle"
}
```
Contenu de `expression-attribute-values.json` :
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
Si l’élément possède déjà un attribut `Year`, DynamoDB renvoie le résultat suivant.
```
An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed
```
Pour plus d’informations, consultez [Écriture d’un élément](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) dans le *Guide du développeur Amazon DynamoDB*.
+ Pour plus de détails sur l'API, voir [UpdateItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-item.html)la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// TableBasics encapsulates the Amazon DynamoDB service actions used in the examples.
// It contains a DynamoDB service client that is used to act on the specified table.
type TableBasics struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// UpdateMovie updates the rating and plot of a movie that already exists in the
// DynamoDB table. This function uses the `expression` package to build the update
// expression.
func (basics TableBasics) UpdateMovie(ctx context.Context, movie Movie) (map[string]map[string]interface{}, error) {
var err error
var response *dynamodb.UpdateItemOutput
var attributeMap map[string]map[string]interface{}
update := expression.Set(expression.Name("info.rating"), expression.Value(movie.Info["rating"]))
update.Set(expression.Name("info.plot"), expression.Value(movie.Info["plot"]))
expr, err := expression.NewBuilder().WithUpdate(update).Build()
if err != nil {
log.Printf("Couldn't build expression for update. Here's why: %v\n", err)
} else {
response, err = basics.DynamoDbClient.UpdateItem(ctx, &dynamodb.UpdateItemInput{
TableName: aws.String(basics.TableName),
Key: movie.GetKey(),
ExpressionAttributeNames: expr.Names(),
ExpressionAttributeValues: expr.Values(),
UpdateExpression: expr.Update(),
ReturnValues: types.ReturnValueUpdatedNew,
})
if err != nil {
log.Printf("Couldn't update movie %v. Here's why: %v\n", movie.Title, err)
} else {
err = attributevalue.UnmarshalMap(response.Attributes, &attributeMap)
if err != nil {
log.Printf("Couldn't unmarshall update response. Here's why: %v\n", err)
}
}
}
return attributeMap, err
}
```
Définissez une structure Movie utilisée dans cet exemple.
```
import (
"archive/zip"
"bytes"
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// Movie encapsulates data about a movie. Title and Year are the composite primary key
// of the movie in Amazon DynamoDB. Title is the sort key, Year is the partition key,
// and Info is additional data.
type Movie struct {
Title string `dynamodbav:"title"`
Year int `dynamodbav:"year"`
Info map[string]interface{} `dynamodbav:"info"`
}
// GetKey returns the composite primary key of the movie in a format that can be
// sent to DynamoDB.
func (movie Movie) GetKey() map[string]types.AttributeValue {
title, err := attributevalue.Marshal(movie.Title)
if err != nil {
panic(err)
}
year, err := attributevalue.Marshal(movie.Year)
if err != nil {
panic(err)
}
return map[string]types.AttributeValue{"title": title, "year": year}
}
// String returns the title, year, rating, and plot of a movie, formatted for the example.
func (movie Movie) String() string {
return fmt.Sprintf("%v\n\tReleased: %v\n\tRating: %v\n\tPlot: %v\n",
movie.Title, movie.Year, movie.Info["rating"], movie.Info["plot"])
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.UpdateItem)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
Met à jour un élément d'un tableau à l'aide de [DynamoDbClient](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/dynamodb/DynamoDbClient.html).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.AttributeAction;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.AttributeValueUpdate;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import java.util.HashMap;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To update an Amazon DynamoDB table using the AWS SDK for Java V2, its better
* practice to use the
* Enhanced Client, See the EnhancedModifyItem example.
*/
public class UpdateItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table (for example, Music3).
key - The name of the key in the table (for example, Artist).
keyVal - The value of the key (for example, Famous Band).
name - The name of the column where the value is updated (for example, Awards).
updateVal - The value used to update an item (for example, 14).
Example:
UpdateItem Music3 Artist Famous Band Awards 14
""";
if (args.length != 5) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
String name = args[3];
String updateVal = args[4];
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
updateTableItem(ddb, tableName, key, keyVal, name, updateVal);
ddb.close();
}
public static void updateTableItem(DynamoDbClient ddb,
String tableName,
String key,
String keyVal,
String name,
String updateVal) {
HashMap itemKey = new HashMap<>();
itemKey.put(key, AttributeValue.builder()
.s(keyVal)
.build());
HashMap updatedValues = new HashMap<>();
updatedValues.put(name, AttributeValueUpdate.builder()
.value(AttributeValue.builder().s(updateVal).build())
.action(AttributeAction.PUT)
.build());
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(itemKey)
.attributeUpdates(updatedValues)
.build();
try {
ddb.updateItem(request);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
System.out.println("The Amazon DynamoDB table was updated!");
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples).
Cet exemple utilise le client de document pour simplifier l’utilisation d’éléments dans DynamoDB. Pour plus de détails sur l'API, voir [UpdateCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-lib-dynamodb/Class/UpdateCommand/).
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, UpdateCommand } from "@aws-sdk/lib-dynamodb";
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
export const main = async () => {
const command = new UpdateCommand({
TableName: "Dogs",
Key: {
Breed: "Labrador",
},
UpdateExpression: "set Color = :color",
ExpressionAttributeValues: {
":color": "black",
},
ReturnValues: "ALL_NEW",
});
const response = await docClient.send(command);
console.log(response);
return response;
};
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/dynamodb#code-examples).
```
suspend fun updateTableItem(
tableNameVal: String,
keyName: String,
keyVal: String,
name: String,
updateVal: String,
) {
val itemKey = mutableMapOf()
itemKey[keyName] = AttributeValue.S(keyVal)
val updatedValues = mutableMapOf()
updatedValues[name] =
AttributeValueUpdate {
value = AttributeValue.S(updateVal)
action = AttributeAction.Put
}
val request =
UpdateItemRequest {
tableName = tableNameVal
key = itemKey
attributeUpdates = updatedValues
}
DynamoDbClient.fromEnvironment { region = "us-east-1" }.use { ddb ->
ddb.updateItem(request)
println("Item in $tableNameVal was updated")
}
}
```
+ Pour plus de détails sur l'API, consultez [UpdateItem](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
```
echo "What rating would you like to give {$movie['Item']['title']['S']}?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
$service->updateItemAttributeByKey($tableName, $key, 'rating', 'N', $rating);
public function updateItemAttributeByKey(
string $tableName,
array $key,
string $attributeName,
string $attributeType,
string $newValue
) {
$this->dynamoDbClient->updateItem([
'Key' => $key['Item'],
'TableName' => $tableName,
'UpdateExpression' => "set #NV=:NV",
'ExpressionAttributeNames' => [
'#NV' => $attributeName,
],
'ExpressionAttributeValues' => [
':NV' => [
$attributeType => $newValue
]
],
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : définit l'attribut genre sur « Rap » sur l'élément DynamoDB avec la clé de partition et la SongTitle clé de tri Artist.**
```
$key = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
} | ConvertTo-DDBItem
$updateDdbItem = @{
TableName = 'Music'
Key = $key
UpdateExpression = 'set Genre = :val1'
ExpressionAttributeValue = (@{
':val1' = ([Amazon.DynamoDBv2.Model.AttributeValue]'Rap')
})
}
Update-DDBItem @updateDdbItem
```
**Sortie** :
```
Name Value
---- -----
Genre Rap
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/powershell/v4/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : définit l'attribut genre sur « Rap » sur l'élément DynamoDB avec la clé de partition et la SongTitle clé de tri Artist.**
```
$key = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
} | ConvertTo-DDBItem
$updateDdbItem = @{
TableName = 'Music'
Key = $key
UpdateExpression = 'set Genre = :val1'
ExpressionAttributeValue = (@{
':val1' = ([Amazon.DynamoDBv2.Model.AttributeValue]'Rap')
})
}
Update-DDBItem @updateDdbItem
```
**Sortie** :
```
Name Value
---- -----
Genre Rap
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/powershell/v5/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/dynamodb#code-examples).
Mettez à jour un élément à l’aide d’une expression de mise à jour.
```
class Movies:
"""Encapsulates an Amazon DynamoDB table of movie data.
Example data structure for a movie record in this table:
{
"year": 1999,
"title": "For Love of the Game",
"info": {
"directors": ["Sam Raimi"],
"release_date": "1999-09-15T00:00:00Z",
"rating": 6.3,
"plot": "A washed up pitcher flashes through his career.",
"rank": 4987,
"running_time_secs": 8220,
"actors": [
"Kevin Costner",
"Kelly Preston",
"John C. Reilly"
]
}
}
"""
def __init__(self, dyn_resource):
"""
:param dyn_resource: A Boto3 DynamoDB resource.
"""
self.dyn_resource = dyn_resource
# The table variable is set during the scenario in the call to
# 'exists' if the table exists. Otherwise, it is set by 'create_table'.
self.table = None
def update_movie(self, title, year, rating, plot):
"""
Updates rating and plot data for a movie in the table.
:param title: The title of the movie to update.
:param year: The release year of the movie to update.
:param rating: The updated rating to the give the movie.
:param plot: The updated plot summary to give the movie.
:return: The fields that were updated, with their new values.
"""
try:
response = self.table.update_item(
Key={"year": year, "title": title},
UpdateExpression="set info.rating=:r, info.plot=:p",
ExpressionAttributeValues={":r": Decimal(str(rating)), ":p": plot},
ReturnValues="UPDATED_NEW",
)
except ClientError as err:
logger.error(
"Couldn't update movie %s in table %s. Here's why: %s: %s",
title,
self.table.name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response["Attributes"]
```
Mettez à jour un élément à l’aide d’une expression de mise à jour qui inclut une opération arithmétique.
```
class UpdateQueryWrapper:
def __init__(self, table):
self.table = table
def update_rating(self, title, year, rating_change):
"""
Updates the quality rating of a movie in the table by using an arithmetic
operation in the update expression. By specifying an arithmetic operation,
you can adjust a value in a single request, rather than first getting its
value and then setting its new value.
:param title: The title of the movie to update.
:param year: The release year of the movie to update.
:param rating_change: The amount to add to the current rating for the movie.
:return: The updated rating.
"""
try:
response = self.table.update_item(
Key={"year": year, "title": title},
UpdateExpression="set info.rating = info.rating + :val",
ExpressionAttributeValues={":val": Decimal(str(rating_change))},
ReturnValues="UPDATED_NEW",
)
except ClientError as err:
logger.error(
"Couldn't update movie %s in table %s. Here's why: %s: %s",
title,
self.table.name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response["Attributes"]
```
Mettre à jour un élément uniquement lorsqu’il remplit certaines conditions.
```
class UpdateQueryWrapper:
def __init__(self, table):
self.table = table
def remove_actors(self, title, year, actor_threshold):
"""
Removes an actor from a movie, but only when the number of actors is greater
than a specified threshold. If the movie does not list more than the threshold,
no actors are removed.
:param title: The title of the movie to update.
:param year: The release year of the movie to update.
:param actor_threshold: The threshold of actors to check.
:return: The movie data after the update.
"""
try:
response = self.table.update_item(
Key={"year": year, "title": title},
UpdateExpression="remove info.actors[0]",
ConditionExpression="size(info.actors) > :num",
ExpressionAttributeValues={":num": actor_threshold},
ReturnValues="ALL_NEW",
)
except ClientError as err:
if err.response["Error"]["Code"] == "ConditionalCheckFailedException":
logger.warning(
"Didn't update %s because it has fewer than %s actors.",
title,
actor_threshold + 1,
)
else:
logger.error(
"Couldn't update movie %s. Here's why: %s: %s",
title,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response["Attributes"]
```
+ Pour plus de détails sur l'API, consultez [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/dynamodb#code-examples).
```
class DynamoDBBasics
attr_reader :dynamo_resource, :table
def initialize(table_name)
client = Aws::DynamoDB::Client.new(region: 'us-east-1')
@dynamo_resource = Aws::DynamoDB::Resource.new(client: client)
@table = @dynamo_resource.table(table_name)
end
# Updates rating and plot data for a movie in the table.
#
# @param movie [Hash] The title, year, plot, rating of the movie.
def update_item(movie)
response = @table.update_item(
key: { 'year' => movie[:year], 'title' => movie[:title] },
update_expression: 'set info.rating=:r',
expression_attribute_values: { ':r' => movie[:rating] },
return_values: 'UPDATED_NEW'
)
rescue Aws::DynamoDB::Errors::ServiceError => e
puts("Couldn't update movie #{movie[:title]} (#{movie[:year]}) in table #{@table.name}\n")
puts("\t#{e.code}: #{e.message}")
raise
else
response.attributes
end
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/UpdateItem)à la section *Référence des AWS SDK pour Ruby API*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/dyn#code-examples).
```
TRY.
oo_output = lo_dyn->updateitem(
iv_tablename = iv_table_name
it_key = it_item_key
it_attributeupdates = it_attribute_updates ).
MESSAGE '1 item updated in DynamoDB Table' && iv_table_name TYPE 'I'.
CATCH /aws1/cx_dyncondalcheckfaile00.
MESSAGE 'A condition specified in the operation could not be evaluated.' TYPE 'E'.
CATCH /aws1/cx_dynresourcenotfoundex.
MESSAGE 'The table or index does not exist' TYPE 'E'.
CATCH /aws1/cx_dyntransactconflictex.
MESSAGE 'Another transaction is using the item' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez [UpdateItem](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/dynamodb#code-examples).
```
import AWSDynamoDB
/// Update the specified movie with new `rating` and `plot` information.
///
/// - Parameters:
/// - title: The title of the movie to update.
/// - year: The release year of the movie to update.
/// - rating: The new rating for the movie.
/// - plot: The new plot summary string for the movie.
///
/// - Returns: An array of mappings of attribute names to their new
/// listing each item actually changed. Items that didn't need to change
/// aren't included in this list. `nil` if no changes were made.
///
func update(title: String, year: Int, rating: Double? = nil, plot: String? = nil) async throws
-> [Swift.String: DynamoDBClientTypes.AttributeValue]?
{
do {
guard let client = self.ddbClient else {
throw MoviesError.UninitializedClient
}
// Build the update expression and the list of expression attribute
// values. Include only the information that's changed.
var expressionParts: [String] = []
var attrValues: [Swift.String: DynamoDBClientTypes.AttributeValue] = [:]
if rating != nil {
expressionParts.append("info.rating=:r")
attrValues[":r"] = .n(String(rating!))
}
if plot != nil {
expressionParts.append("info.plot=:p")
attrValues[":p"] = .s(plot!)
}
let expression = "set \(expressionParts.joined(separator: ", "))"
let input = UpdateItemInput(
// Create substitution tokens for the attribute values, to ensure
// no conflicts in expression syntax.
expressionAttributeValues: attrValues,
// The key identifying the movie to update consists of the release
// year and title.
key: [
"year": .n(String(year)),
"title": .s(title)
],
returnValues: .updatedNew,
tableName: self.tableName,
updateExpression: expression
)
let output = try await client.updateItem(input: input)
guard let attributes: [Swift.String: DynamoDBClientTypes.AttributeValue] = output.attributes else {
throw MoviesError.InvalidAttributes
}
return attributes
} catch {
print("ERROR: update:", dump(error))
throw error
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateItem](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/updateitem(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
Pour obtenir plus d’exemples avec DynamoDB, consultez [Exemples de code pour DynamoDB utilisant AWS SDKs](service_code_examples.md).
Pour interroger les données dans la table `Music`, passez à l’[Étape 5 : interroger des données dans une table DynamoDB](getting-started-step-5.md).
# Étape 5 : interroger des données dans une table DynamoDB
Dans cette étape, vous interrogez les données que vous avez écrites dans la table `Music` dans [Étape 2 : écrire des données dans une table DynamoDB](getting-started-step-2.md) en spécifiant l’`Artist`. Cela affichera tous les morceaux associés à la clé de partition : `Artist`.
Pour plus d’informations sur les opérations d’interrogation, consultez [Interrogation de tables dans DynamoDB](Query.md).
## AWS Management Console
Suivez ces étapes pour utiliser la console DynamoDB afin d’interroger les données de la table `Music`.
1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dans le volet de navigation de gauche, choisissez **Tables**.
1. Dans la liste de tables, choisissez la table **Music (Musique)**.
1. Sélectionnez **Explorer les éléments de table**.
1. Dans **Analyser ou interroger des éléments**, assurez-vous que l’option **Requête** est sélectionnée.
1. Pour **Clé de partition**, entrez **Acme Band**, puis choisissez **Exécuter**.
## AWS CLI
L' AWS CLI exemple suivant interroge un élément de la `Music` table. Vous pouvez procéder via l’API DynamoDB ou [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL pour DynamoDB.
------
#### [ DynamoDB API ]
Vous interrogez un élément via l’API DynamoDB en utilisant `query` et en fournissant la clé de partition.
**Linux**
```
aws dynamodb query \
--table-name Music \
--key-condition-expression "Artist = :name" \
--expression-attribute-values '{":name":{"S":"Acme Band"}}'
```
**Windows CMD**
```
aws dynamodb query ^
--table-name Music ^
--key-condition-expression "Artist = :name" ^
--expression-attribute-values "{\":name\":{\"S\":\"Acme Band\"}}"
```
Une telle utilisation de `query` renvoie tous les morceaux associés à cet `Artist` spécifique.
```
{
"Items": [
{
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"N": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
},
{
"AlbumTitle": {
"S": "Another Album Title"
},
"Awards": {
"N": "8"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "PartiQL Rocks"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": null
}
```
------
#### [ PartiQL for DynamoDB ]
Vous interrogez un élément via PartiQL en utilisant l’instruction `Select` et en fournissant la clé de partition.
**Linux**
```
aws dynamodb execute-statement --statement "SELECT * FROM Music \
WHERE Artist='Acme Band'"
```
**Windows CMD**
```
aws dynamodb execute-statement --statement "SELECT * FROM Music WHERE Artist='Acme Band'"
```
Une telle utilisation de l’instruction `Select` renvoie tous les morceaux associés à cet `Artist` spécifique.
```
{
"Items": [
{
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
},
{
"AlbumTitle": {
"S": "Another Album Title"
},
"Awards": {
"S": "8"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "PartiQL Rocks"
}
}
]
}
```
Pour plus d’informations sur l’interrogation de données avec PartiQL, consultez [Instructions de sélection de PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html).
------
## AWS SDK
Les exemples de code suivants expliquent comment interroger une table DynamoDB à l’aide d’un kit AWS SDK.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/DynamoDB#code-examples).
```
///
/// Queries the table for movies released in a particular year and
/// then displays the information for the movies returned.
///
/// The name of the table to query.
/// The release year for which we want to
/// view movies.
/// The number of movies that match the query.
public async Task QueryMoviesAsync(string tableName, int year)
{
try
{
var movieTable = new TableBuilder(_amazonDynamoDB, tableName)
.AddHashKey("year", DynamoDBEntryType.Numeric)
.AddRangeKey("title", DynamoDBEntryType.String)
.Build();
var filter = new QueryFilter("year", QueryOperator.Equal, year);
Console.WriteLine("\nFind movies released in: {year}:");
var config = new QueryOperationConfig()
{
Limit = 10, // 10 items per page.
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List
{
"title",
"year",
},
ConsistentRead = true,
Filter = filter,
};
// Value used to track how many movies match the
// supplied criteria.
var moviesFound = 0;
var search = movieTable.Query(config);
do
{
var movieList = await search.GetNextSetAsync();
moviesFound += movieList.Count;
foreach (var movie in movieList)
{
DisplayDocument(movie);
}
}
while (!search.IsDone);
return moviesFound;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine($"Table {tableName} was not found. {ex.Message}");
return 0;
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine($"An Amazon DynamoDB error occurred while querying movies. {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred while querying movies. {ex.Message}");
throw;
}
}
```
+ Pour plus de détails sur l’API, consultez [Query](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/Query) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/dynamodb#code-examples).
```
#############################################################################
# function dynamodb_query
#
# This function queries a DynamoDB table.
#
# Parameters:
# -n table_name -- The name of the table.
# -k key_condition_expression -- The key condition expression.
# -a attribute_names -- Path to JSON file containing the attribute names.
# -v attribute_values -- Path to JSON file containing the attribute values.
# [-p projection_expression] -- Optional projection expression.
#
# Returns:
# The items as json output.
# And:
# 0 - If successful.
# 1 - If it fails.
###########################################################################
function dynamodb_query() {
local table_name key_condition_expression attribute_names attribute_values projection_expression response
local option OPTARG # Required to use getopts command in a function.
# ######################################
# Function usage explanation
#######################################
function usage() {
echo "function dynamodb_query"
echo "Query a DynamoDB table."
echo " -n table_name -- The name of the table."
echo " -k key_condition_expression -- The key condition expression."
echo " -a attribute_names -- Path to JSON file containing the attribute names."
echo " -v attribute_values -- Path to JSON file containing the attribute values."
echo " [-p projection_expression] -- Optional projection expression."
echo ""
}
while getopts "n:k:a:v:p:h" option; do
case "${option}" in
n) table_name="${OPTARG}" ;;
k) key_condition_expression="${OPTARG}" ;;
a) attribute_names="${OPTARG}" ;;
v) attribute_values="${OPTARG}" ;;
p) projection_expression="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$table_name" ]]; then
errecho "ERROR: You must provide a table name with the -n parameter."
usage
return 1
fi
if [[ -z "$key_condition_expression" ]]; then
errecho "ERROR: You must provide a key condition expression with the -k parameter."
usage
return 1
fi
if [[ -z "$attribute_names" ]]; then
errecho "ERROR: You must provide a attribute names with the -a parameter."
usage
return 1
fi
if [[ -z "$attribute_values" ]]; then
errecho "ERROR: You must provide a attribute values with the -v parameter."
usage
return 1
fi
if [[ -z "$projection_expression" ]]; then
response=$(aws dynamodb query \
--table-name "$table_name" \
--key-condition-expression "$key_condition_expression" \
--expression-attribute-names file://"$attribute_names" \
--expression-attribute-values file://"$attribute_values")
else
response=$(aws dynamodb query \
--table-name "$table_name" \
--key-condition-expression "$key_condition_expression" \
--expression-attribute-names file://"$attribute_names" \
--expression-attribute-values file://"$attribute_values" \
--projection-expression "$projection_expression")
fi
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports query operation failed.$response"
return 1
fi
echo "$response"
return 0
}
```
Fonctions utilitaires utilisées dans cet exemple.
```
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
##############################################################################
# function aws_cli_error_log()
#
# This function is used to log the error messages from the AWS CLI.
#
# See https://docs.aws.amazon.com/cli/latest/topic/return-codes.html#cli-aws-help-return-codes.
#
# The function expects the following argument:
# $1 - The error code returned by the AWS CLI.
#
# Returns:
# 0: - Success.
#
##############################################################################
function aws_cli_error_log() {
local err_code=$1
errecho "Error code : $err_code"
if [ "$err_code" == 1 ]; then
errecho " One or more S3 transfers failed."
elif [ "$err_code" == 2 ]; then
errecho " Command line failed to parse."
elif [ "$err_code" == 130 ]; then
errecho " Process received SIGINT."
elif [ "$err_code" == 252 ]; then
errecho " Command syntax invalid."
elif [ "$err_code" == 253 ]; then
errecho " The system environment or configuration was invalid."
elif [ "$err_code" == 254 ]; then
errecho " The service returned an error."
elif [ "$err_code" == 255 ]; then
errecho " 255 is a catch-all error."
fi
return 0
}
```
+ Pour plus d’informations sur l’API, consultez [Query](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/Query) dans la *Référence des commandes AWS CLI *.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
//! Perform a query on an Amazon DynamoDB Table and retrieve items.
/*!
\sa queryItem()
\param tableName: The table name.
\param partitionKey: The partition key.
\param partitionValue: The value for the partition key.
\param projectionExpression: The projections expression, which is ignored if empty.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
/*
* The partition key attribute is searched with the specified value. By default, all fields and values
* contained in the item are returned. If an optional projection expression is
* specified on the command line, only the specified fields and values are
* returned.
*/
bool AwsDoc::DynamoDB::queryItems(const Aws::String &tableName,
const Aws::String &partitionKey,
const Aws::String &partitionValue,
const Aws::String &projectionExpression,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
Aws::DynamoDB::Model::QueryRequest request;
request.SetTableName(tableName);
if (!projectionExpression.empty()) {
request.SetProjectionExpression(projectionExpression);
}
// Set query key condition expression.
request.SetKeyConditionExpression(partitionKey + "= :valueToMatch");
// Set Expression AttributeValues.
Aws::Map attributeValues;
attributeValues.emplace(":valueToMatch", partitionValue);
request.SetExpressionAttributeValues(attributeValues);
bool result = true;
// "exclusiveStartKey" is used for pagination.
Aws::Map exclusiveStartKey;
do {
if (!exclusiveStartKey.empty()) {
request.SetExclusiveStartKey(exclusiveStartKey);
exclusiveStartKey.clear();
}
// Perform Query operation.
const Aws::DynamoDB::Model::QueryOutcome &outcome = dynamoClient.Query(request);
if (outcome.IsSuccess()) {
// Reference the retrieved items.
const Aws::Vector> &items = outcome.GetResult().GetItems();
if (!items.empty()) {
std::cout << "Number of items retrieved from Query: " << items.size()
<< std::endl;
// Iterate each item and print.
for (const auto &item: items) {
std::cout
<< "******************************************************"
<< std::endl;
// Output each retrieved field and its value.
for (const auto &i: item)
std::cout << i.first << ": " << i.second.GetS() << std::endl;
}
}
else {
std::cout << "No item found in table: " << tableName << std::endl;
}
exclusiveStartKey = outcome.GetResult().GetLastEvaluatedKey();
}
else {
std::cerr << "Failed to Query items: " << outcome.GetError().GetMessage();
result = false;
break;
}
} while (!exclusiveStartKey.empty());
return result;
}
```
+ Pour plus d’informations sur l’API, consultez [Requête](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/Query) dans la *référence d’API AWS SDK pour C\$1\$1 *.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour interroger une table**
L’exemple `query` suivant interroge des éléments dans la table `MusicCollection`. La table possède une clé hash-and-range primaire (`Artist`et`SongTitle`), mais cette requête indique uniquement la valeur de la clé de hachage. Elle renvoie les titres des chansons de l’artiste « No One You Know ».
```
aws dynamodb query \
--table-name MusicCollection \
--projection-expression "SongTitle" \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json \
--return-consumed-capacity TOTAL
```
Contenu de `expression-attributes.json` :
```
{
":v1": {"S": "No One You Know"}
}
```
Sortie :
```
{
"Items": [
{
"SongTitle": {
"S": "Call Me Today"
},
"SongTitle": {
"S": "Scared of My Shadow"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
Pour plus d’informations, consultez [Utilisation de requêtes dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 2 : pour interroger une table à l’aide de lectures fortement cohérentes et parcourir l’index par ordre décroissant**
L’exemple suivant exécute la même requête que le premier exemple, mais renvoie les résultats dans l’ordre inverse et utilise des lectures fortement cohérentes.
```
aws dynamodb query \
--table-name MusicCollection \
--projection-expression "SongTitle" \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json \
--consistent-read \
--no-scan-index-forward \
--return-consumed-capacity TOTAL
```
Contenu de `expression-attributes.json` :
```
{
":v1": {"S": "No One You Know"}
}
```
Sortie :
```
{
"Items": [
{
"SongTitle": {
"S": "Scared of My Shadow"
}
},
{
"SongTitle": {
"S": "Call Me Today"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
}
}
```
Pour plus d’informations, consultez [Utilisation des requêtes dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 3 : pour filtrer des résultats spécifiques**
L’exemple suivant interroge `MusicCollection`, mais exclut les résultats contenant des valeurs spécifiques dans l’attribut `AlbumTitle`. Notez que cela n’affecte pas `ScannedCount` ni `ConsumedCapacity`, car le filtre est appliqué après la lecture des éléments.
```
aws dynamodb query \
--table-name MusicCollection \
--key-condition-expression "#n1 = :v1" \
--filter-expression "NOT (#n2 IN (:v2, :v3))" \
--expression-attribute-names file://names.json \
--expression-attribute-values file://values.json \
--return-consumed-capacity TOTAL
```
Contenu de `values.json` :
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Blue Sky Blues"},
":v3": {"S": "Greatest Hits"}
}
```
Contenu de `names.json` :
```
{
"#n1": "Artist",
"#n2": "AlbumTitle"
}
```
Sortie :
```
{
"Items": [
{
"AlbumTitle": {
"S": "Somewhat Famous"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Call Me Today"
}
}
],
"Count": 1,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
Pour plus d’informations, consultez [Utilisation des requêtes dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 4 : pour extraire uniquement le nombre d’éléments**
L’exemple suivant extrait le nombre d’éléments correspondant à la requête, mais n’extrait aucun des éléments eux-mêmes.
```
aws dynamodb query \
--table-name MusicCollection \
--select COUNT \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json
```
Contenu de `expression-attributes.json` :
```
{
":v1": {"S": "No One You Know"}
}
```
Sortie :
```
{
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": null
}
```
Pour plus d’informations, consultez [Utilisation des requêtes dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) dans le *Guide du développeur Amazon DynamoDB*.
**Exemple 5 : pour interroger un index**
L’exemple suivant interroge l’index secondaire global `AlbumTitleIndex`. La requête renvoie tous les attributs de la table de base qui ont été projetés dans l’index secondaire local. Notez que lorsque vous interrogez un index secondaire local ou un index secondaire global, vous devez également fournir le nom de la table de base à l’aide du paramètre `table-name`.
```
aws dynamodb query \
--table-name MusicCollection \
--index-name AlbumTitleIndex \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json \
--select ALL_PROJECTED_ATTRIBUTES \
--return-consumed-capacity INDEXES
```
Contenu de `expression-attributes.json` :
```
{
":v1": {"S": "No One You Know"}
}
```
Sortie :
```
{
"Items": [
{
"AlbumTitle": {
"S": "Blue Sky Blues"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Scared of My Shadow"
}
},
{
"AlbumTitle": {
"S": "Somewhat Famous"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Call Me Today"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5,
"Table": {
"CapacityUnits": 0.0
},
"LocalSecondaryIndexes": {
"AlbumTitleIndex": {
"CapacityUnits": 0.5
}
}
}
}
```
Pour plus d’informations, consultez [Utilisation des requêtes dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) dans le *Guide du développeur Amazon DynamoDB*.
+ Pour plus d’informations sur l’API, consultez [Query](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/query.html) dans la *Référence des commandes AWS CLI *.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// TableBasics encapsulates the Amazon DynamoDB service actions used in the examples.
// It contains a DynamoDB service client that is used to act on the specified table.
type TableBasics struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// Query gets all movies in the DynamoDB table that were released in the specified year.
// The function uses the `expression` package to build the key condition expression
// that is used in the query.
func (basics TableBasics) Query(ctx context.Context, releaseYear int) ([]Movie, error) {
var err error
var response *dynamodb.QueryOutput
var movies []Movie
keyEx := expression.Key("year").Equal(expression.Value(releaseYear))
expr, err := expression.NewBuilder().WithKeyCondition(keyEx).Build()
if err != nil {
log.Printf("Couldn't build expression for query. Here's why: %v\n", err)
} else {
queryPaginator := dynamodb.NewQueryPaginator(basics.DynamoDbClient, &dynamodb.QueryInput{
TableName: aws.String(basics.TableName),
ExpressionAttributeNames: expr.Names(),
ExpressionAttributeValues: expr.Values(),
KeyConditionExpression: expr.KeyCondition(),
})
for queryPaginator.HasMorePages() {
response, err = queryPaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't query for movies released in %v. Here's why: %v\n", releaseYear, err)
break
} else {
var moviePage []Movie
err = attributevalue.UnmarshalListOfMaps(response.Items, &moviePage)
if err != nil {
log.Printf("Couldn't unmarshal query response. Here's why: %v\n", err)
break
} else {
movies = append(movies, moviePage...)
}
}
}
}
return movies, err
}
```
Définissez une structure Movie utilisée dans cet exemple.
```
import (
"archive/zip"
"bytes"
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// Movie encapsulates data about a movie. Title and Year are the composite primary key
// of the movie in Amazon DynamoDB. Title is the sort key, Year is the partition key,
// and Info is additional data.
type Movie struct {
Title string `dynamodbav:"title"`
Year int `dynamodbav:"year"`
Info map[string]interface{} `dynamodbav:"info"`
}
// GetKey returns the composite primary key of the movie in a format that can be
// sent to DynamoDB.
func (movie Movie) GetKey() map[string]types.AttributeValue {
title, err := attributevalue.Marshal(movie.Title)
if err != nil {
panic(err)
}
year, err := attributevalue.Marshal(movie.Year)
if err != nil {
panic(err)
}
return map[string]types.AttributeValue{"title": title, "year": year}
}
// String returns the title, year, rating, and plot of a movie, formatted for the example.
func (movie Movie) String() string {
return fmt.Sprintf("%v\n\tReleased: %v\n\tRating: %v\n\tPlot: %v\n",
movie.Title, movie.Year, movie.Info["rating"], movie.Info["plot"])
}
```
+ Pour plus d’informations sur l’API, consultez [Requête](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.Query) dans la *référence d’API AWS SDK pour Go *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
Interroge une table à l'aide de [DynamoDbClient](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/dynamodb/DynamoDbClient.html).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.QueryRequest;
import software.amazon.awssdk.services.dynamodb.model.QueryResponse;
import java.util.HashMap;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To query items from an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client. See the EnhancedQueryRecords example.
*/
public class Query {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table to put the item in (for example, Music3).
partitionKeyName - The partition key name of the Amazon DynamoDB table (for example, Artist).
partitionKeyVal - The value of the partition key that should match (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String partitionKeyName = args[1];
String partitionKeyVal = args[2];
// For more information about an alias, see:
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html
String partitionAlias = "#a";
System.out.format("Querying %s", tableName);
System.out.println("");
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
int count = queryTable(ddb, tableName, partitionKeyName, partitionKeyVal, partitionAlias);
System.out.println("There were " + count + " record(s) returned");
ddb.close();
}
public static int queryTable(DynamoDbClient ddb, String tableName, String partitionKeyName, String partitionKeyVal,
String partitionAlias) {
// Set up an alias for the partition key name in case it's a reserved word.
HashMap attrNameAlias = new HashMap();
attrNameAlias.put(partitionAlias, partitionKeyName);
// Set up mapping of the partition name with the value.
HashMap attrValues = new HashMap<>();
attrValues.put(":" + partitionKeyName, AttributeValue.builder()
.s(partitionKeyVal)
.build());
QueryRequest queryReq = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(partitionAlias + " = :" + partitionKeyName)
.expressionAttributeNames(attrNameAlias)
.expressionAttributeValues(attrValues)
.build();
try {
QueryResponse response = ddb.query(queryReq);
return response.count();
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return -1;
}
}
```
Interroge une table à l’aide de `DynamoDbClient` et d’un index secondaire.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.QueryRequest;
import software.amazon.awssdk.services.dynamodb.model.QueryResponse;
import java.util.HashMap;
import java.util.Map;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* Create the Movies table by running the Scenario example and loading the Movie
* data from the JSON file. Next create a secondary
* index for the Movies table that uses only the year column. Name the index
* **year-index**. For more information, see:
*
* https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html
*/
public class QueryItemsUsingIndex {
public static void main(String[] args) {
String tableName = "Movies";
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
queryIndex(ddb, tableName);
ddb.close();
}
public static void queryIndex(DynamoDbClient ddb, String tableName) {
try {
Map expressionAttributesNames = new HashMap<>();
expressionAttributesNames.put("#year", "year");
Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(":yearValue", AttributeValue.builder().n("2013").build());
QueryRequest request = QueryRequest.builder()
.tableName(tableName)
.indexName("year-index")
.keyConditionExpression("#year = :yearValue")
.expressionAttributeNames(expressionAttributesNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
System.out.println("=== Movie Titles ===");
QueryResponse response = ddb.query(request);
response.items()
.forEach(movie -> System.out.println(movie.get("title").s()));
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
+ Pour plus d’informations sur l’API, consultez [Requête](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) dans la *référence d’API AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples).
Cet exemple utilise le client de document pour simplifier l’utilisation d’éléments dans DynamoDB. Pour plus de détails sur l'API, voir [QueryCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-lib-dynamodb/Class/QueryCommand/).
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { QueryCommand, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
export const main = async () => {
const command = new QueryCommand({
TableName: "CoffeeCrop",
KeyConditionExpression:
"OriginCountry = :originCountry AND RoastDate > :roastDate",
ExpressionAttributeValues: {
":originCountry": "Ethiopia",
":roastDate": "2023-05-01",
},
ConsistentRead: true,
});
const response = await docClient.send(command);
console.log(response);
return response;
};
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/dynamodb-example-query-scan.html#dynamodb-example-table-query-scan-querying).
+ Pour plus d’informations sur l’API, consultez [Requête](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand) dans la *référence d’API AWS SDK pour JavaScript *.
**SDK pour JavaScript (v2)**
Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/dynamodb#code-examples).
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create DynamoDB document client
var docClient = new AWS.DynamoDB.DocumentClient({ apiVersion: "2012-08-10" });
var params = {
ExpressionAttributeValues: {
":s": 2,
":e": 9,
":topic": "PHRASE",
},
KeyConditionExpression: "Season = :s and Episode > :e",
FilterExpression: "contains (Subtitle, :topic)",
TableName: "EPISODES_TABLE",
};
docClient.query(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data.Items);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-example-query-scan.html#dynamodb-example-table-query-scan-querying).
+ Pour plus d’informations sur l’API, consultez [Requête](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/Query) dans la *référence d’API AWS SDK pour JavaScript *.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/dynamodb#code-examples).
```
suspend fun queryDynTable(
tableNameVal: String,
partitionKeyName: String,
partitionKeyVal: String,
partitionAlias: String,
): Int {
val attrNameAlias = mutableMapOf()
attrNameAlias[partitionAlias] = partitionKeyName
// Set up mapping of the partition name with the value.
val attrValues = mutableMapOf()
attrValues[":$partitionKeyName"] = AttributeValue.S(partitionKeyVal)
val request =
QueryRequest {
tableName = tableNameVal
keyConditionExpression = "$partitionAlias = :$partitionKeyName"
expressionAttributeNames = attrNameAlias
this.expressionAttributeValues = attrValues
}
DynamoDbClient.fromEnvironment { region = "us-east-1" }.use { ddb ->
val response = ddb.query(request)
return response.count
}
}
```
+ Pour plus de détails sur l’API, consultez [Query](https://sdk.amazonaws.com/kotlin/api/latest/index.html) dans la *Référence des API du kit AWS SDK pour Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
```
$birthKey = [
'Key' => [
'year' => [
'N' => "$birthYear",
],
],
];
$result = $service->query($tableName, $birthKey);
public function query(string $tableName, $key)
{
$expressionAttributeValues = [];
$expressionAttributeNames = [];
$keyConditionExpression = "";
$index = 1;
foreach ($key as $name => $value) {
$keyConditionExpression .= "#" . array_key_first($value) . " = :v$index,";
$expressionAttributeNames["#" . array_key_first($value)] = array_key_first($value);
$hold = array_pop($value);
$expressionAttributeValues[":v$index"] = [
array_key_first($hold) => array_pop($hold),
];
}
$keyConditionExpression = substr($keyConditionExpression, 0, -1);
$query = [
'ExpressionAttributeValues' => $expressionAttributeValues,
'ExpressionAttributeNames' => $expressionAttributeNames,
'KeyConditionExpression' => $keyConditionExpression,
'TableName' => $tableName,
];
return $this->dynamoDbClient->query($query);
}
```
+ Pour plus de détails sur l’API, consultez [Query](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query) dans la *Référence des API du kit AWS SDK pour PHP *.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : invoque une requête qui renvoie des éléments DynamoDB avec les valeurs spécifiées et Artist. SongTitle **
```
$invokeDDBQuery = @{
TableName = 'Music'
KeyConditionExpression = ' SongTitle = :SongTitle and Artist = :Artist'
ExpressionAttributeValues = @{
':SongTitle' = 'Somewhere Down The Road'
':Artist' = 'No One You Know'
} | ConvertTo-DDBItem
}
Invoke-DDBQuery @invokeDDBQuery | ConvertFrom-DDBItem
```
**Sortie** :
```
Name Value
---- -----
Genre Country
Artist No One You Know
Price 1.94
CriticRating 9
SongTitle Somewhere Down The Road
AlbumTitle Somewhat Famous
```
+ Pour plus de détails sur l’API, consultez [Query](https://docs.aws.amazon.com/powershell/v4/reference) dans la *Référence des applets de commande pour les Outils AWS pour PowerShell (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : invoque une requête qui renvoie des éléments DynamoDB avec les valeurs spécifiées et Artist. SongTitle **
```
$invokeDDBQuery = @{
TableName = 'Music'
KeyConditionExpression = ' SongTitle = :SongTitle and Artist = :Artist'
ExpressionAttributeValues = @{
':SongTitle' = 'Somewhere Down The Road'
':Artist' = 'No One You Know'
} | ConvertTo-DDBItem
}
Invoke-DDBQuery @invokeDDBQuery | ConvertFrom-DDBItem
```
**Sortie** :
```
Name Value
---- -----
Genre Country
Artist No One You Know
Price 1.94
CriticRating 9
SongTitle Somewhere Down The Road
AlbumTitle Somewhat Famous
```
+ Pour plus de détails sur l’API, consultez [Query](https://docs.aws.amazon.com/powershell/v5/reference) dans la *Référence des applets de commande pour les Outils AWS pour PowerShell (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/dynamodb#code-examples).
Interrogez des éléments à l’aide d’une expression de condition clé.
```
class Movies:
"""Encapsulates an Amazon DynamoDB table of movie data.
Example data structure for a movie record in this table:
{
"year": 1999,
"title": "For Love of the Game",
"info": {
"directors": ["Sam Raimi"],
"release_date": "1999-09-15T00:00:00Z",
"rating": 6.3,
"plot": "A washed up pitcher flashes through his career.",
"rank": 4987,
"running_time_secs": 8220,
"actors": [
"Kevin Costner",
"Kelly Preston",
"John C. Reilly"
]
}
}
"""
def __init__(self, dyn_resource):
"""
:param dyn_resource: A Boto3 DynamoDB resource.
"""
self.dyn_resource = dyn_resource
# The table variable is set during the scenario in the call to
# 'exists' if the table exists. Otherwise, it is set by 'create_table'.
self.table = None
def query_movies(self, year):
"""
Queries for movies that were released in the specified year.
:param year: The year to query.
:return: The list of movies that were released in the specified year.
"""
try:
response = self.table.query(KeyConditionExpression=Key("year").eq(year))
except ClientError as err:
logger.error(
"Couldn't query for movies released in %s. Here's why: %s: %s",
year,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response["Items"]
```
Interrogez des éléments et projetez-les pour renvoyer un sous-ensemble de données.
```
class UpdateQueryWrapper:
def __init__(self, table):
self.table = table
def query_and_project_movies(self, year, title_bounds):
"""
Query for movies that were released in a specified year and that have titles
that start within a range of letters. A projection expression is used
to return a subset of data for each movie.
:param year: The release year to query.
:param title_bounds: The range of starting letters to query.
:return: The list of movies.
"""
try:
response = self.table.query(
ProjectionExpression="#yr, title, info.genres, info.actors[0]",
ExpressionAttributeNames={"#yr": "year"},
KeyConditionExpression=(
Key("year").eq(year)
& Key("title").between(
title_bounds["first"], title_bounds["second"]
)
),
)
except ClientError as err:
if err.response["Error"]["Code"] == "ValidationException":
logger.warning(
"There's a validation error. Here's the message: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
else:
logger.error(
"Couldn't query for movies. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response["Items"]
```
+ Pour plus de détails sur l’API, consultez [Query](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/dynamodb#code-examples).
```
class DynamoDBBasics
attr_reader :dynamo_resource, :table
def initialize(table_name)
client = Aws::DynamoDB::Client.new(region: 'us-east-1')
@dynamo_resource = Aws::DynamoDB::Resource.new(client: client)
@table = @dynamo_resource.table(table_name)
end
# Queries for movies that were released in the specified year.
#
# @param year [Integer] The year to query.
# @return [Array] The list of movies that were released in the specified year.
def query_items(year)
response = @table.query(
key_condition_expression: '#yr = :year',
expression_attribute_names: { '#yr' => 'year' },
expression_attribute_values: { ':year' => year }
)
rescue Aws::DynamoDB::Errors::ServiceError => e
puts("Couldn't query for movies released in #{year}. Here's why:")
puts("\t#{e.code}: #{e.message}")
raise
else
response.items
end
```
+ Pour plus d’informations sur l’API, consultez [Requête](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/Query) dans la *référence d’API AWS SDK pour Ruby *.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
Trouvez les films réalisés au cours de l’année spécifiée.
```
pub async fn movies_in_year(
client: &Client,
table_name: &str,
year: u16,
) -> Result, MovieError> {
let results = client
.query()
.table_name(table_name)
.key_condition_expression("#yr = :yyyy")
.expression_attribute_names("#yr", "year")
.expression_attribute_values(":yyyy", AttributeValue::N(year.to_string()))
.send()
.await?;
if let Some(items) = results.items {
let movies = items.iter().map(|v| v.into()).collect();
Ok(movies)
} else {
Ok(vec![])
}
}
```
+ Pour plus de détails sur l’API, consultez [Query](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.query) dans la *Référence des API du kit AWS SDK pour Rust*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/dyn#code-examples).
```
TRY.
" Query movies for a given year .
DATA(lt_attributelist) = VALUE /aws1/cl_dynattributevalue=>tt_attributevaluelist(
( NEW /aws1/cl_dynattributevalue( iv_n = |{ iv_year }| ) ) ).
DATA(lt_key_conditions) = VALUE /aws1/cl_dyncondition=>tt_keyconditions(
( VALUE /aws1/cl_dyncondition=>ts_keyconditions_maprow(
key = 'year'
value = NEW /aws1/cl_dyncondition(
it_attributevaluelist = lt_attributelist
iv_comparisonoperator = |EQ|
) ) ) ).
oo_result = lo_dyn->query(
iv_tablename = iv_table_name
it_keyconditions = lt_key_conditions ).
DATA(lt_items) = oo_result->get_items( ).
"You can loop over the results to get item attributes.
LOOP AT lt_items INTO DATA(lt_item).
DATA(lo_title) = lt_item[ key = 'title' ]-value.
DATA(lo_year) = lt_item[ key = 'year' ]-value.
ENDLOOP.
DATA(lv_count) = oo_result->get_count( ).
MESSAGE 'Item count is: ' && lv_count TYPE 'I'.
CATCH /aws1/cx_dynresourcenotfoundex.
MESSAGE 'The table or index does not exist' TYPE 'E'.
ENDTRY.
```
+ Pour plus d’informations sur l’API, consultez [Query](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) dans le *guide de référence d’API du kit SDK AWS pour SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/dynamodb#code-examples).
```
import AWSDynamoDB
/// Get all the movies released in the specified year.
///
/// - Parameter year: The release year of the movies to return.
///
/// - Returns: An array of `Movie` objects describing each matching movie.
///
func getMovies(fromYear year: Int) async throws -> [Movie] {
do {
guard let client = self.ddbClient else {
throw MoviesError.UninitializedClient
}
let input = QueryInput(
expressionAttributeNames: [
"#y": "year"
],
expressionAttributeValues: [
":y": .n(String(year))
],
keyConditionExpression: "#y = :y",
tableName: self.tableName
)
// Use "Paginated" to get all the movies.
// This lets the SDK handle the 'lastEvaluatedKey' property in "QueryOutput".
let pages = client.queryPaginated(input: input)
var movieList: [Movie] = []
for try await page in pages {
guard let items = page.items else {
print("Error: no items returned.")
continue
}
// Convert the found movies into `Movie` objects and return an array
// of them.
for item in items {
let movie = try Movie(withItem: item)
movieList.append(movie)
}
}
return movieList
} catch {
print("ERROR: getMovies:", dump(error))
throw error
}
}
```
+ Pour plus d’informations sur l’API, consultez [Requête](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/query(input:)) dans la *référence de l’API du kit SDK AWS for Swift*.
------
Pour obtenir plus d’exemples avec DynamoDB, consultez [Exemples de code pour DynamoDB utilisant AWS SDKs](service_code_examples.md).
Pour créer un index secondaire global pour votre table, passez à l’ [Étape 6 : (Facultatif) supprimer votre table DynamoDB pour nettoyer les ressources](getting-started-step-6.md).
# Étape 6 : (Facultatif) supprimer votre table DynamoDB pour nettoyer les ressources
Si vous n’avez plus besoin de la table Amazon DynamoDB que vous avez créée pour le didacticiel, vous pouvez la supprimer. Cette étape permet de vous assurer de ne pas être facturé pour des ressources que vous n’utilisez pas. Vous pouvez utiliser la console DynamoDB ou AWS CLI le pour supprimer la table que vous avez `Music` créée dans. [Étape 1 : création d’une table dans DynamoDB](getting-started-step-1.md)
Pour plus d’informations sur les opérations de table dans DynamoDB, consultez [Utilisation de tables et de données dans DynamoDB](WorkingWithTables.md).
## AWS Management Console
Pour supprimer la table `Music` à l’aide de la console :
1. Ouvrez la console DynamoDB à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dans le volet de navigation de gauche, choisissez **Tables**.
1. Choisissez la case à cocher en regard de la table **Musique** dans la liste de tables.
1. Sélectionnez **Delete (Supprimer)**.
## AWS CLI
L' AWS CLI exemple suivant supprime le `Music` tableau à l'aide `delete-table` de.
```
aws dynamodb delete-table --table-name Music
```
## AWS SDK
Les exemples de code suivants montrent comment supprimer une table DynamoDB à l’aide d’un kit SDK AWS .
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/DynamoDB#code-examples).
```
///
/// Deletes a DynamoDB table.
///
/// The name of the table to delete.
/// A Boolean value indicating the success of the operation.
public async Task DeleteTableAsync(string tableName)
{
try
{
var request = new DeleteTableRequest
{
TableName = tableName,
};
var response = await _amazonDynamoDB.DeleteTableAsync(request);
Console.WriteLine($"Table {response.TableDescription.TableName} successfully deleted.");
return true;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine($"Table {tableName} was not found and cannot be deleted. {ex.Message}");
return false;
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine($"An Amazon DynamoDB error occurred while deleting table {tableName}. {ex.Message}");
return false;
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred while deleting table {tableName}. {ex.Message}");
return false;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/DeleteTable)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/dynamodb#code-examples).
```
###############################################################################
# function dynamodb_delete_table
#
# This function deletes a DynamoDB table.
#
# Parameters:
# -n table_name -- The name of the table to delete.
#
# Returns:
# 0 - If successful.
# 1 - If it fails.
###############################################################################
function dynamodb_delete_table() {
local table_name response
local option OPTARG # Required to use getopts command in a function.
# bashsupport disable=BP5008
function usage() {
echo "function dynamodb_delete_table"
echo "Deletes an Amazon DynamoDB table."
echo " -n table_name -- The name of the table to delete."
echo ""
}
# Retrieve the calling parameters.
while getopts "n:h" option; do
case "${option}" in
n) table_name="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$table_name" ]]; then
errecho "ERROR: You must provide a table name with the -n parameter."
usage
return 1
fi
iecho "Parameters:\n"
iecho " table_name: $table_name"
iecho ""
response=$(aws dynamodb delete-table \
--table-name "$table_name")
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports delete-table operation failed.$response"
return 1
fi
return 0
}
```
Fonctions utilitaires utilisées dans cet exemple.
```
###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
if [[ $VERBOSE == true ]]; then
echo "$@"
fi
}
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
##############################################################################
# function aws_cli_error_log()
#
# This function is used to log the error messages from the AWS CLI.
#
# See https://docs.aws.amazon.com/cli/latest/topic/return-codes.html#cli-aws-help-return-codes.
#
# The function expects the following argument:
# $1 - The error code returned by the AWS CLI.
#
# Returns:
# 0: - Success.
#
##############################################################################
function aws_cli_error_log() {
local err_code=$1
errecho "Error code : $err_code"
if [ "$err_code" == 1 ]; then
errecho " One or more S3 transfers failed."
elif [ "$err_code" == 2 ]; then
errecho " Command line failed to parse."
elif [ "$err_code" == 130 ]; then
errecho " Process received SIGINT."
elif [ "$err_code" == 252 ]; then
errecho " Command syntax invalid."
elif [ "$err_code" == 253 ]; then
errecho " The system environment or configuration was invalid."
elif [ "$err_code" == 254 ]; then
errecho " The service returned an error."
elif [ "$err_code" == 255 ]; then
errecho " 255 is a catch-all error."
fi
return 0
}
```
+ Pour plus de détails sur l'API, voir [DeleteTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/DeleteTable)la section *Référence des AWS CLI commandes*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
//! Delete an Amazon DynamoDB table.
/*!
\sa deleteTable()
\param tableName: The DynamoDB table name.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::deleteTable(const Aws::String &tableName,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
Aws::DynamoDB::Model::DeleteTableRequest request;
request.SetTableName(tableName);
const Aws::DynamoDB::Model::DeleteTableOutcome &result = dynamoClient.DeleteTable(
request);
if (result.IsSuccess()) {
std::cout << "Your table \""
<< result.GetResult().GetTableDescription().GetTableName()
<< " was deleted.\n";
}
else {
std::cerr << "Failed to delete table: " << result.GetError().GetMessage()
<< std::endl;
}
return result.IsSuccess();
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/DeleteTable)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Pour supprimer une table**
L’exemple `delete-table` suivant supprime la table `MusicCollection`.
```
aws dynamodb delete-table \
--table-name MusicCollection
```
Sortie :
```
{
"TableDescription": {
"TableStatus": "DELETING",
"TableSizeBytes": 0,
"ItemCount": 0,
"TableName": "MusicCollection",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 5
}
}
}
```
Pour plus d’informations, consultez [Suppression d’une table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeleteTable) dans le *Guide du développeur Amazon DynamoDB*.
+ Pour plus de détails sur l'API, voir [DeleteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-table.html)la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
"github.com/aws/aws-sdk-go-v2/feature/dynamodb/expression"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// TableBasics encapsulates the Amazon DynamoDB service actions used in the examples.
// It contains a DynamoDB service client that is used to act on the specified table.
type TableBasics struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// DeleteTable deletes the DynamoDB table and all of its data.
func (basics TableBasics) DeleteTable(ctx context.Context) error {
_, err := basics.DynamoDbClient.DeleteTable(ctx, &dynamodb.DeleteTableInput{
TableName: aws.String(basics.TableName)})
if err != nil {
log.Printf("Couldn't delete table %v. Here's why: %v\n", basics.TableName, err)
}
return err
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.DeleteTable)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DeleteTableRequest;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DeleteTable {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table to delete (for example, Music3).
**Warning** This program will delete the table that you specify!
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
System.out.format("Deleting the Amazon DynamoDB table %s...\n", tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
deleteDynamoDBTable(ddb, tableName);
ddb.close();
}
public static void deleteDynamoDBTable(DynamoDbClient ddb, String tableName) {
DeleteTableRequest request = DeleteTableRequest.builder()
.tableName(tableName)
.build();
try {
ddb.deleteTable(request);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
System.out.println(tableName + " was successfully deleted!");
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DeleteTable)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples).
```
import { DeleteTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient({});
export const main = async () => {
const command = new DeleteTableCommand({
TableName: "DecafCoffees",
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/DeleteTableCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus sur GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/dynamodb#code-examples).
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the DynamoDB service object
var ddb = new AWS.DynamoDB({ apiVersion: "2012-08-10" });
var params = {
TableName: process.argv[2],
};
// Call DynamoDB to delete the specified table
ddb.deleteTable(params, function (err, data) {
if (err && err.code === "ResourceNotFoundException") {
console.log("Error: Table not found");
} else if (err && err.code === "ResourceInUseException") {
console.log("Error: Table in use");
} else {
console.log("Success", data);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-examples-using-tables.html#dynamodb-examples-using-tables-deleting-a-table).
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/DeleteTable)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/dynamodb#code-examples).
```
suspend fun deleteDynamoDBTable(tableNameVal: String) {
val request =
DeleteTableRequest {
tableName = tableNameVal
}
DynamoDbClient.fromEnvironment { region = "us-east-1" }.use { ddb ->
ddb.deleteTable(request)
println("$tableNameVal was deleted")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteTable](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
```
public function deleteTable(string $TableName)
{
$this->customWaiter(function () use ($TableName) {
return $this->dynamoDbClient->deleteTable([
'TableName' => $TableName,
]);
});
}
```
+ Pour plus de détails sur l'API, voir [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)la section *Référence des AWS SDK pour PHP API*.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : supprime la table spécifiée. Vous êtes invité à confirmer avant que l’opération ne se poursuive.**
```
Remove-DDBTable -TableName "myTable"
```
**Exemple 2 : supprime la table spécifiée. Aucune confirmation ne vous est demandée avant le début de l’opération.**
```
Remove-DDBTable -TableName "myTable" -Force
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/powershell/v4/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : supprime la table spécifiée. Vous êtes invité à confirmer avant que l’opération ne se poursuive.**
```
Remove-DDBTable -TableName "myTable"
```
**Exemple 2 : supprime la table spécifiée. Aucune confirmation ne vous est demandée avant le début de l’opération.**
```
Remove-DDBTable -TableName "myTable" -Force
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://docs.aws.amazon.com/powershell/v5/reference)à la section *Référence des Outils AWS pour PowerShell applets de commande (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/dynamodb#code-examples).
```
class Movies:
"""Encapsulates an Amazon DynamoDB table of movie data.
Example data structure for a movie record in this table:
{
"year": 1999,
"title": "For Love of the Game",
"info": {
"directors": ["Sam Raimi"],
"release_date": "1999-09-15T00:00:00Z",
"rating": 6.3,
"plot": "A washed up pitcher flashes through his career.",
"rank": 4987,
"running_time_secs": 8220,
"actors": [
"Kevin Costner",
"Kelly Preston",
"John C. Reilly"
]
}
}
"""
def __init__(self, dyn_resource):
"""
:param dyn_resource: A Boto3 DynamoDB resource.
"""
self.dyn_resource = dyn_resource
# The table variable is set during the scenario in the call to
# 'exists' if the table exists. Otherwise, it is set by 'create_table'.
self.table = None
def delete_table(self):
"""
Deletes the table.
"""
try:
self.table.delete()
self.table = None
except ClientError as err:
logger.error(
"Couldn't delete table. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Pour plus de détails sur l'API, consultez [DeleteTable](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/DeleteTable)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/dynamodb#code-examples).
```
# Encapsulates an Amazon DynamoDB table of movie data.
class Scaffold
attr_reader :dynamo_resource, :table_name, :table
def initialize(table_name)
client = Aws::DynamoDB::Client.new(region: 'us-east-1')
@dynamo_resource = Aws::DynamoDB::Resource.new(client: client)
@table_name = table_name
@table = nil
@logger = Logger.new($stdout)
@logger.level = Logger::DEBUG
end
# Deletes the table.
def delete_table
@table.delete
@table = nil
rescue Aws::DynamoDB::Errors::ServiceError => e
puts("Couldn't delete table. Here's why:")
puts("\t#{e.code}: #{e.message}")
raise
end
```
+ Pour plus de détails sur l'API, voir [DeleteTable](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/DeleteTable)la section *Référence des AWS SDK pour Ruby API*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn delete_table(client: &Client, table: &str) -> Result {
let resp = client.delete_table().table_name(table).send().await;
match resp {
Ok(out) => {
println!("Deleted table");
Ok(out)
}
Err(e) => Err(Error::Unhandled(e.into())),
}
}
```
+ Pour plus de détails sur l'API, voir [DeleteTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.delete_table)la section de *référence de l'API AWS SDK for Rust*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/dyn#code-examples).
```
TRY.
lo_dyn->deletetable( iv_tablename = iv_table_name ).
" Wait till the table is actually deleted.
lo_dyn->get_waiter( )->tablenotexists(
iv_max_wait_time = 200
iv_tablename = iv_table_name ).
MESSAGE 'Table ' && iv_table_name && ' deleted.' TYPE 'I'.
CATCH /aws1/cx_dynresourcenotfoundex.
MESSAGE 'The table ' && iv_table_name && ' does not exist' TYPE 'E'.
CATCH /aws1/cx_dynresourceinuseex.
MESSAGE 'The table cannot be deleted since it is in use' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez [DeleteTable](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/dynamodb#code-examples).
```
import AWSDynamoDB
///
/// Deletes the table from Amazon DynamoDB.
///
func deleteTable() async throws {
do {
guard let client = self.ddbClient else {
throw MoviesError.UninitializedClient
}
let input = DeleteTableInput(
tableName: self.tableName
)
_ = try await client.deleteTable(input: input)
} catch {
print("ERROR: deleteTable:", dump(error))
throw error
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTable](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/deletetable(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
Pour obtenir plus d’exemples avec DynamoDB, consultez [Exemples de code pour DynamoDB utilisant AWS SDKs](service_code_examples.md).
# Poursuivre l’apprentissage concernant DynamoDB
Pour plus d’informations sur l’utilisation d’Amazon DynamoDB, consultez les rubriques suivantes :
+ [Utilisation de tables et de données dans DynamoDB](WorkingWithTables.md)
+ [Utilisation d’éléments et d’attributs dans DynamoDB](WorkingWithItems.md)
+ [Interrogation de tables dans DynamoDB](Query.md)
+ [Utilisation d’index secondaires globaux dans DynamoDB](GSI.md)
+ [Utilisation des transactionsExemple de code](transactions.md)
+ [Accélération en mémoire avec DynamoDB Accelerator (DAX)](DAX.md)
+ [Programmation avec DynamoDB et le AWS SDKs](Programming.md)
# Générez du code d'infrastructure pour Amazon DynamoDB à l'aide de Console-to-Code
La Console-to-Code fonctionnalité Amazon Q Developer simplifie la gestion de l'infrastructure pour Amazon DynamoDB en transformant les étapes de création manuelle de tables en code d'automatisation reproductible. Cette fonctionnalité aide les développeurs à mettre à l’échelle efficacement la configuration des ressources de base de données dans leurs environnements. Pour plus d'informations, consultez [Automatiser Services AWS avec Amazon Q Developer Console-to-Code](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/console-to-code.html).
Console-to-Code capture les configurations détaillées des tables DynamoDB, y compris les clés de partition, les clés de tri, les paramètres de débit provisionnés et les index secondaires, et les convertit en modèles précis. infrastructure-as-code Grâce à l’IA générative, cet outil garantit que le code généré maintient la compatibilité des paramètres établie au cours du flux de travail de la console.
Les développeurs peuvent générer du code d’infrastructure DynamoDB dans plusieurs formats, tels que :
+ AWS Cloud Development Kit (AWS CDK) TypeScript en Python et Java
+ CloudFormation en YAML ou JSON
Cette approche permet aux équipes de :
+ normaliser la gestion des ressources de base de données ;
+ mettre en œuvre une infrastructure contrôlée par version ;
+ réduire les erreurs de configuration manuelle.
Console-to-Code pour Amazon DynamoDB est disponible dans toutes les régions AWS commerciales, fournissant une solution puissante pour transformer les configurations manuelles en code d'infrastructure automatisé et reproductible.
## Comment ça marche
Lors de l'utilisation Console-to-Code avec DynamoDB, le processus implique généralement :
1. **Prototypage dans la console** : utilisez la console DynamoDB pour créer et configurer des ressources telles que des tables. Consultez [Connect to Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) pour plus d’informations.
1. **Enregistrement des actions** : Console-to-Code enregistre ces actions au fur et à mesure que vous les effectuez.
1. **Génération de code** : cette fonctionnalité utilise les capacités d’IA générative d’Amazon Q Developer pour transformer les actions de votre console en code réutilisable dans le format de votre choix.
1. **Personnalisation du code** : vous pouvez ensuite copier ou télécharger ce code et le personnaliser davantage en fonction de vos charges de travail de production.
## Avantages de l'utilisation Console-to-Code avec DynamoDB
**Automatisation simplifiée**
Convertissez la création et la configuration manuelles de tables DynamoDB en code réutilisable d’un simple clic.
**Bonnes pratiques**
Le code généré suit les meilleures pratiques AWS guidées pour des déploiements fiables.
**Pont entre la console et le code**
Vous n'avez pas à choisir entre utiliser le AWS Management Console ou Infrastructure-as-Code (iAc). Vous pouvez utiliser les deux approches ensemble.
**Développement accéléré**
Démarrez rapidement avec un code d’automatisation qui peut être davantage personnalisé pour une utilisation en production.
## Exemples de cas d’utilisation
+ Création de tables DynamoDB avec des attributs, des clés et des paramètres de capacité spécifiques
+ Configuration d’index secondaires globaux et d’index secondaires locaux
+ Configuration de politiques d’autoscaling pour les tables DynamoDB
+ Définition de configurations de sauvegarde et de restauration
+ Création et gestion de DynamoDB Streams
## Prise en main
Pour commencer à utiliser Console-to-Code DynamoDB :
1. Connectez-vous à la console DynamoDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/dynamodbv2/](https://console.aws.amazon.com/dynamodbv2/)
1. Commencez à créer ou à modifier des ressources DynamoDB via l’interface de console.
1. Utilisez Console-to-Code cette fonctionnalité pour générer du code pour vos actions dans le format de votre choix.
1. Copiez ou téléchargez le code généré et personnalisez-le selon vos besoins spécifiques.
Pour plus d'informations et des instructions détaillées sur l'utilisation Console-to-Code, consultez [Automating Services AWS with Amazon Q Developer Console-to-Code](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/console-to-code.html) dans le *guide de l'utilisateur Amazon Q Developer*.