Hay más ejemplos de AWS SDK disponibles en el GitHub repositorio de [ejemplos de AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Escenarios de uso de DynamoDB AWS SDKs
This method demonstrates how to use the IN operator in a filter expression
* to match an attribute against multiple values.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param partitionKeyName The name of the partition key attribute
* @param partitionKeyValue The value of the partition key to query
* @param attributeName The name of the attribute to compare
* @param valuesList List of values to compare against
* @return The query response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static QueryResponse compareMultipleValues(
DynamoDbClient dynamoDbClient,
String tableName,
String partitionKeyName,
AttributeValue partitionKeyValue,
String attributeName,
List valuesList) {
// Create expression attribute names
Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put("#pkName", partitionKeyName);
expressionAttributeNames.put("#attrName", attributeName);
// Create expression attribute values
Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(":pkValue", partitionKeyValue);
// Add values for IN operator
for (int i = 0; i < valuesList.size(); i++) {
expressionAttributeValues.put(":val" + i, valuesList.get(i));
}
// Build the IN clause
StringBuilder inClause = new StringBuilder();
for (int i = 0; i < valuesList.size(); i++) {
if (i > 0) {
inClause.append(", ");
}
inClause.append(":val").append(i);
}
// Define the query parameters
QueryRequest request = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression("#pkName = :pkValue")
.filterExpression("#attrName IN (" + inClause.toString() + ")")
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
// Perform the query operation
return dynamoDbClient.query(request);
}
/**
* Queries a table using multiple OR conditions to compare multiple values with a single attribute.
*
* This method demonstrates the alternative approach to using the IN operator,
* by using multiple OR conditions.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param partitionKeyName The name of the partition key attribute
* @param partitionKeyValue The value of the partition key to query
* @param attributeName The name of the attribute to compare
* @param valuesList List of values to compare against
* @return The query response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static QueryResponse compareWithOrConditions(
DynamoDbClient dynamoDbClient,
String tableName,
String partitionKeyName,
AttributeValue partitionKeyValue,
String attributeName,
List valuesList) {
// Create expression attribute names
Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put("#pkName", partitionKeyName);
expressionAttributeNames.put("#attrName", attributeName);
// Create expression attribute values
Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(":pkValue", partitionKeyValue);
// Add values for OR conditions
for (int i = 0; i < valuesList.size(); i++) {
expressionAttributeValues.put(":val" + i, valuesList.get(i));
}
// Build the OR conditions
StringBuilder orConditions = new StringBuilder();
for (int i = 0; i < valuesList.size(); i++) {
if (i > 0) {
orConditions.append(" OR ");
}
orConditions.append("#attrName = :val").append(i);
}
// Define the query parameters
QueryRequest request = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression("#pkName = :pkValue")
.filterExpression(orConditions.toString())
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
// Perform the query operation
return dynamoDbClient.query(request);
}
/**
* Compares the performance of using the IN operator versus multiple OR conditions.
*
* This method demonstrates the performance difference between using the IN operator
* and using multiple OR conditions.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param partitionKeyName The name of the partition key attribute
* @param partitionKeyValue The value of the partition key to query
* @param attributeName The name of the attribute to compare
* @param valuesList List of values to compare against
* @return Map containing the performance comparison results
*/
public static Map comparePerformance(
DynamoDbClient dynamoDbClient,
String tableName,
String partitionKeyName,
AttributeValue partitionKeyValue,
String attributeName,
List valuesList) {
Map results = new HashMap<>();
try {
// Measure performance of IN operator
long inStartTime = System.nanoTime();
QueryResponse inResponse = compareMultipleValues(
dynamoDbClient, tableName, partitionKeyName, partitionKeyValue, attributeName, valuesList);
long inEndTime = System.nanoTime();
long inDuration = inEndTime - inStartTime;
// Measure performance of OR conditions
long orStartTime = System.nanoTime();
QueryResponse orResponse = compareWithOrConditions(
dynamoDbClient, tableName, partitionKeyName, partitionKeyValue, attributeName, valuesList);
long orEndTime = System.nanoTime();
long orDuration = orEndTime - orStartTime;
// Record results
results.put("inOperatorDuration", inDuration);
results.put("orConditionsDuration", orDuration);
results.put("inOperatorItems", inResponse.count());
results.put("orConditionsItems", orResponse.count());
results.put("inOperatorExpression", "IN operator with " + valuesList.size() + " values");
results.put("orConditionsExpression", valuesList.size() + " OR conditions");
results.put("success", true);
} catch (DynamoDbException e) {
results.put("success", false);
results.put("error", e.getMessage());
}
return results;
}
/**
* Scans a table using the IN operator with a large number of values.
*
* This method demonstrates how to use the IN operator with a large number of values,
* which can help stay within the 300 operator limit.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param attributeName The name of the attribute to compare
* @param valuesList List of values to compare against
* @return The scan response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static ScanResponse scanWithLargeInClause(
DynamoDbClient dynamoDbClient, String tableName, String attributeName, List valuesList) {
// Create expression attribute names
Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put("#attrName", attributeName);
// Create expression attribute values
Map expressionAttributeValues = new HashMap<>();
// Add values for IN operator
for (int i = 0; i < valuesList.size(); i++) {
expressionAttributeValues.put(":val" + i, valuesList.get(i));
}
// Build the IN clause
StringBuilder inClause = new StringBuilder();
for (int i = 0; i < valuesList.size(); i++) {
if (i > 0) {
inClause.append(", ");
}
inClause.append(":val").append(i);
}
// Define the scan parameters
ScanRequest request = ScanRequest.builder()
.tableName(tableName)
.filterExpression("#attrName IN (" + inClause.toString() + ")")
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
// Perform the scan operation
return dynamoDbClient.scan(request);
}
/**
* Generates a list of sample values for testing.
*
* Helper method to generate a list of sample values for testing.
*
* @param valueType The type of values to generate (string, number, or boolean)
* @param count The number of values to generate
* @return List of generated attribute values
*/
public static List generateSampleValues(String valueType, int count) {
List values = new ArrayList<>();
for (int i = 0; i < count; i++) {
AttributeValue value;
switch (valueType.toLowerCase(Locale.ROOT)) {
case "string":
value = AttributeValue.builder().s("Value" + i).build();
break;
case "number":
value = AttributeValue.builder().n(String.valueOf(i)).build();
break;
case "boolean":
value = AttributeValue.builder().bool(i % 2 == 0).build();
break;
default:
throw new IllegalArgumentException("Unsupported value type: " + valueType);
}
values.add(value);
}
return values;
}
```
Ejemplo de uso de la comparación de varios valores con. AWS SDK for Java 2.x
```
public static void exampleUsage(DynamoDbClient dynamoDbClient, String tableName) {
System.out.println("Demonstrating how to compare multiple values with a single attribute in DynamoDB");
try {
// Example 1: Using the IN operator
System.out.println("\nExample 1: Using the IN operator");
List categories = List.of(
AttributeValue.builder().s("Electronics").build(),
AttributeValue.builder().s("Computers").build(),
AttributeValue.builder().s("Accessories").build());
QueryResponse inResponse = compareMultipleValues(
dynamoDbClient,
tableName,
"Department",
AttributeValue.builder().s("Retail").build(),
"Category",
categories);
System.out.println("Found " + inResponse.count() + " items using IN operator");
System.out.println("Items: " + inResponse.items());
// Example 2: Using multiple OR conditions
System.out.println("\nExample 2: Using multiple OR conditions");
QueryResponse orResponse = compareWithOrConditions(
dynamoDbClient,
tableName,
"Department",
AttributeValue.builder().s("Retail").build(),
"Category",
categories);
System.out.println("Found " + orResponse.count() + " items using OR conditions");
System.out.println("Items: " + orResponse.items());
// Example 3: Performance comparison
System.out.println("\nExample 3: Performance comparison");
Map perfComparison = comparePerformance(
dynamoDbClient,
tableName,
"Department",
AttributeValue.builder().s("Retail").build(),
"Category",
categories);
if ((boolean) perfComparison.get("success")) {
System.out.println("IN operator duration: " + perfComparison.get("inOperatorDuration") + " ns");
System.out.println("OR conditions duration: " + perfComparison.get("orConditionsDuration") + " ns");
System.out.println("IN operator found " + perfComparison.get("inOperatorItems") + " items");
System.out.println("OR conditions found " + perfComparison.get("orConditionsItems") + " items");
System.out.println("Expression complexity comparison:");
System.out.println(" IN operator: " + perfComparison.get("inOperatorExpression"));
System.out.println(" OR conditions: " + perfComparison.get("orConditionsExpression"));
} else {
System.out.println("Performance comparison failed: " + perfComparison.get("error"));
}
// Example 4: Using IN with a large number of values
System.out.println("\nExample 4: Using IN with a large number of values");
List productIds = generateSampleValues("string", 20);
ScanResponse largeInResponse = scanWithLargeInClause(dynamoDbClient, tableName, "ProductId", productIds);
System.out.println(
"Found " + largeInResponse.count() + " items using IN with " + productIds.size() + " values");
// Explain the benefits of using IN
System.out.println("\nKey points about using the IN operator in DynamoDB:");
System.out.println("1. The IN operator allows comparing a single attribute against multiple values");
System.out.println("2. IN is more concise than using multiple OR conditions");
System.out.println("3. IN counts as only 1 operator regardless of the number of values");
System.out.println("4. Multiple OR conditions count as 1 operator per condition plus 1 per OR");
System.out.println("5. Using IN helps stay within the 300 operator limit for complex expressions");
System.out.println("6. IN can be used in filter expressions and condition expressions");
System.out.println("7. The IN operator supports up to 100 comparison values");
} catch (DynamoDbException e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK for Java 2.x *.
+ [Query](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query)
+ [Scan](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Scan)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Compare varios valores con un solo atributo utilizando AWS SDK para JavaScript.
```
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const {
DynamoDBDocumentClient,
ScanCommand,
QueryCommand
} = require("@aws-sdk/lib-dynamodb");
/**
* Query or scan a DynamoDB table to find items where an attribute matches any value from a list.
*
* This function demonstrates the use of the IN operator to compare a single attribute
* against multiple possible values, which is more efficient than using multiple OR conditions.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} attributeName - The name of the attribute to compare against the values list
* @param {Array} valuesList - List of values to compare the attribute against
* @param {string} [partitionKeyName] - Optional name of the partition key attribute for query operations
* @param {string} [partitionKeyValue] - Optional value of the partition key to query
* @returns {Promise} - The response from DynamoDB containing the matching items
*/
async function compareMultipleValues(
config,
tableName,
attributeName,
valuesList,
partitionKeyName,
partitionKeyValue
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Create the filter expression using the IN operator
const filterExpression = `${attributeName} IN (${valuesList.map((_, index) => `:val${index}`).join(', ')})`;
// Create expression attribute values for the values list
const expressionAttributeValues = valuesList.reduce((acc, val, index) => {
acc[`:val${index}`] = val;
return acc;
}, {});
// If partition key is provided, perform a query operation
if (partitionKeyName && partitionKeyValue) {
const keyCondition = `${partitionKeyName} = :partitionKey`;
expressionAttributeValues[':partitionKey'] = partitionKeyValue;
// Initialize array to collect all items
let allItems = [];
let lastEvaluatedKey;
// Use pagination to get all results
do {
const params = {
TableName: tableName,
KeyConditionExpression: keyCondition,
FilterExpression: filterExpression,
ExpressionAttributeValues: expressionAttributeValues
};
// Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous query
if (lastEvaluatedKey) {
params.ExclusiveStartKey = lastEvaluatedKey;
}
const response = await docClient.send(new QueryCommand(params));
// Add the items from this page to our collection
if (response.Items && response.Items.length > 0) {
allItems = [...allItems, ...response.Items];
}
// Get the key for the next page of results
lastEvaluatedKey = response.LastEvaluatedKey;
} while (lastEvaluatedKey);
// Return the complete result
return {
Items: allItems,
Count: allItems.length
};
} else {
// Otherwise, perform a scan operation
// Initialize array to collect all items
let allItems = [];
let lastEvaluatedKey;
// Use pagination to get all results
do {
const params = {
TableName: tableName,
FilterExpression: filterExpression,
ExpressionAttributeValues: expressionAttributeValues
};
// Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous scan
if (lastEvaluatedKey) {
params.ExclusiveStartKey = lastEvaluatedKey;
}
const response = await docClient.send(new ScanCommand(params));
// Add the items from this page to our collection
if (response.Items && response.Items.length > 0) {
allItems = [...allItems, ...response.Items];
}
// Get the key for the next page of results
lastEvaluatedKey = response.LastEvaluatedKey;
} while (lastEvaluatedKey);
// Return the complete result
return {
Items: allItems,
Count: allItems.length
};
}
}
/**
* Alternative implementation using multiple OR conditions instead of the IN operator.
*
* This function is provided for comparison to show why using the IN operator is preferable.
* With many values, this approach becomes verbose and less efficient.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} attributeName - The name of the attribute to compare against the values list
* @param {Array} valuesList - List of values to compare the attribute against
* @param {string} [partitionKeyName] - Optional name of the partition key attribute for query operations
* @param {string} [partitionKeyValue] - Optional value of the partition key to query
* @returns {Promise} - The response from DynamoDB containing the matching items
*/
async function compareWithOrConditions(
config,
tableName,
attributeName,
valuesList,
partitionKeyName,
partitionKeyValue
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// If no values provided, return empty result
if (!valuesList || valuesList.length === 0) {
return {
Items: [],
Count: 0
};
}
// Create the filter expression using multiple OR conditions
const filterConditions = valuesList.map((_, index) => `${attributeName} = :val${index}`);
const filterExpression = filterConditions.join(' OR ');
// Create expression attribute values for the values list
const expressionAttributeValues = valuesList.reduce((acc, val, index) => {
acc[`:val${index}`] = val;
return acc;
}, {});
// If partition key is provided, perform a query operation
if (partitionKeyName && partitionKeyValue) {
const keyCondition = `${partitionKeyName} = :partitionKey`;
expressionAttributeValues[':partitionKey'] = partitionKeyValue;
// Initialize array to collect all items
let allItems = [];
let lastEvaluatedKey;
// Use pagination to get all results
do {
const params = {
TableName: tableName,
KeyConditionExpression: keyCondition,
FilterExpression: filterExpression,
ExpressionAttributeValues: expressionAttributeValues
};
// Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous query
if (lastEvaluatedKey) {
params.ExclusiveStartKey = lastEvaluatedKey;
}
const response = await docClient.send(new QueryCommand(params));
// Add the items from this page to our collection
if (response.Items && response.Items.length > 0) {
allItems = [...allItems, ...response.Items];
}
// Get the key for the next page of results
lastEvaluatedKey = response.LastEvaluatedKey;
} while (lastEvaluatedKey);
// Return the complete result
return {
Items: allItems,
Count: allItems.length
};
} else {
// Otherwise, perform a scan operation
// Initialize array to collect all items
let allItems = [];
let lastEvaluatedKey;
// Use pagination to get all results
do {
const params = {
TableName: tableName,
FilterExpression: filterExpression,
ExpressionAttributeValues: expressionAttributeValues
};
// Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous scan
if (lastEvaluatedKey) {
params.ExclusiveStartKey = lastEvaluatedKey;
}
const response = await docClient.send(new ScanCommand(params));
// Add the items from this page to our collection
if (response.Items && response.Items.length > 0) {
allItems = [...allItems, ...response.Items];
}
// Get the key for the next page of results
lastEvaluatedKey = response.LastEvaluatedKey;
} while (lastEvaluatedKey);
// Return the complete result
return {
Items: allItems,
Count: allItems.length
};
}
}
```
Ejemplo de uso de la comparación de varios valores con AWS SDK para JavaScript.
```
/**
* Example of how to use the compareMultipleValues function.
*/
async function exampleUsage() {
// Example parameters
const config = { region: "us-west-2" };
const tableName = "Products";
const attributeName = "Category";
const valuesList = ["Electronics", "Computers", "Accessories"];
console.log(`Searching for products in any of these categories: ${valuesList.join(', ')}`);
try {
// Using the IN operator (recommended approach)
console.log("\nApproach 1: Using the IN operator");
const response = await compareMultipleValues(
config,
tableName,
attributeName,
valuesList
);
console.log(`Found ${response.Count} products in the specified categories`);
// Using multiple OR conditions (alternative approach)
console.log("\nApproach 2: Using multiple OR conditions");
const response2 = await compareWithOrConditions(
config,
tableName,
attributeName,
valuesList
);
console.log(`Found ${response2.Count} products in the specified categories`);
// Example with a query operation
console.log("\nQuerying a specific manufacturer's products in multiple categories");
const partitionKeyName = "Manufacturer";
const partitionKeyValue = "Acme";
const response3 = await compareMultipleValues(
config,
tableName,
attributeName,
valuesList,
partitionKeyName,
partitionKeyValue
);
console.log(`Found ${response3.Count} Acme products in the specified categories`);
// Explain the benefits of using the IN operator
console.log("\nBenefits of using the IN operator:");
console.log("1. More concise expression compared to multiple OR conditions");
console.log("2. Better readability and maintainability");
console.log("3. Potentially better performance with large value lists");
console.log("4. Simpler code that's less prone to errors");
console.log("5. Easier to modify when adding or removing values");
} catch (error) {
console.error("Error:", error);
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [Query](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand)
+ [Scan](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/ScanCommand)
------
#### [ Python ]
**SDK para Python (Boto3)**
Compare varios valores con un solo atributo utilizando AWS SDK para Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Attr, Key
from typing import Any, Dict, List, Optional
def compare_multiple_values(
table_name: str,
attribute_name: str,
values_list: List[Any],
partition_key_name: Optional[str] = None,
partition_key_value: Optional[str] = None,
) -> Dict[str, Any]:
"""
Query or scan a DynamoDB table to find items where an attribute matches any value from a list.
This function demonstrates the use of the IN operator to compare a single attribute
against multiple possible values, which is more efficient than using multiple OR conditions.
Args:
table_name (str): The name of the DynamoDB table.
attribute_name (str): The name of the attribute to compare against the values list.
values_list (List[Any]): List of values to compare the attribute against.
partition_key_name (Optional[str]): The name of the partition key attribute for query operations.
partition_key_value (Optional[str]): The value of the partition key to query.
Returns:
Dict[str, Any]: The response from DynamoDB containing the matching items.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Create the filter expression using the is_in method
filter_expression = Attr(attribute_name).is_in(values_list)
# If partition key is provided, perform a query operation
if partition_key_name and partition_key_value:
key_condition = Key(partition_key_name).eq(partition_key_value)
response = table.query(
KeyConditionExpression=key_condition, FilterExpression=filter_expression
)
else:
# Otherwise, perform a scan operation
response = table.scan(FilterExpression=filter_expression)
# Handle pagination if there are more results
items = response.get("Items", [])
while "LastEvaluatedKey" in response:
if partition_key_name and partition_key_value:
response = table.query(
KeyConditionExpression=key_condition,
FilterExpression=filter_expression,
ExclusiveStartKey=response["LastEvaluatedKey"],
)
else:
response = table.scan(
FilterExpression=filter_expression, ExclusiveStartKey=response["LastEvaluatedKey"]
)
items.extend(response.get("Items", []))
# Return the complete result
return {"Items": items, "Count": len(items)}
def compare_with_or_conditions(
table_name: str,
attribute_name: str,
values_list: List[Any],
partition_key_name: Optional[str] = None,
partition_key_value: Optional[str] = None,
) -> Dict[str, Any]:
"""
Alternative implementation using multiple OR conditions instead of the IN operator.
This function is provided for comparison to show why using the IN operator is preferable.
With many values, this approach becomes verbose and less efficient.
Args:
table_name (str): The name of the DynamoDB table.
attribute_name (str): The name of the attribute to compare against the values list.
values_list (List[Any]): List of values to compare the attribute against.
partition_key_name (Optional[str]): The name of the partition key attribute for query operations.
partition_key_value (Optional[str]): The value of the partition key to query.
Returns:
Dict[str, Any]: The response from DynamoDB containing the matching items.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Create a filter expression with multiple OR conditions
filter_expression = None
for value in values_list:
condition = Attr(attribute_name).eq(value)
if filter_expression is None:
filter_expression = condition
else:
filter_expression = filter_expression | condition
# If partition key is provided, perform a query operation
if partition_key_name and partition_key_value and filter_expression:
key_condition = Key(partition_key_name).eq(partition_key_value)
response = table.query(
KeyConditionExpression=key_condition, FilterExpression=filter_expression
)
elif filter_expression:
# Otherwise, perform a scan operation
response = table.scan(FilterExpression=filter_expression)
else:
# Return empty response if no values provided
return {"Items": [], "Count": 0}
# Handle pagination if there are more results
items = response.get("Items", [])
while "LastEvaluatedKey" in response:
if partition_key_name and partition_key_value:
response = table.query(
KeyConditionExpression=key_condition,
FilterExpression=filter_expression,
ExclusiveStartKey=response["LastEvaluatedKey"],
)
else:
response = table.scan(
FilterExpression=filter_expression, ExclusiveStartKey=response["LastEvaluatedKey"]
)
items.extend(response.get("Items", []))
# Return the complete result
return {"Items": items, "Count": len(items)}
```
Ejemplo de uso de la comparación de varios valores con AWS SDK para Python (Boto3).
```
def example_usage():
"""Example of how to use the compare_multiple_values function."""
# Example parameters
table_name = "Products"
attribute_name = "Category"
values_list = ["Electronics", "Computers", "Accessories"]
print(f"Searching for products in any of these categories: {values_list}")
# Using the IN operator (recommended approach)
print("\nApproach 1: Using the IN operator")
response = compare_multiple_values(
table_name=table_name, attribute_name=attribute_name, values_list=values_list
)
print(f"Found {response['Count']} products in the specified categories")
# Using multiple OR conditions (alternative approach)
print("\nApproach 2: Using multiple OR conditions")
response2 = compare_with_or_conditions(
table_name=table_name, attribute_name=attribute_name, values_list=values_list
)
print(f"Found {response2['Count']} products in the specified categories")
# Example with a query operation
print("\nQuerying a specific manufacturer's products in multiple categories")
partition_key_name = "Manufacturer"
partition_key_value = "Acme"
response3 = compare_multiple_values(
table_name=table_name,
attribute_name=attribute_name,
values_list=values_list,
partition_key_name=partition_key_name,
partition_key_value=partition_key_value,
)
print(f"Found {response3['Count']} Acme products in the specified categories")
# Explain the benefits of using the IN operator
print("\nBenefits of using the IN operator:")
print("1. More concise expression compared to multiple OR conditions")
print("2. Better readability and maintainability")
print("3. Potentially better performance with large value lists")
print("4. Simpler code that's less prone to errors")
print("5. Easier to modify when adding or removing values")
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para Python (Boto3)*.
+ [Query](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query)
+ [Scan](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Scan)
------
# Actualizar condicionalmente un elemento de DynamoDB con un TTL mediante un SDK AWS
Where:
tableName - The Amazon DynamoDB table being queried.
primaryKey - The name of the primary key. Also known as the hash or partition key.
sortKey - The name of the sort key. Also known as the range attribute.
region (optional) - The AWS region that the Amazon DynamoDB table is located in. (Default: us-east-1)
""";
private static final int DAYS_TO_EXPIRE = 90;
private static final int SECONDS_PER_DAY = 24 * 60 * 60;
private static final String PRIMARY_KEY_ATTR = "primaryKey";
private static final String SORT_KEY_ATTR = "sortKey";
private static final String UPDATED_AT_ATTR = "updatedAt";
private static final String EXPIRE_AT_ATTR = "expireAt";
private static final String UPDATE_EXPRESSION = "SET " + UPDATED_AT_ATTR + "=:c, " + EXPIRE_AT_ATTR + "=:e";
private static final String CONDITION_EXPRESSION = "attribute_exists(" + PRIMARY_KEY_ATTR + ")";
private static final String SUCCESS_MESSAGE = "%s UpdateItem operation with TTL successful.";
private static final String CONDITION_FAILED_MESSAGE = "Condition check failed. Item does not exist.";
private static final String TABLE_NOT_FOUND_ERROR = "Error: The Amazon DynamoDB table \"%s\" can't be found.";
private final DynamoDbClient dynamoDbClient;
/**
* Constructs an UpdateTTLConditional with a default DynamoDB client.
*/
public UpdateTTLConditional() {
this.dynamoDbClient = null;
}
/**
* Constructs an UpdateTTLConditional with the specified DynamoDB client.
*
* @param dynamoDbClient The DynamoDB client to use
*/
public UpdateTTLConditional(final DynamoDbClient dynamoDbClient) {
this.dynamoDbClient = dynamoDbClient;
}
/**
* Main method to demonstrate conditionally updating an item with TTL.
*
* @param args Command line arguments
*/
public static void main(final String[] args) {
try {
int result = new UpdateTTLConditional().processArgs(args);
System.exit(result);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
/**
* Process command line arguments and conditionally update an item with TTL.
*
* @param args Command line arguments
* @return 0 if successful, non-zero otherwise
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
* @throws IllegalArgumentException If arguments are invalid
*/
public int processArgs(final String[] args) {
// Argument validation (remove or replace this line when reusing this code)
CodeSampleUtils.validateArgs(args, new int[] {3, 4}, USAGE);
final String tableName = args[0];
final String primaryKey = args[1];
final String sortKey = args[2];
final Region region = Optional.ofNullable(args.length > 3 ? args[3] : null)
.map(Region::of)
.orElse(Region.US_EAST_1);
// Get current time in epoch second format
final long currentTime = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = currentTime + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
// Create the key map for the item to update
final Map keyMap = Map.of(
PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKey).build(),
SORT_KEY_ATTR, AttributeValue.builder().s(sortKey).build());
// Create the expression attribute values
final Map expressionAttributeValues = Map.of(
":c", AttributeValue.builder().n(String.valueOf(currentTime)).build(),
":e", AttributeValue.builder().n(String.valueOf(expireDate)).build());
final UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(keyMap)
.updateExpression(UPDATE_EXPRESSION)
.conditionExpression(CONDITION_EXPRESSION)
.expressionAttributeValues(expressionAttributeValues)
.build();
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final UpdateItemResponse response = ddb.updateItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return 0;
} catch (ConditionalCheckFailedException e) {
System.err.println(CONDITION_FAILED_MESSAGE);
throw e;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)la *referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Actualice el TTL en un elemento de DynamoDB existente en una tabla con una condición.
```
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const updateItemConditional = async (tableName, partitionKey, sortKey, region = 'us-east-1', newAttribute = 'default-value') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const params = {
TableName: tableName,
Key: marshall({
artist: partitionKey,
album: sortKey
}),
UpdateExpression: "SET newAttribute = :newAttribute",
ConditionExpression: "expireAt > :expiration",
ExpressionAttributeValues: marshall({
':newAttribute': newAttribute,
':expiration': currentTime
}),
ReturnValues: "ALL_NEW"
};
try {
const response = await client.send(new UpdateItemCommand(params));
const responseData = unmarshall(response.Attributes);
console.log("Item updated successfully: ", responseData);
return responseData;
} catch (error) {
if (error.name === "ConditionalCheckFailedException") {
console.log("Condition check failed: Item's 'expireAt' is expired.");
} else {
console.error("Error updating item: ", error);
}
throw error;
}
};
// Example usage (commented out for testing)
// updateItemConditional('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)la *Referencia de AWS SDK para JavaScript la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Actualice el TTL en un elemento de DynamoDB existente en una tabla con una condición.
```
from datetime import datetime, timedelta
import boto3
from botocore.exceptions import ClientError
def update_dynamodb_item_ttl(table_name, region, primary_key, sort_key, ttl_attribute):
"""
Updates an existing record in a DynamoDB table with a new or updated TTL attribute.
:param table_name: Name of the DynamoDB table
:param region: AWS Region of the table - example `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:param ttl_attribute: name of the TTL attribute in the target DynamoDB table
:return:
"""
try:
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Generate updated TTL in epoch second format
updated_expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())
# Define the update expression for adding/updating a new attribute
update_expression = "SET newAttribute = :val1"
# Define the condition expression for checking if 'expireAt' is not expired
condition_expression = "expireAt > :val2"
# Define the expression attribute values
expression_attribute_values = {":val1": ttl_attribute, ":val2": updated_expiration_time}
response = table.update_item(
Key={"primaryKey": primary_key, "sortKey": sort_key},
UpdateExpression=update_expression,
ConditionExpression=condition_expression,
ExpressionAttributeValues=expression_attribute_values,
)
print("Item updated successfully.")
return response["ResponseMetadata"]["HTTPStatusCode"] # Ideally a 200 OK
except ClientError as e:
if e.response["Error"]["Code"] == "ConditionalCheckFailedException":
print("Condition check failed: Item's 'expireAt' is expired.")
else:
print(f"Error updating item: {e}")
except Exception as e:
print(f"Error updating item: {e}")
# replace with your values
update_dynamodb_item_ttl(
"your-table-name",
"us-east-1",
"your-partition-key-value",
"your-sort-key-value",
"your-ttl-attribute-value",
)
```
+ Para obtener más información sobre la API, consulta [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)la *AWS Referencia de API de SDK for Python (Boto3*).
------
# Conéctese a una instancia local de DynamoDB mediante un SDK AWS
This method demonstrates how to generate a complex expression with
* a specific number of operators to test the 300 operator limit.
*
* @param conditionsCount Number of conditions to include
* @param useAnd Whether to use AND (true) or OR (false) between conditions
* @return Map containing the filter expression, attribute values, and operator count
*/
public static Map createComplexFilterExpression(int conditionsCount, boolean useAnd) {
// Initialize the expression parts and attribute values
StringBuilder filterExpression = new StringBuilder();
Map expressionAttributeValues = new HashMap<>();
// Generate the specified number of conditions
for (int i = 0; i < conditionsCount; i++) {
// Add the operator between conditions (except for the first one)
if (i > 0) {
filterExpression.append(useAnd ? " AND " : " OR ");
}
// Alternate between different comparison operators for variety
String valueKey = ":val" + i;
switch (i % 5) {
case 0:
filterExpression.append("attribute").append(i).append(" = ").append(valueKey);
expressionAttributeValues.put(
valueKey, AttributeValue.builder().s("value" + i).build());
break;
case 1:
filterExpression.append("attribute").append(i).append(" > ").append(valueKey);
expressionAttributeValues.put(
valueKey, AttributeValue.builder().n(String.valueOf(i)).build());
break;
case 2:
filterExpression.append("attribute").append(i).append(" < ").append(valueKey);
expressionAttributeValues.put(
valueKey,
AttributeValue.builder().n(String.valueOf(i * 10)).build());
break;
case 3:
filterExpression
.append("contains(attribute")
.append(i)
.append(", ")
.append(valueKey)
.append(")");
expressionAttributeValues.put(
valueKey, AttributeValue.builder().s("substring" + i).build());
break;
case 4:
filterExpression
.append("attribute_exists(attribute")
.append(i)
.append(")");
break;
default:
// This case will never be reached, but added to satisfy checkstyle
break;
}
}
// Calculate the operator count
// Each condition has 1 operator (=, >, <, contains, attribute_exists)
// Each AND or OR between conditions is 1 operator
int operatorCount = conditionsCount + (conditionsCount > 0 ? conditionsCount - 1 : 0);
// Create the result map
Map result = new HashMap<>();
result.put("filterExpression", filterExpression.toString());
result.put("expressionAttributeValues", expressionAttributeValues);
result.put("operatorCount", operatorCount);
return result;
}
/**
* Creates a complex update expression with a specified number of operations.
*
* This method demonstrates how to generate a complex update expression with
* a specific number of operators to test the 300 operator limit.
*
* @param operationsCount Number of operations to include
* @return Map containing the update expression, attribute values, and operator count
*/
public static Map createComplexUpdateExpression(int operationsCount) {
// Initialize the expression parts and attribute values
StringBuilder updateExpression = new StringBuilder("SET ");
Map expressionAttributeValues = new HashMap<>();
// Generate the specified number of SET operations
for (int i = 0; i < operationsCount; i++) {
// Add comma between operations (except for the first one)
if (i > 0) {
updateExpression.append(", ");
}
// Alternate between different types of SET operations
String valueKey = ":val" + i;
switch (i % 3) {
case 0:
// Simple assignment (1 operator: =)
updateExpression.append("attribute").append(i).append(" = ").append(valueKey);
expressionAttributeValues.put(
valueKey, AttributeValue.builder().s("value" + i).build());
break;
case 1:
// Addition (2 operators: = and +)
updateExpression
.append("attribute")
.append(i)
.append(" = attribute")
.append(i)
.append(" + ")
.append(valueKey);
expressionAttributeValues.put(
valueKey, AttributeValue.builder().n(String.valueOf(i)).build());
break;
case 2:
// Conditional assignment with if_not_exists (2 operators: = and if_not_exists)
updateExpression
.append("attribute")
.append(i)
.append(" = if_not_exists(attribute")
.append(i)
.append(", ")
.append(valueKey)
.append(")");
expressionAttributeValues.put(
valueKey,
AttributeValue.builder().n(String.valueOf(i * 10)).build());
break;
default:
// This case will never be reached, but added to satisfy checkstyle
break;
}
}
// Calculate the operator count
// Each operation has 1-2 operators as noted above
int operatorCount = 0;
for (int i = 0; i < operationsCount; i++) {
operatorCount += (i % 3 == 0) ? 1 : 2;
}
// Create the result map
Map result = new HashMap<>();
result.put("updateExpression", updateExpression.toString());
result.put("expressionAttributeValues", expressionAttributeValues);
result.put("operatorCount", operatorCount);
return result;
}
/**
* Test the operator limit by attempting an operation with a complex expression.
*
* This method demonstrates what happens when an expression approaches or
* exceeds the 300 operator limit.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param operatorCount Target number of operators to include
* @return Map containing the result of the operation attempt
*/
public static Map testOperatorLimit(
DynamoDbClient dynamoDbClient, String tableName, Map key, int operatorCount) {
// Create a complex update expression with the specified operator count
Map expressionData =
createComplexUpdateExpression((int) Math.ceil(operatorCount / 1.5)); // Adjust to get close to target count
String updateExpression = (String) expressionData.get("updateExpression");
@SuppressWarnings("unchecked")
Map expressionAttributeValues =
(Map) expressionData.get("expressionAttributeValues");
int actualCount = (int) expressionData.get("operatorCount");
System.out.println("Generated update expression with approximately " + actualCount + " operators");
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression(updateExpression)
.expressionAttributeValues(expressionAttributeValues)
.returnValues("UPDATED_NEW")
.build();
try {
// Attempt the update operation
UpdateItemResponse response = dynamoDbClient.updateItem(request);
Map result = new HashMap<>();
result.put("success", true);
result.put("message", "Operation succeeded with " + actualCount + " operators");
result.put("data", response);
return result;
} catch (DynamoDbException e) {
// Check if the error is due to exceeding the operator limit
if (e.getMessage().contains("too many operators")) {
Map result = new HashMap<>();
result.put("success", false);
result.put("message", "Operation failed: " + e.getMessage());
result.put("operatorCount", actualCount);
return result;
}
// Return other errors
Map result = new HashMap<>();
result.put("success", false);
result.put("message", "Operation failed: " + e.getMessage());
result.put("error", e);
return result;
}
}
/**
* Break down a complex expression into multiple simpler operations.
*
* This method demonstrates how to handle expressions that would exceed
* the 300 operator limit by breaking them into multiple operations.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param totalOperations Total number of operations to perform
* @return Map containing the results of the operations
*/
public static Map breakDownComplexExpression(
DynamoDbClient dynamoDbClient, String tableName, Map key, int totalOperations) {
// Calculate how many operations we can safely include in each batch
// Using 150 as a conservative limit (well below 300)
final int operationsPerBatch = 100;
final int batchCount = (int) Math.ceil((double) totalOperations / operationsPerBatch);
System.out.println("Breaking down " + totalOperations + " operations into " + batchCount + " batches");
Map results = new HashMap<>();
results.put("totalBatches", batchCount);
Map> batchResults = new HashMap<>();
// Process each batch
for (int batch = 0; batch < batchCount; batch++) {
// Calculate the operations for this batch
int batchStart = batch * operationsPerBatch;
int batchEnd = Math.min(batchStart + operationsPerBatch, totalOperations);
int batchSize = batchEnd - batchStart;
System.out.println(
"Processing batch " + (batch + 1) + "/" + batchCount + " with " + batchSize + " operations");
// Create an update expression for this batch
Map expressionData = createComplexUpdateExpression(batchSize);
String updateExpression = (String) expressionData.get("updateExpression");
@SuppressWarnings("unchecked")
Map expressionAttributeValues =
(Map) expressionData.get("expressionAttributeValues");
int operatorCount = (int) expressionData.get("operatorCount");
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression(updateExpression)
.expressionAttributeValues(expressionAttributeValues)
.returnValues("UPDATED_NEW")
.build();
try {
// Perform the update operation for this batch
UpdateItemResponse response = dynamoDbClient.updateItem(request);
Map batchResult = new HashMap<>();
batchResult.put("batch", batch + 1);
batchResult.put("success", true);
batchResult.put("operatorCount", operatorCount);
batchResult.put("attributes", response.attributes());
batchResults.put(batch, batchResult);
} catch (DynamoDbException e) {
Map batchResult = new HashMap<>();
batchResult.put("batch", batch + 1);
batchResult.put("success", false);
batchResult.put("operatorCount", operatorCount);
batchResult.put("error", e.getMessage());
batchResults.put(batch, batchResult);
// Continue with next batch instead of breaking
continue;
}
}
results.put("results", batchResults);
return results;
}
/**
* Count operators in a DynamoDB expression based on the rules in the documentation.
*
* This method demonstrates how operators are counted according to the
* DynamoDB documentation.
*
* @param expression The DynamoDB expression to analyze
* @return Map containing the breakdown of operator counts
*/
public static Map countOperatorsInExpression(String expression) {
// Initialize counters for different operator types
Map counts = new HashMap<>();
counts.put("comparisonOperators", 0);
counts.put("logicalOperators", 0);
counts.put("functions", 0);
counts.put("arithmeticOperators", 0);
counts.put("specialOperators", 0);
counts.put("total", 0);
// Count comparison operators (=, <>, <, <=, >, >=)
// This is a simplified approach and may not catch all cases
int comparisonCount = 0;
Pattern comparisonPattern = Pattern.compile("(=|<>|<=|>=|<|>)");
Matcher comparisonMatcher = comparisonPattern.matcher(expression);
while (comparisonMatcher.find()) {
comparisonCount++;
}
counts.put("comparisonOperators", comparisonCount);
// Count logical operators (AND, OR, NOT)
int andCount = countOccurrences(expression, "\\bAND\\b");
int orCount = countOccurrences(expression, "\\bOR\\b");
int notCount = countOccurrences(expression, "\\bNOT\\b");
counts.put("logicalOperators", andCount + orCount + notCount);
// Count functions (attribute_exists, attribute_not_exists, attribute_type, begins_with, contains, size)
int functionCount = countOccurrences(
expression,
"\\b(attribute_exists|attribute_not_exists|attribute_type|begins_with|contains|size|if_not_exists)\\(");
counts.put("functions", functionCount);
// Count arithmetic operators (+ and -)
// This is a simplified approach and may not catch all cases
int arithmeticCount = 0;
Pattern arithmeticPattern = Pattern.compile("[a-zA-Z0-9_)\\]]\\s*[\\+\\-]\\s*[a-zA-Z0-9_:(]");
Matcher arithmeticMatcher = arithmeticPattern.matcher(expression);
while (arithmeticMatcher.find()) {
arithmeticCount++;
}
counts.put("arithmeticOperators", arithmeticCount);
// Count special operators (BETWEEN, IN)
int betweenCount = countOccurrences(expression, "\\bBETWEEN\\b");
int inCount = countOccurrences(expression, "\\bIN\\b");
counts.put("specialOperators", betweenCount + inCount);
// Add extra operators for BETWEEN (each BETWEEN includes an AND)
int currentLogicalOps = counts.getOrDefault("logicalOperators", 0);
counts.put("logicalOperators", currentLogicalOps + betweenCount);
// Calculate total
int total = counts.getOrDefault("comparisonOperators", 0)
+ counts.getOrDefault("logicalOperators", 0)
+ counts.getOrDefault("functions", 0)
+ counts.getOrDefault("arithmeticOperators", 0)
+ counts.getOrDefault("specialOperators", 0);
counts.put("total", total);
return counts;
}
/**
* Helper method to count occurrences of a pattern in a string.
*
* @param text The text to search in
* @param regex The regular expression pattern to search for
* @return The number of occurrences
*/
private static int countOccurrences(String text, String regex) {
final Pattern pattern = Pattern.compile(regex);
final Matcher matcher = pattern.matcher(text);
int count = 0;
while (matcher.find()) {
count++;
}
return count;
}
```
Ejemplo de uso de un operador de expresión que cuenta con AWS SDK for Java 2.x.
```
public static void exampleUsage(DynamoDbClient dynamoDbClient, String tableName) {
// Example key
Map key = new HashMap<>();
key.put("ProductId", AttributeValue.builder().s("P12345").build());
System.out.println("Demonstrating DynamoDB expression operator counting and the 300 operator limit");
try {
// Example 1: Analyze a simple expression
System.out.println("\nExample 1: Analyzing a simple expression");
String simpleExpression = "Price = :price AND Rating > :rating AND Category IN (:cat1, :cat2, :cat3)";
Map simpleCount = countOperatorsInExpression(simpleExpression);
System.out.println("Expression: " + simpleExpression);
System.out.println("Operator count breakdown:");
System.out.println("- Comparison operators: " + simpleCount.get("comparisonOperators"));
System.out.println("- Logical operators: " + simpleCount.get("logicalOperators"));
System.out.println("- Functions: " + simpleCount.get("functions"));
System.out.println("- Arithmetic operators: " + simpleCount.get("arithmeticOperators"));
System.out.println("- Special operators: " + simpleCount.get("specialOperators"));
System.out.println("- Total operators: " + simpleCount.get("total"));
// Example 2: Analyze a complex expression
System.out.println("\nExample 2: Analyzing a complex expression");
String complexExpression = "(attribute_exists(Category) AND Size BETWEEN :min AND :max) OR "
+ "(Price > :price AND contains(Description, :keyword) AND "
+ "(Rating >= :minRating OR Reviews > :minReviews))";
Map complexCount = countOperatorsInExpression(complexExpression);
System.out.println("Expression: " + complexExpression);
System.out.println("Operator count breakdown:");
System.out.println("- Comparison operators: " + complexCount.get("comparisonOperators"));
System.out.println("- Logical operators: " + complexCount.get("logicalOperators"));
System.out.println("- Functions: " + complexCount.get("functions"));
System.out.println("- Arithmetic operators: " + complexCount.get("arithmeticOperators"));
System.out.println("- Special operators: " + complexCount.get("specialOperators"));
System.out.println("- Total operators: " + complexCount.get("total"));
// Example 3: Test approaching the operator limit
System.out.println("\nExample 3: Testing an expression approaching the operator limit");
Map approachingLimit = testOperatorLimit(dynamoDbClient, tableName, key, 290);
System.out.println(approachingLimit.get("message"));
// Example 4: Test exceeding the operator limit
System.out.println("\nExample 4: Testing an expression exceeding the operator limit");
Map exceedingLimit = testOperatorLimit(dynamoDbClient, tableName, key, 310);
System.out.println(exceedingLimit.get("message"));
// Example 5: Breaking down a complex expression
System.out.println("\nExample 5: Breaking down a complex expression into multiple operations");
Map breakdownResult = breakDownComplexExpression(dynamoDbClient, tableName, key, 500);
@SuppressWarnings("unchecked")
Map> results =
(Map>) breakdownResult.get("results");
System.out.println(
"Processed " + results.size() + " of " + breakdownResult.get("totalBatches") + " batches");
// Explain the operator counting rules
System.out.println("\nKey points about DynamoDB expression operator counting:");
System.out.println("1. The maximum number of operators in any expression is 300");
System.out.println("2. Each comparison operator (=, <>, <, <=, >, >=) counts as 1 operator");
System.out.println("3. Each logical operator (AND, OR, NOT) counts as 1 operator");
System.out.println("4. Each function call (attribute_exists, contains, etc.) counts as 1 operator");
System.out.println("5. Each arithmetic operator (+ or -) counts as 1 operator");
System.out.println("6. BETWEEN counts as 2 operators (BETWEEN itself and the AND within it)");
System.out.println("7. IN counts as 1 operator regardless of the number of values");
System.out.println("8. Parentheses for grouping and attribute paths don't count as operators");
System.out.println("9. When you exceed the limit, the error always reports '301 operators'");
System.out.println("10. For complex operations, break them into multiple smaller operations");
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)la *referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Demuestre el recuento de operadores de expresión con AWS SDK para JavaScript.
```
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const {
DynamoDBDocumentClient,
UpdateCommand,
QueryCommand
} = require("@aws-sdk/lib-dynamodb");
/**
* Create a complex filter expression with a specified number of conditions.
*
* This function demonstrates how to generate a complex expression with
* a specific number of operators to test the 300 operator limit.
*
* @param {number} conditionsCount - Number of conditions to include
* @param {boolean} useAnd - Whether to use AND (true) or OR (false) between conditions
* @returns {Object} - Object containing the filter expression and attribute values
*/
function createComplexFilterExpression(conditionsCount, useAnd = true) {
// Initialize the expression parts and attribute values
const conditions = [];
const expressionAttributeValues = {};
// Generate the specified number of conditions
for (let i = 0; i < conditionsCount; i++) {
// Alternate between different comparison operators for variety
let condition;
const valueKey = `:val${i}`;
switch (i % 5) {
case 0:
condition = `attribute${i} = ${valueKey}`;
expressionAttributeValues[valueKey] = `value${i}`;
break;
case 1:
condition = `attribute${i} > ${valueKey}`;
expressionAttributeValues[valueKey] = i;
break;
case 2:
condition = `attribute${i} < ${valueKey}`;
expressionAttributeValues[valueKey] = i * 10;
break;
case 3:
condition = `contains(attribute${i}, ${valueKey})`;
expressionAttributeValues[valueKey] = `substring${i}`;
break;
case 4:
condition = `attribute_exists(attribute${i})`;
break;
}
conditions.push(condition);
}
// Join the conditions with AND or OR
const operator = useAnd ? " AND " : " OR ";
const filterExpression = conditions.join(operator);
// Calculate the operator count
// Each condition has 1 operator (=, >, <, contains, attribute_exists)
// Each AND or OR between conditions is 1 operator
const operatorCount = conditionsCount + (conditionsCount > 0 ? conditionsCount - 1 : 0);
return {
filterExpression,
expressionAttributeValues,
operatorCount
};
}
/**
* Create a complex update expression with a specified number of operations.
*
* This function demonstrates how to generate a complex update expression with
* a specific number of operators to test the 300 operator limit.
*
* @param {number} operationsCount - Number of operations to include
* @returns {Object} - Object containing the update expression and attribute values
*/
function createComplexUpdateExpression(operationsCount) {
// Initialize the expression parts and attribute values
const setOperations = [];
const expressionAttributeValues = {};
// Generate the specified number of SET operations
for (let i = 0; i < operationsCount; i++) {
// Alternate between different types of SET operations
let operation;
const valueKey = `:val${i}`;
switch (i % 3) {
case 0:
// Simple assignment (1 operator: =)
operation = `attribute${i} = ${valueKey}`;
expressionAttributeValues[valueKey] = `value${i}`;
break;
case 1:
// Addition (2 operators: = and +)
operation = `attribute${i} = attribute${i} + ${valueKey}`;
expressionAttributeValues[valueKey] = i;
break;
case 2:
// Conditional assignment with if_not_exists (2 operators: = and if_not_exists)
operation = `attribute${i} = if_not_exists(attribute${i}, ${valueKey})`;
expressionAttributeValues[valueKey] = i * 10;
break;
}
setOperations.push(operation);
}
// Create the update expression
const updateExpression = `SET ${setOperations.join(", ")}`;
// Calculate the operator count
// Each operation has 1-2 operators as noted above
let operatorCount = 0;
for (let i = 0; i < operationsCount; i++) {
operatorCount += (i % 3 === 0) ? 1 : 2;
}
return {
updateExpression,
expressionAttributeValues,
operatorCount
};
}
/**
* Test the operator limit by attempting an operation with a complex expression.
*
* This function demonstrates what happens when an expression approaches or
* exceeds the 300 operator limit.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {number} operatorCount - Target number of operators to include
* @returns {Promise} - Result of the operation attempt
*/
async function testOperatorLimit(
config,
tableName,
key,
operatorCount
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Create a complex update expression with the specified operator count
const { updateExpression, expressionAttributeValues, operatorCount: actualCount } =
createComplexUpdateExpression(Math.ceil(operatorCount / 1.5)); // Adjust to get close to target count
console.log(`Generated update expression with approximately ${actualCount} operators`);
// Define the update parameters
const params = {
TableName: tableName,
Key: key,
UpdateExpression: updateExpression,
ExpressionAttributeValues: expressionAttributeValues,
ReturnValues: "UPDATED_NEW"
};
try {
// Attempt the update operation
const response = await docClient.send(new UpdateCommand(params));
return {
success: true,
message: `Operation succeeded with ${actualCount} operators`,
data: response
};
} catch (error) {
// Check if the error is due to exceeding the operator limit
if (error.name === "ValidationException" &&
error.message.includes("too many operators")) {
return {
success: false,
message: `Operation failed: ${error.message}`,
operatorCount: actualCount
};
}
// Return other errors
return {
success: false,
message: `Operation failed: ${error.message}`,
error
};
}
}
/**
* Break down a complex expression into multiple simpler operations.
*
* This function demonstrates how to handle expressions that would exceed
* the 300 operator limit by breaking them into multiple operations.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {number} totalOperations - Total number of operations to perform
* @returns {Promise} - Result of the operations
*/
async function breakDownComplexExpression(
config,
tableName,
key,
totalOperations
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Calculate how many operations we can safely include in each batch
// Using 150 as a conservative limit (well below 300)
const operationsPerBatch = 100;
const batchCount = Math.ceil(totalOperations / operationsPerBatch);
console.log(`Breaking down ${totalOperations} operations into ${batchCount} batches`);
const results = [];
// Process each batch
for (let batch = 0; batch < batchCount; batch++) {
// Calculate the operations for this batch
const batchStart = batch * operationsPerBatch;
const batchEnd = Math.min(batchStart + operationsPerBatch, totalOperations);
const batchSize = batchEnd - batchStart;
console.log(`Processing batch ${batch + 1}/${batchCount} with ${batchSize} operations`);
// Create an update expression for this batch
const { updateExpression, expressionAttributeValues, operatorCount } =
createComplexUpdateExpression(batchSize);
// Define the update parameters
const params = {
TableName: tableName,
Key: key,
UpdateExpression: updateExpression,
ExpressionAttributeValues: expressionAttributeValues,
ReturnValues: "UPDATED_NEW"
};
try {
// Perform the update operation for this batch
const response = await docClient.send(new UpdateCommand(params));
results.push({
batch: batch + 1,
success: true,
operatorCount,
attributes: response.Attributes
});
} catch (error) {
results.push({
batch: batch + 1,
success: false,
operatorCount,
error: error.message
});
// Stop processing if an error occurs
break;
}
}
return {
totalBatches: batchCount,
results
};
}
/**
* Count operators in a DynamoDB expression based on the rules in the documentation.
*
* This function demonstrates how operators are counted according to the
* DynamoDB documentation.
*
* @param {string} expression - The DynamoDB expression to analyze
* @returns {Object} - Breakdown of operator counts
*/
function countOperatorsInExpression(expression) {
// Initialize counters for different operator types
const counts = {
comparisonOperators: 0,
logicalOperators: 0,
functions: 0,
arithmeticOperators: 0,
specialOperators: 0,
total: 0
};
// Count comparison operators (=, <>, <, <=, >, >=)
const comparisonRegex = /[^<>]=[^=]|<>|<=|>=|[^<]>[^=]|[^>]<[^=]/g;
const comparisonMatches = expression.match(comparisonRegex) || [];
counts.comparisonOperators = comparisonMatches.length;
// Count logical operators (AND, OR, NOT)
const andMatches = expression.match(/\bAND\b/g) || [];
const orMatches = expression.match(/\bOR\b/g) || [];
const notMatches = expression.match(/\bNOT\b/g) || [];
counts.logicalOperators = andMatches.length + orMatches.length + notMatches.length;
// Count functions (attribute_exists, attribute_not_exists, attribute_type, begins_with, contains, size)
const functionRegex = /\b(attribute_exists|attribute_not_exists|attribute_type|begins_with|contains|size|if_not_exists)\(/g;
const functionMatches = expression.match(functionRegex) || [];
counts.functions = functionMatches.length;
// Count arithmetic operators (+ and -)
const arithmeticMatches = expression.match(/[a-zA-Z0-9_)\]]\s*[\+\-]\s*[a-zA-Z0-9_(:]/g) || [];
counts.arithmeticOperators = arithmeticMatches.length;
// Count special operators (BETWEEN, IN)
const betweenMatches = expression.match(/\bBETWEEN\b/g) || [];
const inMatches = expression.match(/\bIN\b/g) || [];
counts.specialOperators = betweenMatches.length + inMatches.length;
// Add extra operators for BETWEEN (each BETWEEN includes an AND)
counts.logicalOperators += betweenMatches.length;
// Calculate total
counts.total = counts.comparisonOperators +
counts.logicalOperators +
counts.functions +
counts.arithmeticOperators +
counts.specialOperators;
return counts;
}
```
Ejemplo de uso del operador de expresión que cuenta con AWS SDK para JavaScript.
```
/**
* Example of how to work with expression operator counting.
*/
async function exampleUsage() {
// Example parameters
const config = { region: "us-west-2" };
const tableName = "Products";
const key = { ProductId: "P12345" };
console.log("Demonstrating DynamoDB expression operator counting and the 300 operator limit");
try {
// Example 1: Analyze a simple expression
console.log("\nExample 1: Analyzing a simple expression");
const simpleExpression = "Price = :price AND Rating > :rating AND Category IN (:cat1, :cat2, :cat3)";
const simpleCount = countOperatorsInExpression(simpleExpression);
console.log(`Expression: ${simpleExpression}`);
console.log("Operator count breakdown:");
console.log(`- Comparison operators: ${simpleCount.comparisonOperators}`);
console.log(`- Logical operators: ${simpleCount.logicalOperators}`);
console.log(`- Functions: ${simpleCount.functions}`);
console.log(`- Arithmetic operators: ${simpleCount.arithmeticOperators}`);
console.log(`- Special operators: ${simpleCount.specialOperators}`);
console.log(`- Total operators: ${simpleCount.total}`);
// Example 2: Analyze a complex expression
console.log("\nExample 2: Analyzing a complex expression");
const complexExpression =
"(attribute_exists(Category) AND Size BETWEEN :min AND :max) OR " +
"(Price > :price AND contains(Description, :keyword) AND " +
"(Rating >= :minRating OR Reviews > :minReviews))";
const complexCount = countOperatorsInExpression(complexExpression);
console.log(`Expression: ${complexExpression}`);
console.log("Operator count breakdown:");
console.log(`- Comparison operators: ${complexCount.comparisonOperators}`);
console.log(`- Logical operators: ${complexCount.logicalOperators}`);
console.log(`- Functions: ${complexCount.functions}`);
console.log(`- Arithmetic operators: ${complexCount.arithmeticOperators}`);
console.log(`- Special operators: ${complexCount.specialOperators}`);
console.log(`- Total operators: ${complexCount.total}`);
// Example 3: Test approaching the operator limit
console.log("\nExample 3: Testing an expression approaching the operator limit");
const approachingLimit = await testOperatorLimit(config, tableName, key, 290);
console.log(approachingLimit.message);
// Example 4: Test exceeding the operator limit
console.log("\nExample 4: Testing an expression exceeding the operator limit");
const exceedingLimit = await testOperatorLimit(config, tableName, key, 310);
console.log(exceedingLimit.message);
// Example 5: Breaking down a complex expression
console.log("\nExample 5: Breaking down a complex expression into multiple operations");
const breakdownResult = await breakDownComplexExpression(config, tableName, key, 500);
console.log(`Processed ${breakdownResult.results.length} of ${breakdownResult.totalBatches} batches`);
// Explain the operator counting rules
console.log("\nKey points about DynamoDB expression operator counting:");
console.log("1. The maximum number of operators in any expression is 300");
console.log("2. Each comparison operator (=, <>, <, <=, >, >=) counts as 1 operator");
console.log("3. Each logical operator (AND, OR, NOT) counts as 1 operator");
console.log("4. Each function call (attribute_exists, contains, etc.) counts as 1 operator");
console.log("5. Each arithmetic operator (+ or -) counts as 1 operator");
console.log("6. BETWEEN counts as 2 operators (BETWEEN itself and the AND within it)");
console.log("7. IN counts as 1 operator regardless of the number of values");
console.log("8. Parentheses for grouping and attribute paths don't count as operators");
console.log("9. When you exceed the limit, the error always reports '301 operators'");
console.log("10. For complex operations, break them into multiple smaller operations");
} catch (error) {
console.error("Error:", error);
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)la *referencia AWS SDK para JavaScript de la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Demuestre el recuento de operadores de expresión con AWS SDK para Python (Boto3).
```
import boto3
from botocore.exceptions import ClientError
from typing import Any, Dict, List, Optional, Tuple
def create_complex_filter_expression(
attribute_name: str, values: List[Any], use_or: bool = True
) -> Tuple[str, Dict[str, Any], Dict[str, str], int]:
"""
Create a complex filter expression with multiple conditions.
This function demonstrates how to build a complex filter expression
and count the number of operators used.
Args:
attribute_name (str): The name of the attribute to filter on.
values (List[Any]): List of values to compare against.
use_or (bool, optional): Whether to use OR between conditions. Defaults to True.
Returns:
Tuple[str, Dict[str, Any], Dict[str, str], int]: A tuple containing:
- The filter expression string
- Expression attribute values
- Expression attribute names
- The number of operators used
"""
if not values:
return "", {}, {}, 0
# Initialize expression components
filter_expression = ""
expression_attribute_values = {}
expression_attribute_names = {"#attr": attribute_name}
operator_count = 0
# Build the filter expression
for i, value in enumerate(values):
value_placeholder = f":val{i}"
expression_attribute_values[value_placeholder] = value
if i > 0:
# Add OR or AND operator between conditions
filter_expression += " OR " if use_or else " AND "
operator_count += 1 # Count the OR/AND operator
# Add the condition
filter_expression += f"#attr = {value_placeholder}"
operator_count += 1 # Count the = operator
return (
filter_expression,
expression_attribute_values,
expression_attribute_names,
operator_count,
)
def create_nested_filter_expression(
depth: int, conditions_per_level: int
) -> Tuple[str, Dict[str, Any], Dict[str, str], int]:
"""
Create a deeply nested filter expression with multiple conditions.
This function demonstrates how to build a complex nested filter expression
and count the number of operators used.
Args:
depth (int): The depth of nesting.
conditions_per_level (int): Number of conditions at each level.
Returns:
Tuple[str, Dict[str, Any], Dict[str, str], int]: A tuple containing:
- The filter expression string
- Expression attribute values
- Expression attribute names
- The number of operators used
"""
if depth <= 0 or conditions_per_level <= 0:
return "", {}, {}, 0
# Initialize expression components
expression_attribute_values = {}
expression_attribute_names = {}
operator_count = 0
def build_nested_expression(current_depth: int, prefix: str) -> str:
nonlocal operator_count
if current_depth <= 0:
return ""
# Build conditions at this level
conditions = []
for i in range(conditions_per_level):
attr_name = f"attr{prefix}_{i}"
attr_placeholder = f"#attr{prefix}_{i}"
val_placeholder = f":val{prefix}_{i}"
expression_attribute_names[attr_placeholder] = attr_name
expression_attribute_values[val_placeholder] = i
conditions.append(f"{attr_placeholder} = {val_placeholder}")
operator_count += 1 # Count the = operator
# Join conditions with AND
level_expression = " AND ".join(conditions)
operator_count += max(0, len(conditions) - 1) # Count the AND operators
# If not at the deepest level, add nested expressions
if current_depth > 1:
nested_expr = build_nested_expression(current_depth - 1, f"{prefix}_{current_depth}")
if nested_expr:
level_expression = f"({level_expression}) OR ({nested_expr})"
operator_count += 1 # Count the OR operator
return level_expression
# Build the expression starting from the top level
filter_expression = build_nested_expression(depth, "1")
return (
filter_expression,
expression_attribute_values,
expression_attribute_names,
operator_count,
)
def count_operators_in_update_expression(update_expression: str) -> int:
"""
Count the number of operators in an update expression.
This function demonstrates how to count operators in an update expression
based on DynamoDB's rules.
Args:
update_expression (str): The update expression to analyze.
Returns:
int: The number of operators in the expression.
"""
operator_count = 0
# Count SET operations
if "SET" in update_expression:
set_section = (
update_expression.split("SET")[1].split("REMOVE")[0].split("ADD")[0].split("DELETE")[0]
)
# Count assignment operators (=)
operator_count += set_section.count("=")
# Count arithmetic operators (+, -)
operator_count += set_section.count("+")
operator_count += set_section.count("-")
# Count list_append function calls (each counts as 1 operator)
operator_count += set_section.lower().count("list_append")
# Count if_not_exists function calls (each counts as 1 operator)
operator_count += set_section.lower().count("if_not_exists")
# Count REMOVE operations (no additional operators)
# Count ADD operations (each ADD counts as 1 operator)
if "ADD" in update_expression:
add_section = (
update_expression.split("ADD")[1].split("DELETE")[0].split("SET")[0].split("REMOVE")[0]
)
operator_count += add_section.count(",") + 1
# Count DELETE operations (each DELETE counts as 1 operator)
if "DELETE" in update_expression:
delete_section = (
update_expression.split("DELETE")[1].split("SET")[0].split("ADD")[0].split("REMOVE")[0]
)
operator_count += delete_section.count(",") + 1
return operator_count
def count_operators_in_condition_expression(condition_expression: str) -> int:
"""
Count the number of operators in a condition expression.
This function demonstrates how to count operators in a condition expression
based on DynamoDB's rules.
Args:
condition_expression (str): The condition expression to analyze.
Returns:
int: The number of operators in the expression.
"""
operator_count = 0
# Count comparison operators
comparison_operators = ["=", "<>", "<", "<=", ">", ">="]
for op in comparison_operators:
operator_count += condition_expression.count(op)
# Count logical operators
operator_count += condition_expression.upper().count(" AND ")
operator_count += condition_expression.upper().count(" OR ")
operator_count += condition_expression.upper().count("NOT ")
# Count BETWEEN operator (counts as 2: BETWEEN + AND)
between_count = condition_expression.upper().count(" BETWEEN ")
operator_count += between_count * 2
# Count IN operator (counts as 1 regardless of number of values)
operator_count += condition_expression.upper().count(" IN ")
# Count functions (each counts as 1 operator)
functions = [
"attribute_exists",
"attribute_not_exists",
"attribute_type",
"begins_with",
"contains",
"size",
]
for func in functions:
operator_count += condition_expression.lower().count(func)
return operator_count
# Note: This function is for demonstration purposes only and should be called from example_usage()
# It's not meant to be used directly as a test function
def _test_expression_limit(
table_name: str, key: Dict[str, Any], operator_count: int, attribute_name: str = "TestAttribute"
) -> Tuple[bool, Optional[str]]:
"""
Test if an expression with a specific number of operators exceeds the limit.
This function demonstrates how to test the 300 operator limit by creating
an expression with a specified number of operators.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
operator_count (int): The number of operators to include in the expression.
attribute_name (str, optional): The name of the attribute to update. Defaults to "TestAttribute".
Returns:
Tuple[bool, Optional[str]]: A tuple containing:
- A boolean indicating if the operation succeeded
- The error message if it failed, None otherwise
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Create an update expression with the specified number of operators
update_expression = f"SET #{attribute_name} = :val0"
expression_attribute_names = {f"#{attribute_name}": attribute_name}
expression_attribute_values = {":val0": 0}
# Add additional SET operations to reach the desired operator count
# Each assignment adds 1 operator
for i in range(1, operator_count):
attr_name = f"{attribute_name}{i}"
attr_placeholder = f"#attr{i}"
val_placeholder = f":val{i}"
update_expression += f", {attr_placeholder} = {val_placeholder}"
expression_attribute_names[attr_placeholder] = attr_name
expression_attribute_values[val_placeholder] = i
try:
# Attempt the update operation
table.update_item(
Key=key,
UpdateExpression=update_expression,
ExpressionAttributeNames=expression_attribute_names,
ExpressionAttributeValues=expression_attribute_values,
)
return True, None
except ClientError as e:
error_message = e.response["Error"]["Message"]
if "expression contains too many operators" in error_message.lower():
return False, error_message
else:
# Other error occurred
raise
```
Ejemplo de uso de un operador de expresión que cuenta con AWS SDK para Python (Boto3).
```
def example_usage():
"""Example of how to use the expression operator counting functions."""
print("Example 1: Creating a complex filter expression with multiple conditions")
attribute_name = "Status"
values = ["Active", "Pending", "Processing", "Shipped", "Delivered"]
filter_expr, expr_attr_vals, expr_attr_names, op_count = create_complex_filter_expression(
attribute_name=attribute_name, values=values, use_or=True
)
print(f"Filter Expression: {filter_expr}")
print(f"Expression Attribute Values: {expr_attr_vals}")
print(f"Expression Attribute Names: {expr_attr_names}")
print(f"Operator Count: {op_count}")
print("\nExample 2: Creating a nested filter expression")
nested_expr, nested_vals, nested_names, nested_count = create_nested_filter_expression(
depth=3, conditions_per_level=2
)
print(f"Nested Filter Expression: {nested_expr}")
print(f"Operator Count: {nested_count}")
print("\nExample 3: Counting operators in an update expression")
update_expression = "SET #name = :name, #age = :age + :increment, #address.#city = :city, #status = if_not_exists(#status, :default_status) REMOVE #old_field ADD #counter :value DELETE #set_attr :set_val"
update_op_count = count_operators_in_update_expression(update_expression)
print(f"Update Expression: {update_expression}")
print(f"Operator Count: {update_op_count}")
print("\nExample 4: Counting operators in a condition expression")
condition_expression = "(#status = :active OR #status = :pending) AND #price BETWEEN :min_price AND :max_price AND attribute_exists(#category) AND NOT (#stock <= :min_stock)"
condition_op_count = count_operators_in_condition_expression(condition_expression)
print(f"Condition Expression: {condition_expression}")
print(f"Operator Count: {condition_op_count}")
print("\nExample 5: Testing the 300 operator limit")
# This is just for demonstration - in a real application, you would use your actual table
# Note: This function is renamed to _test_expression_limit to avoid pytest trying to run it
print("In a real application, you would test with _test_expression_limit function")
print("Expression with 250 operators would be under the limit")
print("Expression with 350 operators would exceed the 300 operator limit")
print("\nOperator Counting Rules in DynamoDB:")
print("1. Comparison Operators (=, <>, <, <=, >, >=): 1 operator each")
print("2. Logical Operators (AND, OR, NOT): 1 operator each")
print("3. BETWEEN: 2 operators (BETWEEN + AND)")
print("4. IN: 1 operator (regardless of number of values)")
print("5. Functions (attribute_exists, begins_with, etc.): 1 operator each")
print("6. Arithmetic Operators (+, -): 1 operator each")
print("7. SET assignments (=): 1 operator each")
print("8. ADD and DELETE operations: 1 operator each")
print("\nStrategies for Working Within the 300 Operator Limit:")
print("1. Break operations into multiple requests")
print("2. Use DynamoDB Transactions for complex operations")
print("3. Optimize data model to reduce query complexity")
print("4. Use application-side filtering for less critical filters")
print("5. Consider using IN operator instead of multiple OR conditions")
```
+ Para obtener más información sobre la API, consulta [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)la *AWS Referencia de API de SDK for Python (Boto3*).
------
# Creación de una API de REST de API Gateway para realizar un seguimiento de datos de COVID-19
attributeDefinitions = new ArrayList<>();
attributeDefinitions.add(AttributeDefinition.builder()
.attributeName(ISSUE_ID_ATTR)
.attributeType(ScalarAttributeType.S)
.build());
attributeDefinitions.add(AttributeDefinition.builder()
.attributeName(TITLE_ATTR)
.attributeType(ScalarAttributeType.S)
.build());
attributeDefinitions.add(AttributeDefinition.builder()
.attributeName(CREATE_DATE_ATTR)
.attributeType(ScalarAttributeType.S)
.build());
attributeDefinitions.add(AttributeDefinition.builder()
.attributeName(DUE_DATE_ATTR)
.attributeType(ScalarAttributeType.S)
.build());
// Key schema for table
final List tableKeySchema = new ArrayList<>();
tableKeySchema.add(KeySchemaElement.builder()
.attributeName(ISSUE_ID_ATTR)
.keyType(KeyType.HASH)
.build()); // Partition key
tableKeySchema.add(KeySchemaElement.builder()
.attributeName(TITLE_ATTR)
.keyType(KeyType.RANGE)
.build()); // Sort key
// Initial provisioned throughput settings for the indexes
final ProvisionedThroughput ptIndex = ProvisionedThroughput.builder()
.readCapacityUnits(1L)
.writeCapacityUnits(1L)
.build();
// CreateDateIndex
final List createDateKeySchema = new ArrayList<>();
createDateKeySchema.add(KeySchemaElement.builder()
.attributeName(CREATE_DATE_ATTR)
.keyType(KeyType.HASH)
.build());
createDateKeySchema.add(KeySchemaElement.builder()
.attributeName(ISSUE_ID_ATTR)
.keyType(KeyType.RANGE)
.build());
final Projection createDateProjection = Projection.builder()
.projectionType(ProjectionType.INCLUDE)
.nonKeyAttributes(DESCRIPTION_ATTR, STATUS_ATTR)
.build();
final GlobalSecondaryIndex createDateIndex = GlobalSecondaryIndex.builder()
.indexName(CREATE_DATE_INDEX)
.keySchema(createDateKeySchema)
.projection(createDateProjection)
.provisionedThroughput(ptIndex)
.build();
// TitleIndex
final List titleKeySchema = new ArrayList<>();
titleKeySchema.add(KeySchemaElement.builder()
.attributeName(TITLE_ATTR)
.keyType(KeyType.HASH)
.build());
titleKeySchema.add(KeySchemaElement.builder()
.attributeName(ISSUE_ID_ATTR)
.keyType(KeyType.RANGE)
.build());
final Projection titleProjection =
Projection.builder().projectionType(ProjectionType.KEYS_ONLY).build();
final GlobalSecondaryIndex titleIndex = GlobalSecondaryIndex.builder()
.indexName(TITLE_INDEX)
.keySchema(titleKeySchema)
.projection(titleProjection)
.provisionedThroughput(ptIndex)
.build();
// DueDateIndex
final List dueDateKeySchema = new ArrayList<>();
dueDateKeySchema.add(KeySchemaElement.builder()
.attributeName(DUE_DATE_ATTR)
.keyType(KeyType.HASH)
.build());
final Projection dueDateProjection =
Projection.builder().projectionType(ProjectionType.ALL).build();
final GlobalSecondaryIndex dueDateIndex = GlobalSecondaryIndex.builder()
.indexName(DUE_DATE_INDEX)
.keySchema(dueDateKeySchema)
.projection(dueDateProjection)
.provisionedThroughput(ptIndex)
.build();
final CreateTableRequest createTableRequest = CreateTableRequest.builder()
.tableName(TABLE_NAME)
.keySchema(tableKeySchema)
.attributeDefinitions(attributeDefinitions)
.globalSecondaryIndexes(createDateIndex, titleIndex, dueDateIndex)
.provisionedThroughput(ProvisionedThroughput.builder()
.readCapacityUnits(1L)
.writeCapacityUnits(1L)
.build())
.build();
System.out.println("Creating table " + TABLE_NAME + "...");
dynamoDbClient.createTable(createTableRequest);
// Wait for table to become active
System.out.println("Waiting for " + TABLE_NAME + " to become ACTIVE...");
final DynamoDbWaiter waiter = dynamoDbClient.waiter();
final DescribeTableRequest describeTableRequest =
DescribeTableRequest.builder().tableName(TABLE_NAME).build();
final WaiterResponse waiterResponse =
waiter.waitUntilTableExists(describeTableRequest);
waiterResponse.matched().response().ifPresent(response -> System.out.println("Table is now ready for use"));
} catch (DynamoDbException e) {
System.err.println("Error creating table: " + e.getMessage());
e.printStackTrace();
}
}
```
+ Para obtener más información sobre la API, consulte la referencia de [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)la *AWS SDK for Java 2.x API*.
------
# Cree una tabla de DynamoDB con una configuración de rendimiento cálido mediante un SDK AWS
Where:
tableName - The Amazon DynamoDB table being queried.
primaryKey - The name of the primary key. Also known as the hash or partition key.
sortKey - The name of the sort key. Also known as the range attribute.
region (optional) - The AWS region that the Amazon DynamoDB table is located in. (Default: us-east-1)
""";
private static final int DAYS_TO_EXPIRE = 90;
private static final int SECONDS_PER_DAY = 24 * 60 * 60;
private static final String PRIMARY_KEY_ATTR = "primaryKey";
private static final String SORT_KEY_ATTR = "sortKey";
private static final String CREATION_DATE_ATTR = "creationDate";
private static final String EXPIRE_AT_ATTR = "expireAt";
private static final String SUCCESS_MESSAGE = "%s PutItem operation with TTL successful.";
private static final String TABLE_NOT_FOUND_ERROR = "Error: The Amazon DynamoDB table \"%s\" can't be found.";
private final DynamoDbClient dynamoDbClient;
/**
* Constructs a CreateTTL instance with the specified DynamoDB client.
*
* @param dynamoDbClient The DynamoDB client to use
*/
public CreateTTL(final DynamoDbClient dynamoDbClient) {
this.dynamoDbClient = dynamoDbClient;
}
/**
* Constructs a CreateTTL with a default DynamoDB client.
*/
public CreateTTL() {
this.dynamoDbClient = null;
}
/**
* Main method to demonstrate creating an item with TTL.
*
* @param args Command line arguments
*/
public static void main(final String[] args) {
try {
int result = new CreateTTL().processArgs(args);
System.exit(result);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
/**
* Process command line arguments and create an item with TTL.
*
* @param args Command line arguments
* @return 0 if successful, non-zero otherwise
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
* @throws IllegalArgumentException If arguments are invalid
*/
public int processArgs(final String[] args) {
// Argument validation (remove or replace this line when reusing this code)
CodeSampleUtils.validateArgs(args, new int[] {3, 4}, USAGE);
final String tableName = args[0];
final String primaryKey = args[1];
final String sortKey = args[2];
final Region region = Optional.ofNullable(args.length > 3 ? args[3] : null)
.map(Region::of)
.orElse(Region.US_EAST_1);
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final CreateTTL createTTL = new CreateTTL(ddb);
createTTL.createItemWithTTL(tableName, primaryKey, sortKey);
return 0;
} catch (Exception e) {
throw e;
}
}
/**
* Creates an item in the specified table with TTL attributes.
*
* @param tableName The name of the table
* @param primaryKeyValue The value for the primary key
* @param sortKeyValue The value for the sort key
* @return The response from the PutItem operation
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
*/
public PutItemResponse createItemWithTTL(
final String tableName, final String primaryKeyValue, final String sortKeyValue) {
// Get current time in epoch second format
final long createDate = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = createDate + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
final Map itemMap = new HashMap<>();
itemMap.put(
PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKeyValue).build());
itemMap.put(SORT_KEY_ATTR, AttributeValue.builder().s(sortKeyValue).build());
itemMap.put(
CREATION_DATE_ATTR,
AttributeValue.builder().n(String.valueOf(createDate)).build());
itemMap.put(
EXPIRE_AT_ATTR,
AttributeValue.builder().n(String.valueOf(expireDate)).build());
final PutItemRequest request =
PutItemRequest.builder().tableName(tableName).item(itemMap).build();
try {
final PutItemResponse response = dynamoDbClient.putItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return response;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
}
```
+ Para obtener más información sobre la API, consulte [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)la *referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
```
import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
export function createDynamoDBItem(table_name, region, partition_key, sort_key) {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
// Get the current time in epoch second format
const current_time = Math.floor(new Date().getTime() / 1000);
// Calculate the expireAt time (90 days from now) in epoch second format
const expire_at = Math.floor((new Date().getTime() + 90 * 24 * 60 * 60 * 1000) / 1000);
// Create DynamoDB item
const item = {
'partitionKey': {'S': partition_key},
'sortKey': {'S': sort_key},
'createdAt': {'N': current_time.toString()},
'expireAt': {'N': expire_at.toString()}
};
const putItemCommand = new PutItemCommand({
TableName: table_name,
Item: item,
ProvisionedThroughput: {
ReadCapacityUnits: 1,
WriteCapacityUnits: 1,
},
});
client.send(putItemCommand, function(err, data) {
if (err) {
console.log("Exception encountered when creating item %s, here's what happened: ", data, err);
throw err;
} else {
console.log("Item created successfully: %s.", data);
return data;
}
});
}
// Example usage (commented out for testing)
// createDynamoDBItem('your-table-name', 'us-east-1', 'your-partition-key-value', 'your-sort-key-value');
```
+ Para obtener más información sobre la API, consulte [PutItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/PutItemCommand)la *Referencia de AWS SDK para JavaScript la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
```
from datetime import datetime, timedelta
import boto3
def create_dynamodb_item(table_name, region, primary_key, sort_key):
"""
Creates a DynamoDB item with an attached expiry attribute.
:param table_name: Table name for the boto3 resource to target when creating an item
:param region: string representing the AWS region. Example: `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:return: Void (nothing)
"""
try:
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Get the current time in epoch second format
current_time = int(datetime.now().timestamp())
# Calculate the expiration time (90 days from now) in epoch second format
expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())
item = {
"primaryKey": primary_key,
"sortKey": sort_key,
"creationDate": current_time,
"expireAt": expiration_time,
}
response = table.put_item(Item=item)
print("Item created successfully.")
return response
except Exception as e:
print(f"Error creating item: {e}")
raise e
# Use your own values
create_dynamodb_item(
"your-table-name", "us-west-2", "your-partition-key-value", "your-sort-key-value"
)
```
+ Para obtener más información sobre la API, consulta [PutItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem)la *AWS Referencia de API de SDK for Python (Boto3*).
------
# Cree y gestione tablas globales de DynamoDB con una sólida coherencia multirregional mediante un SDK AWS
item = new HashMap<>();
item.put("Artist", AttributeValue.builder().s(artist).build());
item.put("SongTitle", AttributeValue.builder().s(songTitle).build());
if (album != null && !album.trim().isEmpty()) {
item.put("Album", AttributeValue.builder().s(album).build());
}
if (year != null && !year.trim().isEmpty()) {
item.put("Year", AttributeValue.builder().n(year).build());
}
PutItemRequest putItemRequest =
PutItemRequest.builder().tableName(tableName).item(item).build();
PutItemResponse response = dynamoDbClient.putItem(putItemRequest);
LOGGER.info("Test item added successfully with strong consistency");
return response;
} catch (DynamoDbException e) {
LOGGER.severe("Failed to add test item to table: " + tableName + " - " + e.getMessage());
throw DynamoDbException.builder()
.message("Failed to add test item to table: " + tableName)
.cause(e)
.build();
}
}
```
Lea los elementos con lecturas consistentes de las réplicas del MRSC utilizando. AWS SDK for Java 2.x
```
public static GetItemResponse getItemWithConsistentRead(
final DynamoDbClient dynamoDbClient, final String tableName, final String artist, final String songTitle) {
if (dynamoDbClient == null) {
throw new IllegalArgumentException("DynamoDB client cannot be null");
}
if (tableName == null || tableName.trim().isEmpty()) {
throw new IllegalArgumentException("Table name cannot be null or empty");
}
if (artist == null || artist.trim().isEmpty()) {
throw new IllegalArgumentException("Artist cannot be null or empty");
}
if (songTitle == null || songTitle.trim().isEmpty()) {
throw new IllegalArgumentException("Song title cannot be null or empty");
}
try {
LOGGER.info("Reading item from MRSC global table with consistent read: " + tableName);
Map key = new HashMap<>();
key.put("Artist", AttributeValue.builder().s(artist).build());
key.put("SongTitle", AttributeValue.builder().s(songTitle).build());
GetItemRequest getItemRequest = GetItemRequest.builder()
.tableName(tableName)
.key(key)
.consistentRead(true)
.build();
GetItemResponse response = dynamoDbClient.getItem(getItemRequest);
if (response.hasItem()) {
LOGGER.info("Item found with strong consistency - no wait time needed");
} else {
LOGGER.info("Item not found");
}
return response;
} catch (DynamoDbException e) {
LOGGER.severe("Failed to read item from table: " + tableName + " - " + e.getMessage());
throw DynamoDbException.builder()
.message("Failed to read item from table: " + tableName)
.cause(e)
.build();
}
}
```
Realice actualizaciones condicionales con las garantías del MRSC utilizando. AWS SDK for Java 2.x
```
public static UpdateItemResponse performConditionalUpdate(
final DynamoDbClient dynamoDbClient,
final String tableName,
final String artist,
final String songTitle,
final String rating) {
if (dynamoDbClient == null) {
throw new IllegalArgumentException("DynamoDB client cannot be null");
}
if (tableName == null || tableName.trim().isEmpty()) {
throw new IllegalArgumentException("Table name cannot be null or empty");
}
if (artist == null || artist.trim().isEmpty()) {
throw new IllegalArgumentException("Artist cannot be null or empty");
}
if (songTitle == null || songTitle.trim().isEmpty()) {
throw new IllegalArgumentException("Song title cannot be null or empty");
}
if (rating == null || rating.trim().isEmpty()) {
throw new IllegalArgumentException("Rating cannot be null or empty");
}
try {
LOGGER.info("Performing conditional update on MRSC global table: " + tableName);
Map key = new HashMap<>();
key.put("Artist", AttributeValue.builder().s(artist).build());
key.put("SongTitle", AttributeValue.builder().s(songTitle).build());
Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put("#rating", "Rating");
Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
":rating", AttributeValue.builder().n(rating).build());
UpdateItemRequest updateItemRequest = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #rating = :rating")
.conditionExpression("attribute_exists(Artist)")
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
UpdateItemResponse response = dynamoDbClient.updateItem(updateItemRequest);
LOGGER.info("Conditional update successful - demonstrates strong consistency");
return response;
} catch (ConditionalCheckFailedException e) {
LOGGER.warning("Conditional check failed: " + e.getMessage());
throw e;
} catch (DynamoDbException e) {
LOGGER.severe("Failed to perform conditional update: " + tableName + " - " + e.getMessage());
throw DynamoDbException.builder()
.message("Failed to perform conditional update: " + tableName)
.cause(e)
.build();
}
}
```
Espere a que las réplicas del MRSC y los testigos se activen utilizando. AWS SDK for Java 2.x
```
public static void waitForMRSCReplicasActive(
final DynamoDbClient dynamoDbClient, final String tableName, final int maxWaitTimeSeconds)
throws InterruptedException {
if (dynamoDbClient == null) {
throw new IllegalArgumentException("DynamoDB client cannot be null");
}
if (tableName == null || tableName.trim().isEmpty()) {
throw new IllegalArgumentException("Table name cannot be null or empty");
}
if (maxWaitTimeSeconds <= 0) {
throw new IllegalArgumentException("Max wait time must be positive");
}
try {
LOGGER.info("Waiting for MRSC replicas and witnesses to become active: " + tableName);
final long startTime = System.currentTimeMillis();
final long maxWaitTimeMillis = maxWaitTimeSeconds * 1000L;
int backoffSeconds = 5; // Start with 5 second intervals
final int maxBackoffSeconds = 30; // Cap at 30 seconds
while (System.currentTimeMillis() - startTime < maxWaitTimeMillis) {
DescribeTableResponse response = describeMRSCTable(dynamoDbClient, tableName);
boolean allActive = true;
StringBuilder statusReport = new StringBuilder();
if (response.table().multiRegionConsistency() == null
|| !MultiRegionConsistency.STRONG
.toString()
.equals(response.table().multiRegionConsistency().toString())) {
allActive = false;
statusReport
.append("MultiRegionConsistency: ")
.append(response.table().multiRegionConsistency())
.append(" ");
}
if (response.table().replicas() == null
|| response.table().replicas().isEmpty()) {
allActive = false;
statusReport.append("No replicas found. ");
}
if (response.table().globalTableWitnesses() == null
|| response.table().globalTableWitnesses().isEmpty()) {
allActive = false;
statusReport.append("No witnesses found. ");
}
// Check table status
if (!"ACTIVE".equals(response.table().tableStatus().toString())) {
allActive = false;
statusReport
.append("Table: ")
.append(response.table().tableStatus())
.append(" ");
}
// Check replica status
if (response.table().replicas() != null) {
for (var replica : response.table().replicas()) {
if (!"ACTIVE".equals(replica.replicaStatus().toString())) {
allActive = false;
statusReport
.append("Replica(")
.append(replica.regionName())
.append("): ")
.append(replica.replicaStatus())
.append(" ");
}
}
}
// Check witness status
if (response.table().globalTableWitnesses() != null) {
for (var witness : response.table().globalTableWitnesses()) {
if (!"ACTIVE".equals(witness.witnessStatus().toString())) {
allActive = false;
statusReport
.append("Witness(")
.append(witness.regionName())
.append("): ")
.append(witness.witnessStatus())
.append(" ");
}
}
}
if (allActive) {
LOGGER.info("All MRSC replicas and witnesses are now active: " + tableName);
return;
}
LOGGER.info("Waiting for MRSC components to become active. Status: " + statusReport.toString());
LOGGER.info("Next check in " + backoffSeconds + " seconds...");
tempWait(backoffSeconds);
// Exponential backoff with cap
backoffSeconds = Math.min(backoffSeconds * 2, maxBackoffSeconds);
}
throw DynamoDbException.builder()
.message("Timeout waiting for MRSC replicas to become active after " + maxWaitTimeSeconds + " seconds")
.build();
} catch (DynamoDbException | InterruptedException e) {
LOGGER.severe("Failed to wait for MRSC replicas to become active: " + tableName + " - " + e.getMessage());
throw e;
}
}
```
Limpie las réplicas y los testigos del MRSC utilizando. AWS SDK for Java 2.x
```
public static UpdateTableResponse cleanupMRSCReplicas(
final DynamoDbClient dynamoDbClient,
final String tableName,
final Region replicaRegion,
final Region witnessRegion) {
if (dynamoDbClient == null) {
throw new IllegalArgumentException("DynamoDB client cannot be null");
}
if (tableName == null || tableName.trim().isEmpty()) {
throw new IllegalArgumentException("Table name cannot be null or empty");
}
if (replicaRegion == null) {
throw new IllegalArgumentException("Replica region cannot be null");
}
if (witnessRegion == null) {
throw new IllegalArgumentException("Witness region cannot be null");
}
try {
LOGGER.info("Cleaning up MRSC replicas and witnesses for table: " + tableName);
// Remove replica using ReplicationGroupUpdate
ReplicationGroupUpdate replicaUpdate = ReplicationGroupUpdate.builder()
.delete(DeleteReplicationGroupMemberAction.builder()
.regionName(replicaRegion.id())
.build())
.build();
// Remove witness
GlobalTableWitnessGroupUpdate witnessUpdate = GlobalTableWitnessGroupUpdate.builder()
.delete(DeleteGlobalTableWitnessGroupMemberAction.builder()
.regionName(witnessRegion.id())
.build())
.build();
UpdateTableRequest updateTableRequest = UpdateTableRequest.builder()
.tableName(tableName)
.replicaUpdates(List.of(replicaUpdate))
.globalTableWitnessUpdates(List.of(witnessUpdate))
.build();
UpdateTableResponse response = dynamoDbClient.updateTable(updateTableRequest);
LOGGER.info("MRSC cleanup initiated - removing replica and witness. Response: " + response);
return response;
} catch (DynamoDbException e) {
LOGGER.severe("Failed to cleanup MRSC replicas: " + tableName + " - " + e.getMessage());
throw DynamoDbException.builder()
.message("Failed to cleanup MRSC replicas: " + tableName)
.cause(e)
.build();
}
}
```
Complete la demostración del flujo de trabajo del MRSC utilizando. AWS SDK for Java 2.x
```
public static void demonstrateCompleteMRSCWorkflow(
final DynamoDbClient primaryClient,
final DynamoDbClient replicaClient,
final String tableName,
final Region replicaRegion,
final Region witnessRegion)
throws InterruptedException {
if (primaryClient == null) {
throw new IllegalArgumentException("Primary DynamoDB client cannot be null");
}
if (replicaClient == null) {
throw new IllegalArgumentException("Replica DynamoDB client cannot be null");
}
if (tableName == null || tableName.trim().isEmpty()) {
throw new IllegalArgumentException("Table name cannot be null or empty");
}
if (replicaRegion == null) {
throw new IllegalArgumentException("Replica region cannot be null");
}
if (witnessRegion == null) {
throw new IllegalArgumentException("Witness region cannot be null");
}
try {
LOGGER.info("=== Starting Complete MRSC Workflow Demonstration ===");
// Step 1: Create an empty single-Region table
LOGGER.info("Step 1: Creating empty single-Region table");
createRegionalTable(primaryClient, tableName);
// Use the existing GlobalTableOperations method for basic table waiting
LOGGER.info("Intermediate step: Waiting for table [" + tableName + "] to become active before continuing");
GlobalTableOperations.waitForTableActive(primaryClient, tableName);
// Step 2: Convert to MRSC with replica and witness
LOGGER.info("Step 2: Converting to MRSC with replica and witness");
convertToMRSCWithWitness(primaryClient, tableName, replicaRegion, witnessRegion);
// Wait for MRSC conversion to complete using MRSC-specific waiter
LOGGER.info("Waiting for MRSC conversion to complete...");
waitForMRSCReplicasActive(primaryClient, tableName);
LOGGER.info("Intermediate step: Waiting for table [" + tableName + "] to become active before continuing");
GlobalTableOperations.waitForTableActive(primaryClient, tableName);
// Step 3: Verify MRSC configuration
LOGGER.info("Step 3: Verifying MRSC configuration");
describeMRSCTable(primaryClient, tableName);
// Step 4: Test strong consistency with data operations
LOGGER.info("Step 4: Testing strong consistency with data operations");
// Add test item to primary region
putTestItem(primaryClient, tableName, "The Beatles", "Hey Jude", "The Beatles 1967-1970", "1968");
// Immediately read from replica region (no wait needed with MRSC)
LOGGER.info("Reading from replica region immediately (strong consistency):");
GetItemResponse getResponse =
getItemWithConsistentRead(replicaClient, tableName, "The Beatles", "Hey Jude");
if (getResponse.hasItem()) {
LOGGER.info("✓ Strong consistency verified - item immediately available in replica region");
} else {
LOGGER.warning("✗ Item not found in replica region");
}
// Test conditional update from replica region
LOGGER.info("Testing conditional update from replica region:");
performConditionalUpdate(replicaClient, tableName, "The Beatles", "Hey Jude", "5");
LOGGER.info("✓ Conditional update successful - demonstrates strong consistency");
// Step 5: Cleanup
LOGGER.info("Step 5: Cleaning up resources");
cleanupMRSCReplicas(primaryClient, tableName, replicaRegion, witnessRegion);
// Wait for cleanup to complete using basic table waiter
LOGGER.info("Waiting for replica cleanup to complete...");
GlobalTableOperations.waitForTableActive(primaryClient, tableName);
// "Halt" until replica/witness cleanup is complete
DescribeTableResponse cleanupVerification = describeMRSCTable(primaryClient, tableName);
int backoffSeconds = 5; // Start with 5 second intervals
while (cleanupVerification.table().multiRegionConsistency() != null) {
LOGGER.info("Waiting additional time (" + backoffSeconds + " seconds) for MRSC cleanup to complete...");
tempWait(backoffSeconds);
// Exponential backoff with cap
backoffSeconds = Math.min(backoffSeconds * 2, 30);
cleanupVerification = describeMRSCTable(primaryClient, tableName);
}
// Delete the primary table
deleteTable(primaryClient, tableName);
LOGGER.info("=== MRSC Workflow Demonstration Complete ===");
LOGGER.info("");
LOGGER.info("Key benefits of Multi-Region Strong Consistency (MRSC):");
LOGGER.info("- Immediate consistency across all regions (no eventual consistency delays)");
LOGGER.info("- Simplified application logic (no need to handle eventual consistency)");
LOGGER.info("- Support for conditional writes and transactions across regions");
LOGGER.info("- Consistent read operations from any region without waiting");
} catch (DynamoDbException | InterruptedException e) {
LOGGER.severe("MRSC workflow failed: " + e.getMessage());
throw e;
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK for Java 2.x *.
+ [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)
+ [DeleteTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DeleteTable)
+ [DescribeTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DescribeTable)
+ [GetItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/GetItem)
+ [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)
+ [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)
+ [UpdateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateTable)
------
# Cree y gestione tablas globales de DynamoDB que muestren MREC mediante un SDK AWS
item = new HashMap<>();
item.put(
"Artist",
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder()
.s(artist)
.build());
item.put(
"SongTitle",
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder()
.s(songTitle)
.build());
PutItemRequest putItemRequest =
PutItemRequest.builder().tableName(tableName).item(item).build();
PutItemResponse response = dynamoDbClient.putItem(putItemRequest);
LOGGER.info("Test item added successfully");
return response;
} catch (DynamoDbException e) {
LOGGER.severe("Failed to add test item to table: " + tableName + " - " + e.getMessage());
throw e;
}
}
```
Describa la configuración de la tabla global y las réplicas mediante AWS SDK for Java 2.x.
```
public static DescribeTableResponse describeTable(final DynamoDbClient dynamoDbClient, final String tableName) {
if (dynamoDbClient == null) {
throw new IllegalArgumentException("DynamoDB client cannot be null");
}
if (tableName == null || tableName.trim().isEmpty()) {
throw new IllegalArgumentException("Table name cannot be null or empty");
}
try {
LOGGER.info("Describing table: " + tableName);
DescribeTableRequest request =
DescribeTableRequest.builder().tableName(tableName).build();
DescribeTableResponse response = dynamoDbClient.describeTable(request);
LOGGER.info("Table status: " + response.table().tableStatus());
if (response.table().replicas() != null
&& !response.table().replicas().isEmpty()) {
LOGGER.info("Number of replicas: " + response.table().replicas().size());
response.table()
.replicas()
.forEach(replica -> LOGGER.info(
"Replica region: " + replica.regionName() + ", Status: " + replica.replicaStatus()));
}
return response;
} catch (ResourceNotFoundException e) {
LOGGER.severe("Table not found: " + tableName + " - " + e.getMessage());
throw e;
} catch (DynamoDbException e) {
LOGGER.severe("Failed to describe table: " + tableName + " - " + e.getMessage());
throw e;
}
}
```
Ejemplo completo de operaciones de tablas globales utilizando AWS SDK for Java 2.x.
```
public static void exampleUsage(final Region sourceRegion, final Region replicaRegion) {
String tableName = "Music";
String indexName = "SongTitleIndex";
Long readCapacity = 15L;
// Create DynamoDB client for the source region
try (DynamoDbClient dynamoDbClient =
DynamoDbClient.builder().region(sourceRegion).build()) {
try {
// Step 1: Create the initial table with GSI and streams
LOGGER.info("Step 1: Creating table in source region: " + sourceRegion.id());
createTableWithGSI(dynamoDbClient, tableName, indexName);
// Step 2: Wait for table to become active
LOGGER.info("Step 2: Waiting for table to become active");
waitForTableActive(dynamoDbClient, tableName);
// Step 3: Add replica in destination region
LOGGER.info("Step 3: Adding replica in region: " + replicaRegion.id());
addReplica(dynamoDbClient, tableName, replicaRegion, indexName, readCapacity);
// Step 4: Wait a moment for replica creation to start
Thread.sleep(5000);
// Step 5: Describe table to view replica information
LOGGER.info("Step 5: Describing table to view replicas");
describeTable(dynamoDbClient, tableName);
// Step 6: Add a test item to verify replication
LOGGER.info("Step 6: Adding test item to verify replication");
putTestItem(dynamoDbClient, tableName, "TestArtist", "TestSong");
LOGGER.info("Global table setup completed successfully!");
LOGGER.info("You can verify replication by checking the item in region: " + replicaRegion.id());
// Step 7: Remove replica and clean up table
LOGGER.info("Step 7: Removing replica from region: " + replicaRegion.id());
removeReplica(dynamoDbClient, tableName, replicaRegion);
DeleteTableResponse deleteTableResponse = dynamoDbClient.deleteTable(
DeleteTableRequest.builder().tableName(tableName).build());
LOGGER.info("MREC global table demonstration completed successfully!");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Thread was interrupted", e);
} catch (DynamoDbException e) {
LOGGER.severe("DynamoDB operation failed: " + e.getMessage());
throw e;
}
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK for Java 2.x *.
+ [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)
+ [DescribeTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DescribeTable)
+ [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)
+ [UpdateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateTable)
------
# Eliminar datos de DynamoDB mediante sentencias DELETE de PartiQL con un SDK AWS
) => {
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
// Convert the item to a string representation for PartiQL
const itemString = JSON.stringify(item).replace(/"([^"]+)":/g, '$1:');
const params = {
Statement: `INSERT INTO "${tableName}" VALUE ${itemString}`,
};
try {
const data = await docClient.send(new ExecuteStatementCommand(params));
console.log("Item inserted successfully");
return data;
} catch (err) {
console.error("Error inserting item:", err);
throw err;
}
};
/**
* Insert multiple items into a DynamoDB table using PartiQL batch operation.
* This is more efficient than inserting items one by one.
*
* @param tableName - The name of the DynamoDB table
* @param items - Array of items to insert
* @returns The response from the BatchExecuteStatementCommand
*/
export const batchInsertItems = async (tableName: string, items: Record[]) => {
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
// Create statements for each item
const statements = items.map((item) => {
const itemString = JSON.stringify(item).replace(/"([^"]+)":/g, '$1:');
return {
Statement: `INSERT INTO "${tableName}" VALUE ${itemString}`,
};
});
const params = {
Statements: statements,
};
try {
const data = await docClient.send(new BatchExecuteStatementCommand(params));
console.log("Items inserted successfully");
return data;
} catch (err) {
console.error("Error batch inserting items:", err);
throw err;
}
};
/**
* Insert an item with a condition to prevent overwriting existing items.
* This is useful for ensuring you don't accidentally overwrite data.
*
* @param tableName - The name of the DynamoDB table
* @param item - The item to insert
* @param partitionKeyName - The name of the partition key attribute
* @returns The response from the ExecuteStatementCommand
*/
export const insertItemWithCondition = async (
tableName: string,
item: Record,
partitionKeyName: string
) => {
const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
const itemString = JSON.stringify(item).replace(/"([^"]+)":/g, '$1:');
const partitionKeyValue = JSON.stringify(item[partitionKeyName]);
const params = {
Statement: `INSERT INTO "${tableName}" VALUE ${itemString} WHERE attribute_not_exists(${partitionKeyName})`,
Parameters: [{ S: partitionKeyValue }],
};
try {
const data = await docClient.send(new ExecuteStatementCommand(params));
console.log("Item inserted with condition successfully");
return data;
} catch (err) {
console.error("Error inserting item with condition:", err);
throw err;
}
};
/**
* Example usage showing how to insert items with different index types
*/
export const insertExamples = async () => {
// Example table with a simple primary key (just partition key)
const simpleKeyItem = {
userId: "user123",
name: "John Doe",
email: "john@example.com",
};
await insertItem("UsersTable", simpleKeyItem);
// Example table with composite key (partition key + sort key)
const compositeKeyItem = {
orderId: "order456",
productId: "prod789",
quantity: 2,
price: 29.99,
};
await insertItem("OrdersTable", compositeKeyItem);
// Example with Global Secondary Index (GSI)
// The GSI might be on the email attribute
const gsiItem = {
userId: "user789",
email: "jane@example.com",
name: "Jane Smith",
userType: "premium", // This could be part of a GSI
};
await insertItem("UsersTable", gsiItem);
// Example with Local Secondary Index (LSI)
// LSI uses the same partition key but different sort key
const lsiItem = {
orderId: "order567", // Partition key
productId: "prod123", // Sort key for the table
orderDate: "2023-11-15", // Potential sort key for an LSI
quantity: 1,
price: 19.99,
};
await insertItem("OrdersTable", lsiItem);
// Batch insert example with multiple items
const batchItems = [
{
userId: "user234",
name: "Alice Johnson",
email: "alice@example.com",
},
{
userId: "user345",
name: "Bob Williams",
email: "bob@example.com",
},
];
await batchInsertItems("UsersTable", batchItems);
};
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [BatchExecuteStatement](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/BatchExecuteStatementCommand)
+ [ExecuteStatement](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/ExecuteStatementCommand)
------
# Invocación de una función de Lambda desde un navegador
expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_PK, partitionKeyName);
// Create expression attribute values for the column values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_PK,
AttributeValue.builder().s(partitionKeyValue).build());
// Create the query request
final QueryRequest queryRequest = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.consistentRead(useConsistentRead)
.build();
try {
final QueryResponse response = dynamoDbClient.query(queryRequest);
LOGGER.log(Level.INFO, "Query successful. Found {0} items", response.count());
return response;
} catch (ResourceNotFoundException e) {
LOGGER.log(Level.SEVERE, "Table not found: {0}", tableName);
throw e;
} catch (DynamoDbException e) {
LOGGER.log(Level.SEVERE, "Error querying with consistent reads", e);
throw e;
}
}
```
Realice la consulta mediante un índice secundario global con AWS SDK for Java 2.x.
```
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 software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
import java.util.Map;
public QueryResponse queryTable(
final String tableName, final String partitionKeyName, final String partitionKeyValue) {
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
// Create expression attribute names for the column names
final Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_PK, partitionKeyName);
// Create expression attribute values for the column values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_PK,
AttributeValue.builder().s(partitionKeyValue).build());
// Create the query request
final QueryRequest queryRequest = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
try {
final QueryResponse response = dynamoDbClient.query(queryRequest);
System.out.println("Query on base table successful. Found " + response.count() + " items");
return response;
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
throw new DynamoDbQueryException("Table not found: " + tableName, e);
} catch (DynamoDbException e) {
System.err.println("Error querying base table: " + e.getMessage());
throw new DynamoDbQueryException("Failed to execute query on base table", e);
}
}
/**
* Queries a DynamoDB Global Secondary Index (GSI) by partition key.
*
* @param tableName The name of the DynamoDB table
* @param indexName The name of the GSI
* @param partitionKeyName The name of the GSI partition key attribute
* @param partitionKeyValue The value of the GSI partition key to query
* @return The query response from DynamoDB
* @throws ResourceNotFoundException if the table or index doesn't exist
* @throws DynamoDbException if the query fails
*/
public QueryResponse queryGlobalSecondaryIndex(
final String tableName, final String indexName, final String partitionKeyName, final String partitionKeyValue) {
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
CodeSampleUtils.validateStringParameter("Index name", indexName);
// Create expression attribute names for the column names
final Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_IK, partitionKeyName);
// Create expression attribute values for the column values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_IK,
AttributeValue.builder().s(partitionKeyValue).build());
// Create the query request
final QueryRequest queryRequest = QueryRequest.builder()
.tableName(tableName)
.indexName(indexName)
.keyConditionExpression(GSI_KEY_CONDITION_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
try {
final QueryResponse response = dynamoDbClient.query(queryRequest);
System.out.println("Query on GSI successful. Found " + response.count() + " items");
return response;
} catch (ResourceNotFoundException e) {
System.err.format(
"Error: The Amazon DynamoDB table \"%s\" or index \"%s\" can't be found.\n", tableName, indexName);
throw new DynamoDbQueryException("Table or index not found: " + tableName + "/" + indexName, e);
} catch (DynamoDbException e) {
System.err.println("Error querying GSI: " + e.getMessage());
throw new DynamoDbQueryException("Failed to execute query on GSI", e);
}
}
```
Consulta con paginación utilizando AWS SDK for Java 2.x.
```
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 software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public List> queryWithPagination(
final String tableName, final String partitionKeyName, final String partitionKeyValue, final int pageSize) {
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
CodeSampleUtils.validatePositiveInteger("Page size", pageSize);
// Create expression attribute names for the column names
final Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_PK, partitionKeyName);
// Create expression attribute values for the column values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_PK,
AttributeValue.builder().s(partitionKeyValue).build());
// Create the query request
QueryRequest.Builder queryRequestBuilder = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.limit(pageSize);
// List to store all items from all pages
final List> allItems = new ArrayList<>();
// Map to store the last evaluated key for pagination
Map lastEvaluatedKey = null;
int pageNumber = 1;
try {
do {
// If we have a last evaluated key, use it for the next page
if (lastEvaluatedKey != null) {
queryRequestBuilder.exclusiveStartKey(lastEvaluatedKey);
}
// Execute the query
final QueryResponse response = dynamoDbClient.query(queryRequestBuilder.build());
// Process the current page of results
final List> pageItems = response.items();
allItems.addAll(pageItems);
// Get the last evaluated key for the next page
lastEvaluatedKey = response.lastEvaluatedKey();
if (lastEvaluatedKey != null && lastEvaluatedKey.isEmpty()) {
lastEvaluatedKey = null;
}
System.out.println("Page " + pageNumber + ": Retrieved " + pageItems.size() + " items (Running total: "
+ allItems.size() + ")");
pageNumber++;
} while (lastEvaluatedKey != null);
System.out.println("Query with pagination complete. Retrieved a total of " + allItems.size()
+ " items across " + (pageNumber - 1) + " pages");
return allItems;
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println("Error querying with pagination: " + e.getMessage());
throw e;
}
}
```
Consulta con filtros complejos utilizando AWS SDK for Java 2.x.
```
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 software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public QueryResponse queryWithComplexFilter(
final String tableName,
final String partitionKeyName,
final String partitionKeyValue,
final String statusAttrName,
final String activeStatus,
final String pendingStatus,
final String priceAttrName,
final double minPrice,
final double maxPrice,
final String categoryAttrName) {
// Validate parameters
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
CodeSampleUtils.validateStringParameter("Status attribute name", statusAttrName);
CodeSampleUtils.validateStringParameter("Active status", activeStatus);
CodeSampleUtils.validateStringParameter("Pending status", pendingStatus);
CodeSampleUtils.validateStringParameter("Price attribute name", priceAttrName);
CodeSampleUtils.validateStringParameter("Category attribute name", categoryAttrName);
CodeSampleUtils.validateNumericRange("Minimum price", minPrice, 0.0, Double.MAX_VALUE);
CodeSampleUtils.validateNumericRange("Maximum price", maxPrice, minPrice, Double.MAX_VALUE);
// Create expression attribute names for the column names
final Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put("#pk", partitionKeyName);
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_STATUS, statusAttrName);
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_PRICE, priceAttrName);
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_CATEGORY, categoryAttrName);
// Create expression attribute values for the column values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
":pkValue", AttributeValue.builder().s(partitionKeyValue).build());
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_ACTIVE,
AttributeValue.builder().s(activeStatus).build());
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_PENDING,
AttributeValue.builder().s(pendingStatus).build());
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_MIN_PRICE,
AttributeValue.builder().n(String.valueOf(minPrice)).build());
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_MAX_PRICE,
AttributeValue.builder().n(String.valueOf(maxPrice)).build());
// Create the query request
final QueryRequest queryRequest = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.filterExpression(FILTER_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
return dynamoDbClient.query(queryRequest);
}
```
Consulte con una expresión de filtro construida dinámicamente utilizando AWS SDK for Java 2.x.
```
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 software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
import java.util.Map;
public static QueryResponse queryWithDynamicFilter(
final String tableName,
final String partitionKeyName,
final String partitionKeyValue,
final Map filterCriteria,
final Region region,
final DynamoDbClient dynamoDbClient) {
validateParameters(tableName, partitionKeyName, partitionKeyValue, filterCriteria);
DynamoDbClient ddbClient = dynamoDbClient;
boolean shouldClose = false;
try {
if (ddbClient == null) {
ddbClient = createClient(region);
shouldClose = true;
}
final QueryWithDynamicFilter queryHelper = new QueryWithDynamicFilter(ddbClient);
return queryHelper.queryWithDynamicFilter(tableName, partitionKeyName, partitionKeyValue, filterCriteria);
} catch (ResourceNotFoundException e) {
System.err.println("Table not found: " + tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println("Failed to execute dynamic filter query: " + e.getMessage());
throw e;
} catch (Exception e) {
System.err.println("Unexpected error during query: " + e.getMessage());
throw e;
} finally {
if (shouldClose && ddbClient != null) {
ddbClient.close();
}
}
}
public static void main(String[] args) {
final String usage =
"""
Usage:
[region]
Where:
tableName - The Amazon DynamoDB table to query.
partitionKeyName - The name of the partition key attribute.
partitionKeyValue - The value of the partition key to query.
filterAttrName - The name of the attribute to filter on.
filterAttrValue - The value to filter by.
region (optional) - The AWS region where the table exists. (Default: us-east-1)
""";
if (args.length < 5) {
System.out.println(usage);
System.exit(1);
}
final String tableName = args[0];
final String partitionKeyName = args[1];
final String partitionKeyValue = args[2];
final String filterAttrName = args[3];
final String filterAttrValue = args[4];
final Region region = args.length > 5 ? Region.of(args[5]) : Region.US_EAST_1;
System.out.println("Querying items with dynamic filter: " + filterAttrName + " = " + filterAttrValue);
try {
// Using the builder pattern to create and execute the query
final QueryResponse response = new DynamicFilterQueryBuilder()
.withTableName(tableName)
.withPartitionKeyName(partitionKeyName)
.withPartitionKeyValue(partitionKeyValue)
.withFilterCriterion(filterAttrName, filterAttrValue)
.withRegion(region)
.execute();
// Process the results
System.out.println("Found " + response.count() + " items:");
response.items().forEach(item -> System.out.println(item));
// Demonstrate multiple filter criteria
System.out.println("\nNow querying with multiple filter criteria:");
Map multipleFilters = new HashMap<>();
multipleFilters.put(filterAttrName, filterAttrValue);
multipleFilters.put("status", "active");
final QueryResponse multiFilterResponse = new DynamicFilterQueryBuilder()
.withTableName(tableName)
.withPartitionKeyName(partitionKeyName)
.withPartitionKeyValue(partitionKeyValue)
.withFilterCriteria(multipleFilters)
.withRegion(region)
.execute();
System.out.println("Found " + multiFilterResponse.count() + " items with multiple filters:");
multiFilterResponse.items().forEach(item -> System.out.println(item));
} catch (IllegalArgumentException e) {
System.err.println("Invalid input: " + e.getMessage());
System.exit(1);
} catch (ResourceNotFoundException e) {
System.err.println("Table not found: " + tableName);
System.exit(1);
} catch (DynamoDbException e) {
System.err.println("DynamoDB error: " + e.getMessage());
System.exit(1);
} catch (Exception e) {
System.err.println("Unexpected error: " + e.getMessage());
System.exit(1);
}
}
```
Realice una consulta con una expresión de filtro y limite su uso AWS SDK for Java 2.x.
```
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 software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public QueryResponse queryWithFilterAndLimit(
final String tableName,
final String partitionKeyName,
final String partitionKeyValue,
final String filterAttrName,
final String filterAttrValue,
final int limit) {
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
CodeSampleUtils.validateStringParameter("Filter attribute name", filterAttrName);
CodeSampleUtils.validateStringParameter("Filter attribute value", filterAttrValue);
CodeSampleUtils.validatePositiveInteger("Limit", limit);
// Create expression attribute names for the column names
final Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_PK, partitionKeyName);
expressionAttributeNames.put(EXPRESSION_ATTRIBUTE_NAME_FILTER, filterAttrName);
// Create expression attribute values for the column values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_PK,
AttributeValue.builder().s(partitionKeyValue).build());
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_FILTER,
AttributeValue.builder().s(filterAttrValue).build());
// Create the filter expression
final String filterExpression = "#filterAttr = :filterValue";
// Create the query request
final QueryRequest queryRequest = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.filterExpression(filterExpression)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.limit(limit)
.build();
try {
final QueryResponse response = dynamoDbClient.query(queryRequest);
LOGGER.log(Level.INFO, "Query with filter and limit successful. Found {0} items", response.count());
LOGGER.log(
Level.INFO, "ScannedCount: {0} (total items evaluated before filtering)", response.scannedCount());
return response;
} catch (ResourceNotFoundException e) {
LOGGER.log(Level.SEVERE, "Table not found: {0}", tableName);
throw e;
} catch (DynamoDbException e) {
LOGGER.log(Level.SEVERE, "Error querying with filter and limit: {0}", e.getMessage());
throw e;
}
}
```
+ Para obtener información sobre la API, consulte [Query](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) en la *referencia de la API de AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Consulta con lecturas muy consistentes utilizando AWS SDK para JavaScript.
```
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
/**
* Queries a DynamoDB table with configurable read consistency
*
* @param {Object} config - AWS SDK configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} partitionKeyName - The name of the partition key
* @param {string} partitionKeyValue - The value of the partition key
* @param {boolean} useConsistentRead - Whether to use strongly consistent reads
* @returns {Promise} - The query response
*/
async function queryWithConsistentRead(
config,
tableName,
partitionKeyName,
partitionKeyValue,
useConsistentRead = false
) {
try {
// Create DynamoDB client
const client = new DynamoDBClient(config);
// Construct the query input
const input = {
TableName: tableName,
KeyConditionExpression: "#pk = :pkValue",
ExpressionAttributeNames: {
"#pk": partitionKeyName
},
ExpressionAttributeValues: {
":pkValue": { S: partitionKeyValue }
},
ConsistentRead: useConsistentRead
};
// Execute the query
const command = new QueryCommand(input);
return await client.send(command);
} catch (error) {
console.error(`Error querying with consistent read: ${error}`);
throw error;
}
}
```
Realice la consulta mediante un índice secundario global con AWS SDK para JavaScript.
```
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
/**
* Queries a DynamoDB table using the primary key
*
* @param {Object} config - AWS SDK configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} userId - The user ID to query by (partition key)
* @returns {Promise} - The query response
*/
async function queryTable(
config,
tableName,
userId
) {
try {
// Create DynamoDB client
const client = new DynamoDBClient(config);
// Construct the query input for the base table
const input = {
TableName: tableName,
KeyConditionExpression: "user_id = :userId",
ExpressionAttributeValues: {
":userId": { S: userId }
}
};
// Execute the query
const command = new QueryCommand(input);
return await client.send(command);
} catch (error) {
console.error(`Error querying table: ${error}`);
throw error;
}
}
/**
* Queries a DynamoDB Global Secondary Index (GSI)
*
* @param {Object} config - AWS SDK configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} indexName - The name of the GSI to query
* @param {string} gameId - The game ID to query by (GSI partition key)
* @returns {Promise} - The query response
*/
async function queryGSI(
config,
tableName,
indexName,
gameId
) {
try {
// Create DynamoDB client
const client = new DynamoDBClient(config);
// Construct the query input for the GSI
const input = {
TableName: tableName,
IndexName: indexName,
KeyConditionExpression: "game_id = :gameId",
ExpressionAttributeValues: {
":gameId": { S: gameId }
}
};
// Execute the query
const command = new QueryCommand(input);
return await client.send(command);
} catch (error) {
console.error(`Error querying GSI: ${error}`);
throw error;
}
}
```
Consulta con paginación utilizando AWS SDK para JavaScript.
```
/**
* Example demonstrating how to handle large query result sets in DynamoDB using pagination
*
* This example shows:
* - How to use pagination to handle large result sets
* - How to use LastEvaluatedKey to retrieve the next page of results
* - How to construct subsequent query requests using ExclusiveStartKey
*/
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
/**
* Queries a DynamoDB table with pagination to handle large result sets
*
* @param {Object} config - AWS SDK configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} partitionKeyName - The name of the partition key
* @param {string} partitionKeyValue - The value of the partition key
* @param {number} pageSize - Number of items per page
* @returns {Promise} - All items from the query
*/
async function queryWithPagination(
config,
tableName,
partitionKeyName,
partitionKeyValue,
pageSize = 25
) {
try {
// Create DynamoDB client
const client = new DynamoDBClient(config);
// Initialize variables for pagination
let lastEvaluatedKey = undefined;
const allItems = [];
let pageCount = 0;
// Loop until all pages are retrieved
do {
// Construct the query input
const input = {
TableName: tableName,
KeyConditionExpression: "#pk = :pkValue",
Limit: pageSize,
ExpressionAttributeNames: {
"#pk": partitionKeyName
},
ExpressionAttributeValues: {
":pkValue": { S: partitionKeyValue }
}
};
// Add ExclusiveStartKey if we have a LastEvaluatedKey from a previous query
if (lastEvaluatedKey) {
input.ExclusiveStartKey = lastEvaluatedKey;
}
// Execute the query
const command = new QueryCommand(input);
const response = await client.send(command);
// Process the current page of results
pageCount++;
console.log(`Processing page ${pageCount} with ${response.Items.length} items`);
// Add the items from this page to our collection
if (response.Items && response.Items.length > 0) {
allItems.push(...response.Items);
}
// Get the LastEvaluatedKey for the next page
lastEvaluatedKey = response.LastEvaluatedKey;
} while (lastEvaluatedKey); // Continue until there are no more pages
console.log(`Query complete. Retrieved ${allItems.length} items in ${pageCount} pages.`);
return allItems;
} catch (error) {
console.error(`Error querying with pagination: ${error}`);
throw error;
}
}
/**
* Example usage:
*
* // Query all items in the "AWS DynamoDB" forum with pagination
* const allItems = await queryWithPagination(
* { region: "us-west-2" },
* "ForumThreads",
* "ForumName",
* "AWS DynamoDB",
* 25 // 25 items per page
* );
*
* console.log(`Total items retrieved: ${allItems.length}`);
*
* // Notes on pagination:
* // - LastEvaluatedKey contains the primary key of the last evaluated item
* // - When LastEvaluatedKey is undefined/null, there are no more items to retrieve
* // - ExclusiveStartKey tells DynamoDB where to start the next page
* // - Pagination helps manage memory usage for large result sets
* // - Each page requires a separate network request to DynamoDB
*/
module.exports = { queryWithPagination };
```
Consulta con filtros complejos utilizando AWS SDK para JavaScript.
```
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
/**
* Queries a DynamoDB table with a complex filter expression
*
* @param {Object} config - AWS SDK configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {string} partitionKeyName - The name of the partition key
* @param {string} partitionKeyValue - The value of the partition key
* @param {number|string} minViews - Minimum number of views for filtering
* @param {number|string} minReplies - Minimum number of replies for filtering
* @param {string} requiredTag - Tag that must be present in the item's tags set
* @returns {Promise} - The query response
*/
async function queryWithComplexFilter(
config,
tableName,
partitionKeyName,
partitionKeyValue,
minViews,
minReplies,
requiredTag
) {
try {
// Create DynamoDB client
const client = new DynamoDBClient(config);
// Construct the query input
const input = {
TableName: tableName,
KeyConditionExpression: "#pk = :pkValue",
FilterExpression: "views >= :minViews AND replies >= :minReplies AND contains(tags, :tag)",
ExpressionAttributeNames: {
"#pk": partitionKeyName
},
ExpressionAttributeValues: {
":pkValue": { S: partitionKeyValue },
":minViews": { N: minViews.toString() },
":minReplies": { N: minReplies.toString() },
":tag": { S: requiredTag }
}
};
// Execute the query
const command = new QueryCommand(input);
return await client.send(command);
} catch (error) {
console.error(`Error querying with complex filter: ${error}`);
throw error;
}
}
```
Consulte con una expresión de filtro construida dinámicamente utilizando AWS SDK para JavaScript.
```
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
async function queryWithDynamicFilter(
config,
tableName,
partitionKeyName,
partitionKeyValue,
sortKeyName,
sortKeyValue,
filterParams = {}
) {
try {
// Create DynamoDB client
const client = new DynamoDBClient(config);
// Initialize filter expression components
let filterExpressions = [];
const expressionAttributeValues = {
":pkValue": { S: partitionKeyValue },
":skValue": { S: sortKeyValue }
};
const expressionAttributeNames = {
"#pk": partitionKeyName,
"#sk": sortKeyName
};
// Add status filter if provided
if (filterParams.status) {
filterExpressions.push("status = :status");
expressionAttributeValues[":status"] = { S: filterParams.status };
}
// Add minimum views filter if provided
if (filterParams.minViews !== undefined) {
filterExpressions.push("views >= :minViews");
expressionAttributeValues[":minViews"] = { N: filterParams.minViews.toString() };
}
// Add author filter if provided
if (filterParams.author) {
filterExpressions.push("author = :author");
expressionAttributeValues[":author"] = { S: filterParams.author };
}
// Construct the query input
const input = {
TableName: tableName,
KeyConditionExpression: "#pk = :pkValue AND #sk = :skValue"
};
// Add filter expression if any filters were provided
if (filterExpressions.length > 0) {
input.FilterExpression = filterExpressions.join(" AND ");
}
// Add expression attribute names and values
input.ExpressionAttributeNames = expressionAttributeNames;
input.ExpressionAttributeValues = expressionAttributeValues;
// Execute the query
const command = new QueryCommand(input);
return await client.send(command);
} catch (error) {
console.error(`Error querying with dynamic filter: ${error}`);
throw error;
}
}
```
+ Para obtener información sobre la API, consulte [Query](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand) en la *referencia de la API de AWS SDK para JavaScript *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Consulte con lecturas muy consistentes utilizando AWS SDK para Python (Boto3).
```
import time
import boto3
from boto3.dynamodb.conditions import Key
def query_with_consistent_read(
table_name,
partition_key_name,
partition_key_value,
sort_key_name=None,
sort_key_value=None,
consistent_read=True,
):
"""
Query a DynamoDB table with the option for strongly consistent reads.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
sort_key_name (str, optional): The name of the sort key attribute.
sort_key_value (str, optional): The value of the sort key to query.
consistent_read (bool, optional): Whether to use strongly consistent reads. Defaults to True.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Build the key condition expression
key_condition = Key(partition_key_name).eq(partition_key_value)
if sort_key_name and sort_key_value:
key_condition = key_condition & Key(sort_key_name).eq(sort_key_value)
# Perform the query with the consistent read option
response = table.query(KeyConditionExpression=key_condition, ConsistentRead=consistent_read)
return response
```
Realice la consulta mediante un índice secundario global con AWS SDK para Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Key
def query_table(table_name, partition_key_name, partition_key_value):
"""
Query a DynamoDB table using its primary key.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Perform the query on the table's primary key
response = table.query(KeyConditionExpression=Key(partition_key_name).eq(partition_key_value))
return response
def query_gsi(table_name, index_name, partition_key_name, partition_key_value):
"""
Query a Global Secondary Index (GSI) on a DynamoDB table.
Args:
table_name (str): The name of the DynamoDB table.
index_name (str): The name of the Global Secondary Index.
partition_key_name (str): The name of the GSI's partition key attribute.
partition_key_value (str): The value of the GSI's partition key to query.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Perform the query on the GSI
response = table.query(
IndexName=index_name, KeyConditionExpression=Key(partition_key_name).eq(partition_key_value)
)
return response
```
Consulta con paginación utilizando AWS SDK para Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Key
def query_with_pagination(
table_name, partition_key_name, partition_key_value, page_size=25, max_pages=None
):
"""
Query a DynamoDB table with pagination to handle large result sets.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
page_size (int, optional): The number of items to return per page. Defaults to 25.
max_pages (int, optional): The maximum number of pages to retrieve. If None, retrieves all pages.
Returns:
list: All items retrieved from the query across all pages.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Initialize variables for pagination
last_evaluated_key = None
page_count = 0
all_items = []
# Paginate through the results
while True:
# Check if we've reached the maximum number of pages
if max_pages is not None and page_count >= max_pages:
break
# Prepare the query parameters
query_params = {
"KeyConditionExpression": Key(partition_key_name).eq(partition_key_value),
"Limit": page_size,
}
# Add the ExclusiveStartKey if we have a LastEvaluatedKey from a previous query
if last_evaluated_key:
query_params["ExclusiveStartKey"] = last_evaluated_key
# Execute the query
response = table.query(**query_params)
# Process the current page of results
items = response.get("Items", [])
all_items.extend(items)
# Update pagination tracking
page_count += 1
# Get the LastEvaluatedKey for the next page, if any
last_evaluated_key = response.get("LastEvaluatedKey")
# If there's no LastEvaluatedKey, we've reached the end of the results
if not last_evaluated_key:
break
return all_items
def query_with_pagination_generator(
table_name, partition_key_name, partition_key_value, page_size=25
):
"""
Query a DynamoDB table with pagination using a generator to handle large result sets.
This approach is memory-efficient as it yields one page at a time.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
page_size (int, optional): The number of items to return per page. Defaults to 25.
Yields:
tuple: A tuple containing (items, page_number, last_page) where:
- items is a list of items for the current page
- page_number is the current page number (starting from 1)
- last_page is a boolean indicating if this is the last page
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Initialize variables for pagination
last_evaluated_key = None
page_number = 0
# Paginate through the results
while True:
# Prepare the query parameters
query_params = {
"KeyConditionExpression": Key(partition_key_name).eq(partition_key_value),
"Limit": page_size,
}
# Add the ExclusiveStartKey if we have a LastEvaluatedKey from a previous query
if last_evaluated_key:
query_params["ExclusiveStartKey"] = last_evaluated_key
# Execute the query
response = table.query(**query_params)
# Get the current page of results
items = response.get("Items", [])
page_number += 1
# Get the LastEvaluatedKey for the next page, if any
last_evaluated_key = response.get("LastEvaluatedKey")
# Determine if this is the last page
is_last_page = last_evaluated_key is None
# Yield the current page of results
yield (items, page_number, is_last_page)
# If there's no LastEvaluatedKey, we've reached the end of the results
if is_last_page:
break
```
Consulta con filtros complejos utilizando AWS SDK para Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Attr, Key
def query_with_complex_filter(
table_name,
partition_key_name,
partition_key_value,
min_rating=None,
status_list=None,
max_price=None,
):
"""
Query a DynamoDB table with a complex filter expression.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
min_rating (float, optional): Minimum rating value for filtering.
status_list (list, optional): List of status values to include.
max_price (float, optional): Maximum price value for filtering.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Start with the key condition expression
key_condition = Key(partition_key_name).eq(partition_key_value)
# Initialize the filter expression and expression attribute values
filter_expression = None
expression_attribute_values = {}
# Build the filter expression based on provided parameters
if min_rating is not None:
filter_expression = Attr("rating").gte(min_rating)
expression_attribute_values[":min_rating"] = min_rating
if status_list and len(status_list) > 0:
status_condition = None
for i, status in enumerate(status_list):
status_value_name = f":status{i}"
expression_attribute_values[status_value_name] = status
if status_condition is None:
status_condition = Attr("status").eq(status)
else:
status_condition = status_condition | Attr("status").eq(status)
if filter_expression is None:
filter_expression = status_condition
else:
filter_expression = filter_expression & status_condition
if max_price is not None:
price_condition = Attr("price").lte(max_price)
expression_attribute_values[":max_price"] = max_price
if filter_expression is None:
filter_expression = price_condition
else:
filter_expression = filter_expression & price_condition
# Prepare the query parameters
query_params = {"KeyConditionExpression": key_condition}
if filter_expression:
query_params["FilterExpression"] = filter_expression
if expression_attribute_values:
query_params["ExpressionAttributeValues"] = expression_attribute_values
# Execute the query
response = table.query(**query_params)
return response
def query_with_complex_filter_and_or(
table_name,
partition_key_name,
partition_key_value,
category=None,
min_rating=None,
max_price=None,
):
"""
Query a DynamoDB table with a complex filter expression using AND and OR operators.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
category (str, optional): Category value for filtering.
min_rating (float, optional): Minimum rating value for filtering.
max_price (float, optional): Maximum price value for filtering.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Start with the key condition expression
key_condition = Key(partition_key_name).eq(partition_key_value)
# Build a complex filter expression with AND and OR operators
filter_expression = None
expression_attribute_values = {}
# Build the category condition
if category:
filter_expression = Attr("category").eq(category)
expression_attribute_values[":category"] = category
# Build the rating and price condition (rating >= min_rating OR price <= max_price)
rating_price_condition = None
if min_rating is not None:
rating_price_condition = Attr("rating").gte(min_rating)
expression_attribute_values[":min_rating"] = min_rating
if max_price is not None:
price_condition = Attr("price").lte(max_price)
expression_attribute_values[":max_price"] = max_price
if rating_price_condition is None:
rating_price_condition = price_condition
else:
rating_price_condition = rating_price_condition | price_condition
# Combine the conditions
if rating_price_condition:
if filter_expression is None:
filter_expression = rating_price_condition
else:
filter_expression = filter_expression & rating_price_condition
# Prepare the query parameters
query_params = {"KeyConditionExpression": key_condition}
if filter_expression:
query_params["FilterExpression"] = filter_expression
if expression_attribute_values:
query_params["ExpressionAttributeValues"] = expression_attribute_values
# Execute the query
response = table.query(**query_params)
return response
```
Consulte con una expresión de filtro construida dinámicamente utilizando AWS SDK para Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Attr, Key
def query_with_dynamic_filter(
table_name, partition_key_name, partition_key_value, filter_conditions=None
):
"""
Query a DynamoDB table with a dynamically constructed filter expression.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
filter_conditions (dict, optional): A dictionary of filter conditions where
keys are attribute names and values are dictionaries with 'operator' and 'value'.
Example: {'rating': {'operator': '>=', 'value': 4}, 'status': {'operator': '=', 'value': 'active'}}
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Start with the key condition expression
key_condition = Key(partition_key_name).eq(partition_key_value)
# Initialize variables for the filter expression and attribute values
filter_expression = None
expression_attribute_values = {":pk_val": partition_key_value}
# Dynamically build the filter expression if filter conditions are provided
if filter_conditions:
for attr_name, condition in filter_conditions.items():
operator = condition.get("operator")
value = condition.get("value")
attr_value_name = f":{attr_name}"
expression_attribute_values[attr_value_name] = value
# Create the appropriate filter expression based on the operator
current_condition = None
if operator == "=":
current_condition = Attr(attr_name).eq(value)
elif operator == "!=":
current_condition = Attr(attr_name).ne(value)
elif operator == ">":
current_condition = Attr(attr_name).gt(value)
elif operator == ">=":
current_condition = Attr(attr_name).gte(value)
elif operator == "<":
current_condition = Attr(attr_name).lt(value)
elif operator == "<=":
current_condition = Attr(attr_name).lte(value)
elif operator == "contains":
current_condition = Attr(attr_name).contains(value)
elif operator == "begins_with":
current_condition = Attr(attr_name).begins_with(value)
# Combine with existing filter expression using AND
if current_condition:
if filter_expression is None:
filter_expression = current_condition
else:
filter_expression = filter_expression & current_condition
# Perform the query with the dynamically built filter expression
query_params = {"KeyConditionExpression": key_condition}
if filter_expression:
query_params["FilterExpression"] = filter_expression
response = table.query(**query_params)
return response
```
Realice una consulta con una expresión de filtro y limite su uso AWS SDK para Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Attr, Key
def query_with_filter_and_limit(
table_name,
partition_key_name,
partition_key_value,
filter_attribute=None,
filter_value=None,
limit=10,
):
"""
Query a DynamoDB table with a filter expression and limit the number of results.
Args:
table_name (str): The name of the DynamoDB table.
partition_key_name (str): The name of the partition key attribute.
partition_key_value (str): The value of the partition key to query.
filter_attribute (str, optional): The attribute name to filter on.
filter_value (any, optional): The value to compare against in the filter.
limit (int, optional): The maximum number of items to evaluate. Defaults to 10.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Build the key condition expression
key_condition = Key(partition_key_name).eq(partition_key_value)
# Prepare the query parameters
query_params = {"KeyConditionExpression": key_condition, "Limit": limit}
# Add the filter expression if filter attributes are provided
if filter_attribute and filter_value is not None:
query_params["FilterExpression"] = Attr(filter_attribute).gt(filter_value)
query_params["ExpressionAttributeValues"] = {":filter_value": filter_value}
# Execute the query
response = table.query(**query_params)
return response
```
+ Para obtener información sobre la API, consulte [Query](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query) en la *referencia de la API de AWS SDK para Python (Boto3)*.
------
# Realice operaciones de lista en DynamoDB con un SDK AWS
This method demonstrates how to use the list_append function to add
* items to the end of a list attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param listAttributeName The name of the list attribute
* @param itemsToAppend The items to append to the list
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse appendToList(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String listAttributeName,
List itemsToAppend) {
// Create a list value from the items to append
AttributeValue listValue = AttributeValue.builder().l(itemsToAppend).build();
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #attrName = list_append(if_not_exists(#attrName, :emptyList), :newItems)")
.expressionAttributeNames(Map.of("#attrName", listAttributeName))
.expressionAttributeValues(Map.of(
":newItems",
listValue,
":emptyList",
AttributeValue.builder().l(new ArrayList()).build()))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Prepends items to a list attribute.
*
* This method demonstrates how to use the list_append function to add
* items to the beginning of a list attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param listAttributeName The name of the list attribute
* @param itemsToPrepend The items to prepend to the list
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse prependToList(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String listAttributeName,
List itemsToPrepend) {
// Create a list value from the items to prepend
AttributeValue listValue = AttributeValue.builder().l(itemsToPrepend).build();
// Define the update parameters
// Note: To prepend, we put the new items first in the list_append function
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #attrName = list_append(:newItems, if_not_exists(#attrName, :emptyList))")
.expressionAttributeNames(Map.of("#attrName", listAttributeName))
.expressionAttributeValues(Map.of(
":newItems",
listValue,
":emptyList",
AttributeValue.builder().l(new ArrayList()).build()))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Updates a specific element in a list attribute.
*
* This method demonstrates how to update a specific element in a list
* by its index.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param listAttributeName The name of the list attribute
* @param index The index of the element to update
* @param newValue The new value for the element
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse updateListElement(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String listAttributeName,
int index,
AttributeValue newValue) {
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #attrName[" + index + "] = :newValue")
.expressionAttributeNames(Map.of("#attrName", listAttributeName))
.expressionAttributeValues(Map.of(":newValue", newValue))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Removes a specific element from a list attribute.
*
* This method demonstrates how to remove a specific element from a list
* by its index.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param listAttributeName The name of the list attribute
* @param index The index of the element to remove
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse removeListElement(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String listAttributeName,
int index) {
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("REMOVE #attrName[" + index + "]")
.expressionAttributeNames(Map.of("#attrName", listAttributeName))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Gets the current value of a list attribute.
*
* Helper method to retrieve the current value of a list attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to get
* @param listAttributeName The name of the list attribute
* @return The list attribute value or null if not found
* @throws DynamoDbException if an error occurs during the operation
*/
public static List getListAttribute(
DynamoDbClient dynamoDbClient, String tableName, Map key, String listAttributeName) {
// Define the get parameters
GetItemRequest request = GetItemRequest.builder()
.tableName(tableName)
.key(key)
.projectionExpression(listAttributeName)
.build();
try {
// Perform the get operation
GetItemResponse response = dynamoDbClient.getItem(request);
// Return the list attribute if it exists, otherwise null
if (response.item() != null && response.item().containsKey(listAttributeName)) {
return response.item().get(listAttributeName).l();
}
return null;
} catch (DynamoDbException e) {
throw DynamoDbException.builder()
.message("Failed to get list attribute: " + e.getMessage())
.cause(e)
.build();
}
}
```
Ejemplo de uso de operaciones de lista con AWS SDK for Java 2.x.
```
public static void exampleUsage(DynamoDbClient dynamoDbClient, String tableName) {
// Example key
Map key = new HashMap<>();
key.put("ProductId", AttributeValue.builder().s("P12345").build());
System.out.println("Demonstrating list operations in DynamoDB");
try {
// Example 1: Append items to a list
System.out.println("\nExample 1: Appending items to a list");
List tagsToAppend = List.of(
AttributeValue.builder().s("Electronics").build(),
AttributeValue.builder().s("Gadget").build());
UpdateItemResponse appendResponse = appendToList(dynamoDbClient, tableName, key, "Tags", tagsToAppend);
System.out.println("Updated list attribute: " + appendResponse.attributes());
// Example 2: Prepend items to a list
System.out.println("\nExample 2: Prepending items to a list");
List tagsToPrepend = List.of(
AttributeValue.builder().s("Featured").build(),
AttributeValue.builder().s("New").build());
UpdateItemResponse prependResponse = prependToList(dynamoDbClient, tableName, key, "Tags", tagsToPrepend);
System.out.println("Updated list attribute: " + prependResponse.attributes());
// Example 3: Update a specific element in a list
System.out.println("\nExample 3: Updating a specific element in a list");
UpdateItemResponse updateResponse = updateListElement(
dynamoDbClient,
tableName,
key,
"Tags",
0,
AttributeValue.builder().s("BestSeller").build());
System.out.println("Updated list attribute: " + updateResponse.attributes());
// Example 4: Remove a specific element from a list
System.out.println("\nExample 4: Removing a specific element from a list");
UpdateItemResponse removeResponse = removeListElement(dynamoDbClient, tableName, key, "Tags", 1);
System.out.println("Updated list attribute: " + removeResponse.attributes());
// Example 5: Get the current value of a list attribute
System.out.println("\nExample 5: Getting the current value of a list attribute");
List currentList = getListAttribute(dynamoDbClient, tableName, key, "Tags");
if (currentList != null) {
System.out.println("Current list attribute:");
for (int i = 0; i < currentList.size(); i++) {
System.out.println(" [" + i + "]: " + currentList.get(i).s());
}
} else {
System.out.println("List attribute not found");
}
// Explain list operations
System.out.println("\nKey points about DynamoDB list operations:");
System.out.println("1. Lists are ordered collections of attributes");
System.out.println("2. Use list_append to add items to a list");
System.out.println("3. To append items, use list_append(existingList, newItems)");
System.out.println("4. To prepend items, use list_append(newItems, existingList)");
System.out.println("5. Use index notation (list[0]) to access or update specific elements");
System.out.println("6. Use REMOVE to delete elements from a list");
System.out.println("7. List indices are zero-based");
System.out.println("8. Use if_not_exists to handle the case where the list doesn't exist yet");
} catch (DynamoDbException e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)la *referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Demuestre las operaciones de listas utilizando AWS SDK para JavaScript.
```
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const {
DynamoDBDocumentClient,
UpdateCommand,
GetCommand,
PutCommand
} = require("@aws-sdk/lib-dynamodb");
/**
* Append elements to a list attribute.
*
* This function demonstrates how to use the list_append function to add elements
* to the end of a list.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName - The name of the list attribute
* @param {Array} values - The values to append to the list
* @returns {Promise} - The response from DynamoDB
*/
async function appendToList(
config,
tableName,
key,
listName,
values
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using list_append
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${listName} = list_append(if_not_exists(${listName}, :empty_list), :values)`,
ExpressionAttributeValues: {
":empty_list": [],
":values": values
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Prepend elements to a list attribute.
*
* This function demonstrates how to use the list_append function to add elements
* to the beginning of a list.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName - The name of the list attribute
* @param {Array} values - The values to prepend to the list
* @returns {Promise} - The response from DynamoDB
*/
async function prependToList(
config,
tableName,
key,
listName,
values
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using list_append
// Note: To prepend, we put the new values first in the list_append function
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${listName} = list_append(:values, if_not_exists(${listName}, :empty_list))`,
ExpressionAttributeValues: {
":empty_list": [],
":values": values
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Update a specific element in a list by index.
*
* This function demonstrates how to update a specific element in a list
* using the index notation.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName - The name of the list attribute
* @param {number} index - The index of the element to update
* @param {any} value - The new value for the element
* @returns {Promise} - The response from DynamoDB
*/
async function updateListElement(
config,
tableName,
key,
listName,
index,
value
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using index notation
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${listName}[${index}] = :value`,
ExpressionAttributeValues: {
":value": value
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Remove an element from a list by index.
*
* This function demonstrates how to remove a specific element from a list
* using the REMOVE action with index notation.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName - The name of the list attribute
* @param {number} index - The index of the element to remove
* @returns {Promise} - The response from DynamoDB
*/
async function removeListElement(
config,
tableName,
key,
listName,
index
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using REMOVE with index notation
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `REMOVE ${listName}[${index}]`,
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Concatenate two lists.
*
* This function demonstrates how to concatenate two lists using the list_append function.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName1 - The name of the first list attribute
* @param {string} listName2 - The name of the second list attribute
* @param {string} resultListName - The name of the attribute to store the concatenated list
* @returns {Promise} - The response from DynamoDB
*/
async function concatenateLists(
config,
tableName,
key,
listName1,
listName2,
resultListName
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using list_append
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${resultListName} = list_append(if_not_exists(${listName1}, :empty_list), if_not_exists(${listName2}, :empty_list))`,
ExpressionAttributeValues: {
":empty_list": []
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Create a nested list structure.
*
* This function demonstrates how to create and work with nested lists.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName - The name of the list attribute
* @param {Array} nestedLists - An array of arrays to create a nested list structure
* @returns {Promise} - The response from DynamoDB
*/
async function createNestedList(
config,
tableName,
key,
listName,
nestedLists
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters to create a nested list
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${listName} = :nested_lists`,
ExpressionAttributeValues: {
":nested_lists": nestedLists
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Update an element in a nested list.
*
* This function demonstrates how to update an element in a nested list
* using multiple index notations.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} listName - The name of the list attribute
* @param {number} outerIndex - The index in the outer list
* @param {number} innerIndex - The index in the inner list
* @param {any} value - The new value for the element
* @returns {Promise} - The response from DynamoDB
*/
async function updateNestedListElement(
config,
tableName,
key,
listName,
outerIndex,
innerIndex,
value
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using multiple index notations
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${listName}[${outerIndex}][${innerIndex}] = :value`,
ExpressionAttributeValues: {
":value": value
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Get the current value of an item.
*
* Helper function to retrieve the current value of an item.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to get
* @returns {Promise} - The item or null if not found
*/
async function getItem(
config,
tableName,
key
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the get parameters
const params = {
TableName: tableName,
Key: key
};
// Perform the get operation
const response = await docClient.send(new GetCommand(params));
// Return the item if it exists, otherwise null
return response.Item || null;
}
```
Ejemplo de uso de operaciones de lista con AWS SDK para JavaScript.
```
/**
* Example of how to work with lists in DynamoDB.
*/
async function exampleUsage() {
// Example parameters
const config = { region: "us-west-2" };
const tableName = "UserProfiles";
const key = { UserId: "U12345" };
console.log("Demonstrating list operations in DynamoDB");
try {
// Example 1: Append elements to a list
console.log("\nExample 1: Appending elements to a list");
const response1 = await appendToList(
config,
tableName,
key,
"RecentSearches",
["laptop", "headphones", "monitor"]
);
console.log("Appended to list:", response1.Attributes);
// Example 2: Prepend elements to a list
console.log("\nExample 2: Prepending elements to a list");
const response2 = await prependToList(
config,
tableName,
key,
"RecentSearches",
["keyboard", "mouse"]
);
console.log("Prepended to list:", response2.Attributes);
// Get the current state of the item
let currentItem = await getItem(config, tableName, key);
console.log("\nCurrent state of RecentSearches:", currentItem?.RecentSearches);
// Example 3: Update a specific element in a list
console.log("\nExample 3: Updating a specific element in a list");
const response3 = await updateListElement(
config,
tableName,
key,
"RecentSearches",
0, // Update the first element
"mechanical keyboard" // New value
);
console.log("Updated list element:", response3.Attributes);
// Example 4: Remove an element from a list
console.log("\nExample 4: Removing an element from a list");
const response4 = await removeListElement(
config,
tableName,
key,
"RecentSearches",
2 // Remove the third element
);
console.log("List after removing element:", response4.Attributes);
// Example 5: Create and concatenate lists
console.log("\nExample 5: Creating and concatenating lists");
// First, create two separate lists
await updateWithMultipleActions(
config,
tableName,
key,
"SET WishList = :wishlist, SavedItems = :saveditems",
null,
{
":wishlist": ["gaming laptop", "wireless earbuds"],
":saveditems": ["smartphone", "tablet"]
}
);
// Then, concatenate them
const response5 = await concatenateLists(
config,
tableName,
key,
"WishList",
"SavedItems",
"AllItems"
);
console.log("Concatenated lists:", response5.Attributes);
// Example 6: Create a nested list structure
console.log("\nExample 6: Creating a nested list structure");
const response6 = await createNestedList(
config,
tableName,
key,
"Categories",
[
["Electronics", "Computers", "Accessories"],
["Books", "Magazines", "E-books"],
["Clothing", "Shoes", "Watches"]
]
);
console.log("Created nested list:", response6.Attributes);
// Example 7: Update an element in a nested list
console.log("\nExample 7: Updating an element in a nested list");
const response7 = await updateNestedListElement(
config,
tableName,
key,
"Categories",
0, // First inner list
1, // Second element in that list
"Laptops" // New value
);
console.log("Updated nested list element:", response7.Attributes);
// Get the final state of the item
currentItem = await getItem(config, tableName, key);
console.log("\nFinal state of the item:", JSON.stringify(currentItem, null, 2));
// Explain list operations
console.log("\nKey points about list operations in DynamoDB:");
console.log("1. Use list_append to add elements to a list");
console.log("2. To append elements, use list_append(existingList, newElements)");
console.log("3. To prepend elements, use list_append(newElements, existingList)");
console.log("4. Use if_not_exists to handle cases where the list might not exist yet");
console.log("5. Use index notation (list[0]) to access or update specific elements");
console.log("6. Use REMOVE with index notation to remove elements from a list");
console.log("7. Lists can contain elements of different types");
console.log("8. Lists can be nested (lists of lists)");
console.log("9. Use multiple index notations (list[0][1]) to access nested list elements");
} catch (error) {
console.error("Error:", error);
}
}
/**
* Helper function for the examples.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} updateExpression - The update expression
* @param {Object} expressionAttributeNames - Expression attribute name placeholders
* @param {Object} expressionAttributeValues - Expression attribute value placeholders
* @returns {Promise} - The response from DynamoDB
*/
async function updateWithMultipleActions(
config,
tableName,
key,
updateExpression,
expressionAttributeNames,
expressionAttributeValues
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Prepare the update parameters
const updateParams = {
TableName: tableName,
Key: key,
UpdateExpression: updateExpression,
ReturnValues: "UPDATED_NEW"
};
// Add expression attribute names if provided
if (expressionAttributeNames) {
updateParams.ExpressionAttributeNames = expressionAttributeNames;
}
// Add expression attribute values if provided
if (expressionAttributeValues) {
updateParams.ExpressionAttributeValues = expressionAttributeValues;
}
// Execute the update
const response = await docClient.send(new UpdateCommand(updateParams));
return response;
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)la *referencia AWS SDK para JavaScript de la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Demuestre las operaciones de la lista utilizando AWS SDK para Python (Boto3).
```
import boto3
import json
from typing import Any, Dict, List, Optional, Union
def create_list_attribute(
table_name: str, key: Dict[str, Any], list_name: str, list_values: List[Any]
) -> Dict[str, Any]:
"""
Create a new list attribute or replace an existing one.
This function demonstrates how to create a new list attribute or replace
an existing list with new values.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
list_values (List[Any]): The values to set in the list.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use the SET operation to create or replace the list
response = table.update_item(
Key=key,
UpdateExpression=f"SET {list_name} = :list_values",
ExpressionAttributeValues={":list_values": list_values},
ReturnValues="UPDATED_NEW",
)
return response
def append_to_list(
table_name: str, key: Dict[str, Any], list_name: str, values_to_append: List[Any]
) -> Dict[str, Any]:
"""
Append values to the end of a list attribute.
This function demonstrates how to use the list_append function to add elements
to the end of a list attribute.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
values_to_append (List[Any]): The values to append to the list.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use list_append to add values to the end of the list
response = table.update_item(
Key=key,
UpdateExpression=f"SET {list_name} = list_append({list_name}, :values)",
ExpressionAttributeValues={":values": values_to_append},
ReturnValues="UPDATED_NEW",
)
return response
def prepend_to_list(
table_name: str, key: Dict[str, Any], list_name: str, values_to_prepend: List[Any]
) -> Dict[str, Any]:
"""
Prepend values to the beginning of a list attribute.
This function demonstrates how to use the list_append function to add elements
to the beginning of a list attribute.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
values_to_prepend (List[Any]): The values to prepend to the list.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use list_append with reversed order to add values to the beginning of the list
response = table.update_item(
Key=key,
UpdateExpression=f"SET {list_name} = list_append(:values, {list_name})",
ExpressionAttributeValues={":values": values_to_prepend},
ReturnValues="UPDATED_NEW",
)
return response
def update_list_element(
table_name: str, key: Dict[str, Any], list_name: str, index: int, new_value: Any
) -> Dict[str, Any]:
"""
Update a specific element in a list attribute.
This function demonstrates how to update a specific element in a list attribute
using the index notation.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
index (int): The zero-based index of the element to update.
new_value (Any): The new value for the element.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use the index notation to update a specific element
response = table.update_item(
Key=key,
UpdateExpression=f"SET {list_name}[{index}] = :value",
ExpressionAttributeValues={":value": new_value},
ReturnValues="UPDATED_NEW",
)
return response
def remove_list_element(
table_name: str, key: Dict[str, Any], list_name: str, index: int
) -> Dict[str, Any]:
"""
Remove a specific element from a list attribute.
This function demonstrates how to remove a specific element from a list attribute
using the REMOVE action with index notation.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
index (int): The zero-based index of the element to remove.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use the REMOVE action with index notation to remove a specific element
response = table.update_item(
Key=key, UpdateExpression=f"REMOVE {list_name}[{index}]", ReturnValues="UPDATED_NEW"
)
return response
def update_nested_list_element(
table_name: str, key: Dict[str, Any], path: str, new_value: Any
) -> Dict[str, Any]:
"""
Update an element in a nested list structure.
This function demonstrates how to update an element in a nested list structure
using expression attribute names for the path components.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
path (str): The path to the nested element (e.g., "parent[0].child[1]").
new_value (Any): The new value for the element.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Define a type for path parts
path_part = Dict[str, Union[str, int]]
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Parse the path to extract attribute names and indices
path_parts: List[path_part] = []
current_part = ""
in_bracket = False
for char in path:
if char == "[":
if current_part:
path_parts.append({"type": "attribute", "value": current_part})
current_part = ""
in_bracket = True
elif char == "]":
if current_part:
# Fix for mypy: Use a properly typed dictionary with Union type
path_parts.append({"type": "index", "value": int(current_part)})
current_part = ""
in_bracket = False
elif char == "." and not in_bracket:
if current_part:
path_parts.append({"type": "attribute", "value": current_part})
current_part = ""
else:
current_part += char
if current_part:
path_parts.append({"type": "attribute", "value": current_part})
# Build the update expression and attribute names
update_expression = "SET "
expression_attribute_names = {}
# Build the path expression
path_expression = ""
for i, part in enumerate(path_parts):
if part["type"] == "attribute":
name_placeholder = f"#attr{i}"
expression_attribute_names[name_placeholder] = part["value"]
if path_expression:
path_expression += "."
path_expression += name_placeholder
elif part["type"] == "index":
path_expression += f"[{part['value']}]"
# Complete the update expression
update_expression += f"{path_expression} = :value"
# Execute the update
response = table.update_item(
Key=key,
UpdateExpression=update_expression,
ExpressionAttributeNames=expression_attribute_names,
ExpressionAttributeValues={":value": new_value},
ReturnValues="UPDATED_NEW",
)
return response
def create_list_if_not_exists(
table_name: str, key: Dict[str, Any], list_name: str, default_values: List[Any]
) -> Dict[str, Any]:
"""
Create a list attribute if it doesn't exist.
This function demonstrates how to use if_not_exists to create a list attribute
with default values if it doesn't already exist.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
default_values (List[Any]): The default values for the list.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use if_not_exists to create the list if it doesn't exist
response = table.update_item(
Key=key,
UpdateExpression=f"SET {list_name} = if_not_exists({list_name}, :default)",
ExpressionAttributeValues={":default": default_values},
ReturnValues="UPDATED_NEW",
)
return response
def append_to_list_safely(
table_name: str,
key: Dict[str, Any],
list_name: str,
values_to_append: List[Any],
default_values: Optional[List[Any]] = None,
) -> Dict[str, Any]:
"""
Append values to a list, creating it if it doesn't exist.
This function demonstrates how to safely append values to a list attribute,
creating the list with default values if it doesn't exist.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
list_name (str): The name of the list attribute.
values_to_append (List[Any]): The values to append to the list.
default_values (Optional[List[Any]]): The default values if the list doesn't exist.
If not provided, values_to_append will be used as the default.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# If default_values is not provided, use values_to_append
if default_values is None:
default_values = values_to_append
# Use if_not_exists with list_append to safely append to the list
response = table.update_item(
Key=key,
UpdateExpression=f"SET {list_name} = list_append(if_not_exists({list_name}, :default), :values)",
ExpressionAttributeValues={
":default": default_values if default_values else [],
":values": values_to_append,
},
ReturnValues="UPDATED_NEW",
)
return response
```
Ejemplo de uso de operaciones de lista con AWS SDK para Python (Boto3).
```
def example_usage():
"""Example of how to use list operations in DynamoDB."""
# Example parameters
table_name = "UserData"
key = {"UserId": "user123"}
print("Example 1: Creating a list attribute")
try:
response = create_list_attribute(
table_name=table_name,
key=key,
list_name="Interests",
list_values=["Reading", "Hiking", "Photography"],
)
print(
f"List attribute created successfully: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error creating list attribute: {e}")
print("\nExample 2: Appending values to a list")
try:
response = append_to_list(
table_name=table_name,
key=key,
list_name="Interests",
values_to_append=["Cooking", "Gardening"],
)
print(
f"Values appended to list successfully: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error appending to list: {e}")
print("\nExample 3: Prepending values to a list")
try:
response = prepend_to_list(
table_name=table_name,
key=key,
list_name="Interests",
values_to_prepend=["Travel", "Music"],
)
print(
f"Values prepended to list successfully: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error prepending to list: {e}")
print("\nExample 4: Updating a specific list element")
try:
response = update_list_element(
table_name=table_name,
key=key,
list_name="Interests",
index=2,
new_value="Mountain Hiking",
)
print(
f"List element updated successfully: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error updating list element: {e}")
print("\nExample 5: Removing a list element")
try:
response = remove_list_element(
table_name=table_name, key=key, list_name="Interests", index=0
)
print(
f"List element removed successfully: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error removing list element: {e}")
print("\nExample 6: Working with nested lists")
try:
# First, create an item with a nested structure
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
table.update_item(
Key={"UserId": "user456"},
UpdateExpression="SET #skills = :skills",
ExpressionAttributeNames={"#skills": "Skills"},
ExpressionAttributeValues={
":skills": [
{"Category": "Programming", "Languages": ["Python", "Java", "JavaScript"]},
{"Category": "Database", "Systems": ["DynamoDB", "MongoDB", "PostgreSQL"]},
]
},
)
# Now update a nested element
response = update_nested_list_element(
table_name=table_name,
key={"UserId": "user456"},
path="Skills[0].Languages[1]",
new_value="TypeScript",
)
print(
f"Nested list element updated successfully: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error working with nested lists: {e}")
print("\nExample 7: Creating a list if it doesn't exist")
try:
response = create_list_if_not_exists(
table_name=table_name,
key={"UserId": "user789"},
list_name="Preferences",
default_values=["Default1", "Default2", "Default3"],
)
print(
f"List created with default values: {json.dumps(response.get('Attributes', {}), default=str)}"
)
except Exception as e:
print(f"Error creating list with default values: {e}")
print("\nExample 8: Safely appending to a list")
try:
response = append_to_list_safely(
table_name=table_name,
key={"UserId": "user789"},
list_name="Notifications",
values_to_append=["New message received"],
default_values=[],
)
print(f"Safely appended to list: {json.dumps(response.get('Attributes', {}), default=str)}")
except Exception as e:
print(f"Error safely appending to list: {e}")
print("\nKey Points About Working with Lists in DynamoDB:")
print("1. Lists are ordered collections of elements that can be of different types")
print("2. Use the SET operation with direct assignment to create or replace a list")
print("3. Use list_append() to add elements to a list without replacing the entire list")
print("4. To append to the end: list_append(list_name, :values)")
print("5. To prepend to the beginning: list_append(:values, list_name)")
print("6. Use index notation list_name[index] to access or update specific elements")
print("7. Use the REMOVE action with index notation to remove specific elements")
print("8. Lists can contain nested structures like maps and other lists")
print("9. Use if_not_exists() to create a list with default values if it doesn't exist")
print("10. List indices are zero-based (the first element is at index 0)")
print("11. Attempting to access an index beyond the list bounds will result in an error")
```
+ Para obtener más información sobre la API, consulta [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)la *AWS Referencia de API de SDK for Python (Boto3*).
------
# Realice operaciones de mapas en DynamoDB con un SDK AWS
This method demonstrates how to safely update a map attribute
* by using if_not_exists to handle the case where the map doesn't exist yet.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param mapName The name of the map attribute
* @param mapKey The key within the map to update
* @param value The value to set
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse updateMapAttributeSafe(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String mapName,
String mapKey,
AttributeValue value) {
// Create an empty map to use if the map doesn't exist
Map emptyMap = new HashMap<>();
AttributeValue emptyMapValue = AttributeValue.builder().m(emptyMap).build();
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #mapName = if_not_exists(#mapName, :emptyMap), #mapName.#mapKey = :value")
.expressionAttributeNames(Map.of(
"#mapName", mapName,
"#mapKey", mapKey))
.expressionAttributeValues(Map.of(
":value",
value,
":emptyMap",
AttributeValue.builder().m(new HashMap<>()).build()))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Adds an attribute to a nested map.
*
* This method demonstrates how to update a nested attribute without
* overwriting the entire map.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param path The path to the nested attribute as a list
* @param value The value to set
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse addToNestedMap(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
List path,
AttributeValue value) {
// Create expression attribute names for each part of the path
Map expressionAttributeNames = new HashMap<>();
for (int i = 0; i < path.size(); i++) {
expressionAttributeNames.put("#attr" + i, path.get(i));
}
// Build the attribute path using the expression attribute names
StringBuilder attributePathExpression = new StringBuilder();
for (int i = 0; i < path.size(); i++) {
if (i > 0) {
attributePathExpression.append(".");
}
attributePathExpression.append("#attr").append(i);
}
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET " + attributePathExpression.toString() + " = :value")
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(Map.of(":value", value))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Removes an attribute from a map.
*
* This method demonstrates how to remove a specific attribute from a map.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param mapName The name of the map attribute
* @param mapKey The key within the map to remove
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse removeMapAttribute(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String mapName,
String mapKey) {
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("REMOVE #mapName.#mapKey")
.expressionAttributeNames(Map.of(
"#mapName", mapName,
"#mapKey", mapKey))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Creates a map with multiple attributes in a single operation.
*
* This method demonstrates how to create a map with multiple attributes
* in a single update operation.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param mapName The name of the map attribute
* @param attributes The attributes to set in the map
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse createMapWithAttributes(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String mapName,
Map attributes) {
// Create a map value from the attributes
AttributeValue mapValue = AttributeValue.builder().m(attributes).build();
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #mapName = :mapValue")
.expressionAttributeNames(Map.of("#mapName", mapName))
.expressionAttributeValues(Map.of(":mapValue", mapValue))
.returnValues("UPDATED_NEW")
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Gets the current value of a map attribute.
*
* Helper method to retrieve the current value of a map attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to get
* @param mapName The name of the map attribute
* @return The map attribute value or null if not found
* @throws DynamoDbException if an error occurs during the operation
*/
public static Map getMapAttribute(
DynamoDbClient dynamoDbClient, String tableName, Map key, String mapName) {
// Define the get parameters
GetItemRequest request = GetItemRequest.builder()
.tableName(tableName)
.key(key)
.projectionExpression(mapName)
.build();
try {
// Perform the get operation
GetItemResponse response = dynamoDbClient.getItem(request);
// Return the map attribute if it exists, otherwise null
if (response.item() != null && response.item().containsKey(mapName)) {
return response.item().get(mapName).m();
}
return null;
} catch (DynamoDbException e) {
throw DynamoDbException.builder()
.message("Failed to get map attribute: " + e.getMessage())
.cause(e)
.build();
}
}
```
Ejemplo de uso de operaciones de mapas con AWS SDK for Java 2.x.
```
public static void exampleUsage(DynamoDbClient dynamoDbClient, String tableName) {
// Example key
Map key = new HashMap<>();
key.put("ProductId", AttributeValue.builder().s("P12345").build());
System.out.println("Demonstrating map operations in DynamoDB");
try {
// Example 1: Create a map with multiple attributes
System.out.println("\nExample 1: Creating a map with multiple attributes");
Map productDetails = new HashMap<>();
productDetails.put("Color", AttributeValue.builder().s("Red").build());
productDetails.put("Weight", AttributeValue.builder().n("2.5").build());
productDetails.put(
"Dimensions", AttributeValue.builder().s("10x20x5").build());
UpdateItemResponse createResponse =
createMapWithAttributes(dynamoDbClient, tableName, key, "Details", productDetails);
System.out.println("Created map attribute: " + createResponse.attributes());
// Example 2: Update a specific attribute in a map
System.out.println("\nExample 2: Updating a specific attribute in a map");
UpdateItemResponse updateResponse = updateMapAttributeSafe(
dynamoDbClient,
tableName,
key,
"Details",
"Color",
AttributeValue.builder().s("Blue").build());
System.out.println("Updated map attribute: " + updateResponse.attributes());
// Example 3: Add an attribute to a nested map
System.out.println("\nExample 3: Adding an attribute to a nested map");
UpdateItemResponse nestedResponse = addToNestedMap(
dynamoDbClient,
tableName,
key,
List.of("Specifications", "Technical", "Resolution"),
AttributeValue.builder().s("1920x1080").build());
System.out.println("Added to nested map: " + nestedResponse.attributes());
// Example 4: Remove an attribute from a map
System.out.println("\nExample 4: Removing an attribute from a map");
UpdateItemResponse removeResponse =
removeMapAttribute(dynamoDbClient, tableName, key, "Details", "Dimensions");
System.out.println("Updated map after removal: " + removeResponse.attributes());
// Example 5: Get the current value of a map attribute
System.out.println("\nExample 5: Getting the current value of a map attribute");
Map currentMap = getMapAttribute(dynamoDbClient, tableName, key, "Details");
if (currentMap != null) {
System.out.println("Current map attribute:");
for (Map.Entry entry : currentMap.entrySet()) {
System.out.println(" " + entry.getKey() + ": " + entry.getValue());
}
} else {
System.out.println("Map attribute not found");
}
// Explain map operations
System.out.println("\nKey points about DynamoDB map operations:");
System.out.println("1. Maps are unordered collections of name-value pairs");
System.out.println("2. Use dot notation (map.key) to access or update specific attributes");
System.out.println("3. You can update individual attributes without overwriting the entire map");
System.out.println("4. Maps can be nested to create complex data structures");
System.out.println("5. Use REMOVE to delete attributes from a map");
System.out.println("6. You can create a map with multiple attributes in a single operation");
System.out.println("7. Map keys are case-sensitive");
} catch (DynamoDbException e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)la *referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Demuestre las operaciones del mapa utilizando AWS SDK para JavaScript.
```
/**
* Example of updating map attributes in DynamoDB.
*
* This module demonstrates how to update map attributes that may not exist,
* how to update nested attributes, and how to handle various map update scenarios.
*/
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const {
DynamoDBDocumentClient,
UpdateCommand,
GetCommand
} = require("@aws-sdk/lib-dynamodb");
/**
* Update a map attribute safely, handling the case where the map might not exist.
*
* This function demonstrates using the if_not_exists function to safely update
* a map attribute that might not exist yet.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} mapName - The name of the map attribute
* @param {string} mapKey - The key within the map to update
* @param {any} value - The value to set
* @returns {Promise} - The response from DynamoDB
*/
async function updateMapAttributeSafe(
config,
tableName,
key,
mapName,
mapKey,
value
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using SET with if_not_exists
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${mapName}.${mapKey} = :value`,
ExpressionAttributeValues: {
":value": value
},
ReturnValues: "UPDATED_NEW"
};
try {
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
} catch (error) {
// If the error is because the map doesn't exist, create it
if (error.name === "ValidationException" &&
error.message.includes("The document path provided in the update expression is invalid")) {
// Create the map with the specified key-value pair
const createParams = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${mapName} = :map`,
ExpressionAttributeValues: {
":map": { [mapKey]: value }
},
ReturnValues: "UPDATED_NEW"
};
return await docClient.send(new UpdateCommand(createParams));
}
// Re-throw other errors
throw error;
}
}
/**
* Update a map attribute using the if_not_exists function.
*
* This function demonstrates a more elegant approach using if_not_exists
* to handle the case where the map doesn't exist yet.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} mapName - The name of the map attribute
* @param {string} mapKey - The key within the map to update
* @param {any} value - The value to set
* @returns {Promise} - The response from DynamoDB
*/
async function updateMapAttributeWithIfNotExists(
config,
tableName,
key,
mapName,
mapKey,
value
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the update parameters using SET with if_not_exists
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${mapName} = if_not_exists(${mapName}, :emptyMap), ${mapName}.${mapKey} = :value`,
ExpressionAttributeValues: {
":emptyMap": {},
":value": value
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Add a value to a deeply nested map, creating parent maps if they don't exist.
*
* This function demonstrates how to update a deeply nested attribute,
* creating any parent maps that don't exist along the way.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string[]} path - The path to the nested attribute as an array of keys
* @param {any} value - The value to set
* @returns {Promise} - The response from DynamoDB
*/
async function addToNestedMap(
config,
tableName,
key,
path,
value
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Build the update expression and expression attribute values
let updateExpression = "SET";
const expressionAttributeValues = {};
// For each level in the path, create a map if it doesn't exist
for (let i = 0; i < path.length; i++) {
const currentPath = path.slice(0, i + 1).join(".");
const parentPath = i > 0 ? path.slice(0, i).join(".") : null;
if (parentPath) {
updateExpression += ` ${parentPath} = if_not_exists(${parentPath}, :emptyMap${i}),`;
expressionAttributeValues[`:emptyMap${i}`] = {};
}
}
// Set the final value
const fullPath = path.join(".");
updateExpression += ` ${fullPath} = :value`;
expressionAttributeValues[":value"] = value;
// Define the update parameters
const params = {
TableName: tableName,
Key: key,
UpdateExpression: updateExpression,
ExpressionAttributeValues: expressionAttributeValues,
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Update multiple fields in a map attribute in a single operation.
*
* This function demonstrates how to update multiple fields in a map
* in a single DynamoDB operation.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} mapName - The name of the map attribute
* @param {Object} updates - Object containing key-value pairs to update
* @returns {Promise} - The response from DynamoDB
*/
async function updateMultipleMapFields(
config,
tableName,
key,
mapName,
updates
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Build the update expression and expression attribute values
let updateExpression = `SET ${mapName} = if_not_exists(${mapName}, :emptyMap)`;
const expressionAttributeValues = {
":emptyMap": {}
};
// Add each update to the expression
Object.entries(updates).forEach(([field, value], index) => {
updateExpression += `, ${mapName}.${field} = :val${index}`;
expressionAttributeValues[`:val${index}`] = value;
});
// Define the update parameters
const params = {
TableName: tableName,
Key: key,
UpdateExpression: updateExpression,
ExpressionAttributeValues: expressionAttributeValues,
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Get the current value of an item.
*
* Helper function to retrieve the current value of an item.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to get
* @returns {Promise} - The item or null if not found
*/
async function getItem(
config,
tableName,
key
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the get parameters
const params = {
TableName: tableName,
Key: key
};
// Perform the get operation
const response = await docClient.send(new GetCommand(params));
// Return the item if it exists, otherwise null
return response.Item || null;
}
/**
* Example of how to use the map attribute update functions.
*/
async function exampleUsage() {
// Example parameters
const config = { region: "us-west-2" };
const tableName = "Users";
const key = { UserId: "U12345" };
console.log("Demonstrating different approaches to update map attributes in DynamoDB");
try {
// Example 1: Update a map attribute that might not exist (two-step approach)
console.log("\nExample 1: Updating a map attribute that might not exist (two-step approach)");
const response1 = await updateMapAttributeSafe(
config,
tableName,
key,
"Preferences",
"Theme",
"Dark"
);
console.log("Updated preferences:", response1.Attributes);
// Example 2: Update a map attribute using if_not_exists (elegant approach)
console.log("\nExample 2: Updating a map attribute using if_not_exists (elegant approach)");
const response2 = await updateMapAttributeWithIfNotExists(
config,
tableName,
key,
"Settings",
"NotificationsEnabled",
true
);
console.log("Updated settings:", response2.Attributes);
// Example 3: Update a deeply nested attribute
console.log("\nExample 3: Updating a deeply nested attribute");
const response3 = await addToNestedMap(
config,
tableName,
key,
["Profile", "Address", "City"],
"Seattle"
);
console.log("Updated nested attribute:", response3.Attributes);
// Example 4: Update multiple fields in a map
console.log("\nExample 4: Updating multiple fields in a map");
const response4 = await updateMultipleMapFields(
config,
tableName,
key,
"ContactInfo",
{
Email: "user@example.com",
Phone: "555-123-4567",
PreferredContact: "Email"
}
);
console.log("Updated multiple fields:", response4.Attributes);
// Get the final state of the item
console.log("\nFinal state of the item:");
const item = await getItem(config, tableName, key);
console.log(JSON.stringify(item, null, 2));
// Explain the benefits of different approaches
console.log("\nKey points about updating map attributes:");
console.log("1. Use if_not_exists to handle maps that might not exist");
console.log("2. Multiple updates can be combined in a single operation");
console.log("3. Deeply nested attributes require creating parent maps");
console.log("4. DynamoDB expressions are atomic - the entire update succeeds or fails");
console.log("5. Using a single operation is more efficient than multiple separate updates");
} catch (error) {
console.error("Error:", error);
}
}
// Export the functions
module.exports = {
updateMapAttributeSafe,
updateMapAttributeWithIfNotExists,
addToNestedMap,
updateMultipleMapFields,
getItem,
exampleUsage
};
// Run the example if this file is executed directly
if (require.main === module) {
exampleUsage();
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)la *Referencia AWS SDK para JavaScript de la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Demuestre las operaciones del mapa utilizando AWS SDK para Python (Boto3).
```
"""
Example of updating map attributes in DynamoDB.
This module demonstrates how to update map attributes in DynamoDB, including
handling cases where the map attribute might not exist yet.
"""
import boto3
from typing import Any, Dict, Optional
def update_map_attribute_safe(
table_name: str, key: Dict[str, Any], map_name: str, map_key: str, value: Any
) -> Dict[str, Any]:
"""
Update a specific key in a map attribute, creating the map if it doesn't exist.
This function demonstrates how to safely update a key within a map attribute,
even if the map doesn't exist yet in the item.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
map_name (str): The name of the map attribute.
map_key (str): The key within the map to update.
value (Any): The value to set for the map key.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Use SET with attribute_not_exists to safely update the map
response = table.update_item(
Key=key,
UpdateExpression="SET #map.#key = :value",
ExpressionAttributeNames={"#map": map_name, "#key": map_key},
ExpressionAttributeValues={":value": value},
ReturnValues="UPDATED_NEW",
)
return response
def add_to_nested_map(
table_name: str, key: Dict[str, Any], path: str, value: Any
) -> Dict[str, Any]:
"""
Add or update a value in a deeply nested map structure.
This function demonstrates how to update a value at a specific path in a
nested map structure, creating any intermediate maps as needed.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
path (str): The path to the nested attribute (e.g., "user.preferences.theme").
value (Any): The value to set at the specified path.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Split the path into components
path_parts = path.split(".")
# Build the update expression and attribute names
update_expression = "SET "
expression_attribute_names = {}
# Build the path expression
path_expression = ""
for i, part in enumerate(path_parts):
name_placeholder = f"#attr{i}"
expression_attribute_names[name_placeholder] = part
if i == 0:
path_expression = name_placeholder
else:
path_expression += f".{name_placeholder}"
# Complete the update expression
update_expression += f"{path_expression} = :value"
# Execute the update
response = table.update_item(
Key=key,
UpdateExpression=update_expression,
ExpressionAttributeNames=expression_attribute_names,
ExpressionAttributeValues={":value": value},
ReturnValues="UPDATED_NEW",
)
return response
def update_map_with_if_not_exists(
table_name: str,
key: Dict[str, Any],
map_name: str,
map_key: str,
value: Any,
default_map: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""
Update a key in a map, creating the map with default values if it doesn't exist.
This function demonstrates how to use if_not_exists to initialize a map with
default values if it doesn't exist yet, and then update a specific key.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
map_name (str): The name of the map attribute.
map_key (str): The key within the map to update.
value (Any): The value to set for the map key.
default_map (Optional[Dict[str, Any]]): Default map values if the map doesn't exist.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Set default map if not provided
if default_map is None:
default_map = {}
# Create a map with the new key-value pair
updated_map = default_map.copy()
updated_map[map_key] = value
# Use if_not_exists to initialize the map if it doesn't exist
response = table.update_item(
Key=key,
UpdateExpression="SET #map = if_not_exists(#map, :default_map)",
ExpressionAttributeNames={"#map": map_name},
ExpressionAttributeValues={":default_map": updated_map},
ReturnValues="UPDATED_NEW",
)
return response
def merge_into_map(
table_name: str, key: Dict[str, Any], map_name: str, values_to_merge: Dict[str, Any]
) -> Dict[str, Any]:
"""
Merge multiple key-value pairs into a map attribute.
This function demonstrates how to update multiple keys in a map attribute
in a single operation, without overwriting the entire map.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
map_name (str): The name of the map attribute.
values_to_merge (Dict[str, Any]): Key-value pairs to merge into the map.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Build the update expression for each key-value pair
update_expression = "SET "
expression_attribute_names = {"#map": map_name}
expression_attribute_values = {}
# Add each key-value pair to the update expression
for i, (k, v) in enumerate(values_to_merge.items()):
key_placeholder = f"#key{i}"
value_placeholder = f":value{i}"
expression_attribute_names[key_placeholder] = k
expression_attribute_values[value_placeholder] = v
if i > 0:
update_expression += ", "
update_expression += f"#map.{key_placeholder} = {value_placeholder}"
# Execute the update
response = table.update_item(
Key=key,
UpdateExpression=update_expression,
ExpressionAttributeNames=expression_attribute_names,
ExpressionAttributeValues=expression_attribute_values,
ReturnValues="UPDATED_NEW",
)
return response
def example_usage():
"""Example of how to use the map attribute update functions."""
# Example parameters
table_name = "UserProfiles"
key = {"UserId": "user123"}
print("Example 1: Updating a specific key in a map attribute")
try:
response = update_map_attribute_safe(
table_name=table_name, key=key, map_name="Preferences", map_key="Theme", value="Dark"
)
print(f"Map attribute updated successfully: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error updating map attribute: {e}")
print("\nExample 2: Adding a value to a deeply nested map")
try:
response = add_to_nested_map(
table_name=table_name, key=key, path="Settings.Notifications.Email", value=True
)
print(f"Nested map updated successfully: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error updating nested map: {e}")
print("\nExample 3: Initializing a map with default values if it doesn't exist")
try:
default_map = {"Language": "English", "Currency": "USD", "TimeZone": "UTC"}
response = update_map_with_if_not_exists(
table_name=table_name,
key={"UserId": "newuser456"},
map_name="Preferences",
map_key="Theme",
value="Light",
default_map=default_map,
)
print(f"Map initialized with defaults: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error initializing map: {e}")
print("\nExample 4: Merging multiple values into a map")
try:
values_to_merge = {
"NotificationsEnabled": True,
"EmailFrequency": "Daily",
"PushNotifications": False,
}
response = merge_into_map(
table_name=table_name,
key=key,
map_name="NotificationSettings",
values_to_merge=values_to_merge,
)
print(f"Multiple values merged into map: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error merging values into map: {e}")
print("\nBest practices for working with map attributes in DynamoDB:")
print("1. Use dot notation to access and update nested attributes")
print("2. Use ExpressionAttributeNames to handle reserved words and special characters")
print("3. Use if_not_exists() to handle cases where attributes might not exist")
print("4. Update specific map keys rather than overwriting the entire map")
print("5. Use a single update operation to modify multiple map keys for better performance")
print("6. Consider your data model carefully to minimize the need for deeply nested attributes")
if __name__ == "__main__":
example_usage()
```
+ Para obtener más información sobre la API, consulta [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)la *AWS Referencia de API de SDK for Python (Boto3*).
------
# Realice operaciones de conjunto en DynamoDB con un SDK AWS
This method demonstrates how to use the ADD operation to add values
* to a string set attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param setAttributeName The name of the set attribute
* @param valuesToAdd The values to add to the set
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse addToStringSet(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String setAttributeName,
Set valuesToAdd) {
// Create a string set value from the values to add
AttributeValue setValue = AttributeValue.builder().ss(valuesToAdd).build();
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("ADD #setAttr :valuesToAdd")
.expressionAttributeNames(Map.of("#setAttr", setAttributeName))
.expressionAttributeValues(Map.of(":valuesToAdd", setValue))
.returnValues(ReturnValue.UPDATED_NEW)
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Adds values to a number set attribute.
*
* This method demonstrates how to use the ADD operation to add values
* to a number set attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param setAttributeName The name of the set attribute
* @param valuesToAdd The values to add to the set
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse addToNumberSet(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String setAttributeName,
Set valuesToAdd) {
// Convert numbers to strings for DynamoDB
Set stringValues = new HashSet<>();
for (Number value : valuesToAdd) {
stringValues.add(value.toString());
}
// Create a number set value from the values to add
AttributeValue setValue = AttributeValue.builder().ns(stringValues).build();
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("ADD #setAttr :valuesToAdd")
.expressionAttributeNames(Map.of("#setAttr", setAttributeName))
.expressionAttributeValues(Map.of(":valuesToAdd", setValue))
.returnValues(ReturnValue.UPDATED_NEW)
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Removes values from a set attribute.
*
* This method demonstrates how to use the DELETE operation to remove values
* from a set attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param setAttributeName The name of the set attribute
* @param valuesToRemove The values to remove from the set
* @param isNumberSet Whether the set is a number set (true) or string set (false)
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse removeFromSet(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String setAttributeName,
Set valuesToRemove,
boolean isNumberSet) {
AttributeValue setValue;
if (isNumberSet) {
// Convert numbers to strings for DynamoDB
Set stringValues = new HashSet<>();
for (Object value : valuesToRemove) {
if (value instanceof Number) {
stringValues.add(value.toString());
} else {
throw new IllegalArgumentException("Values must be numbers for a number set");
}
}
setValue = AttributeValue.builder().ns(stringValues).build();
} else {
// Convert objects to strings for DynamoDB
Set stringValues = new HashSet<>();
for (Object value : valuesToRemove) {
stringValues.add(value.toString());
}
setValue = AttributeValue.builder().ss(stringValues).build();
}
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("DELETE #setAttr :valuesToRemove")
.expressionAttributeNames(Map.of("#setAttr", setAttributeName))
.expressionAttributeValues(Map.of(":valuesToRemove", setValue))
.returnValues(ReturnValue.UPDATED_NEW)
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Checks if a value exists in a set attribute.
*
* This method demonstrates how to use the contains function to check
* if a value exists in a set attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to check
* @param setAttributeName The name of the set attribute
* @param valueToCheck The value to check for
* @return Map containing the result of the check
* @throws DynamoDbException if an error occurs during the operation
*/
public static Map checkIfValueInSet(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String setAttributeName,
String valueToCheck) {
Map result = new HashMap<>();
try {
// Define the update parameters with a condition expression
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #tempAttr = :tempVal")
.conditionExpression("contains(#setAttr, :valueToCheck)")
.expressionAttributeNames(Map.of("#setAttr", setAttributeName, "#tempAttr", "TempAttribute"))
.expressionAttributeValues(Map.of(
":valueToCheck", AttributeValue.builder().s(valueToCheck).build(),
":tempVal", AttributeValue.builder().s("TempValue").build()))
.returnValues(ReturnValue.UPDATED_NEW)
.build();
// Attempt the update operation
dynamoDbClient.updateItem(request);
// If we get here, the condition was met
result.put("exists", true);
result.put("message", "Value '" + valueToCheck + "' exists in the set");
// Clean up the temporary attribute
UpdateItemRequest cleanupRequest = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("REMOVE #tempAttr")
.expressionAttributeNames(Map.of("#tempAttr", "TempAttribute"))
.build();
dynamoDbClient.updateItem(cleanupRequest);
} catch (DynamoDbException e) {
if (e.getMessage().contains("ConditionalCheckFailed")) {
// The condition was not met
result.put("exists", false);
result.put("message", "Value '" + valueToCheck + "' does not exist in the set");
} else {
// Some other error occurred
result.put("exists", false);
result.put("message", "Error checking set: " + e.getMessage());
result.put("error", e.getClass().getSimpleName());
}
}
return result;
}
/**
* Creates a set with multiple values in a single operation.
*
* This method demonstrates how to create a set with multiple values
* in a single update operation.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to update
* @param setAttributeName The name of the set attribute
* @param setValues The values to include in the set
* @param isNumberSet Whether to create a number set (true) or string set (false)
* @return The response from DynamoDB
* @throws DynamoDbException if an error occurs during the operation
*/
public static UpdateItemResponse createSetWithValues(
DynamoDbClient dynamoDbClient,
String tableName,
Map key,
String setAttributeName,
Set setValues,
boolean isNumberSet) {
AttributeValue setValue;
if (isNumberSet) {
// Convert numbers to strings for DynamoDB
Set stringValues = new HashSet<>();
for (Object value : setValues) {
if (value instanceof Number) {
stringValues.add(value.toString());
} else {
throw new IllegalArgumentException("Values must be numbers for a number set");
}
}
setValue = AttributeValue.builder().ns(stringValues).build();
} else {
// Convert objects to strings for DynamoDB
Set stringValues = new HashSet<>();
for (Object value : setValues) {
stringValues.add(value.toString());
}
setValue = AttributeValue.builder().ss(stringValues).build();
}
// Define the update parameters
UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(key)
.updateExpression("SET #setAttr = :setValue")
.expressionAttributeNames(Map.of("#setAttr", setAttributeName))
.expressionAttributeValues(Map.of(":setValue", setValue))
.returnValues(ReturnValue.UPDATED_NEW)
.build();
// Perform the update operation
return dynamoDbClient.updateItem(request);
}
/**
* Gets the current value of a set attribute.
*
* Helper method to retrieve the current value of a set attribute.
*
* @param dynamoDbClient The DynamoDB client
* @param tableName The name of the DynamoDB table
* @param key The key of the item to get
* @param setAttributeName The name of the set attribute
* @return The set attribute value or null if not found
* @throws DynamoDbException if an error occurs during the operation
*/
public static AttributeValue getSetAttribute(
DynamoDbClient dynamoDbClient, String tableName, Map key, String setAttributeName) {
// Define the get parameters
GetItemRequest request = GetItemRequest.builder()
.tableName(tableName)
.key(key)
.projectionExpression(setAttributeName)
.build();
try {
// Perform the get operation
GetItemResponse response = dynamoDbClient.getItem(request);
// Return the set attribute if it exists, otherwise null
if (response.item() != null && response.item().containsKey(setAttributeName)) {
return response.item().get(setAttributeName);
}
return null;
} catch (DynamoDbException e) {
throw DynamoDbException.builder()
.message("Failed to get set attribute: " + e.getMessage())
.cause(e)
.build();
}
}
```
Ejemplo de uso de operaciones de conjunto con AWS SDK for Java 2.x.
```
public static void exampleUsage(DynamoDbClient dynamoDbClient, String tableName) {
// Example key
Map key = new HashMap<>();
key.put("ProductId", AttributeValue.builder().s("P12345").build());
System.out.println("Demonstrating set operations in DynamoDB");
try {
// Example 1: Create a string set with multiple values
System.out.println("\nExample 1: Creating a string set with multiple values");
Set tags = new HashSet<>();
tags.add("Electronics");
tags.add("Gadget");
tags.add("Smartphone");
UpdateItemResponse createResponse = createSetWithValues(
dynamoDbClient, tableName, key, "Tags", tags, false // Not a number set
);
System.out.println("Created set attribute: " + createResponse.attributes());
// Example 2: Add values to a string set
System.out.println("\nExample 2: Adding values to a string set");
Set additionalTags = new HashSet<>();
additionalTags.add("Mobile");
additionalTags.add("Wireless");
UpdateItemResponse addResponse = addToStringSet(dynamoDbClient, tableName, key, "Tags", additionalTags);
System.out.println("Updated set attribute: " + addResponse.attributes());
// Example 3: Create a number set with multiple values
System.out.println("\nExample 3: Creating a number set with multiple values");
Set ratings = new HashSet<>();
ratings.add(4);
ratings.add(5);
ratings.add(4.5);
UpdateItemResponse createNumberSetResponse = createSetWithValues(
dynamoDbClient, tableName, key, "Ratings", ratings, true // Is a number set
);
System.out.println("Created number set attribute: " + createNumberSetResponse.attributes());
// Example 4: Add values to a number set
System.out.println("\nExample 4: Adding values to a number set");
Set additionalRatings = new HashSet<>();
additionalRatings.add(3.5);
additionalRatings.add(4.2);
UpdateItemResponse addNumberResponse =
addToNumberSet(dynamoDbClient, tableName, key, "Ratings", additionalRatings);
System.out.println("Updated number set attribute: " + addNumberResponse.attributes());
// Example 5: Remove values from a set
System.out.println("\nExample 5: Removing values from a set");
Set tagsToRemove = new HashSet<>();
tagsToRemove.add("Gadget");
UpdateItemResponse removeResponse = removeFromSet(
dynamoDbClient, tableName, key, "Tags", tagsToRemove, false // Not a number set
);
System.out.println("Updated set after removal: " + removeResponse.attributes());
// Example 6: Check if a value exists in a set
System.out.println("\nExample 6: Checking if a value exists in a set");
Map checkResult = checkIfValueInSet(dynamoDbClient, tableName, key, "Tags", "Electronics");
System.out.println("Check result: " + checkResult.get("message"));
// Example 7: Get the current value of a set attribute
System.out.println("\nExample 7: Getting the current value of a set attribute");
AttributeValue currentStringSet = getSetAttribute(dynamoDbClient, tableName, key, "Tags");
if (currentStringSet != null && currentStringSet.ss() != null) {
System.out.println("Current string set values: " + currentStringSet.ss());
} else {
System.out.println("String set attribute not found");
}
AttributeValue currentNumberSet = getSetAttribute(dynamoDbClient, tableName, key, "Ratings");
if (currentNumberSet != null && currentNumberSet.ns() != null) {
System.out.println("Current number set values: " + currentNumberSet.ns());
} else {
System.out.println("Number set attribute not found");
}
// Explain set operations
System.out.println("\nKey points about DynamoDB set operations:");
System.out.println(
"1. DynamoDB supports three set types: string sets (SS), number sets (NS), and binary sets (BS)");
System.out.println("2. Sets can only contain elements of the same type");
System.out.println("3. Use ADD to add elements to a set");
System.out.println("4. Use DELETE to remove elements from a set");
System.out.println("5. Sets automatically remove duplicate values");
System.out.println("6. Sets are unordered collections");
System.out.println("7. Use the contains function to check if a value exists in a set");
System.out.println("8. You can create a set with multiple values in a single operation");
} catch (DynamoDbException e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)la *referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Demuestre las operaciones de conjunto utilizando AWS SDK para JavaScript.
```
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb");
const {
DynamoDBDocumentClient,
UpdateCommand,
GetCommand
} = require("@aws-sdk/lib-dynamodb");
/**
* Add elements to a set attribute.
*
* This function demonstrates using the ADD operation to add elements to a set.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} setName - The name of the set attribute
* @param {Array} values - The values to add to the set
* @param {string} setType - The type of set ('string', 'number', or 'binary')
* @returns {Promise} - The response from DynamoDB
*/
async function addToSet(
config,
tableName,
key,
setName,
values,
setType = 'string'
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Create the appropriate set type
let setValues;
if (setType === 'string') {
setValues = new Set(values.map(String));
} else if (setType === 'number') {
setValues = new Set(values.map(Number));
} else if (setType === 'binary') {
setValues = new Set(values);
} else {
throw new Error(`Unsupported set type: ${setType}`);
}
// Define the update parameters using ADD
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `ADD ${setName} :values`,
ExpressionAttributeValues: {
":values": setValues
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Remove elements from a set attribute.
*
* This function demonstrates using the DELETE operation to remove elements from a set.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} setName - The name of the set attribute
* @param {Array} values - The values to remove from the set
* @param {string} setType - The type of set ('string', 'number', or 'binary')
* @returns {Promise} - The response from DynamoDB
*/
async function removeFromSet(
config,
tableName,
key,
setName,
values,
setType = 'string'
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Create the appropriate set type
let setValues;
if (setType === 'string') {
setValues = new Set(values.map(String));
} else if (setType === 'number') {
setValues = new Set(values.map(Number));
} else if (setType === 'binary') {
setValues = new Set(values);
} else {
throw new Error(`Unsupported set type: ${setType}`);
}
// Define the update parameters using DELETE
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `DELETE ${setName} :values`,
ExpressionAttributeValues: {
":values": setValues
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Create a new set attribute with initial values.
*
* This function demonstrates using the SET operation to create a new set attribute.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} setName - The name of the set attribute
* @param {Array} values - The initial values for the set
* @param {string} setType - The type of set ('string', 'number', or 'binary')
* @returns {Promise} - The response from DynamoDB
*/
async function createSet(
config,
tableName,
key,
setName,
values,
setType = 'string'
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Create the appropriate set type
let setValues;
if (setType === 'string') {
setValues = new Set(values.map(String));
} else if (setType === 'number') {
setValues = new Set(values.map(Number));
} else if (setType === 'binary') {
setValues = new Set(values);
} else {
throw new Error(`Unsupported set type: ${setType}`);
}
// Define the update parameters using SET
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `SET ${setName} = :values`,
ExpressionAttributeValues: {
":values": setValues
},
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
const response = await docClient.send(new UpdateCommand(params));
return response;
}
/**
* Replace an entire set attribute with a new set of values.
*
* This function demonstrates using the SET operation to replace an entire set.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} setName - The name of the set attribute
* @param {Array} values - The new values for the set
* @param {string} setType - The type of set ('string', 'number', or 'binary')
* @returns {Promise} - The response from DynamoDB
*/
async function replaceSet(
config,
tableName,
key,
setName,
values,
setType = 'string'
) {
// This is the same as createSet, but included for clarity of intent
return await createSet(config, tableName, key, setName, values, setType);
}
/**
* Remove the last element from a set and handle the empty set case.
*
* This function demonstrates what happens when you delete the last element of a set.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to update
* @param {string} setName - The name of the set attribute
* @returns {Promise} - The result of the operation
*/
async function removeLastElementFromSet(
config,
tableName,
key,
setName
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// First, get the current item to check the set
const currentItem = await getItem(config, tableName, key);
// Check if the set exists and has elements
if (!currentItem || !currentItem[setName] || currentItem[setName].size === 0) {
return {
success: false,
message: "Set doesn't exist or is already empty",
item: currentItem
};
}
// Get the set values
const setValues = Array.from(currentItem[setName]);
// If there's only one element left, remove the attribute entirely
if (setValues.length === 1) {
// Define the update parameters to remove the attribute
const params = {
TableName: tableName,
Key: key,
UpdateExpression: `REMOVE ${setName}`,
ReturnValues: "UPDATED_NEW"
};
// Perform the update operation
await docClient.send(new UpdateCommand(params));
return {
success: true,
message: "Last element removed, attribute has been deleted",
removedValue: setValues[0]
};
} else {
// Otherwise, remove just the last element
// Create a set with just the last element
const lastElement = setValues[setValues.length - 1];
const setType = typeof lastElement === 'number' ? 'number' : 'string';
// Remove the last element
const response = await removeFromSet(
config,
tableName,
key,
setName,
[lastElement],
setType
);
return {
success: true,
message: "Last element removed, set still contains elements",
removedValue: lastElement,
remainingSet: response.Attributes[setName]
};
}
}
/**
* Get the current value of an item.
*
* Helper function to retrieve the current value of an item.
*
* @param {Object} config - AWS configuration object
* @param {string} tableName - The name of the DynamoDB table
* @param {Object} key - The key of the item to get
* @returns {Promise} - The item or null if not found
*/
async function getItem(
config,
tableName,
key
) {
// Initialize the DynamoDB client
const client = new DynamoDBClient(config);
const docClient = DynamoDBDocumentClient.from(client);
// Define the get parameters
const params = {
TableName: tableName,
Key: key
};
// Perform the get operation
const response = await docClient.send(new GetCommand(params));
// Return the item if it exists, otherwise null
return response.Item || null;
}
```
Ejemplo de uso de operaciones de conjunto con AWS SDK para JavaScript.
```
/**
* Example of how to work with sets in DynamoDB.
*/
async function exampleUsage() {
// Example parameters
const config = { region: "us-west-2" };
const tableName = "Users";
const key = { UserId: "U12345" };
console.log("Demonstrating set operations in DynamoDB");
try {
// Example 1: Create a string set
console.log("\nExample 1: Creating a string set");
const response1 = await createSet(
config,
tableName,
key,
"Interests",
["Reading", "Hiking", "Cooking"],
"string"
);
console.log("Created set:", response1.Attributes);
// Example 2: Add elements to a set
console.log("\nExample 2: Adding elements to a set");
const response2 = await addToSet(
config,
tableName,
key,
"Interests",
["Photography", "Travel"],
"string"
);
console.log("Updated set after adding elements:", response2.Attributes);
// Example 3: Remove elements from a set
console.log("\nExample 3: Removing elements from a set");
const response3 = await removeFromSet(
config,
tableName,
key,
"Interests",
["Cooking"],
"string"
);
console.log("Updated set after removing elements:", response3.Attributes);
// Example 4: Create a number set
console.log("\nExample 4: Creating a number set");
const response4 = await createSet(
config,
tableName,
key,
"FavoriteNumbers",
[7, 42, 99],
"number"
);
console.log("Created number set:", response4.Attributes);
// Example 5: Replace an entire set
console.log("\nExample 5: Replacing an entire set");
const response5 = await replaceSet(
config,
tableName,
key,
"Interests",
["Gaming", "Movies", "Music"],
"string"
);
console.log("Replaced set:", response5.Attributes);
// Example 6: Remove the last element from a set
console.log("\nExample 6: Removing the last element from a set");
// First, create a set with just one element
await createSet(
config,
tableName,
{ UserId: "U67890" },
"Tags",
["LastTag"],
"string"
);
// Then, remove the last element
const response6 = await removeLastElementFromSet(
config,
tableName,
{ UserId: "U67890" },
"Tags"
);
console.log(response6.message);
console.log("Removed value:", response6.removedValue);
// Get the final state of the items
console.log("\nFinal state of the items:");
const item1 = await getItem(config, tableName, key);
console.log("User U12345:", JSON.stringify(item1, null, 2));
const item2 = await getItem(config, tableName, { UserId: "U67890" });
console.log("User U67890:", JSON.stringify(item2, null, 2));
// Explain set operations
console.log("\nKey points about set operations in DynamoDB:");
console.log("1. Use ADD to add elements to a set (duplicates are automatically removed)");
console.log("2. Use DELETE to remove elements from a set");
console.log("3. Use SET to create a new set or replace an existing one");
console.log("4. DynamoDB supports three types of sets: string sets, number sets, and binary sets");
console.log("5. When you delete the last element from a set, the attribute remains as an empty set");
console.log("6. To remove an empty set, use the REMOVE operation");
console.log("7. Sets automatically maintain unique values (no duplicates)");
console.log("8. You cannot mix data types within a set");
} catch (error) {
console.error("Error:", error);
}
}
```
+ Para obtener más información sobre la API, consulte [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)la *referencia AWS SDK para JavaScript de la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Demuestre las operaciones de conjunto utilizando AWS SDK para Python (Boto3).
```
import boto3
from typing import Any, Dict, List
def create_set_attribute(
table_name: str,
key: Dict[str, Any],
set_name: str,
set_values: List[Any],
set_type: str = "string",
) -> Dict[str, Any]:
"""
Create a new set attribute or add elements to an existing set.
This function demonstrates how to use the ADD operation to create a new set
or add elements to an existing set.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
set_name (str): The name of the set attribute.
set_values (List[Any]): The values to add to the set.
set_type (str, optional): The type of set to create: "string", "number", or "binary".
Defaults to "string".
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Convert the list to a DynamoDB set based on the specified type
if set_type == "string":
dynamo_set = set(str(value) for value in set_values)
elif set_type == "number":
# We need to use actual float values for the DynamoDB API
# but mypy expects strings in sets, so we need to use type: ignore
dynamo_set = set(float(value) for value in set_values) # type: ignore
else: # binary set is not directly supported in high-level API, handled differently
raise ValueError("Binary sets are not supported in this example")
# Use the ADD operation to create or update the set
response = table.update_item(
Key=key,
UpdateExpression="ADD #set_attr :set_values",
ExpressionAttributeNames={"#set_attr": set_name},
ExpressionAttributeValues={":set_values": dynamo_set},
ReturnValues="UPDATED_NEW",
)
return response
def add_to_set(
table_name: str, key: Dict[str, Any], set_name: str, values_to_add: List[Any]
) -> Dict[str, Any]:
"""
Add elements to an existing set attribute.
This function demonstrates how to use the ADD operation to add elements to an existing set.
If the set doesn't exist, it will be created.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
set_name (str): The name of the set attribute.
values_to_add (List[Any]): The values to add to the set.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Convert the list to a set (assuming string set for simplicity)
dynamo_set = set(str(value) for value in values_to_add)
# Use the ADD operation to add values to the set
response = table.update_item(
Key=key,
UpdateExpression="ADD #set_attr :values_to_add",
ExpressionAttributeNames={"#set_attr": set_name},
ExpressionAttributeValues={":values_to_add": dynamo_set},
ReturnValues="UPDATED_NEW",
)
return response
def remove_from_set(
table_name: str, key: Dict[str, Any], set_name: str, values_to_remove: List[Any]
) -> Dict[str, Any]:
"""
Remove elements from a set attribute.
This function demonstrates how to use the DELETE operation to remove elements from a set.
If the last element is removed, the attribute will be deleted entirely.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
set_name (str): The name of the set attribute.
values_to_remove (List[Any]): The values to remove from the set.
Returns:
Dict[str, Any]: The response from DynamoDB containing the updated attribute values.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Convert the list to a set (assuming string set for simplicity)
dynamo_set = set(str(value) for value in values_to_remove)
# Use the DELETE operation to remove values from the set
response = table.update_item(
Key=key,
UpdateExpression="DELETE #set_attr :values_to_remove",
ExpressionAttributeNames={"#set_attr": set_name},
ExpressionAttributeValues={":values_to_remove": dynamo_set},
ReturnValues="UPDATED_NEW",
)
return response
def check_if_set_exists(table_name: str, key: Dict[str, Any], set_name: str) -> bool:
"""
Check if a set attribute exists in an item.
This function demonstrates how to check if a set attribute exists after
potentially removing all elements from it.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to check.
set_name (str): The name of the set attribute.
Returns:
bool: True if the set attribute exists, False otherwise.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Get the item
response = table.get_item(
Key=key, ProjectionExpression="#set_attr", ExpressionAttributeNames={"#set_attr": set_name}
)
# Check if the item exists and has the set attribute
return "Item" in response and set_name in response["Item"]
def demonstrate_last_element_removal(
table_name: str, key: Dict[str, Any], set_name: str
) -> Dict[str, Any]:
"""
Demonstrate what happens when you remove the last element from a set.
This function creates a set with a single element, then removes that element,
showing that the attribute is completely removed when the last element is deleted.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
set_name (str): The name of the set attribute.
Returns:
Dict[str, Any]: A dictionary containing the results of the demonstration.
"""
# Step 1: Create a set with a single element
create_response = create_set_attribute(
table_name=table_name,
key=key,
set_name=set_name,
set_values=["last_element"],
set_type="string",
)
# Step 2: Check that the set exists
exists_before = check_if_set_exists(table_name, key, set_name)
# Step 3: Remove the last element
delete_response = remove_from_set(
table_name=table_name, key=key, set_name=set_name, values_to_remove=["last_element"]
)
# Step 4: Check if the set still exists
exists_after = check_if_set_exists(table_name, key, set_name)
# Return the results
return {
"create_response": create_response,
"exists_before": exists_before,
"delete_response": delete_response,
"exists_after": exists_after,
}
def work_with_number_set(
table_name: str,
key: Dict[str, Any],
set_name: str,
initial_values: List[float],
values_to_add: List[float],
values_to_remove: List[float],
) -> Dict[str, Any]:
"""
Demonstrate working with a number set in DynamoDB.
This function shows how to create and manipulate a set of numbers.
Args:
table_name (str): The name of the DynamoDB table.
key (Dict[str, Any]): The primary key of the item to update.
set_name (str): The name of the set attribute.
initial_values (List[float]): The initial values for the set.
values_to_add (List[float]): Values to add to the set.
values_to_remove (List[float]): Values to remove from the set.
Returns:
Dict[str, Any]: A dictionary containing the responses from each operation.
"""
# Step 1: Create the number set
create_response = create_set_attribute(
table_name=table_name,
key=key,
set_name=set_name,
set_values=initial_values,
set_type="number",
)
# Step 2: Add more numbers to the set
add_response = add_to_set(
table_name=table_name, key=key, set_name=set_name, values_to_add=values_to_add
)
# Step 3: Remove some numbers from the set
remove_response = remove_from_set(
table_name=table_name, key=key, set_name=set_name, values_to_remove=values_to_remove
)
# Step 4: Get the final state
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
get_response = table.get_item(
Key=key,
ProjectionExpression=f"#{set_name}",
ExpressionAttributeNames={f"#{set_name}": set_name},
)
# Return all responses
return {
"create_response": create_response,
"add_response": add_response,
"remove_response": remove_response,
"final_state": get_response.get("Item", {}),
}
```
Ejemplo de uso de operaciones de conjunto con AWS SDK para Python (Boto3).
```
def example_usage():
"""Example of how to use the set operations functions."""
# Example parameters
table_name = "UserPreferences"
key = {"UserId": "user123"}
print("Example 1: Creating a string set attribute")
try:
response = create_set_attribute(
table_name=table_name,
key=key,
set_name="FavoriteTags",
set_values=["AWS", "DynamoDB", "NoSQL"],
set_type="string",
)
print(f"Set attribute created successfully: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error creating set attribute: {e}")
print("\nExample 2: Adding elements to an existing set")
try:
response = add_to_set(
table_name=table_name,
key=key,
set_name="FavoriteTags",
values_to_add=["Database", "Serverless"],
)
print(f"Elements added to set successfully: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error adding to set: {e}")
print("\nExample 3: Removing elements from a set")
try:
response = remove_from_set(
table_name=table_name, key=key, set_name="FavoriteTags", values_to_remove=["NoSQL"]
)
print(f"Elements removed from set successfully: {response.get('Attributes', {})}")
except Exception as e:
print(f"Error removing from set: {e}")
print("\nExample 4: Demonstrating what happens when you remove the last element from a set")
try:
results = demonstrate_last_element_removal(
table_name=table_name, key={"UserId": "tempUser"}, set_name="SingleElementSet"
)
print(f"Set exists before removal: {results['exists_before']}")
print(f"Set exists after removal: {results['exists_after']}")
if not results["exists_after"]:
print("The set attribute was completely removed when the last element was deleted.")
else:
print("The set attribute still exists after removing the last element.")
except Exception as e:
print(f"Error in last element removal demonstration: {e}")
print("\nExample 5: Working with a number set")
try:
results = work_with_number_set(
table_name=table_name,
key={"UserId": "user456"},
set_name="LuckyNumbers",
initial_values=[7, 13, 42],
values_to_add=[99, 100],
values_to_remove=[13],
)
print(f"Initial number set: {results['create_response'].get('Attributes', {})}")
print(f"After adding numbers: {results['add_response'].get('Attributes', {})}")
print(f"After removing numbers: {results['remove_response'].get('Attributes', {})}")
print(f"Final state: {results['final_state']}")
except Exception as e:
print(f"Error working with number set: {e}")
print("\nKey Points About DynamoDB Sets:")
print("1. Sets can only contain elements of the same type (string, number, or binary)")
print("2. Sets automatically eliminate duplicate values")
print("3. The ADD operation creates a set if it doesn't exist")
print("4. The DELETE operation removes specified elements from a set")
print("5. When the last element is removed from a set, the entire attribute is deleted")
print("6. Empty sets are not allowed in DynamoDB")
print("7. Sets are unordered collections")
print("8. The ADD operation is atomic for sets")
```
+ Para obtener más información sobre la API, consulta [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)la *AWS Referencia de API de SDK for Python (Boto3*).
------
# Consulte una tabla de DynamoDB mediante lotes de sentencias PartiQL y un SDK AWS
/// Displays the description of the application on the console.
///
void DisplayInstructions()
{
Console.Clear();
Console.WriteLine();
Console.Write(new string(' ', 24));
Console.WriteLine("DynamoDB PartiQL Basics Example");
Console.WriteLine(SepBar);
Console.WriteLine("This demo application shows the basics of using Amazon DynamoDB with the AWS SDK for");
Console.WriteLine(".NET version 3.7 and .NET 6.");
Console.WriteLine(SepBar);
Console.WriteLine("Creates a table by using the CreateTable method.");
Console.WriteLine("Gets multiple movies by using a PartiQL SELECT statement.");
Console.WriteLine("Updates multiple movies by using the ExecuteBatch method.");
Console.WriteLine("Deletes multiple movies by using a PartiQL DELETE statement.");
Console.WriteLine("Cleans up the resources created for the demo by deleting the table.");
Console.WriteLine(SepBar);
WaitForEnter();
}
///
/// Simple method to wait for the key to be pressed.
///
void WaitForEnter()
{
Console.WriteLine("\nPress to continue.");
Console.Write(SepBar);
_ = Console.ReadLine();
}
///
/// Gets movies from the movie table by
/// using an Amazon DynamoDB PartiQL SELECT statement.
///
/// True if successful.
public static async Task GetBatch(
string tableName,
string title1,
string title2,
int year1,
int year2)
{
var getBatch = $"SELECT * FROM {tableName} WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = getBatch,
Parameters = new List
{
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = getBatch,
Parameters = new List
{
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
if (response.Responses.Count > 0)
{
response.Responses.ForEach(r =>
{
if (r.Item.Any())
{
Console.WriteLine($"{r.Item["title"]}\t{r.Item["year"]}");
}
});
return true;
}
else
{
Console.WriteLine($"Couldn't find either {title1} or {title2}.");
return false;
}
}
///
/// Inserts movies imported from a JSON file into the movie table by
/// using an Amazon DynamoDB PartiQL INSERT statement.
///
/// A Boolean value that indicates the success or failure of
/// the insert operation.
public static async Task InsertMovies(string tableName, string movieFileName)
{
// Get the list of movies from the JSON file.
var movies = ImportMovies(movieFileName);
var success = false;
if (movies is not null)
{
// Insert the movies in a batch using PartiQL. Because the
// batch can contain a maximum of 25 items, insert 25 movies
// at a time.
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var statements = new List();
try
{
for (var indexOffset = 0; indexOffset < 250; indexOffset += 25)
{
for (var i = indexOffset; i < indexOffset + 25; i++)
{
statements.Add(new BatchStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movies[i].Title },
new AttributeValue { N = movies[i].Year.ToString() },
},
});
}
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
// Wait between batches for movies to be successfully added.
System.Threading.Thread.Sleep(3000);
success = response.HttpStatusCode == System.Net.HttpStatusCode.OK;
// Clear the list of statements for the next batch.
statements.Clear();
}
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine(ex.Message);
}
}
return success;
}
///
/// Loads the contents of a JSON file into a list of movies to be
/// added to the DynamoDB table.
///
/// A generic list of movie objects.
public static List ImportMovies(string movieFileName)
{
if (!File.Exists(movieFileName))
{
return null!;
}
using var sr = new StreamReader(movieFileName);
string json = sr.ReadToEnd();
var allMovies = JsonConvert.DeserializeObject>(json);
if (allMovies is not null)
{
// Return the first 250 entries.
return allMovies.GetRange(0, 250);
}
else
{
return null!;
}
}
///
/// Updates information for multiple movies.
///
/// A Boolean value that indicates the success of the update.
public static async Task UpdateBatch(
string tableName,
string producer1,
string title1,
int year1,
string producer2,
string title2,
int year2)
{
string updateBatch = $"UPDATE {tableName} SET Producer=? WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = producer1 },
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = producer2 },
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Deletes multiple movies using a PartiQL BatchExecuteAsync
/// statement.
///
/// A Boolean value indicating the success of the operation.
public static async Task DeleteBatch(
string tableName,
string title1,
int year1,
string title2,
int year2)
{
string updateBatch = $"DELETE FROM {tableName} WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
+ Para obtener más información sobre la API, consulta [BatchExecuteStatement](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/BatchExecuteStatement)la *Referencia AWS SDK para .NET de la API*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/dynamodb#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// 1. Create a table. (CreateTable)
if (AwsDoc::DynamoDB::createMoviesDynamoDBTable(clientConfig)) {
AwsDoc::DynamoDB::partiqlBatchExecuteScenario(clientConfig);
// 7. Delete the table. (DeleteTable)
AwsDoc::DynamoDB::deleteMoviesDynamoDBTable(clientConfig);
}
//! Scenario to modify and query a DynamoDB table using PartiQL batch statements.
/*!
\sa partiqlBatchExecuteScenario()
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::partiqlBatchExecuteScenario(
const Aws::Client::ClientConfiguration &clientConfiguration) {
// 2. Add multiple movies using "Insert" statements. (BatchExecuteStatement)
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
std::vector titles;
std::vector ratings;
std::vector years;
std::vector plots;
Aws::String doAgain = "n";
do {
Aws::String aTitle = askQuestion(
"Enter the title of a movie you want to add to the table: ");
titles.push_back(aTitle);
int aYear = askQuestionForInt("What year was it released? ");
years.push_back(aYear);
float aRating = askQuestionForFloatRange(
"On a scale of 1 - 10, how do you rate it? ",
1, 10);
ratings.push_back(aRating);
Aws::String aPlot = askQuestion("Summarize the plot for me: ");
plots.push_back(aPlot);
doAgain = askQuestion(Aws::String("Would you like to add more movies? (y/n) "));
} while (doAgain == "y");
std::cout << "Adding " << titles.size()
<< (titles.size() == 1 ? " movie " : " movies ")
<< "to the table using a batch \"INSERT\" statement." << std::endl;
{
Aws::Vector statements(
titles.size());
std::stringstream sqlStream;
sqlStream << "INSERT INTO \"" << MOVIE_TABLE_NAME << "\" VALUE {'"
<< TITLE_KEY << "': ?, '" << YEAR_KEY << "': ?, '"
<< INFO_KEY << "': ?}";
std::string sql(sqlStream.str());
for (size_t i = 0; i < statements.size(); ++i) {
statements[i].SetStatement(sql);
Aws::Vector attributes;
attributes.push_back(
Aws::DynamoDB::Model::AttributeValue().SetS(titles[i]));
attributes.push_back(Aws::DynamoDB::Model::AttributeValue().SetN(years[i]));
// Create attribute for the info map.
Aws::DynamoDB::Model::AttributeValue infoMapAttribute;
std::shared_ptr ratingAttribute = Aws::MakeShared(
ALLOCATION_TAG.c_str());
ratingAttribute->SetN(ratings[i]);
infoMapAttribute.AddMEntry(RATING_KEY, ratingAttribute);
std::shared_ptr plotAttribute = Aws::MakeShared(
ALLOCATION_TAG.c_str());
plotAttribute->SetS(plots[i]);
infoMapAttribute.AddMEntry(PLOT_KEY, plotAttribute);
attributes.push_back(infoMapAttribute);
statements[i].SetParameters(attributes);
}
Aws::DynamoDB::Model::BatchExecuteStatementRequest request;
request.SetStatements(statements);
Aws::DynamoDB::Model::BatchExecuteStatementOutcome outcome = dynamoClient.BatchExecuteStatement(
request);
if (!outcome.IsSuccess()) {
std::cerr << "Failed to add the movies: " << outcome.GetError().GetMessage()
<< std::endl;
return false;
}
}
std::cout << "Retrieving the movie data with a batch \"SELECT\" statement."
<< std::endl;
// 3. Get the data for multiple movies using "Select" statements. (BatchExecuteStatement)
{
Aws::Vector statements(
titles.size());
std::stringstream sqlStream;
sqlStream << "SELECT * FROM \"" << MOVIE_TABLE_NAME << "\" WHERE "
<< TITLE_KEY << "=? and " << YEAR_KEY << "=?";
std::string sql(sqlStream.str());
for (size_t i = 0; i < statements.size(); ++i) {
statements[i].SetStatement(sql);
Aws::Vector attributes;
attributes.push_back(
Aws::DynamoDB::Model::AttributeValue().SetS(titles[i]));
attributes.push_back(Aws::DynamoDB::Model::AttributeValue().SetN(years[i]));
statements[i].SetParameters(attributes);
}
Aws::DynamoDB::Model::BatchExecuteStatementRequest request;
request.SetStatements(statements);
Aws::DynamoDB::Model::BatchExecuteStatementOutcome outcome = dynamoClient.BatchExecuteStatement(
request);
if (outcome.IsSuccess()) {
const Aws::DynamoDB::Model::BatchExecuteStatementResult &result = outcome.GetResult();
const Aws::Vector &responses = result.GetResponses();
for (const Aws::DynamoDB::Model::BatchStatementResponse &response: responses) {
const Aws::Map &item = response.GetItem();
printMovieInfo(item);
}
}
else {
std::cerr << "Failed to retrieve the movie information: "
<< outcome.GetError().GetMessage() << std::endl;
return false;
}
}
// 4. Update the data for multiple movies using "Update" statements. (BatchExecuteStatement)
for (size_t i = 0; i < titles.size(); ++i) {
ratings[i] = askQuestionForFloatRange(
Aws::String("\nLet's update your the movie, \"") + titles[i] +
".\nYou rated it " + std::to_string(ratings[i])
+ ", what new rating would you give it? ", 1, 10);
}
std::cout << "Updating the movie with a batch \"UPDATE\" statement." << std::endl;
{
Aws::Vector statements(
titles.size());
std::stringstream sqlStream;
sqlStream << "UPDATE \"" << MOVIE_TABLE_NAME << "\" SET "
<< INFO_KEY << "." << RATING_KEY << "=? WHERE "
<< TITLE_KEY << "=? AND " << YEAR_KEY << "=?";
std::string sql(sqlStream.str());
for (size_t i = 0; i < statements.size(); ++i) {
statements[i].SetStatement(sql);
Aws::Vector attributes;
attributes.push_back(
Aws::DynamoDB::Model::AttributeValue().SetN(ratings[i]));
attributes.push_back(
Aws::DynamoDB::Model::AttributeValue().SetS(titles[i]));
attributes.push_back(Aws::DynamoDB::Model::AttributeValue().SetN(years[i]));
statements[i].SetParameters(attributes);
}
Aws::DynamoDB::Model::BatchExecuteStatementRequest request;
request.SetStatements(statements);
Aws::DynamoDB::Model::BatchExecuteStatementOutcome outcome = dynamoClient.BatchExecuteStatement(
request);
if (!outcome.IsSuccess()) {
std::cerr << "Failed to update movie information: "
<< outcome.GetError().GetMessage() << std::endl;
return false;
}
}
std::cout << "Retrieving the updated movie data with a batch \"SELECT\" statement."
<< std::endl;
// 5. Get the updated data for multiple movies using "Select" statements. (BatchExecuteStatement)
{
Aws::Vector statements(
titles.size());
std::stringstream sqlStream;
sqlStream << "SELECT * FROM \"" << MOVIE_TABLE_NAME << "\" WHERE "
<< TITLE_KEY << "=? and " << YEAR_KEY << "=?";
std::string sql(sqlStream.str());
for (size_t i = 0; i < statements.size(); ++i) {
statements[i].SetStatement(sql);
Aws::Vector attributes;
attributes.push_back(
Aws::DynamoDB::Model::AttributeValue().SetS(titles[i]));
attributes.push_back(Aws::DynamoDB::Model::AttributeValue().SetN(years[i]));
statements[i].SetParameters(attributes);
}
Aws::DynamoDB::Model::BatchExecuteStatementRequest request;
request.SetStatements(statements);
Aws::DynamoDB::Model::BatchExecuteStatementOutcome outcome = dynamoClient.BatchExecuteStatement(
request);
if (outcome.IsSuccess()) {
const Aws::DynamoDB::Model::BatchExecuteStatementResult &result = outcome.GetResult();
const Aws::Vector &responses = result.GetResponses();
for (const Aws::DynamoDB::Model::BatchStatementResponse &response: responses) {
const Aws::Map &item = response.GetItem();
printMovieInfo(item);
}
}
else {
std::cerr << "Failed to retrieve the movies information: "
<< outcome.GetError().GetMessage() << std::endl;
return false;
}
}
std::cout << "Deleting the movie data with a batch \"DELETE\" statement."
<< std::endl;
// 6. Delete multiple movies using "Delete" statements. (BatchExecuteStatement)
{
Aws::Vector statements(
titles.size());
std::stringstream sqlStream;
sqlStream << "DELETE FROM \"" << MOVIE_TABLE_NAME << "\" WHERE "
<< TITLE_KEY << "=? and " << YEAR_KEY << "=?";
std::string sql(sqlStream.str());
for (size_t i = 0; i < statements.size(); ++i) {
statements[i].SetStatement(sql);
Aws::Vector attributes;
attributes.push_back(
Aws::DynamoDB::Model::AttributeValue().SetS(titles[i]));
attributes.push_back(Aws::DynamoDB::Model::AttributeValue().SetN(years[i]));
statements[i].SetParameters(attributes);
}
Aws::DynamoDB::Model::BatchExecuteStatementRequest request;
request.SetStatements(statements);
Aws::DynamoDB::Model::BatchExecuteStatementOutcome outcome = dynamoClient.BatchExecuteStatement(
request);
if (!outcome.IsSuccess()) {
std::cerr << "Failed to delete the movies: "
<< outcome.GetError().GetMessage() << std::endl;
return false;
}
}
return true;
}
//! Create a DynamoDB table to be used in sample code scenarios.
/*!
\sa createMoviesDynamoDBTable()
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::createMoviesDynamoDBTable(
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
bool movieTableAlreadyExisted = false;
{
Aws::DynamoDB::Model::CreateTableRequest request;
Aws::DynamoDB::Model::AttributeDefinition yearAttributeDefinition;
yearAttributeDefinition.SetAttributeName(YEAR_KEY);
yearAttributeDefinition.SetAttributeType(
Aws::DynamoDB::Model::ScalarAttributeType::N);
request.AddAttributeDefinitions(yearAttributeDefinition);
Aws::DynamoDB::Model::AttributeDefinition titleAttributeDefinition;
yearAttributeDefinition.SetAttributeName(TITLE_KEY);
yearAttributeDefinition.SetAttributeType(
Aws::DynamoDB::Model::ScalarAttributeType::S);
request.AddAttributeDefinitions(yearAttributeDefinition);
Aws::DynamoDB::Model::KeySchemaElement yearKeySchema;
yearKeySchema.WithAttributeName(YEAR_KEY).WithKeyType(
Aws::DynamoDB::Model::KeyType::HASH);
request.AddKeySchema(yearKeySchema);
Aws::DynamoDB::Model::KeySchemaElement titleKeySchema;
yearKeySchema.WithAttributeName(TITLE_KEY).WithKeyType(
Aws::DynamoDB::Model::KeyType::RANGE);
request.AddKeySchema(yearKeySchema);
Aws::DynamoDB::Model::ProvisionedThroughput throughput;
throughput.WithReadCapacityUnits(
PROVISIONED_THROUGHPUT_UNITS).WithWriteCapacityUnits(
PROVISIONED_THROUGHPUT_UNITS);
request.SetProvisionedThroughput(throughput);
request.SetTableName(MOVIE_TABLE_NAME);
std::cout << "Creating table '" << MOVIE_TABLE_NAME << "'..." << std::endl;
const Aws::DynamoDB::Model::CreateTableOutcome &result = dynamoClient.CreateTable(
request);
if (!result.IsSuccess()) {
if (result.GetError().GetErrorType() ==
Aws::DynamoDB::DynamoDBErrors::RESOURCE_IN_USE) {
std::cout << "Table already exists." << std::endl;
movieTableAlreadyExisted = true;
}
else {
std::cerr << "Failed to create table: "
<< result.GetError().GetMessage();
return false;
}
}
}
// Wait for table to become active.
if (!movieTableAlreadyExisted) {
std::cout << "Waiting for table '" << MOVIE_TABLE_NAME
<< "' to become active...." << std::endl;
if (!AwsDoc::DynamoDB::waitTableActive(MOVIE_TABLE_NAME, clientConfiguration)) {
return false;
}
std::cout << "Table '" << MOVIE_TABLE_NAME << "' created and active."
<< std::endl;
}
return true;
}
//! Delete the DynamoDB table used for sample code scenarios.
/*!
\sa deleteMoviesDynamoDBTable()
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::DynamoDB::deleteMoviesDynamoDBTable(
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfiguration);
Aws::DynamoDB::Model::DeleteTableRequest request;
request.SetTableName(MOVIE_TABLE_NAME);
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();
}
//! 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;
}
```
+ Para obtener más información sobre la API, consulta [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/BatchExecuteStatement)la *Referencia AWS SDK para C\$1\$1 de la API*.
------
#### [ Go ]
**SDK para Go V2**
Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/dynamodb#code-examples).
Ejecutar un escenario que crea una tabla y ejecuta lotes de consultas PartiQL.
```
import (
"context"
"fmt"
"log"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/dynamodb/actions"
)
// RunPartiQLBatchScenario shows you how to use the AWS SDK for Go
// to run batches of PartiQL statements to query a table that stores data about movies.
//
// - Use batches of PartiQL statements to add, get, update, and delete data for
// individual movies.
//
// This example creates an Amazon DynamoDB service client from the specified sdkConfig so that
// you can replace it with a mocked or stubbed config for unit testing.
//
// This example creates and deletes a DynamoDB table to use during the scenario.
func RunPartiQLBatchScenario(ctx context.Context, sdkConfig aws.Config, tableName string) {
defer func() {
if r := recover(); r != nil {
fmt.Printf("Something went wrong with the demo.")
}
}()
log.Println(strings.Repeat("-", 88))
log.Println("Welcome to the Amazon DynamoDB PartiQL batch demo.")
log.Println(strings.Repeat("-", 88))
tableBasics := actions.TableBasics{
DynamoDbClient: dynamodb.NewFromConfig(sdkConfig),
TableName: tableName,
}
runner := actions.PartiQLRunner{
DynamoDbClient: dynamodb.NewFromConfig(sdkConfig),
TableName: tableName,
}
exists, err := tableBasics.TableExists(ctx)
if err != nil {
panic(err)
}
if !exists {
log.Printf("Creating table %v...\n", tableName)
_, err = tableBasics.CreateMovieTable(ctx)
if err != nil {
panic(err)
} else {
log.Printf("Created table %v.\n", tableName)
}
} else {
log.Printf("Table %v already exists.\n", tableName)
}
log.Println(strings.Repeat("-", 88))
currentYear, _, _ := time.Now().Date()
customMovies := []actions.Movie{{
Title: "House PartiQL",
Year: currentYear - 5,
Info: map[string]interface{}{
"plot": "Wacky high jinks result from querying a mysterious database.",
"rating": 8.5}}, {
Title: "House PartiQL 2",
Year: currentYear - 3,
Info: map[string]interface{}{
"plot": "Moderate high jinks result from querying another mysterious database.",
"rating": 6.5}}, {
Title: "House PartiQL 3",
Year: currentYear - 1,
Info: map[string]interface{}{
"plot": "Tepid high jinks result from querying yet another mysterious database.",
"rating": 2.5},
},
}
log.Printf("Inserting a batch of movies into table '%v'.\n", tableName)
err = runner.AddMovieBatch(ctx, customMovies)
if err == nil {
log.Printf("Added %v movies to the table.\n", len(customMovies))
}
log.Println(strings.Repeat("-", 88))
log.Println("Getting data for a batch of movies.")
movies, err := runner.GetMovieBatch(ctx, customMovies)
if err == nil {
for _, movie := range movies {
log.Println(movie)
}
}
log.Println(strings.Repeat("-", 88))
newRatings := []float64{7.7, 4.4, 1.1}
log.Println("Updating a batch of movies with new ratings.")
err = runner.UpdateMovieBatch(ctx, customMovies, newRatings)
if err == nil {
log.Printf("Updated %v movies with new ratings.\n", len(customMovies))
}
log.Println(strings.Repeat("-", 88))
log.Println("Getting projected data from the table to verify our update.")
log.Println("Using a page size of 2 to demonstrate paging.")
projections, err := runner.GetAllMovies(ctx, 2)
if err == nil {
log.Println("All movies:")
for _, projection := range projections {
log.Println(projection)
}
}
log.Println(strings.Repeat("-", 88))
log.Println("Deleting a batch of movies.")
err = runner.DeleteMovieBatch(ctx, customMovies)
if err == nil {
log.Printf("Deleted %v movies.\n", len(customMovies))
}
err = tableBasics.DeleteTable(ctx)
if err == nil {
log.Printf("Deleted table %v.\n", tableBasics.TableName)
}
log.Println(strings.Repeat("-", 88))
log.Println("Thanks for watching!")
log.Println(strings.Repeat("-", 88))
}
```
Defina una estructura Película para utilizar en este ejemplo.
```
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"])
}
```
Crear una estructura y métodos que ejecuten instrucciones PartiQL.
```
import (
"context"
"fmt"
"log"
"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/service/dynamodb"
"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)
// PartiQLRunner encapsulates the Amazon DynamoDB service actions used in the
// PartiQL examples. It contains a DynamoDB service client that is used to act on the
// specified table.
type PartiQLRunner struct {
DynamoDbClient *dynamodb.Client
TableName string
}
// AddMovieBatch runs a batch of PartiQL INSERT statements to add multiple movies to the
// DynamoDB table.
func (runner PartiQLRunner) AddMovieBatch(ctx context.Context, movies []Movie) error {
statementRequests := make([]types.BatchStatementRequest, len(movies))
for index, movie := range movies {
params, err := attributevalue.MarshalList([]interface{}{movie.Title, movie.Year, movie.Info})
if err != nil {
panic(err)
}
statementRequests[index] = types.BatchStatementRequest{
Statement: aws.String(fmt.Sprintf(
"INSERT INTO \"%v\" VALUE {'title': ?, 'year': ?, 'info': ?}", runner.TableName)),
Parameters: params,
}
}
_, err := runner.DynamoDbClient.BatchExecuteStatement(ctx, &dynamodb.BatchExecuteStatementInput{
Statements: statementRequests,
})
if err != nil {
log.Printf("Couldn't insert a batch of items with PartiQL. Here's why: %v\n", err)
}
return err
}
// GetMovieBatch runs a batch of PartiQL SELECT statements to get multiple movies from
// the DynamoDB table by title and year.
func (runner PartiQLRunner) GetMovieBatch(ctx context.Context, movies []Movie) ([]Movie, error) {
statementRequests := make([]types.BatchStatementRequest, len(movies))
for index, movie := range movies {
params, err := attributevalue.MarshalList([]interface{}{movie.Title, movie.Year})
if err != nil {
panic(err)
}
statementRequests[index] = types.BatchStatementRequest{
Statement: aws.String(
fmt.Sprintf("SELECT * FROM \"%v\" WHERE title=? AND year=?", runner.TableName)),
Parameters: params,
}
}
output, err := runner.DynamoDbClient.BatchExecuteStatement(ctx, &dynamodb.BatchExecuteStatementInput{
Statements: statementRequests,
})
var outMovies []Movie
if err != nil {
log.Printf("Couldn't get a batch of items with PartiQL. Here's why: %v\n", err)
} else {
for _, response := range output.Responses {
var movie Movie
err = attributevalue.UnmarshalMap(response.Item, &movie)
if err != nil {
log.Printf("Couldn't unmarshal response. Here's why: %v\n", err)
} else {
outMovies = append(outMovies, movie)
}
}
}
return outMovies, err
}
// GetAllMovies runs a PartiQL SELECT statement to get all movies from the DynamoDB table.
// pageSize is not typically required and is used to show how to paginate the results.
// The results are projected to return only the title and rating of each movie.
func (runner PartiQLRunner) GetAllMovies(ctx context.Context, pageSize int32) ([]map[string]interface{}, error) {
var output []map[string]interface{}
var response *dynamodb.ExecuteStatementOutput
var err error
var nextToken *string
for moreData := true; moreData; {
response, err = runner.DynamoDbClient.ExecuteStatement(ctx, &dynamodb.ExecuteStatementInput{
Statement: aws.String(
fmt.Sprintf("SELECT title, info.rating FROM \"%v\"", runner.TableName)),
Limit: aws.Int32(pageSize),
NextToken: nextToken,
})
if err != nil {
log.Printf("Couldn't get movies. Here's why: %v\n", err)
moreData = false
} else {
var pageOutput []map[string]interface{}
err = attributevalue.UnmarshalListOfMaps(response.Items, &pageOutput)
if err != nil {
log.Printf("Couldn't unmarshal response. Here's why: %v\n", err)
} else {
log.Printf("Got a page of length %v.\n", len(response.Items))
output = append(output, pageOutput...)
}
nextToken = response.NextToken
moreData = nextToken != nil
}
}
return output, err
}
// UpdateMovieBatch runs a batch of PartiQL UPDATE statements to update the rating of
// multiple movies that already exist in the DynamoDB table.
func (runner PartiQLRunner) UpdateMovieBatch(ctx context.Context, movies []Movie, ratings []float64) error {
statementRequests := make([]types.BatchStatementRequest, len(movies))
for index, movie := range movies {
params, err := attributevalue.MarshalList([]interface{}{ratings[index], movie.Title, movie.Year})
if err != nil {
panic(err)
}
statementRequests[index] = types.BatchStatementRequest{
Statement: aws.String(
fmt.Sprintf("UPDATE \"%v\" SET info.rating=? WHERE title=? AND year=?", runner.TableName)),
Parameters: params,
}
}
_, err := runner.DynamoDbClient.BatchExecuteStatement(ctx, &dynamodb.BatchExecuteStatementInput{
Statements: statementRequests,
})
if err != nil {
log.Printf("Couldn't update the batch of movies. Here's why: %v\n", err)
}
return err
}
// DeleteMovieBatch runs a batch of PartiQL DELETE statements to remove multiple movies
// from the DynamoDB table.
func (runner PartiQLRunner) DeleteMovieBatch(ctx context.Context, movies []Movie) error {
statementRequests := make([]types.BatchStatementRequest, len(movies))
for index, movie := range movies {
params, err := attributevalue.MarshalList([]interface{}{movie.Title, movie.Year})
if err != nil {
panic(err)
}
statementRequests[index] = types.BatchStatementRequest{
Statement: aws.String(
fmt.Sprintf("DELETE FROM \"%v\" WHERE title=? AND year=?", runner.TableName)),
Parameters: params,
}
}
_, err := runner.DynamoDbClient.BatchExecuteStatement(ctx, &dynamodb.BatchExecuteStatementInput{
Statements: statementRequests,
})
if err != nil {
log.Printf("Couldn't delete the batch of movies. Here's why: %v\n", err)
}
return err
}
```
+ Para obtener más información sobre la API, consulta [BatchExecuteStatement](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/dynamodb#Client.BatchExecuteStatement)la *Referencia AWS SDK para Go de la API*.
------
#### [ Java ]
**SDK para Java 2.x**
Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb#code-examples).
```
public class ScenarioPartiQLBatch {
public static void main(String[] args) throws IOException {
String tableName = "MoviesPartiQBatch";
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
System.out.println("Creating an Amazon DynamoDB table named " + tableName
+ " with a key named year and a sort key named title.");
createTable(ddb, tableName);
System.out.println("Adding multiple records into the " + tableName
+ " table using a batch command.");
putRecordBatch(ddb);
// Update multiple movies by using the BatchExecute statement.
String title1 = "Star Wars";
int year1 = 1977;
String title2 = "Wizard of Oz";
int year2 = 1939;
System.out.println("Query two movies.");
getBatch(ddb, tableName, title1, title2, year1, year2);
System.out.println("Updating multiple records using a batch command.");
updateTableItemBatch(ddb);
System.out.println("Deleting multiple records using a batch command.");
deleteItemBatch(ddb);
System.out.println("Deleting the Amazon DynamoDB table.");
deleteDynamoDBTable(ddb, tableName);
ddb.close();
}
public static boolean getBatch(DynamoDbClient ddb, String tableName, String title1, String title2, int year1, int year2) {
String getBatch = "SELECT * FROM " + tableName + " WHERE title = ? AND year = ?";
List statements = new ArrayList<>();
statements.add(BatchStatementRequest.builder()
.statement(getBatch)
.parameters(AttributeValue.builder().s(title1).build(),
AttributeValue.builder().n(String.valueOf(year1)).build())
.build());
statements.add(BatchStatementRequest.builder()
.statement(getBatch)
.parameters(AttributeValue.builder().s(title2).build(),
AttributeValue.builder().n(String.valueOf(year2)).build())
.build());
BatchExecuteStatementRequest batchExecuteStatementRequest = BatchExecuteStatementRequest.builder()
.statements(statements)
.build();
try {
BatchExecuteStatementResponse response = ddb.batchExecuteStatement(batchExecuteStatementRequest);
if (!response.responses().isEmpty()) {
response.responses().forEach(r -> {
System.out.println(r.item().get("title") + "\\t" + r.item().get("year"));
});
return true;
} else {
System.out.println("Couldn't find either " + title1 + " or " + title2 + ".");
return false;
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
return false;
}
}
public static void createTable(DynamoDbClient ddb, String tableName) {
DynamoDbWaiter dbWaiter = ddb.waiter();
ArrayList attributeDefinitions = new ArrayList<>();
// Define attributes.
attributeDefinitions.add(AttributeDefinition.builder()
.attributeName("year")
.attributeType("N")
.build());
attributeDefinitions.add(AttributeDefinition.builder()
.attributeName("title")
.attributeType("S")
.build());
ArrayList tableKey = new ArrayList<>();
KeySchemaElement key = KeySchemaElement.builder()
.attributeName("year")
.keyType(KeyType.HASH)
.build();
KeySchemaElement key2 = KeySchemaElement.builder()
.attributeName("title")
.keyType(KeyType.RANGE) // Sort
.build();
// Add KeySchemaElement objects to the list.
tableKey.add(key);
tableKey.add(key2);
CreateTableRequest request = CreateTableRequest.builder()
.keySchema(tableKey)
.billingMode(BillingMode.PAY_PER_REQUEST) // DynamoDB automatically scales based on traffic.
.attributeDefinitions(attributeDefinitions)
.tableName(tableName)
.build();
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);
String newTable = response.tableDescription().tableName();
System.out.println("The " + newTable + " was successfully created.");
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void putRecordBatch(DynamoDbClient ddb) {
String sqlStatement = "INSERT INTO MoviesPartiQBatch VALUE {'year':?, 'title' : ?, 'info' : ?}";
try {
// Create three movies to add to the Amazon DynamoDB table.
// Set data for Movie 1.
List parameters = new ArrayList<>();
AttributeValue att1 = AttributeValue.builder()
.n("1977")
.build();
AttributeValue att2 = AttributeValue.builder()
.s("Star Wars")
.build();
AttributeValue att3 = AttributeValue.builder()
.s("No Information")
.build();
parameters.add(att1);
parameters.add(att2);
parameters.add(att3);
BatchStatementRequest statementRequestMovie1 = BatchStatementRequest.builder()
.statement(sqlStatement)
.parameters(parameters)
.build();
// Set data for Movie 2.
List parametersMovie2 = new ArrayList<>();
AttributeValue attMovie2 = AttributeValue.builder()
.n("1939")
.build();
AttributeValue attMovie2A = AttributeValue.builder()
.s("Wizard of Oz")
.build();
AttributeValue attMovie2B = AttributeValue.builder()
.s("No Information")
.build();
parametersMovie2.add(attMovie2);
parametersMovie2.add(attMovie2A);
parametersMovie2.add(attMovie2B);
BatchStatementRequest statementRequestMovie2 = BatchStatementRequest.builder()
.statement(sqlStatement)
.parameters(parametersMovie2)
.build();
// Set data for Movie 3.
List parametersMovie3 = new ArrayList<>();
AttributeValue attMovie3 = AttributeValue.builder()
.n(String.valueOf("2022"))
.build();
AttributeValue attMovie3A = AttributeValue.builder()
.s("My Movie 3")
.build();
AttributeValue attMovie3B = AttributeValue.builder()
.s("No Information")
.build();
parametersMovie3.add(attMovie3);
parametersMovie3.add(attMovie3A);
parametersMovie3.add(attMovie3B);
BatchStatementRequest statementRequestMovie3 = BatchStatementRequest.builder()
.statement(sqlStatement)
.parameters(parametersMovie3)
.build();
// Add all three movies to the list.
List myBatchStatementList = new ArrayList<>();
myBatchStatementList.add(statementRequestMovie1);
myBatchStatementList.add(statementRequestMovie2);
myBatchStatementList.add(statementRequestMovie3);
BatchExecuteStatementRequest batchRequest = BatchExecuteStatementRequest.builder()
.statements(myBatchStatementList)
.build();
BatchExecuteStatementResponse response = ddb.batchExecuteStatement(batchRequest);
System.out.println("ExecuteStatement successful: " + response.toString());
System.out.println("Added new movies using a batch command.");
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void updateTableItemBatch(DynamoDbClient ddb) {
String sqlStatement = "UPDATE MoviesPartiQBatch SET info = 'directors\":[\"Merian C. Cooper\",\"Ernest B. Schoedsack' where year=? and title=?";
List