如何在Golang中使用BoltDB保证数据按存入顺序存储与检索？

我正在使用Golang搭配BoltDB，希望按数据存入数据库的顺序进行存储和检索。

当前存入数据的代码：

func (r *Bolt) Set(key string, value []byte) error {
    return r.Client.Update(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(r.bucket))
        return b.Put([]byte(key), value)
    })
}

获取最多10条数据的代码：

// GetAll will fetch the latest n record from Bolt, up to the limit supplied.
func (r *Bolt) GetAll(limit int) ([][]byte, error) {
    var results [][]byte

    if err := r.Client.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(r.bucket))
        if b == nil {
            return fmt.Errorf("bucket %s not found", r.bucket)
        }

        // Set the cursor to the last key in the bucket
        c := b.Cursor()
        lastKey, _ := c.Last()

        // Iterate over the data in descending order, starting from the last key
        for k, v := c.Seek(lastKey); k != nil; k, v = c.Prev() {
            results = append(results, v)

            // Return if we have collected 50 items
            if len(results) >= limit {
                break
            }
        }

        return nil
    }); err != nil {
        return nil, err
    }

    return results, nil
}

当用test1、test2、test3、test4作为键存入时，检索结果总是乱序。想知道有没有办法保证BoltDB的检索顺序？数据里包含createdAt时间字段，考虑过用它排序，但需要先取所有数据再排序，不太想这么做。

BoltDB的bucket是按键的字典序排序存储的，自定义字符串键（如test1）的字典序和插入顺序不一定一致，所以会出现乱序。以下是几种可行的解决方案：

1. 使用递增序列作为主键 #

生成严格递增的键（如自增ID、固定长度的时间戳），让BoltDB的字典序和插入顺序完全匹配：

// 存入时生成递增键
func (r *Bolt) SetWithOrder(value []byte) error {
    return r.Client.Update(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(r.bucket))
        // 获取自增ID，不存在则从0开始
        id, _ := b.NextSequence()
        // 转成固定长度字符串，避免短ID字典序异常（如10排在2前面）
        key := []byte(fmt.Sprintf("%016d", id))
        return b.Put(key, value)
    })
}

// 按插入正序取数据
func (r *Bolt) GetAllInOrder(limit int) ([][]byte, error) {
    var results [][]byte
    if err := r.Client.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(r.bucket))
        if b == nil {
            return fmt.Errorf("bucket %s not found", r.bucket)
        }
        c := b.Cursor()
        // 从第一个键开始正序遍历
        for k, v := c.First(); k != nil; k, v = c.Next() {
            results = append(results, v)
            if len(results) >= limit {
                break
            }
        }
        return nil
    }); err != nil {
        return nil, err
    }
    return results, nil
}

// 按插入倒序取最新n条数据
func (r *Bolt) GetLatestInOrder(limit int) ([][]byte, error) {
    var results [][]byte
    if err := r.Client.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(r.bucket))
        if b == nil {
            return fmt.Errorf("bucket %s not found", r.bucket)
        }
        c := b.Cursor()
        // 从最后一个键开始倒序遍历
        for k, v := c.Last(); k != nil; k, v = c.Prev() {
            results = append(results, v)
            if len(results) >= limit {
                break
            }
        }
        return nil
    }); err != nil {
        return nil, err
    }
    return results, nil
}

这种方案直接利用BoltDB的有序特性，无需额外排序，性能最优。

2. 维护独立的顺序索引bucket #

如果必须保留test1这类业务键，可以额外创建一个bucket存储插入顺序映射：

• 一个bucket存业务键到值的映射（原逻辑不变）
• 另一个bucket存递增ID到业务键的映射，记录插入顺序

存入时的代码：

func (r *Bolt) SetWithOriginalKey(key string, value []byte) error {
    return r.Client.Update(func(tx *bolt.Tx) error {
        // 业务数据bucket
        dataBucket := tx.Bucket([]byte(r.dataBucket))
        if err := dataBucket.Put([]byte(key), value); err != nil {
            return err
        }
        // 顺序索引bucket
        idxBucket := tx.Bucket([]byte(r.idxBucket))
        id, _ := idxBucket.NextSequence()
        return idxBucket.Put([]byte(fmt.Sprintf("%016d", id)), []byte(key))
    })
}

检索时先从索引bucket拿到有序的业务键，再去数据bucket取值：

func (r *Bolt) GetAllInOrder(limit int) ([][]byte, error) {
    var results [][]byte
    if err := r.Client.View(func(tx *bolt.Tx) error {
        dataBucket := tx.Bucket([]byte(r.dataBucket))
        idxBucket := tx.Bucket([]byte(r.idxBucket))
        if dataBucket == nil || idxBucket == nil {
            return fmt.Errorf("bucket not found")
        }
        c := idxBucket.Cursor()
        for k, bizKey := c.Last(); k != nil; k, bizKey = c.Prev() {
            value := dataBucket.Get(bizKey)
            if value != nil {
                results = append(results, value)
            }
            if len(results) >= limit {
                break
            }
        }
        return nil
    }); err != nil {
        return nil, err
    }
    return results, nil
}

3. 利用createdAt字段优化键结构 #

把createdAt转成纳秒级时间戳作为键的前缀（如1699999999999999999_test1），这样BoltDB的字典序就和时间顺序一致，直接遍历就能得到按插入时间排序的结果，既保留了业务键，又无需全量排序。

内容的提问来源于stack exchange，提问作者N P