There are more AWS SDK examples available in the [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub repo.
# Query a DynamoDB table using a begins\$1with condition with an AWS SDK
The following code examples show how to query a table using a begins\$1with condition.
+ Use the begins\$1with function in a key condition expression.
+ Filter items based on a prefix pattern in the sort key.
------
#### [ Java ]
**SDK for Java 2.x**
Query a DynamoDB table using a begins\$1with condition on the sort key with AWS SDK for Java 2.x.
```
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 queryWithBeginsWithCondition(
final String tableName,
final String partitionKeyName,
final String partitionKeyValue,
final String sortKeyName,
final String sortKeyPrefix) {
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
CodeSampleUtils.validateStringParameter("Sort key name", sortKeyName);
CodeSampleUtils.validateStringParameter("Sort key prefix", sortKeyPrefix);
// 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_SK, sortKeyName);
// 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_SK_PREFIX,
AttributeValue.builder().s(sortKeyPrefix).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);
LOGGER.log(Level.INFO, "Query with begins_with condition 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 begins_with condition", e);
throw e;
}
}
```
Demonstrate using begins\$1with with different prefix lengths with AWS SDK for Java 2.x.
```
public static void main(String[] args) {
try {
CodeSampleUtils.BeginsWithQueryConfig config = CodeSampleUtils.BeginsWithQueryConfig.fromArgs(args);
LOGGER.log(Level.INFO, "Querying items where {0} = {1} and {2} begins with ''{3}''", new Object[] {
config.getPartitionKeyName(),
config.getPartitionKeyValue(),
config.getSortKeyName(),
config.getSortKeyPrefix()
});
// Using the builder pattern to create and execute the query
final QueryResponse response = new BeginsWithQueryBuilder()
.withTableName(config.getTableName())
.withPartitionKeyName(config.getPartitionKeyName())
.withPartitionKeyValue(config.getPartitionKeyValue())
.withSortKeyName(config.getSortKeyName())
.withSortKeyPrefix(config.getSortKeyPrefix())
.withRegion(config.getRegion())
.execute();
// Process the results
LOGGER.log(Level.INFO, "Found {0} items:", response.count());
response.items().forEach(item -> LOGGER.info(item.toString()));
// Demonstrate with a different prefix
if (!config.getSortKeyPrefix().isEmpty()) {
String shorterPrefix = config.getSortKeyPrefix()
.substring(0, Math.max(1, config.getSortKeyPrefix().length() / 2));
LOGGER.log(Level.INFO, "\nNow querying with a shorter prefix: ''{0}''", shorterPrefix);
final QueryResponse response2 = new BeginsWithQueryBuilder()
.withTableName(config.getTableName())
.withPartitionKeyName(config.getPartitionKeyName())
.withPartitionKeyValue(config.getPartitionKeyValue())
.withSortKeyName(config.getSortKeyName())
.withSortKeyPrefix(shorterPrefix)
.withRegion(config.getRegion())
.execute();
LOGGER.log(Level.INFO, "Found {0} items with shorter prefix:", response2.count());
response2.items().forEach(item -> LOGGER.info(item.toString()));
}
} catch (IllegalArgumentException e) {
LOGGER.log(Level.SEVERE, "Invalid input: {0}", e.getMessage());
printUsage();
} catch (ResourceNotFoundException e) {
LOGGER.log(Level.SEVERE, "Table not found", e);
} catch (DynamoDbException e) {
LOGGER.log(Level.SEVERE, "DynamoDB error", e);
} catch (Exception e) {
LOGGER.log(Level.SEVERE, "Unexpected error", e);
}
}
```
+ For API details, see [Query](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
Query a DynamoDB table using a begins\$1with condition on the sort key with AWS SDK for JavaScript.
```
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
/**
* Queries a DynamoDB table for items where the sort key begins with a specific prefix
*
* @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 {string} sortKeyName - The name of the sort key
* @param {string} prefix - The prefix to match at the beginning of the sort key
* @returns {Promise