amazon-dynamodb - DynamoDb：扫描查询不返回所有数据

Question

我有一个包含数千个数据的 DynamoDb 表。我正在使用 Scan 功能扫描表格，并且应用了“Between”FilterExpression。但是，查询响应只给出 3 条记录，而它应该返回大约 100 条记录。

我已经使用 Node js 创建了 Lambda 函数。

Answer 1

另一个常见问题可能是在 LastEvaluatedKey 为空之前是否执行扫描。

如果您已经在执行此操作，但仍未获得所有项目，请显示您的代码以详细查看。

如果扫描的项目总数超过最大数据集大小限制 1 MB，则扫描停止并将结果作为 LastEvaluatedKey 值返回给用户，以在后续操作中继续扫描。结果还包括超出限制的项目数。扫描可能导致没有符合过滤条件的表数据。

如果 LastEvaluatedKey 为空，则结果的“最后一页”已被处理，没有更多数据可检索。

如果 LastEvaluatedKey 不为空，并不一定意味着结果集中有更多的数据。知道何时到达结果集末尾的唯一方法是 LastEvaluatedKey 为空。

Answer 2

这是获取所有结果的示例代码：

 Map<String, AttributeValue> lastKeyEvaluated = null;
    do {
        ScanRequest sr = new ScanRequest()
                .withTableName("tableName")
                .withProjectionExpression("id")
                .withExclusiveStartKey(lastKeyEvaluated);
        ScanResult result = client.scan(sr);
        for (Map<String, AttributeValue> item : result.getItems()) {
            System.out.println(item.get("id").getS());
        }
        lastKeyEvaluated = result.getLastEvaluatedKey();
    } while (lastKeyEvaluated != null);

Answer 3

使用 Node.js，我实际上是在使用 Query 从数据库中检索项目。单个 Query 操作最多可以检索 1 MB 的数据。这就是为什么我创建了一个递归函数来从数据库中检索和连接数据，直到我们收到LastEvaluatedKey响应。当我们收到LastEvaluatedKeyasnull时，这意味着没有更多数据。我的函数使用索引从数据库中获取数据。使用 Query 功能将比 Scan 更快、更有效地工作。

实际上，getItemByGSI函数有很多用于过滤和自定义查询的参数，这很有用。当然，您可以删除不适合您的案例的参数。

所以getAllItemsByGSI函数可用于从 DynamoDB 中检索所有数据，getItemByGSI并可用于使用单个 Query。

'use strict';
    
    const omitBy = require('lodash/omitBy');
    const isNil = require('lodash/isNil');
    const AWS = require('aws-sdk');
    
    const call = (action, params) => {
        return new Promise((resolve, reject) => {
            try {
                const dynamoDb = new AWS.DynamoDB.DocumentClient();
                resolve(dynamoDb[action](params).promise());
            } catch (error) {
                reject(error);
            }
        });
    };
    
    const getItemByGSI = ({
        TableName,
        IndexName,
        attribute,
        value,
        sortKey,
        sortValue,
        filter,
        filterValue,
        operator,
        filter1,
        filterValue1,
        LastEvaluatedKey,
        ScanIndexForward,
        Limit,
    }) => {
        return new Promise(async (resolve, reject) => {
            try {
                const params = {
                    TableName,
                    IndexName,
                    KeyConditionExpression: '#attrKey = :attrValue',
                    ExpressionAttributeValues: { ':attrValue': value },
                    ExpressionAttributeNames: { '#attrKey': attribute },
                    ExclusiveStartKey: LastEvaluatedKey,
                    Limit,
                    FilterExpression: null,
                };
                sortKey && sortValue
                    ? (params.KeyConditionExpression +=
                            ' and #sortKey = :sortValue' &&
                            (params.ExpressionAttributeNames['#sortKey'] = sortKey) &&
                            (params.ExpressionAttributeValues[':sortKey'] = sortValue))
                    : '';
                filter && filterValue
                    ? (params.FilterExpression = `#${filter} = :${filter}`) &&
                      (params.ExpressionAttributeNames[`#${filter}`] = filter) &&
                      (params.ExpressionAttributeValues[`:${filter}`] = filterValue)
                    : '';
                filter && filterValue && operator && filter1 && filterValue1
                    ? (params.FilterExpression += ` ${operator} #${filter1} = :${filter1}`) &&
                      (params.ExpressionAttributeNames[`#${filter1}`] = filter1) &&
                      (params.ExpressionAttributeValues[`:${filter1}`] = filterValue1)
                    : '';
                params = omitBy(params, isNil);
                if (ScanIndexForward === false)
                    params.ScanIndexForward = ScanIndexForward;
                const result = await call('query', params);
                resolve(result);
            } catch (error) {
                reject(error);
            }
        });
    };
    
    const getAllItemsByGSI = (data) => {
        return new Promise(async (resolve, reject) => {
            try {
                const finalData = [];
                const gettingData = await getItemByGSI(data);
                finalData = finalData.concat(gettingData.Items);
                if (gettingData.LastEvaluatedKey) {
                    const final2 = await getAllItemsByGSI({
                        ...data,
                        LastEvaluatedKey: gettingData.LastEvaluatedKey,
                    });
                    finalData = finalData.concat(final2);
                }
                resolve(finalData);
            } catch (err) {
                reject(err);
            }
        });
    };
    
    module.exports = {
        getItemByGSI,
        getAllItemsByGSI,
    };