# 使用 Amazon SDK 通过筛选表达式和限制来查询 DynamoDB 表
以下代码示例显示如何使用筛选表达式和限制来查询表。
+ 将筛选表达式应用于查询结果，但对评估的项目有限制。
+ 了解限制如何影响筛选的查询结果。
+ 控制查询中处理的最大项目数。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
使用Amazon SDK for Java 2.x 通过筛选表达式和限制来查询 DynamoDB 表。
```
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;
}
}
```
+ 有关 API 详细信息，请参阅 *Amazon SDK for Java 2.x API 参考*中的 [Query](https://docs.amazonaws.cn/goto/SdkForJavaV2/dynamodb-2012-08-10/Query)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
使用适用于 Python (Boto3) 的 Amazon SDK 通过筛选表达式和限制来查询 DynamoDB 表。
```
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
```
演示如何在适用于 Python (Boto3) 的 Amazon SDK中将筛选表达式与限制结合使用。
```
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.")
```
+ 有关 API 详细信息，请参阅《Amazon SDK for Python (Boto3) API Reference》**中的 [Query](https://docs.amazonaws.cn/goto/boto3/dynamodb-2012-08-10/Query)。
------
有关 Amazon SDK 开发人员指南和代码示例的完整列表，请参阅 [结合使用 DynamoDB 与 Amazon SDK](sdk-general-information-section.md) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。