DynamoDB pagination - knowing when there is no more results - amazon-dynamodb

Question

The doc states:
The absence of LastEvaluatedKey is the only way to know that you have
reached the end of the result set
However if you have 10 items and you're Query-ing 10 items, you WILL get a result set with LastEvaluatedKey. However there is no more items after that.
Is there a reliable method to actually know when reaching the end of the result set?

Answer 1

When you specify the limit (10 as per this question), it finds number of items as provided by limit and does not look beyond that.
As items are 10 and limit is 10, it is able to find elements as per limit each time.
On the second attempt to read items, it finds no item in table and hence return null. You will need to have while loop something like below:
List<QueryResult> queryResultList = new ArrayList<>();
// Since query returns only max 1MB of items at a time,
// use of this flag tells if no more such elements are present in db.
Map<String, AttributeValue> lastKeyEvaluated = null;
Map<String, AttributeValue> expressionAttributeValue = new HashMap<>();
expressionAttributeValue.put(":primary_key_value", new AttributeValue().withS(primary_key_value));
do {
QueryRequest queryRequest = new QueryRequest()
.withTableName(this.getDynamoTable().getTableName())
.withIndexName(Constants.Table.INDEX_NAME)
.withKeyConditionExpression("primary_key = :primary_key_value")
.withExpressionAttributeValues(expressionAttributeValue)
.withExclusiveStartKey(lastKeyEvaluated);
QueryResult result = this.getAmazonDynamoDBClient().query(queryRequest);
queryResultList.add(result);
lastKeyEvaluated = result.getLastEvaluatedKey();
} while (lastKeyEvaluated != null);

Answer 2

I know this question is 4 years old, but I also encountered this problem and this is how I "solved" it:
In my case I was using the last evaluated key for doing a pagination on the results, and I was giving via a variable (lets call it pageSize) the query size.
Using the example of the question, we would be giving to the function a pageSize = 10.
How do we mitigate the lastEvaluatedKey problem when the results are exactly as the pageSize?
We do a query of pageSize + 1 items, and if the response.length == pageSize + 1, that means that we have 1 + X extra at least items, meaning that the are more pages. Then we retrieve the lastEvaluatedKey of the pageSize item (remember that we retrieved pageSize + 1 items). If there are response.length < pageSize there is no lastEvaluatedKey to pass
Summary example: we want a page of 10 items. Then we query 11 items. Two possibilities:
We get <= 10 items, which is cool, we retrieve the items without the lastEvaluatedKey, because there are no more items xd
We get 11 items, meaning that there are more pages needed, so we retrieve the lastEvaluatedKey of the 10th item. Small downside of this is that we need to "craft" the lastEvaluatedKey of this item, as it won't correspond as the same lastEvaluatedKey that dynamoDB response gives us (remember that we are doing a 10 + 1 query so in case there is a lastEvaluatedKey it would be of the 11 item)