Question

我有一个包含数千个数据的DynamoDb表。我正在使用扫描功能扫描表格，我已经应用了＆＃34;在＆＃34;之间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 我实际上是使用查询从数据库中检索项目。单个查询操作最多可以检索 1 MB 的数据。这就是为什么我创建了一个递归函数来从数据库中检索和连接数据，直到我们从响应中收到 LastEvaluatedKey。当我们收到 LastEvaluatedKey 作为 null 时，这意味着没有更多数据。我的函数使用索引从数据库中获取数据。使用查询功能会比扫描更快、更有效。

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

因此，getAllItemsByGSI 函数可用于从 DynamoDB 中检索所有数据，而 getItemByGSI 可用于使用单个查询。

'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,
    };

DynamoDb：扫描查询不会返回所有数据

3 个答案: