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.
# Abfragen einer DynamoDB-Tabelle mit Paginierung mithilfe eines SDK AWS
In den folgenden Codebeispielen wird gezeigt, wie eine Tabelle mit Paginierung abgefragt wird.
+ Implementieren der Paginierung für DynamoDB-Abfrageergebnisse
+ Verwenden Sie das LastEvaluatedKey , um nachfolgende Seiten abzurufen.
+ Steuern der Anzahl der Elemente pro Seite mit dem Parameter „Limit“
------
#### [ Java ]
**SDK für Java 2.x**
Fragen Sie eine DynamoDB-Tabelle mit Paginierung ab mit. 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;
}
}
```
Demonstriert, wie eine DynamoDB-Tabelle mit Paginierung abgefragt wird.
```
public static void main(String[] args) {
final String usage =
"""
Usage:
[pageSize] [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.
pageSize (optional) - The maximum number of items to return per page. (Default: 10)
region (optional) - The AWS region where the table exists. (Default: us-east-1)
""";
if (args.length < 3) {
System.out.println(usage);
System.exit(1);
}
final String tableName = args[0];
final String partitionKeyName = args[1];
final String partitionKeyValue = args[2];
final int pageSize = args.length > 3 ? Integer.parseInt(args[3]) : 10;
final Region region = args.length > 4 ? Region.of(args[4]) : Region.US_EAST_1;
System.out.println("Querying items with pagination (page size: " + pageSize + ")");
try {
// Using the builder pattern to create and execute the query
final List> allItems = new PaginationQueryBuilder()
.withTableName(tableName)
.withPartitionKeyName(partitionKeyName)
.withPartitionKeyValue(partitionKeyValue)
.withPageSize(pageSize)
.withRegion(region)
.executeWithPagination();
// Process the results
System.out.println("\nSummary: Retrieved a total of " + allItems.size() + " items");
// Display the first few items as a sample
final int sampleSize = Math.min(5, allItems.size());
if (sampleSize > 0) {
System.out.println("\nSample of retrieved items (first " + sampleSize + "):");
for (int i = 0; i < sampleSize; i++) {
System.out.println(allItems.get(i));
}
if (allItems.size() > sampleSize) {
System.out.println("... and " + (allItems.size() - sampleSize) + " more items");
}
}
} 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);
}
}
```
+ 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 mit Paginierung ab mit. AWS SDK für 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 };
```
+ Weitere API-Informationen finden Sie unter [Abfragen](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Fragen Sie eine DynamoDB-Tabelle mit Paginierung ab mit. AWS SDK für 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
```
+ Weitere API-Informationen finden Sie unter [Abfragen](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------