从DynamoDB获取多组值的最新记录：表设计与查询方案

一、表结构设计（核心适配点） #

DynamoDB是主键驱动型数据库，要高效实现"按(A,B)分组取最新日期"的需求，必须将同一(A,B)组合的记录聚合到同一个分区，并按日期排序。推荐两种方案：

方案1：直接修改原表主键

• 分区键（Partition Key）：ABComposite，值格式为{A}#{B}（例如1#2、2#3），确保同一(A,B)组的记录落在同一个分区
• 排序键（Sort Key）：Date，存储ISO8601格式的日期字符串（如2016-12-12），保证字符串排序与时间顺序一致（避免12/12/2016这类格式的排序错误）
• 保留原有属性：ID、A、B、C

方案2：保留原表，创建全局二级索引（GSI）

如果原表结构不能修改，可创建GSI适配查询：

• GSI分区键：ABComposite（同方案1）
• GSI排序键：Date（同方案1）
• 投影属性：选择需要返回的字段（如ID、A、B、C、Date）

二、查询逻辑与AWS Go SDK代码实现 #

1. 查询单个(A,B)组的最新记录

通过Query API直接定位到目标分区，倒序排序后取第一条记录（即为最新日期）：

import (
    "context"
    "fmt"
    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
    "github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
)

// 定义DynamoDB记录结构体
type DBRecord struct {
    ABComposite string `dynamodbav:"ABComposite"`
    Date        string `dynamodbav:"Date"`
    ID          string `dynamodbav:"ID"`
    A           int    `dynamodbav:"A"`
    B           int    `dynamodbav:"B"`
    C           int    `dynamodbav:"C"`
}

// 获取指定(A,B)组的最新记录
func GetLatestRecordForAB(ctx context.Context, client *dynamodb.Client, tableName string, a, b int) (*DBRecord, error) {
    abComposite := fmt.Sprintf("%d#%d", a, b)
    
    queryInput := &dynamodb.QueryInput{
        TableName:                 aws.String(tableName),
        KeyConditionExpression:    aws.String("ABComposite = :ab"),
        ExpressionAttributeValues: map[string]types.AttributeValue{
            ":ab": &types.AttributeValueMemberS{Value: abComposite},
        },
        ScanIndexForward: aws.Bool(false), // 倒序排序，最新日期排在首位
        Limit:            aws.Int32(1),    // 只取第一条
    }

    result, err := client.Query(ctx, queryInput)
    if err != nil {
        return nil, fmt.Errorf("query failed: %w", err)
    }

    if len(result.Items) == 0 {
        return nil, fmt.Errorf("no records found for A=%d, B=%d", a, b)
    }

    var record DBRecord
    if err := attributevalue.UnmarshalMap(result.Items[0], &record); err != nil {
        return nil, fmt.Errorf("unmarshal record failed: %w", err)
    }

    return &record, nil
}

2. 获取所有(A,B)组的最新记录

需要先收集所有唯一的ABComposite值，再逐个查询每组的最新记录：

// 获取所有(A,B)组的最新记录
func GetAllLatestRecords(ctx context.Context, client *dynamodb.Client, tableName string) ([]DBRecord, error) {
    // 第一步：扫描表获取所有唯一的ABComposite值（数据量大时建议分页处理）
    scanInput := &dynamodb.ScanInput{
        TableName:                aws.String(tableName),
        ProjectionExpression:     aws.String("ABComposite"),
        ConsistentRead:           aws.Bool(true),
    }

    abCompositeMap := make(map[string]bool)
    paginator := dynamodb.NewScanPaginator(client, scanInput)
    for paginator.HasMorePages() {
        page, err := paginator.NextPage(ctx)
        if err != nil {
            return nil, fmt.Errorf("scan paginate failed: %w", err)
        }

        for _, item := range page.Items {
            var abComposite string
            if err := attributevalue.Unmarshal(item["ABComposite"], &abComposite); err != nil {
                return nil, fmt.Errorf("unmarshal ABComposite failed: %w", err)
            }
            abCompositeMap[abComposite] = true
        }
    }

    // 第二步：逐个查询每组的最新记录
    var latestRecords []DBRecord
    for ab := range abCompositeMap {
        queryInput := &dynamodb.QueryInput{
            TableName:                 aws.String(tableName),
            KeyConditionExpression:    aws.String("ABComposite = :ab"),
            ExpressionAttributeValues: map[string]types.AttributeValue{
                ":ab": &types.AttributeValueMemberS{Value: ab},
            },
            ScanIndexForward: aws.Bool(false),
            Limit:            aws.Int32(1),
        }

        result, err := client.Query(ctx, queryInput)
        if err != nil {
            return nil, fmt.Errorf("query for %s failed: %w", ab, err)
        }

        if len(result.Items) > 0 {
            var record DBRecord
            if err := attributevalue.UnmarshalMap(result.Items[0], &record); err != nil {
                return nil, fmt.Errorf("unmarshal record failed: %w", err)
            }
            latestRecords = append(latestRecords, record)
        }
    }

    return latestRecords, nil
}

三、关键注意事项 #

1. 日期格式必须规范：必须使用ISO8601格式（如2016-12-12），否则字符串排序会与时间顺序不符，导致取到错误的"最新"记录。
2. 性能优化：如果需要频繁获取所有组的最新记录，建议维护一个汇总表——每次写入原表时，同步更新汇总表中对应(A,B)组的最新记录，避免多次Query操作。
3. GSI使用注意：如果使用GSI，需注意GSI的同步延迟（通常毫秒级，但极端情况可能有延迟），对实时性要求极高的场景建议直接修改原表结构。

内容的提问来源于stack exchange，提问作者Nathan Hyland