# Consultar uma tabela do DynamoDB usando uma condição begins\$1with por meio de um SDK da AWS
Os exemplos de código a seguir mostram como consultar uma tabela usando uma condição begins\$1with.
+ Use a função begins\$1with em uma expressão de condição de chave.
+ Filtre itens com base em um padrão de prefixo na chave de classificação.
------
#### [ Java ]
**SDK para Java 2.x**
Consulte uma tabela do DynamoDB usando uma condição begins\$1with na chave de classificação por meio do 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;
}
}
```
Demonstre o uso de begins\$1with com diferentes comprimentos de prefixo por meio do 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);
}
}
```
+ Consulte detalhes da API em [Query](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) na *Referência da API AWS SDK for Java 2.x*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Consulte uma tabela do DynamoDB usando uma condição begins\$1with na chave de classificação por meio do AWS SDK para 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