()
{
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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 .NET 的 AWS SDK API 參考》**中的 [CreateTable](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/CreateTable)。
------
#### [ Bash ]
**AWS CLI 使用 Bash 指令碼**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
此範例中使用的公用程式函數。
```
###############################################################################
# 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
}
```
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/CreateTable)。
------
#### [ C\$1\$1 ]
**適用於 C\$1\$1 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
等待資料表變成作用中的程式碼。
```
//! 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;
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 C\$1\$1 的 AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/CreateTable)。
------
#### [ CLI ]
**AWS CLI**
**範例 1：建立具有標籤的資料表**
下列 `create-table` 範例使用指定的屬性和索引鍵結構描述，建立名為 `MusicCollection` 的資料表。此資料表使用佈建輸送量，並使用預設 AWS 擁有的 CMK 進行靜態加密。該命令也會運用索引鍵 `Owner` 和值 `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
```
輸出：
```
{
"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"
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 2：在隨需模式下建立資料表**
以下範例使用隨需模式 (而非佈建的輸送量模式)，建立名為 `MusicCollection` 的資料表。這適用於工作負載無法預測的資料表。
```
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
```
輸出：
```
{
"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"
}
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 3：建立資料表，並使用客戶管理的 CMK 進行加密**
下列範例建立名為 `MusicCollection` 的資料表，並使用客戶管理的 CMK 將其加密。
```
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
```
輸出：
```
{
"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"
}
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 4：建立具有本機次要索引的資料表**
以下範例使用指定的屬性和索引鍵結構描述，建立名為 `MusicCollection` 的資料表，其中包含名為 `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\"]
}
}
]"
```
輸出：
```
{
"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"
}
]
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 5：建立具有全域次要索引的資料表**
以下範例會建立名為 `GameScores` 的資料表，以及名為 `GameTitleIndex` 的全域次要索引。基礎資料表具有分割區索引鍵 `UserId` 和排序索引鍵 `GameTitle`，可讓您有效率地找到個別使用者在特定遊戲中的最佳分數，而 GSI 具有分割區索引鍵 `GameTitle` 和排序索引鍵 `TopScore`，可讓您快速找到特定遊戲的整體最高分數。
```
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
}
}
]"
```
輸出：
```
{
"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"
}
]
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 6：建立具有多個全域次要索引的資料表**
以下範例會建立名為 `GameScores`，且具有兩個全域次要索引的資料表。GSI 結構描述是透過檔案傳遞，而不是在命令列上傳遞。
```
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
```
`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
}
}
]
```
輸出：
```
{
"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"
}
]
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 7：建立已啟用串流的資料表**
下列範例建立名為 `GameScores`，並啟用 DynamoDB Streams 的資料表。每個項目的新舊映像都會寫入串流。
```
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
```
輸出：
```
{
"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"
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[資料表基本操作](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html)。
**範例 8：建立已啟用僅限索引鍵串流的資料表**
下列範例建立名為 `GameScores`，並啟用 DynamoDB Streams 的資料表。只有修改過的項目索引鍵屬性才會寫入串流。
```
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
```
輸出：
```
{
"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
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[ DynamoDB Streams 的變更資料擷取](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html)。
**範例 9：建立具有 Standard Infrequent Access 類別的資料表**
下列範例會建立名為 `GameScores` 的資料表，並指派 Standard-Infrequent Access (DynamoDB Standard-IA) 資料表類別。此資料表類別針對主要成本的儲存進行最佳化。
```
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
```
輸出：
```
{
"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
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[資料表類別](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html)。
**範例 10：建立已啟用刪除保護的資料表**
下列範例會建立名為 `GameScores`，並啟用刪除保護的資料表。
```
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
```
輸出：
```
{
"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
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[使用刪除保護](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeletionProtection)。
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [CreateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-table.html)。
------
#### [ Go ]
**SDK for Go V2**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Go 的 AWS SDK API 參考*》中的 [CreateTable](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.CreateTable)。
------
#### [ Java ]
**適用於 Java 2.x 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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 "";
}
}
```
+ 如需 API 的詳細資訊，請參閱《*AWS SDK for Java 2.x API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)。
------
#### [ JavaScript ]
**適用於 JavaScript (v3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
};
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/dynamodb-examples-using-tables.html#dynamodb-examples-using-tables-creating-a-table)》。
+ 如需 API 的詳細資訊，請參閱《*適用於 JavaScript 的 AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/CreateTableCommand)。
**適用於 JavaScript (v2) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
});
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-examples-using-tables.html#dynamodb-examples-using-tables-creating-a-table)》。
+ 如需 API 的詳細資訊，請參閱《*適用於 JavaScript 的 AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/CreateTable)。
------
#### [ Kotlin ]
**適用於 Kotlin 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Kotlin 的AWS SDK API 參考*》中的 [CreateTable](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples)中設定和執行。
建立資料表。
```
$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],
]);
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**範例 1：此範例會建立名為 Thread 的資料表，其主索引鍵包含 'ForumName' (索引鍵類型雜湊) 和 'Subject' (索引鍵類型範圍)。用來建構資料表的結構描述，可以使用 -Schema 參數，依照所示或指定方式輸送至每個 cmdlet。**
```
$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
```
**輸出：**
```
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 : {}
```
**範例 2：此範例會建立名為 Thread 的資料表，其主索引鍵包含 'ForumName' (索引鍵類型雜湊) 和 'Subject' (索引鍵類型範圍)。也會定義本機次要索引。本機次要索引的索引鍵會從資料表 (ForumName) 上的主要雜湊索引鍵自動設定。用來建構資料表的結構描述，可以使用 -Schema 參數，依照所示或指定方式輸送至每個 cmdlet。**
```
$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
```
**輸出：**
```
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}
```
**範例 3：此範例示範如何使用單一管道建立名為 Thread 的資料表，該資料表的主索引鍵包含 'ForumName' (索引鍵類型雜湊) 和 'Subject' (索引鍵類型範圍) 以及本機次要索引。如果管道或 -Schema 參數未提供新的 TableSchema 物件，Add-DDBKeySchema 和 Add-DDBIndexSchema 會為您建立新的 TableSchema 物件。**
```
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
```
**輸出：**
```
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}
```
+ 如需 API 詳細資訊，請參閱《AWS Tools for PowerShell Cmdlet 參考 (V4)》**中的 [CreateTable](https://docs.aws.amazon.com/powershell/v4/reference)。
**Tools for PowerShell V5**
**範例 1：此範例會建立名為 Thread 的資料表，其主索引鍵包含 'ForumName' (索引鍵類型雜湊) 和 'Subject' (索引鍵類型範圍)。用來建構資料表的結構描述，可以使用 -Schema 參數，依照所示或指定方式輸送至每個 cmdlet。**
```
$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
```
**輸出：**
```
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 : {}
```
**範例 2：此範例會建立名為 Thread 的資料表，其主索引鍵包含 'ForumName' (索引鍵類型雜湊) 和 'Subject' (索引鍵類型範圍)。也會定義本機次要索引。本機次要索引的索引鍵會從資料表 (ForumName) 上的主要雜湊索引鍵自動設定。用來建構資料表的結構描述，可以使用 -Schema 參數，依照所示或指定方式輸送至每個 cmdlet。**
```
$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
```
**輸出：**
```
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}
```
**範例 3：此範例示範如何使用單一管道建立名為 Thread 的資料表，該資料表的主索引鍵包含 'ForumName' (索引鍵類型雜湊) 和 'Subject' (索引鍵類型範圍) 以及本機次要索引。如果管道或 -Schema 參數未提供新的 TableSchema 物件，Add-DDBKeySchema 和 Add-DDBIndexSchema 會為您建立新的 TableSchema 物件。**
```
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
```
**輸出：**
```
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}
```
+ 如需 API 詳細資訊，請參閱*《AWS Tools for PowerShell Cmdlet 參考 (V5)》*中的 [CreateTable](https://docs.aws.amazon.com/powershell/v5/reference)。
------
#### [ Python ]
**適用於 Python (Boto3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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 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
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Python (Boto3) 的AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/CreateTable)。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Ruby 的 AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/CreateTable)。
------
#### [ Rust ]
**適用於 Rust 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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))
}
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Rust 的AWS SDK API 參考*》中的 [CreateTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.create_table)。
------
#### [ SAP ABAP ]
**適用於 SAP ABAP 的開發套件**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.
```
+ 如需 API 詳細資訊，請參閱《*適用於 SAP ABAP 的AWS SDK API 參考*》中的 [CreateTable](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**適用於 Swift 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 Swift 的AWS SDK API 參考*》中的 [CreateTable](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/createtable(input:))。
------
如需更多的 DynamoDB 範例，請參閱 [使用 AWS SDKs DynamoDB 程式碼範例](service_code_examples.md)。
在建立新的資料表之後，請繼續 [步驟 2：將資料寫入 DynamoDB 資料表](getting-started-step-2.md)。
# 步驟 2：將資料寫入 DynamoDB 資料表
在此步驟中，您會將數個項目插入至在 [步驟 1：在 DynamoDB 建立資料表](getting-started-step-1.md) 中建立的 `Music` 資料表。
如需寫入操作的詳細資訊，請參閱 [寫入項目](WorkingWithItems.md#WorkingWithItems.WritingData)。
## AWS 管理主控台
請遵循下列步驟，使用 DynamoDB 主控台將資料寫入至 `Music` 資料表。
1. 請在 [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 開啟 DynamoDB 主控台。
1. 在左側導覽窗格中，選擇 **Tables (資料表)**。
1. 在**資料表**頁面選擇 **Music** 資料表。
1. 選擇**探索資料表項目**。
1. 在**已傳回項目**區段中選擇**建立項目**。
1. 在**建立項目**頁面上執行下列動作，將項目新增至資料表：
1. 選擇 **Add new attribute** (新增屬性)，接著選擇 **Number** (數字)。
1. 對於屬性名稱，請輸入 **Awards**。
1. 重複此程序，建立類型 **String** (字串) 的 **AlbumTitle**。
1. 為您的項目輸入下列值：
1. 針對 **Artist** (藝人)，輸入 **No One You Know**。
1. 針對 **SongTitle** (歌曲名稱)，輸入 **Call Me Today**。
1. 針對 **AlbumTitle** (專輯名稱)，輸入 **Somewhat Famous**。
1. 針對 **Awards** (獎項)，輸入 **1**。
1. 選擇 **Create item** (建立項目)。
1. 重複此程序並利用下列值建立另一個項目：
1. 針對 **Artist** (藝人)，輸入 **Acme Band**。
1. 針對 **SongTitle** (歌曲名稱)，輸入 **Happy Day**。
1. 針對 **AlbumTitle** (專輯名稱)，輸入 **Songs About Life**。
1. 針對 **Awards** (獎項)，輸入 **10**。
1. 再執行一次，建立另一個具有與上一步驟相同 **Artist** (藝術家) 但其他屬性值不同的項目：
1. 針對 **Artist** (藝人)，輸入 **Acme Band**。
1. 針對 **SongTitle** (歌曲名稱)，輸入 **PartiQL Rocks**。
1. 針對 **AlbumTitle** (專輯名稱)，輸入 **Another Album Title**。
1. 針對 **Awards** (獎項)，輸入 **8**。
## AWS CLI
下列 AWS CLI 範例會在 `Music` 資料表中建立新的數個項目。您可以透過 DynamoDB API 或 [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (一種適用於 DynamoDB 的 SQL 相容查詢語言) 進行此操作。
------
#### [ 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'}"
```
如需有關使用 PartiQL 寫入資料的詳細資訊，請參閱 [PartiQL Insert 陳述式](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.insert.html)。
------
如需有關 DynamoDB 中支援之資料類型的詳細資訊，請參閱[資料類型](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes)。
如需有關如何以 JSON 表示 DynamoDB 資料類型的詳細資訊，請參閱[屬性值](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_AttributeValue.html)。
## AWS 開發套件
下列程式碼範例示範如何使用 AWS SDK 將項目寫入 DynamoDB 資料表。
------
#### [ .NET ]
**適用於 .NET 的 SDK (v4)**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 .NET 的 AWS SDK API 參考》**中的 [PutItem](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/PutItem)。
------
#### [ Bash ]
**AWS CLI 使用 Bash 指令碼**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
此範例中使用的公用程式函數。
```
###############################################################################
# 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
}
```
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [PutItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem)。
------
#### [ C\$1\$1 ]
**適用於 C\$1\$1 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
等待資料表變成作用中的程式碼。
```
//! 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;
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 C\$1\$1 的 AWS SDK API 參考*》中的 [PutItem](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem)。
------
#### [ CLI ]
**AWS CLI**
**範例 1：將項目新增至資料表**
下列`put-item` 範例會將新項目加入至 *MusicCollection* 資料表。
```
aws dynamodb put-item \
--table-name MusicCollection \
--item file://item.json \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
`item.json` 的內容：
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Greatest Hits"}
}
```
輸出：
```
{
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
},
"ItemCollectionMetrics": {
"ItemCollectionKey": {
"Artist": {
"S": "No One You Know"
}
},
"SizeEstimateRangeGB": [
0.0,
1.0
]
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[寫入項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData)。
**範例 2：有條件地覆寫資料表中的項目**
下列 `put-item` 範例只有在現有項目具有值為 `Greatest Hits` 的 `AlbumTitle` 屬性時，才會覆寫 `MusicCollection` 資料表中的現有項目。命令會傳回項目的上一個值。
```
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
```
`item.json` 的內容：
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}
}
```
`names.json` 的內容：
```
{
"#A": "AlbumTitle"
}
```
`values.json` 的內容：
```
{
":A": {"S": "Greatest Hits"}
}
```
輸出：
```
{
"Attributes": {
"AlbumTitle": {
"S": "Greatest Hits"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Call Me Today"
}
}
}
```
如果索引鍵已存在，您應該會看到下列輸出：
```
A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[寫入項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData)。
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [PutItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/put-item.html)。
------
#### [ Go ]
**SDK for Go V2**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
定義此範例中使用的 Movie 結構。
```
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"])
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Go 的 AWS SDK API 參考](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.PutItem)》中的 *PutItem*。
------
#### [ Java ]
**適用於 Java 2.x 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples)中設定和執行。
使用 [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);
}
}
}
```
+ 如需 API 的詳細資訊，請參閱《*AWS SDK for Java 2.x API 參考*》中的 [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)。
------
#### [ JavaScript ]
**適用於 JavaScript (v3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples)中設定和執行。
此範例使用文件用戶端來簡化 DynamoDB 中處理項目的作業。如需 API 詳細資訊，請參閱 [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;
};
```
+ 如需 API 的詳細資訊，請參閱《*適用於 JavaScript 的 AWS SDK API 參考*》中的 [PutItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/PutItemCommand)。
**適用於 JavaScript (v2) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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: "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);
}
});
```
使用 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);
}
});
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](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)》。
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem)》中的 *PutItem*。
------
#### [ Kotlin ]
**適用於 Kotlin 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.")
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Kotlin 的AWS SDK API 參考*》中的 [PutItem](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**範例 1：建立新的項目，或將現有項目取代為新項目。**
```
$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
```
+ 如需 API 詳細資訊，請參閱*《AWS Tools for PowerShell Cmdlet 參考 (V4)》*中的 [PutItem](https://docs.aws.amazon.com/powershell/v4/reference)。
**Tools for PowerShell V5**
**範例 1：建立新的項目，或將現有項目取代為新項目。**
```
$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
```
+ 如需 API 詳細資訊，請參閱《AWS Tools for PowerShell Cmdlet 參考 (V5)》**中的 [PutItem](https://docs.aws.amazon.com/powershell/v5/reference)。
------
#### [ Python ]
**適用於 Python (Boto3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Python (Boto3) 的AWS SDK API 參考*》中的 [PutItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem)。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Ruby 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/PutItem)》中的 *PutItem*。
------
#### [ Rust ]
**適用於 Rust 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
})
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Rust 的AWS SDK API 參考*》中的 [PutItem](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.put_item)。
------
#### [ SAP ABAP ]
**適用於 SAP ABAP 的開發套件**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.
```
+ 如需 API 詳細資訊，請參閱《*適用於 SAP ABAP 的AWS SDK API 參考*》中的 [PutItem](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**適用於 Swift 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 Swift 的AWS SDK API 參考*》中的 [PutItem](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/putitem(input:))。
------
如需更多的 DynamoDB 範例，請參閱 [使用 AWS SDKs DynamoDB 程式碼範例](service_code_examples.md)。
將資料寫入至您的資料表之後，請繼續 [步驟 3：從 DynamoDB 資料表讀取資料](getting-started-step-3.md)。
# 步驟 3：從 DynamoDB 資料表讀取資料
在此步驟中，您將讀回在 [步驟 2：將資料寫入 DynamoDB 資料表](getting-started-step-2.md) 中建立的其中一個項目。您可以使用 DynamoDB 主控台或 AWS CLI ，透過指定 `Artist`和 從`Music`資料表讀取項目`SongTitle`。
如需 DynamoDB 中讀取操作的詳細資訊，請參閱 [讀取項目](WorkingWithItems.md#WorkingWithItems.ReadingData)。
## AWS 管理主控台
請遵循下列步驟，使用 DynamoDB 主控台從 `Music` 資料表讀取資料。
1. 請在 [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 開啟 DynamoDB 主控台。
1. 在左側導覽窗格中，選擇 **Tables (資料表)**。
1. 在**資料表**頁面選擇 **Music** 資料表。
1. 選擇**探索資料表項目**。
1. 在**已傳回項目**區段檢視資料表中存放的項目清單，依 `Artist` 和 `SongTitle` 排序。清單中的第一個項目包含名為 **Acme Band** 的 **Artist**，以及 **SongTitle** **PartiQL Rocks**。
## AWS CLI
下列 AWS CLI 範例會從 讀取項目`Music`。您可以透過 DynamoDB API 或 [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (一種適用於 DynamoDB 的 SQL 相容查詢語言) 進行此操作。
------
#### [ DynamoDB API ]
**注意**
DynamoDB 的預設行為是最終一致讀取。`consistent-read` 參數在下面用來展示高度一致性讀取。
**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\"}}"
```
使用 `get-item` 傳回以下範例結果。
```
{
"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'"
```
使用 PartiQL `Select` 陳述式傳回以下範例結果。
```
{
"Items": [
{
"AlbumTitle": {
"S": "Songs About Life"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
}
]
}
```
如需有關使用 PartiQL 讀取資料的詳細資訊，請參閱 [PartiQL Select 陳述式](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.SELECT.html)。
------
## AWS 開發套件
下列程式碼範例示範如何使用 AWS SDK 從 DynamoDB 資料表讀取項目。
------
#### [ .NET ]
**適用於 .NET 的 SDK (v4)**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱[《適用於 .NET 的 AWS SDK API 參考》](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/GetItem)中的 *GetItem*。
------
#### [ Bash ]
**AWS CLI 使用 Bash 指令碼**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
此範例中使用的公用程式函數。
```
###############################################################################
# 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
}
```
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [GetItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/GetItem)。
------
#### [ C\$1\$1 ]
**適用於 C\$1\$1 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 C\$1\$1 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/GetItem)》中的 *GetItem*。
------
#### [ CLI ]
**AWS CLI**
**範例 1：讀取資料表中的項目**
下列 `get-item` 範例從 `MusicCollection` 資料表擷取項目。資料表具有 hash-and-range 主索引鍵 (`Artist` 和 `SongTitle`)，因此您必須指定這兩個屬性。該命令也會請求操作所取用讀取容量的相關資訊。
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--return-consumed-capacity TOTAL
```
`key.json` 的內容：
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
輸出：
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[讀取項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData)。
**範例 2：使用一致讀取來讀取項目**
以下範例使用高度一致性讀取，從 `MusicCollection` 資料表擷取項目。
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--consistent-read \
--return-consumed-capacity TOTAL
```
`key.json` 的內容：
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
輸出：
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[讀取項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData)。
**範例 3：擷取特定的項目屬性**
以下範例使用投影表達式，僅擷取所需項目的三個屬性。
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "102"}}' \
--projection-expression "#T, #C, #P" \
--expression-attribute-names file://names.json
```
`names.json` 的內容：
```
{
"#T": "Title",
"#C": "ProductCategory",
"#P": "Price"
}
```
輸出：
```
{
"Item": {
"Price": {
"N": "20"
},
"Title": {
"S": "Book 102 Title"
},
"ProductCategory": {
"S": "Book"
}
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[讀取項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData)。
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [GetItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/get-item.html)。
------
#### [ Go ]
**SDK for Go V2**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
定義此範例中使用的 Movie 結構。
```
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"])
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Go 的 AWS SDK API 參考](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.GetItem)》中的 *GetItem*。
------
#### [ Java ]
**適用於 Java 2.x 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples)中設定和執行。
使用 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);
}
}
}
```
+ 如需 API 的詳細資訊，請參閱《[AWS SDK for Java 2.x API 參考](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/GetItem)》中的 *GetItem*。
------
#### [ JavaScript ]
**適用於 JavaScript (v3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples)中設定和執行。
此範例使用文件用戶端來簡化 DynamoDB 中處理項目的作業。如需 API 詳細資訊，請參閱 [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;
};
```
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/GetItemCommand)》中的 *GetItem*。
**適用於 JavaScript (v2) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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: "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);
}
});
```
使用 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);
}
});
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-example-dynamodb-utilities.html#dynamodb-example-document-client-get)》。
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/GetItem)》中的 *GetItem*。
------
#### [ Kotlin ]
**適用於 Kotlin 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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)
}
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Kotlin 的AWS SDK API 參考*》中的 [GetItem](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 PHP 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)》中的 *GetItem*。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**範例 1：使用分割區索引鍵 SongTitle 和排序索引鍵 Artist 傳回 DynamoDB 項目。**
```
$key = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
} | ConvertTo-DDBItem
Get-DDBItem -TableName 'Music' -Key $key | ConvertFrom-DDBItem
```
**輸出：**
```
Name Value
---- -----
Genre Country
SongTitle Somewhere Down The Road
Price 1.94
Artist No One You Know
CriticRating 9
AlbumTitle Somewhat Famous
```
+ 如需 API 詳細資訊，請參閱*《AWS Tools for PowerShell Cmdlet 參考 (V4)》*中的 [GetItem](https://docs.aws.amazon.com/powershell/v4/reference)。
**Tools for PowerShell V5**
**範例 1：使用分割區索引鍵 SongTitle 和排序索引鍵 Artist 傳回 DynamoDB 項目。**
```
$key = @{
SongTitle = 'Somewhere Down The Road'
Artist = 'No One You Know'
} | ConvertTo-DDBItem
Get-DDBItem -TableName 'Music' -Key $key | ConvertFrom-DDBItem
```
**輸出：**
```
Name Value
---- -----
Genre Country
SongTitle Somewhere Down The Road
Price 1.94
Artist No One You Know
CriticRating 9
AlbumTitle Somewhat Famous
```
+ 如需 API 詳細資訊，請參閱《AWS Tools for PowerShell Cmdlet 參考 (V5)》**中的 [GetItem](https://docs.aws.amazon.com/powershell/v5/reference)。
------
#### [ Python ]
**適用於 Python (Boto3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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"]
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Python (Boto3) 的AWS SDK API 參考*》中的 [GetItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/GetItem)。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Ruby 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/GetItem)》中的 *GetItem*。
------
#### [ SAP ABAP ]
**適用於 SAP ABAP 的開發套件**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.
```
+ 如需 API 詳細資訊，請參閱《*適用於 SAP ABAP 的AWS SDK API 參考*》中的 [GetItem](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**適用於 Swift 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 Swift 的AWS SDK API 參考*》中的 [GetItem](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/getitem(input:))。
------
如需更多的 DynamoDB 範例，請參閱 [使用 AWS SDKs DynamoDB 程式碼範例](service_code_examples.md)。
若要更新資料表中的資料，請繼續[步驟 4：更新 DynamoDB 資料表中的資料](getting-started-step-4.md)。
# 步驟 4：更新 DynamoDB 資料表中的資料
在此步驟中，您會更新已在 [步驟 2：將資料寫入 DynamoDB 資料表](getting-started-step-2.md) 建立的項目。您可以使用 DynamoDB 主控台或 AWS CLI ，透過指定 `Artist`、 和更新的 `SongTitle`來更新`Music`資料表中`AlbumTitle`項目的 `AlbumTitle`。
如需寫入操作的詳細資訊，請參閱 [寫入項目](WorkingWithItems.md#WorkingWithItems.WritingData)。
## AWS 管理主控台
您可以使用 DynamoDB 主控台，更新 `Music` 資料表中的資料。
1. 請在 [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 開啟 DynamoDB 主控台。
1. 在左側導覽窗格中，選擇 **Tables (資料表)**。
1. 從資料表清單中，選擇 **Music** (音樂) 資料表。
1. 選擇**探索資料表項目**。
1. 在**已傳回項目**中，針對具有 **Acme Band** **Artist** 和 **Happy Day** **SongTitle** 的項目列執行下列動作：
1. 將游標放在名為 **Songs About Life** 的 **AlbumTitle** 上。
1. 選擇編輯圖示。
1. 在**編輯字串**快顯視窗中輸入 **Songs of Twilight**。
1. 選擇**儲存**。
**提示**
或者若要更新項目，請在**已傳回項目**區段中執行下列動作：
選擇 **Artist** 名為 **Acme Band** 且 **SongTitle** 名為 **Happy Day** 的項目列。
從**動作**下拉式清單中，選擇**編輯項目**。
針對 **AlbumTitle** 輸入 **Songs of Twilight**。
選擇**儲存與關閉**。
## AWS CLI
下列 AWS CLI 範例會更新 `Music` 資料表中的項目。您可以透過 DynamoDB API 或 [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (一種適用於 DynamoDB 的 SQL 相容查詢語言) 進行此操作。
------
#### [ 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
```
使用 `update-item` 傳回以下範例結果，因為已指定 `return-values ALL_NEW`。
```
{
"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 *"
```
使用 `Update` 陳述式傳回以下範例結果，因為已指定 `RETURNING ALL NEW *`。
```
{
"Items": [
{
"AlbumTitle": {
"S": "Updated Album Title"
},
"Awards": {
"S": "10"
},
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "Happy Day"
}
}
]
}
```
如需有關使用 PartiQL 更新資料的詳細資訊，請參閱 [PartiQL Update 陳述式](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.update.html)。
------
## AWS 開發套件
下列程式碼範例示範如何使用 AWS SDK 更新 DynamoDB 資料表中的項目。
------
#### [ .NET ]
**適用於 .NET 的 SDK (v4)**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 .NET 的 AWS SDK API 參考》**中的 [UpdateItem](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/UpdateItem)。
------
#### [ Bash ]
**AWS CLI 使用 Bash 指令碼**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
此範例中使用的公用程式函數。
```
###############################################################################
# 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
}
```
+ 如需 API 的詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [UpdateItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/UpdateItem)。
------
#### [ C\$1\$1 ]
**適用於 C\$1\$1 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
等待資料表變成作用中的程式碼。
```
//! 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;
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 C\$1\$1 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/UpdateItem)》中的 *UpdateItem*。
------
#### [ CLI ]
**AWS CLI**
**範例 1：更新資料表中的項目**
下列 `update-item` 範例會更新 `MusicCollection` 資料表中的項目。它會新增屬性 (`Year`) 並修改 `AlbumTitle` 屬性。更新後出現的項目的所有屬性，都會在回應中傳回。
```
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
```
`key.json` 的內容：
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
`expression-attribute-names.json` 的內容：
```
{
"#Y":"Year", "#AT":"AlbumTitle"
}
```
`expression-attribute-values.json` 的內容：
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
輸出：
```
{
"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
]
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[寫入項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData)。
**範例 2：有條件地更新項目**
下列範例會更新 `MusicCollection` 資料表中的項目，但前提是現有項目尚未具備 `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)"
```
`key.json` 的內容：
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
`expression-attribute-names.json` 的內容：
```
{
"#Y":"Year",
"#AT":"AlbumTitle"
}
```
`expression-attribute-values.json` 的內容：
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
如果項目已具備 `Year` 屬性，DynamoDB 會傳回下列輸出。
```
An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[寫入項目](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData)。
+ 如需 API 的詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [UpdateItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-item.html)。
------
#### [ Go ]
**SDK for Go V2**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
定義此範例中使用的 Movie 結構。
```
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"])
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Go 的 AWS SDK API 參考](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.UpdateItem)》中的 *UpdateItem*。
------
#### [ Java ]
**適用於 Java 2.x 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples)中設定和執行。
使用 [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!");
}
}
```
+ 如需 API 的詳細資訊，請參閱《[AWS SDK for Java 2.x API 參考](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)》中的 *UpdateItem*。
------
#### [ JavaScript ]
**適用於 JavaScript (v3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples)中設定和執行。
此範例使用文件用戶端來簡化 DynamoDB 中處理項目的作業。如需 API 詳細資訊，請參閱 [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;
};
```
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)》中的 *UpdateItem*。
------
#### [ Kotlin ]
**適用於 Kotlin 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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")
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Kotlin 的AWS SDK API 參考*》中的 [UpdateItem](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
]
],
]);
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 PHP 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)》中的 *UpdateItem*。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**範例 1：使用分割區索引鍵 SongTitle 和排序索引鍵 Artist，將 DynamoDB 項目的類型屬性設定為 'Rap'**。
```
$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
```
**輸出：**
```
Name Value
---- -----
Genre Rap
```
+ 如需 API 詳細資訊，請參閱《AWS Tools for PowerShell Cmdlet 參考 (V4)》**中的 [UpdateItem](https://docs.aws.amazon.com/powershell/v4/reference)。
**Tools for PowerShell V5**
**範例 1：使用分割區索引鍵 SongTitle 和排序索引鍵 Artist，將 DynamoDB 項目的類型屬性設定為 'Rap'**。
```
$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
```
**輸出：**
```
Name Value
---- -----
Genre Rap
```
+ 如需 API 詳細資訊，請參閱*《AWS Tools for PowerShell Cmdlet 參考 (V5)》*中的 [UpdateItem](https://docs.aws.amazon.com/powershell/v5/reference)。
------
#### [ Python ]
**適用於 Python (Boto3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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 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"]
```
使用包含算術運算的更新表達式更新項目。
```
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"]
```
僅在項目符合特定條件時更新項目。
```
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"]
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Python (Boto3) 的AWS SDK API 參考*》中的 [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Ruby 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/UpdateItem)》中的 *UpdateItem*。
------
#### [ SAP ABAP ]
**適用於 SAP ABAP 的開發套件**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.
```
+ 如需 API 詳細資訊，請參閱《*適用於 SAP ABAP 的AWS SDK API 參考*》中的 [UpdateItem](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**適用於 Swift 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Swift 的AWS SDK API 參考*》中的 [UpdateItem](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/updateitem(input:))。
------
如需更多的 DynamoDB 範例，請參閱 [使用 AWS SDKs DynamoDB 程式碼範例](service_code_examples.md)。
若要查詢 `Music` 資料表中的資料，請繼續 [步驟 5：查詢 DynamoDB 資料表中的資料](getting-started-step-5.md)。
# 步驟 5：查詢 DynamoDB 資料表中的資料
在此步驟中，您會指定 `Music`，來查詢您已在 [步驟 2：將資料寫入 DynamoDB 資料表](getting-started-step-2.md) 寫入至 `Artist` 資料表的資料。這將顯示與分割區索引鍵：`Artist` 相關聯的所有歌曲。
如需查詢操作的詳細資訊，請參閱 [在 DynamoDB 中查詢資料表](Query.md)。
## AWS 管理主控台
請遵循下列步驟，使用 DynamoDB 主控台來查詢 `Music` 資料表中的資料。
1. 請在 [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 開啟 DynamoDB 主控台。
1. 在左側導覽窗格中，選擇 **Tables (資料表)**。
1. 從資料表清單中，選擇 **Music** (音樂) 資料表。
1. 選擇**探索資料表項目**。
1. 在**掃描或查詢項目**中確認已選取**查詢**。
1. 針對 **Partition key** (分割區索引鍵)，輸入 **Acme Band**，然後選擇 **Run** (執行)。
## AWS CLI
下列 AWS CLI 範例會查詢 `Music` 資料表中的項目。您可以透過 DynamoDB API 或 [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (一種適用於 DynamoDB 的 SQL 相容查詢語言) 進行此操作。
------
#### [ DynamoDB API ]
您可以藉由使用 `query` 並提供分割區索引鍵，透過 DynamoDB API 查詢項目。
**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\"}}"
```
使用 `query` 傳回所有與此特定 `Artist` 相關聯的歌曲。
```
{
"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 ]
您可以藉由使用 `Select` 陳述式並提供分割區索引鍵，透過 PartiQL 查詢項目。
**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'"
```
以此方式使用 `Select` 陳述式會傳回所有與此特定 `Artist` 相關聯的歌曲。
```
{
"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"
}
}
]
}
```
如需有關使用 PartiQL 查詢資料的詳細資訊，請參閱 [PartiQL Select 陳述式](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html)。
------
## AWS 開發套件
以下程式碼範例示範如何使用 AWS SDK 查詢 DynamoDB 資料表。
------
#### [ .NET ]
**適用於 .NET 的 SDK (v4)**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 .NET 的 AWS SDK API 參考》*中的 [Query](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/Query)。
------
#### [ Bash ]
**AWS CLI 使用 Bash 指令碼**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
此範例中使用的公用程式函數。
```
###############################################################################
# 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
}
```
+ 如需 API 的詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [Query](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/Query)。
------
#### [ C\$1\$1 ]
**適用於 C\$1\$1 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 C\$1\$1 的 AWS SDK API 參考*》中的 [Query](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/Query)。
------
#### [ CLI ]
**AWS CLI**
**範例 1：查詢資料表**
下列 `query` 範例會查詢 `MusicCollection` 資料表中的項目。資料表具有 hash-and-range 主索引鍵 (`Artist` 和 `SongTitle`)，但此查詢只會指定雜湊索引鍵值。命令傳回名為 "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
```
`expression-attributes.json` 的內容：
```
{
":v1": {"S": "No One You Know"}
}
```
輸出：
```
{
"Items": [
{
"SongTitle": {
"S": "Call Me Today"
},
"SongTitle": {
"S": "Scared of My Shadow"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[使用 DynamoDB 中查詢](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html)。
**範例 2：使用高度一致性讀取查詢資料表，並以遞減順序遍歷索引**
下列範例會執行與第一個範例相同的查詢，但會以相反順序傳回結果，並且使用高度一致性讀取。
```
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
```
`expression-attributes.json` 的內容：
```
{
":v1": {"S": "No One You Know"}
}
```
輸出：
```
{
"Items": [
{
"SongTitle": {
"S": "Scared of My Shadow"
}
},
{
"SongTitle": {
"S": "Call Me Today"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[使用 DynamoDB 中查詢](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html)。
**範例 3：篩選出特定結果**
下列範例會查詢 `MusicCollection`，但會在 `AlbumTitle` 屬性中排除具有特定值的結果。請注意，這不會影響 `ScannedCount` 或 `ConsumedCapacity`，因為僅在項目被讀取後才會套用篩選條件。
```
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
```
`values.json` 的內容：
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Blue Sky Blues"},
":v3": {"S": "Greatest Hits"}
}
```
`names.json` 的內容：
```
{
"#n1": "Artist",
"#n2": "AlbumTitle"
}
```
輸出：
```
{
"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
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[使用 DynamoDB 中查詢](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html)。
**範例 4：僅擷取項目計數**
下列範例會擷取符合查詢的項目計數，但不會自行擷取任何項目。
```
aws dynamodb query \
--table-name MusicCollection \
--select COUNT \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json
```
`expression-attributes.json` 的內容：
```
{
":v1": {"S": "No One You Know"}
}
```
輸出：
```
{
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": null
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[使用 DynamoDB 中查詢](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html)。
**範例 5：查詢索引**
下列範例查詢的是本機次要索引 `AlbumTitleIndex`。查詢會從已投射至本機次要索引的基底資料表，傳回所有屬性。請注意，查詢本機次要索引或全域次要索引時，也需要使用 `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
```
`expression-attributes.json` 的內容：
```
{
":v1": {"S": "No One You Know"}
}
```
輸出：
```
{
"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
}
}
}
}
```
如需詳細資訊，請參閱《*Amazon DynamoDB 開發人員指南*》中的[使用 DynamoDB 中查詢](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html)。
+ 如需 API 的詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [Query](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/query.html)。
------
#### [ Go ]
**SDK for Go V2**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
定義此範例中使用的 Movie 結構。
```
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"])
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Go 的 AWS SDK API 參考](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.Query)》中的 *Query*。
------
#### [ Java ]
**適用於 Java 2.x 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples)中設定和執行。
使用 [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;
}
}
```
使用 `DynamoDbClient` 和次要索引查詢資料表。
```
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);
}
}
}
```
+ 如需 API 的詳細資訊，請參閱《*AWS SDK for Java 2.x API 參考*》中的 [Query](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query)。
------
#### [ JavaScript ]
**適用於 JavaScript (v3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/dynamodb#code-examples)中設定和執行。
此範例使用文件用戶端來簡化 DynamoDB 中處理項目的作業。如需 API 詳細資訊，請參閱 [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;
};
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/dynamodb-example-query-scan.html#dynamodb-example-table-query-scan-querying)》。
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand)》中的 *Query*。
**適用於 JavaScript (v2) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
});
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-example-query-scan.html#dynamodb-example-table-query-scan-querying)》。
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/Query)》中的 *Query*。
------
#### [ Kotlin ]
**適用於 Kotlin 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Kotlin 的AWS SDK API 參考*》中的 [Query](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [Query](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query)。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**範例 1：調用查詢，傳回具有指定之 SongTitle 和 Artist 的 DynamoDB 項目。**
```
$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
```
**輸出：**
```
Name Value
---- -----
Genre Country
Artist No One You Know
Price 1.94
CriticRating 9
SongTitle Somewhere Down The Road
AlbumTitle Somewhat Famous
```
+ 如需 API 詳細資訊，請參閱*《AWS Tools for PowerShell Cmdlet 參考 (V4)》*中的 [Query](https://docs.aws.amazon.com/powershell/v4/reference)。
**Tools for PowerShell V5**
**範例 1：調用查詢，傳回具有指定之 SongTitle 和 Artist 的 DynamoDB 項目。**
```
$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
```
**輸出：**
```
Name Value
---- -----
Genre Country
Artist No One You Know
Price 1.94
CriticRating 9
SongTitle Somewhere Down The Road
AlbumTitle Somewhat Famous
```
+ 如需 API 詳細資訊，請參閱《AWS Tools for PowerShell Cmdlet 參考 (V5)》**中的 [Query](https://docs.aws.amazon.com/powershell/v5/reference)。
------
#### [ Python ]
**適用於 Python (Boto3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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 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"]
```
查詢項目並投影以傳回資料子集。
```
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"]
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Python (Boto3) 的AWS SDK API 參考*》中的 [Query](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query)。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Ruby 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/Query)》中的 *Query*。
------
#### [ Rust ]
**適用於 Rust 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)中設定和執行。
尋找在指定年份製作的電影。
```
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![])
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Rust 的AWS SDK API 參考*》中的[Query](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.query)。
------
#### [ SAP ABAP ]
**適用於 SAP ABAP 的開發套件**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.
```
+ 如需 API 詳細資訊，請參閱《*適用於 SAP ABAP 的AWS SDK API 參考*》中的 [Query](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**適用於 Swift 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Swift 的AWS SDK API 參考*》中的 [Query](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/query(input:))。
------
如需更多的 DynamoDB 範例，請參閱 [使用 AWS SDKs DynamoDB 程式碼範例](service_code_examples.md)。
若要為您的資料表建立全域次要索引，請繼續[步驟 6：(選用) 刪除 DynamoDB 資料表以清除資源](getting-started-step-6.md)。
# 步驟 6：(選用) 刪除 DynamoDB 資料表以清除資源
如果您不再需要針對此教學課程建立的 Amazon DynamoDB 資料表，則可以將其刪除。此步驟協助確保您不會為了未使用的資源而付費。您可以使用 DynamoDB 主控台或 AWS CLI 來刪除您在 中建立的`Music`資料表[步驟 1：在 DynamoDB 建立資料表](getting-started-step-1.md)。
如需 DynamoDB 中資料表操作的詳細資訊，請參閱 [在 DynamoDB 中使用資料表和資料](WorkingWithTables.md)。
## AWS 管理主控台
若要使用主控台刪除 `Music` 資料表：
1. 請在 [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 開啟 DynamoDB 主控台。
1. 在左側導覽窗格中，選擇 **Tables (資料表)**。
1. 選擇資料表清單中 **Music** 資料表旁的核取方塊。
1. 選擇 **刪除**。
## AWS CLI
下列 AWS CLI 範例使用 刪除`Music`資料表`delete-table`。
```
aws dynamodb delete-table --table-name Music
```
## AWS 開發套件
下列程式碼範例示範如何使用 AWS SDK 刪除 DynamoDB 資料表。
------
#### [ .NET ]
**適用於 .NET 的 SDK (v4)**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 .NET 的 AWS SDK API 參考》*中的 [DeleteTable](https://docs.aws.amazon.com/goto/DotNetSDKV4/dynamodb-2012-08-10/DeleteTable)。
------
#### [ Bash ]
**AWS CLI 使用 Bash 指令碼**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
此範例中使用的公用程式函數。
```
###############################################################################
# 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
}
```
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [DeleteTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/DeleteTable)。
------
#### [ C\$1\$1 ]
**適用於 C\$1\$1 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 C\$1\$1 的 AWS SDK API 參考*》中的 [DeleteTable](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/DeleteTable)。
------
#### [ CLI ]
**AWS CLI**
**刪除資料表**
下列 `delete-table` 範例會刪除 `MusicCollection` 資料表。
```
aws dynamodb delete-table \
--table-name MusicCollection
```
輸出：
```
{
"TableDescription": {
"TableStatus": "DELETING",
"TableSizeBytes": 0,
"ItemCount": 0,
"TableName": "MusicCollection",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 5
}
}
}
```
如需詳細資訊，請參閱《Amazon DynamoDB 開發人員指南》**中的[刪除資料表](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeleteTable)。
+ 如需 API 詳細資訊，請參閱《*AWS CLI 命令參考*》中的 [DeleteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-table.html)。
------
#### [ Go ]
**SDK for Go V2**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Go 的 AWS SDK API 參考](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.DeleteTable)》中的 *DeleteTable*。
------
#### [ Java ]
**適用於 Java 2.x 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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!");
}
}
```
+ 如需 API 的詳細資訊，請參閱《*AWS SDK for Java 2.x API 參考*》中的 [DeleteTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DeleteTable)。
------
#### [ JavaScript ]
**適用於 JavaScript (v3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
};
```
+ 如需 API 的詳細資訊，請參閱《*適用於 JavaScript 的 AWS SDK API 參考*》中的 [DeleteTable](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/DeleteTableCommand)。
**適用於 JavaScript (v2) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
});
```
+ 如需詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/dynamodb-examples-using-tables.html#dynamodb-examples-using-tables-deleting-a-table)》。
+ 如需 API 的詳細資訊，請參閱《[適用於 JavaScript 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/DeleteTable)》中的 *DeleteTable*。
------
#### [ Kotlin ]
**適用於 Kotlin 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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")
}
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Kotlin 的AWS SDK API 參考*》中的 [DeleteTable](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
});
}
```
+ 如需 API 的詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**範例 1：刪除指定的資料表。在繼續操作之前，系統會提示您確認。**
```
Remove-DDBTable -TableName "myTable"
```
**範例 2：刪除指定的資料表。在繼續操作之前，系統不會提示您進行確認。**
```
Remove-DDBTable -TableName "myTable" -Force
```
+ 如需 API 詳細資訊，請參閱《AWS Tools for PowerShell Cmdlet 參考 (V4)》**中的 [DeleteTable](https://docs.aws.amazon.com/powershell/v4/reference)。
**Tools for PowerShell V5**
**範例 1：刪除指定的資料表。在繼續操作之前，系統會提示您確認。**
```
Remove-DDBTable -TableName "myTable"
```
**範例 2：刪除指定的資料表。在繼續操作之前，系統不會提示您進行確認。**
```
Remove-DDBTable -TableName "myTable" -Force
```
+ 如需 API 詳細資訊，請參閱*《AWS Tools for PowerShell Cmdlet 參考 (V5)》*中的 [DeleteTable](https://docs.aws.amazon.com/powershell/v5/reference)。
------
#### [ Python ]
**適用於 Python (Boto3) 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《*適用於 Python (Boto3) 的AWS SDK API 參考*》中的 [DeleteTable](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/DeleteTable)。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Ruby 的 AWS SDK API 參考](https://docs.aws.amazon.com/goto/SdkForRubyV3/dynamodb-2012-08-10/DeleteTable)》中的 *DeleteTable*。
------
#### [ Rust ]
**適用於 Rust 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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())),
}
}
```
+ 如需 API 的詳細資訊，請參閱《[適用於 Rust 的AWS SDK API 參考](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.delete_table)》中的 *DeleteTable*。
------
#### [ SAP ABAP ]
**適用於 SAP ABAP 的開發套件**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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.
```
+ 如需 API 詳細資訊，請參閱《*適用於 SAP ABAP 的AWS SDK API 參考*》中的 [DeleteTable](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**適用於 Swift 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 Swift 的AWS SDK API 參考*》中的 [DeleteTable](https://sdk.amazonaws.com/swift/api/awsdynamodb/latest/documentation/awsdynamodb/dynamodbclient/deletetable(input:))。
------
如需更多的 DynamoDB 範例，請參閱 [使用 AWS SDKs DynamoDB 程式碼範例](service_code_examples.md)。
# 繼續了解 DynamoDB
如需使用 Amazon DynamoDB 的詳細資訊，請參閱下列主題：
+ [在 DynamoDB 中使用資料表和資料](WorkingWithTables.md)
+ [在 DynamoDB 使用項目和屬性](WorkingWithItems.md)
+ [在 DynamoDB 中查詢資料表](Query.md)
+ [在 DynamoDB 中使用全域次要索引](GSI.md)
+ [搭配交易使用範例程式碼](transactions.md)
+ [使用 DynamoDB Accelerator (DAX) 的記憶體內加速](DAX.md)
+ [使用 DynamoDB 和 AWS SDKs程式設計](Programming.md)
# 使用 Console-to-Code 產生 Amazon DynamoDB 的基礎設施程式碼
Amazon Q Developer 的 Console-to-Code 功能可將手動資料表建立步驟轉換為可重現的自動化程式碼，以簡化 Amazon DynamoDB 的基礎設施管理。此功能可協助開發人員在其環境中有效率地擴展資料庫資源組態。如需詳細資訊，請參閱[AWS 服務 使用 Amazon Q Developer Console-to-Code 自動化](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/console-to-code.html)。
Console-to-Code 會擷取詳細的 DynamoDB 資料表組態，包括分割區索引鍵、排序索引鍵、佈建的輸送量設定和次要索引，並將它們轉換為精確的基礎設施即程式碼範本。使用生成式 AI，此工具可確保產生的程式碼維持主控台工作流程期間建立的參數相容性。
開發人員可以產生多種格式的 DynamoDB 基礎設施程式碼，例如：
+ AWS TypeScript、Python 和 Java 中的雲端開發套件 (AWS CDK)
+ CloudFormation 在 YAML 或 JSON 中
這種方法可讓團隊：
+ 標準化資料庫資源管理
+ 實作版本控制的基礎設施
+ 減少手動組態錯誤
Amazon DynamoDB 的 Console-to-Code 適用於所有商業 AWS 區域，提供強大的解決方案，可將手動組態轉換為自動化、可重現的基礎設施程式碼。
## 運作方式
搭配 DynamoDB 使用 Console-to-Code 時，程序通常涉及：
1. **在主控台中設計原型** – 使用 DynamoDB 主控台來建立和設定資源，例如資料表。如需詳細資訊，請參閱[連接到 Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html)。
1. **錄製動作** – Console-to-Code 會在您執行動作時記錄這些動作。
1. **程式碼產生** – 此功能使用 Amazon Q Developer 的生成式 AI 功能，將您的主控台動作轉換為您偏好格式的可重複使用的程式碼。
1. **程式碼自訂** – 接著您可以複製或下載此程式碼，並進一步針對您的生產工作負載進行自訂。
## 搭配 DynamoDB 使用 Console-to-Code 的優勢
**簡化自動化**
只要按一下，即可將手動 DynamoDB 資料表建立和組態轉換為可重複使用的程式碼。
**最佳實務**
產生的程式碼遵循可靠部署的 AWS 引導式最佳實務。
**橋接主控台與程式碼**
您不需要選擇使用 AWS 管理主控台 或 Infrastructure-as-Code (IaC)。您可以同時使用這兩種方法。
**加速開發**
快速開始自動化程式碼，還能針對生產用途進一步自訂。
## 範例使用案例
+ 建立具備特定屬性、索引鍵和容量設定的 DynamoDB 資料表
+ 設定全域次要索引和本機次要索引
+ 設定 DynamoDB 資料表的自動擴展政策
+ 建立備份與還原組態
+ 建立和管理 DynamoDB 串流
## 開始使用
開始將 Console-to-Code 與 DynamoDB 搭配使用：
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/dynamodbv2/](https://console.aws.amazon.com/dynamodbv2/) 開啟 DynamoDB 主控台。
1. 開始透過主控台介面建立或修改 DynamoDB 資源。
1. 使用 Console-to-Code 功能，以您偏好的格式產生動作的程式碼。
1. 複製或下載產生的程式碼，並根據您的特定需求進行自訂。
如需如何使用 Console-to-Code 的詳細資訊和詳細說明，請參閱《[Amazon Q Developer 使用者指南》中的 AWS 服務 使用 Amazon Q Developer Console-to-Code](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/console-to-code.html) 自動化。 **