# Query a DynamoDB table with a filter expression and limit with an AWS SDK
The following code examples show how to query a table with a filter expression and limit.
+ Apply filter expressions to query results with a limit on items evaluated.
+ Understand how limit affects filtered query results.
+ Control the maximum number of items processed in a query.
------
#### [ Java ]
**SDK for Java 2.x**
Query a DynamoDB table with a filter expression and limit 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.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public QueryResponse queryWithFilterAndLimit(
final String tableName,
final String partitionKeyName,
final String partitionKeyValue,
final String filterAttrName,
final String filterAttrValue,
final int limit) {
CodeSampleUtils.validateTableParameters(tableName, partitionKeyName, partitionKeyValue);
CodeSampleUtils.validateStringParameter("Filter attribute name", filterAttrName);
CodeSampleUtils.validateStringParameter("Filter attribute value", filterAttrValue);
CodeSampleUtils.validatePositiveInteger("Limit", limit);
// 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_FILTER, filterAttrName);
// 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_FILTER,
AttributeValue.builder().s(filterAttrValue).build());
// Create the filter expression
final String filterExpression = "#filterAttr = :filterValue";
// Create the query request
final QueryRequest queryRequest = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.filterExpression(filterExpression)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.limit(limit)
.build();
try {
final QueryResponse response = dynamoDbClient.query(queryRequest);
LOGGER.log(Level.INFO, "Query with filter and limit successful. Found {0} items", response.count());
LOGGER.log(
Level.INFO, "ScannedCount: {0} (total items evaluated before filtering)", response.scannedCount());
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 filter and limit: {0}", e.getMessage());
throw 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*.
------
#### [ Python ]
**SDK for Python (Boto3)**
Query a DynamoDB table with a filter expression and limit using AWS SDK for Python (Boto3).
```
import boto3
from boto3.dynamodb.conditions import Attr, Key
def query_with_filter_and_limit(
table_name,
partition_key_name,
partition_key_value,
filter_attribute=None,
filter_value=None,
limit=10,
):
"""
Query a DynamoDB table with a filter expression and limit the number of results.
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.
filter_attribute (str, optional): The attribute name to filter on.
filter_value (any, optional): The value to compare against in the filter.
limit (int, optional): The maximum number of items to evaluate. Defaults to 10.
Returns:
dict: The response from DynamoDB containing the query results.
"""
# Initialize the DynamoDB resource
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table(table_name)
# Build the key condition expression
key_condition = Key(partition_key_name).eq(partition_key_value)
# Prepare the query parameters
query_params = {"KeyConditionExpression": key_condition, "Limit": limit}
# Add the filter expression if filter attributes are provided
if filter_attribute and filter_value is not None:
query_params["FilterExpression"] = Attr(filter_attribute).gt(filter_value)
query_params["ExpressionAttributeValues"] = {":filter_value": filter_value}
# Execute the query
response = table.query(**query_params)
return response
```
Demonstrates how to use filter expressions with limits in AWS SDK for Python (Boto3).
```
def example_usage():
"""Example of how to use the query_with_filter_and_limit function."""
# Example parameters
table_name = "ProductReviews"
partition_key_name = "ProductId"
partition_key_value = "P123456"
filter_attribute = "Rating"
filter_value = 3 # Filter for ratings > 3
limit = 5
print(f"Querying reviews for product '{partition_key_value}' with rating > {filter_value}")
print(f"Limiting to {limit} evaluated items")
# Execute the query with filter and limit
response = query_with_filter_and_limit(
table_name, partition_key_name, partition_key_value, filter_attribute, filter_value, limit
)
# Process the results
items = response.get("Items", [])
print(f"\nReturned {len(items)} items that passed the filter")
for item in items:
print(f"Review: {item}")
# Explain the difference between Limit and actual results
explain_limit_vs_results(response)
# Check if there are more results
if "LastEvaluatedKey" in response:
print("\nThere are more results available. Use the LastEvaluatedKey for pagination.")
else:
print("\nAll matching results have been retrieved.")
```
+ 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*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using DynamoDB with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.