当我们将更多数据放入表中时，DynamodB查询开始花费更多时间

Question

我们有一个具有以下结构的DynamoDb表。

userId - partition key- number
yearOfBirth -attribute number
dateOfBirth - attribute(number in millisecond)
loginTime - attribute(number in millisecond)

再加上GSIuser_gsi

yearOfBirth - partition key- number
dateOfBirth - sort key (number -in millisecond)
loginTime - attribute(number in millisecond)

我们使用java aws sdk查询表。我们的查询要求是在两个出生日期和两个登录时间之间查询所有用户。我们从dateofBirth range获取所有年份，并在单独的线程中查询每个年份，然后将每个线程返回的结果连接起来。

以下代码用于查询出生年份-

public Set<Long> queryForSingleBirthYear(Long startDateDob, Long endDateDob,Long minLoginTime, Long maxLoginTime, int yearOfBirth){
        Set<Long> userIds = new HashSet<>();

        Map<String, AttributeValue> lastEvaluatedKey = null;
        do{
            QueryRequest queryRequest = new QueryRequest().withTableName("user");
            queryRequest
                    .withIndexName("user_gsi")
                    .withExclusiveStartKey(lastEvaluatedKey);

            Condition keyCond = new Condition().withComparisonOperator(ComparisonOperator.EQ)
                    .withAttributeValueList(new AttributeValue().withN(Integer.toString(yearOfBirth)));

            String startDate = startDateDob.toString();
            String endDate = endDateDob.toString();

            Condition dobCond = new Condition().withComparisonOperator(ComparisonOperator.BETWEEN)
                    .withAttributeValueList(new AttributeValue().withN(startDate), new AttributeValue().withN(endDate));

            Map<String, Condition> keyCondMap = new HashMap<>();
            keyCondMap.put("yearOfBirth", keyCond);
            keyCondMap.put("dateOfBirth", dobCond);

            queryRequest.setKeyConditions(keyCondMap);
            Map<String,String> attrNames = new HashMap<>();
            attrNames.put("#loginTime","loginTime");
            Map<String,AttributeValue> attrvalues = new HashMap<>();
            attrvalues.put(":v_minLoginTime",new AttributeValue().withN(minLoginTime.toString()));
            attrvalues.put(":v_maxLoginTime",new AttributeValue().withN(maxLoginTime.toString()));

            String queryFilter = "#loginTime > :v_minLoginTime and #loginTime <= :v_maxLoginTime";

            queryRequest.withFilterExpression(queryFilter)
                    .withExpressionAttributeNames(attrNames)
                    .withExpressionAttributeValues(attrvalues);;

            QueryResult queryResult = amazonDynamoDB.query(queryRequest);
            List<Map<String, AttributeValue>> items = queryResult.getItems();
            for (Map<String, AttributeValue> item : items) {
                String id = item.get("userId").getN();
                userIds.add(Long.valueOf(id));
            }
            lastEvaluatedKey = queryResult.getLastEvaluatedKey();
        }while (lastEvaluatedKey != null);
        return basicFilterRes;
    }

在进行负载测试时，随着我们将更多数据加载到表中，查询开始花费时间。对于20万条记录和大约25年的出生日期范围，大约需要2-3秒。如果我们将表中的记录数增加到150万条，则开始需要大约15-20秒。我们已经尝试增加RCU，甚至将RCU更改为按需模式，但时间保持不变。

编辑

以下是查询每年花费的打印时间后的结果-

yearOfBirth=1972, resultSize=110, timeMs=56
yearOfBirth=1977, resultSize=199, timeMs=54
yearOfBirth=1971, resultSize=89, timeMs=59
yearOfBirth=1973, resultSize=113, timeMs=60
yearOfBirth=1974, resultSize=143, timeMs=60
yearOfBirth=1978, resultSize=266, timeMs=59
yearOfBirth=1998, resultSize=3524, timeMs=612
yearOfBirth=1993, resultSize=3923, timeMs=677
yearOfBirth=1995, resultSize=4569, timeMs=714
yearOfBirth=1994, resultSize=4688, timeMs=777

Answer 1

loginTime范围是什么？如果它比dateOfBirth范围窄，请考虑将gsi切换为loginTime上的索引。

使用150万记录和25年查询，每个查询将不得不读取大约60,000条记录，这将需要一些时间，因为每个页面都是串行加载的。您可以通过同时查询每年的一部分来并行化每年的查询，方法是将start DateDob和endDateDob之间的范围拆分为更小的非重叠范围。例如，如果start DateDob和endDateDob涵盖一整年，则分为12个查询，每个月一个。