Weitere AWS SDK-Beispiele sind im GitHub Repo [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) verfügbar.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Fragen Sie eine DynamoDB-Tabelle mithilfe eines Datumsbereichs im Sortierschlüssel mit einem SDK ab AWS
In den folgenden Codebeispielen wird gezeigt, wie eine Tabelle mithilfe eines Datumsbereichs im Sortierschlüssel abgefragt wird.
+ Abfragen von Elementen innerhalb eines bestimmten Datumsbereichs
+ Verwenden von Vergleichsoperatoren für Sortierschlüssel im Datumsformat
------
#### [ Java ]
**SDK für Java 2.x**
Fragen Sie eine DynamoDB-Tabelle nach Elementen innerhalb eines Datumsbereichs mit ab. 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.time.LocalDate;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public QueryResponse queryWithDateRange(
final String tableName,
final String partitionKeyName,
final String partitionKeyValue,
final String dateKeyName,
final LocalDate startDate,
final LocalDate endDate) {
// Focus on query logic, assuming parameters are valid
if (startDate == null || endDate == null) {
throw new IllegalArgumentException("Start date and end date cannot be null");
}
if (endDate.isBefore(startDate)) {
throw new IllegalArgumentException("End date must be after start date");
}
// Format dates as ISO strings for DynamoDB (using just the date part)
final String formattedStartDate = startDate.toString();
final String formattedEndDate = endDate.toString();
// 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, dateKeyName);
// 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_START_DATE,
AttributeValue.builder().s(formattedStartDate).build());
expressionAttributeValues.put(
EXPRESSION_ATTRIBUTE_VALUE_END_DATE,
AttributeValue.builder().s(formattedEndDate).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 by date range 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 by date range: {0}", e.getMessage());
throw e;
}
}
```
Zeigt, wie eine DynamoDB-Tabelle mit Datumsbereichsfilterung abgefragt wird.
```
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.
dateKeyName - The name of the date attribute to filter on.
startDate - The start date for the range query (YYYY-MM-DD).
endDate - The end date for the range query (YYYY-MM-DD).
region (optional) - The AWS region where the table exists. (Default: us-east-1)
""";
if (args.length < 6) {
System.out.println(usage);
System.exit(1);
}
try {
// Parse command line arguments into a config object
CodeSampleUtils.DateRangeQueryConfig config = CodeSampleUtils.DateRangeQueryConfig.fromArgs(args);
LOGGER.log(
Level.INFO, "Querying items from {0} to {1}", new Object[] {config.getStartDate(), config.getEndDate()
});
// Using the builder pattern to create and execute the query
final QueryResponse response = new DateRangeQueryBuilder()
.withTableName(config.getTableName())
.withPartitionKeyName(config.getPartitionKeyName())
.withPartitionKeyValue(config.getPartitionKeyValue())
.withDateKeyName(config.getDateKeyName())
.withStartDate(config.getStartDate())
.withEndDate(config.getEndDate())
.withRegion(config.getRegion())
.execute();
// Process the results
LOGGER.log(Level.INFO, "Found {0} items:", response.count());
response.items().forEach(item -> {
LOGGER.info(item.toString());
// Extract and display the date attribute for clarity
if (item.containsKey(config.getDateKeyName())) {
LOGGER.log(
Level.INFO,
" Date attribute: {0}",
item.get(config.getDateKeyName()).s());
}
});
// Demonstrate with a different date range
LocalDate narrowerStartDate = config.getStartDate().plusDays(1);
LocalDate narrowerEndDate = config.getEndDate().minusDays(1);
if (!narrowerStartDate.isAfter(narrowerEndDate)) {
LOGGER.log(Level.INFO, "\nNow querying with a narrower date range: {0} to {1}", new Object[] {
narrowerStartDate, narrowerEndDate
});
final QueryResponse response2 = new DateRangeQueryBuilder()
.withTableName(config.getTableName())
.withPartitionKeyName(config.getPartitionKeyName())
.withPartitionKeyValue(config.getPartitionKeyValue())
.withDateKeyName(config.getDateKeyName())
.withStartDate(narrowerStartDate)
.withEndDate(narrowerEndDate)
.withRegion(config.getRegion())
.execute();
LOGGER.log(Level.INFO, "Found {0} items with narrower date range:", response2.count());
response2.items().forEach(item -> LOGGER.info(item.toString()));
}
LOGGER.info("\nNote: When storing dates in DynamoDB:");
LOGGER.info("1. Use ISO format (YYYY-MM-DD) for lexicographical ordering");
LOGGER.info("2. Use the BETWEEN operator for inclusive date range queries");
LOGGER.info("3. Consider using ISO-8601 format for timestamps with time components");
} catch (IllegalArgumentException e) {
LOGGER.log(Level.SEVERE, "Invalid input: {0}", e.getMessage());
System.exit(1);
} catch (ResourceNotFoundException e) {
LOGGER.log(Level.SEVERE, "Table not found: {0}", e.getMessage());
System.exit(1);
} catch (DynamoDbException e) {
LOGGER.log(Level.SEVERE, "DynamoDB error: {0}", e.getMessage());
System.exit(1);
} catch (Exception e) {
LOGGER.log(Level.SEVERE, "Unexpected error: {0}", e.getMessage());
System.exit(1);
}
}
```
+ Weitere API-Informationen finden Sie unter [Abfragen](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Fragen Sie eine DynamoDB-Tabelle nach Elementen innerhalb eines Datumsbereichs mit ab. AWS SDK für JavaScript
```
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb");
/**
* Queries a DynamoDB table for items within a specific date range on the sort key
*
* @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 (must be a date/time attribute)
* @param {Date} startDate - The start date for the range query
* @param {Date} endDate - The end date for the range query
* @returns {Promise