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 with pagination using an AWS SDK
The following code examples show how to query a table with pagination.
+ Implement pagination for DynamoDB query results.
+ Use the LastEvaluatedKey to retrieve subsequent pages.
+ Control the number of items per page with the Limit parameter.
------
#### [ Java ]
**SDK for Java 2.x**
Query a DynamoDB table with pagination using 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;
}
}
```
Demonstrates how to query a DynamoDB table with pagination.
```
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);
}
}
```
+ 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 with pagination using AWS SDK for 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 };
```
+ For API details, see [Query](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
Query a DynamoDB table with pagination using AWS SDK for 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
```
+ For API details, see [Query](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query) in *AWS SDK for Python (Boto3) API Reference*.
------