srdb

package module
v0.0.0-...-a3cf744 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 21, 2025 License: MIT Imports: 24 Imported by: 0

README

SRDB - Simple Row Database

Go Version License

一个用 Go 编写的高性能 Append-Only 时序数据库引擎，专为高并发写入和快速查询设计。

🎯 核心特性

  • Append-Only 架构 - WAL + MemTable + mmap B+Tree SST，简化并发控制
  • 强类型 Schema - 21 种数据类型，包括 Object（map）和 Array（slice）
  • 高性能写入 - 200K+ 写/秒（多线程），<1ms 延迟（p99）
  • 快速查询 - <0.1ms（内存），1-5ms（磁盘），支持二级索引
  • 智能 Scan - 自动扫描到结构体，完整支持复杂类型
  • 链式查询 API - 18 种操作符，支持复合条件
  • 自动 Compaction - 后台异步合并，优化存储空间
  • 零拷贝读取 - mmap 访问 SST 文件，内存占用 <150MB
  • Web 管理界面 - 简单的数据浏览和监控工具

📋 目录

🚀 快速开始

安装
go get github.com/hupeh/srdb

要求：Go 1.21+

基本示例
package main

import (
    "fmt"
    "log"
    "github.com/hupeh/srdb"
)

func main() {
    // 1. 打开数据库
    db, err := srdb.Open("./data")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 2. 定义 Schema（强类型，21 种类型）
    schema, err := srdb.NewSchema("users", []srdb.Field{
        {Name: "id", Type: srdb.Uint32, Indexed: true, Comment: "用户ID"},
        {Name: "name", Type: srdb.String, Comment: "用户名"},
        {Name: "email", Type: srdb.String, Indexed: true, Comment: "邮箱"},
        {Name: "age", Type: srdb.Int32, Comment: "年龄"},
        {Name: "tags", Type: srdb.Array, Comment: "标签"},          // Array 类型
        {Name: "settings", Type: srdb.Object, Comment: "设置"},     // Object 类型
    })
    if err != nil {
        log.Fatal(err)
    }

    // 3. 创建表
    table, err := db.CreateTable("users", schema)
    if err != nil {
        log.Fatal(err)
    }

    // 4. 插入数据
    err = table.Insert(map[string]any{
        "id":    uint32(1),
        "name":  "Alice",
        "email": "alice@example.com",
        "age":   int32(25),
        "tags":  []any{"golang", "database"},
        "settings": map[string]any{
            "theme": "dark",
            "lang":  "zh-CN",
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    // 5. 查询并扫描到结构体
    type User struct {
        ID       uint32            `srdb:"field:id"`
        Name     string            `srdb:"field:name"`
        Email    string            `srdb:"field:email"`
        Age      int32             `srdb:"field:age"`
        Tags     []string          `srdb:"field:tags"`
        Settings map[string]string `srdb:"field:settings"`
    }

    var users []User
    err = table.Query().
        Eq("name", "Alice").
        Gte("age", 18).
        Scan(&users)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Found %d users\n", len(users))
    fmt.Printf("Tags: %v\n", users[0].Tags)
    fmt.Printf("Settings: %v\n", users[0].Settings)
}

💡 核心概念

架构

SRDB 使用 Append-Only 架构，分为两层：

  1. 内存层 - WAL（Write-Ahead Log）+ MemTable（Active + Immutable）
  2. 磁盘层 - SST 文件（带 B+Tree 索引），分层存储（L0-L3）
写入流程：
数据 → WAL（持久化）→ MemTable → Flush → SST L0 → Compaction → SST L1-L3

读取流程：
查询 → MemTable（O(1)）→ Immutable MemTables → SST Files（B+Tree）
数据文件
database_dir/
├── database.meta        # 数据库元数据
└── table_name/          # 每表一个目录
    ├── schema.json      # 表 Schema 定义
    ├── MANIFEST-000001  # 表级版本控制
    ├── CURRENT          # 当前 MANIFEST 指针
    ├── wal/             # WAL 子目录
    │   ├── 000001.wal   # WAL 文件
    │   └── CURRENT      # 当前 WAL 指针
    ├── sst/             # SST 子目录（L0-L3 层级文件）
    │   └── 000001.sst   # SST 文件（B+Tree + 数据）
    └── idx/             # 索引子目录
        └── idx_email.sst # 二级索引文件
设计特点
  • Append-Only - 无原地更新，简化并发控制
  • MemTable - map[int64][]byte + sorted slice，O(1) 读写
  • SST 文件 - 4KB 节点的 B+Tree，mmap 零拷贝访问
  • 二进制编码 - ROW1 格式，无压缩，优先查询性能
  • Compaction - 后台异步合并，按层级管理文件大小

📚 文档

核心文档
示例教程

🛠️ 开发

运行测试
# 所有测试
go test -v ./...

# 单个测试
go test -v -run TestTable

# 性能测试
go test -bench=. -benchmem
构建 WebUI
cd examples/webui
go build -o webui main.go
./webui serve --db ./data

🤝 贡献

欢迎提交 Issue 和 Pull Request！

开发流程
  1. Fork 项目
  2. 创建特性分支 (git checkout -b feature/amazing-feature)
  3. 提交更改 (git commit -m 'Add amazing feature')
  4. 推送到分支 (git push origin feature/amazing-feature)
  5. 提交 Pull Request
代码规范
  • 遵循 Go 官方代码风格
  • 添加必要的注释和文档
  • 编写单元测试
  • 确保所有测试通过

📝 许可证

MIT License - 详见 LICENSE 文件

🙏 致谢

📧 联系

SRDB - 简单、高效、可靠的嵌入式数据库 🚀

Documentation

Index

Constants

View Source 
const (
	BTreeNodeSize         = 4096 // 节点大小 (4 KB)
	BTreeOrder            = 200  // B+Tree 阶数 (保守估计，叶子节点每个entry 20 bytes)
	BTreeHeaderSize       = 32   // 节点头大小
	BTreeNodeTypeInternal = 0    // 内部节点
	BTreeNodeTypeLeaf     = 1    // 叶子节点
)
View Source 
const (
	IndexHeaderSize = 256        // 索引文件头大小
	IndexMagic      = 0x49445842 // "IDXB" - Index B-Tree
	IndexVersion    = 1          // 文件格式版本
)
View Source 
const (
	// 文件格式
	SSTableMagicNumber = 0x53535433 // "SST3"
	SSTableVersion     = 1
	SSTableHeaderSize  = 256       // 文件头大小
	SSTableBlockSize   = 64 * 1024 // 数据块大小 (64 KB)

	// 二进制编码格式:
	// [Magic: 4 bytes][Seq: 8 bytes][Time: 8 bytes][DataLen: 4 bytes][Data: variable]
	SSTableRowMagic = 0x524F5731 // "ROW1"
)
View Source 
const (
	DefaultMemTableSize     = 64 * 1024 * 1024 // 64 MB
	DefaultAutoFlushTimeout = 30 * time.Second // 30 秒无写入自动 flush
)
View Source 
const (
	// Entry 类型
	WALEntryTypePut    = 1
	WALEntryTypeDelete = 2 // 预留，暂不支持

	// Entry Header 大小
	WALEntryHeaderSize = 17 // CRC32(4) + Length(4) + Type(1) + Seq(8)
)
View Source 
const (
	NumLevels = 4 // L0-L3
)

Variables

View Source 
var (
	// ErrNotFound 数据未找到
	ErrNotFound = NewError(ErrCodeNotFound, nil)

	// ErrClosed 对象已关闭
	ErrClosed = NewError(ErrCodeClosed, nil)

	// ErrInvalidData 无效数据
	ErrInvalidData = NewError(ErrCodeInvalidData, nil)

	// ErrCorrupted 数据损坏
	ErrCorrupted = NewError(ErrCodeCorrupted, nil)
)

预定义的常用错误（向后兼容）

View Source 
var (
	ErrDatabaseNotFound = NewError(ErrCodeDatabaseNotFound, nil)
	ErrDatabaseExists   = NewError(ErrCodeDatabaseExists, nil)
	ErrDatabaseClosed   = NewError(ErrCodeDatabaseClosed, nil)
)

数据库错误（向后兼容）

View Source 
var (
	ErrTableNotFound = NewError(ErrCodeTableNotFound, nil)
	ErrTableExists   = NewError(ErrCodeTableExists, nil)
	ErrTableClosed   = NewError(ErrCodeTableClosed, nil)
)

表错误（向后兼容）

View Source 
var (
	ErrSchemaNotFound         = NewError(ErrCodeSchemaNotFound, nil)
	ErrSchemaInvalid          = NewError(ErrCodeSchemaInvalid, nil)
	ErrSchemaMismatch         = NewError(ErrCodeSchemaMismatch, nil)
	ErrSchemaValidationFailed = NewError(ErrCodeSchemaValidationFailed, nil)
	ErrSchemaChecksumMismatch = NewError(ErrCodeSchemaChecksumMismatch, nil)
)

Schema 错误（向后兼容）

View Source 
var (
	ErrFieldNotFound     = NewError(ErrCodeFieldNotFound, nil)
	ErrFieldTypeMismatch = NewError(ErrCodeFieldTypeMismatch, nil)
	ErrFieldRequired     = NewError(ErrCodeFieldRequired, nil)
)

字段错误（向后兼容）

View Source 
var (
	ErrIndexNotFound  = NewError(ErrCodeIndexNotFound, nil)
	ErrIndexExists    = NewError(ErrCodeIndexExists, nil)
	ErrIndexNotReady  = NewError(ErrCodeIndexNotReady, nil)
	ErrIndexCorrupted = NewError(ErrCodeIndexCorrupted, nil)
)

索引错误（向后兼容）

View Source 
var (
	ErrInvalidFormat      = NewError(ErrCodeInvalidFormat, nil)
	ErrUnsupportedVersion = NewError(ErrCodeUnsupportedVersion, nil)
	ErrInvalidMagicNumber = NewError(ErrCodeInvalidMagicNumber, nil)
	ErrChecksumMismatch   = NewError(ErrCodeChecksumMismatch, nil)
)

文件格式错误（向后兼容）

View Source 
var (
	ErrWALCorrupted = NewError(ErrCodeWALCorrupted, nil)
	ErrWALClosed    = NewError(ErrCodeWALClosed, nil)
)

WAL 错误（向后兼容）

View Source 
var (
	ErrSSTableNotFound  = NewError(ErrCodeSSTableNotFound, nil)
	ErrSSTableCorrupted = NewError(ErrCodeSSTableCorrupted, nil)
)

SSTable 错误（向后兼容）

View Source 
var (
	ErrCompactionInProgress = NewError(ErrCodeCompactionInProgress, nil)
	ErrNoCompactionNeeded   = NewError(ErrCodeNoCompactionNeeded, nil)
)

Compaction 错误（向后兼容）

View Source 
var (
	ErrEncodeFailed = NewError(ErrCodeEncodeFailed, nil)
	ErrDecodeFailed = NewError(ErrCodeDecodeFailed, nil)
)

编解码错误（向后兼容）

Functions

func IsClosed 

func IsClosed(err error) bool

IsClosed 判断是否是已关闭错误

func IsCorrupted 

func IsCorrupted(err error) bool

IsCorrupted 判断是否是数据损坏错误

func IsError 

func IsError(err error, code ErrCode) bool

IsError 判断错误是否匹配指定的错误码

func IsNotFound 

func IsNotFound(err error) bool

IsNotFound 判断是否是 NotFound 错误

func WrapError 

func WrapError(err error, format string, args ...any) error

WrapError 包装错误并添加上下文

Types

type BTreeBuilder 

type BTreeBuilder struct {
	// contains filtered or unexported fields
}

BTreeBuilder 从下往上构建 B+Tree

构建流程：

  1. Add(): 添加所有 (key, offset, size) 到叶子节点 - 当叶子节点满时，创建新的叶子节点 - 所有叶子节点按 key 有序

  2. Build(): 从叶子层向上构建 - Level 0: 叶子节点（已创建） - Level 1: 为叶子节点创建父节点（内部节点） - Level 2+: 递归创建更高层级 - 最终返回根节点偏移量

示例（100 个 key，Order=200）：

  • 叶子层: 1 个叶子节点（100 个 key）
  • 根节点: 叶子节点本身

示例（500 个 key，Order=200）：

  • 叶子层: 3 个叶子节点（200, 200, 100 个 key）
  • Level 1: 1 个内部节点（3 个子节点）
  • 根节点: Level 1 的内部节点

func NewBTreeBuilder 

func NewBTreeBuilder(file *os.File, startOffset int64) *BTreeBuilder

NewBTreeBuilder 创建构建器

func (*BTreeBuilder) Add 

func (b *BTreeBuilder) Add(key int64, dataOffset int64, dataSize int32) error

Add 添加一个 key-value 对 (数据必须已排序)

func (*BTreeBuilder) Build 

func (b *BTreeBuilder) Build() (rootOffset int64, err error)

Build 构建完整的 B+Tree，返回根节点的 offset

type BTreeNode 

type BTreeNode struct {
	// Header (32 bytes)
	NodeType byte     // 0=Internal, 1=Leaf
	KeyCount uint16   // key 数量
	Level    byte     // 层级 (0=叶子层)
	Reserved [28]byte // 预留字段

	// Keys (variable, 最多 256 个)
	Keys []int64 // key 数组

	// Values (variable)
	// Internal Node: 子节点指针
	Children []int64 // 子节点的文件 offset

	// Leaf Node: 数据位置
	DataOffsets []int64 // 数据块的文件 offset
	DataSizes   []int32 // 数据块大小
}

BTreeNode 表示一个 B+Tree 节点 (4 KB)

func NewInternalNode 

func NewInternalNode(level byte) *BTreeNode

NewInternalNode 创建内部节点

func NewLeafNode 

func NewLeafNode() *BTreeNode

NewLeafNode 创建叶子节点

func UnmarshalBTree 

func UnmarshalBTree(data []byte) *BTreeNode

UnmarshalBTree 从字节数组反序列化节点

参数： 

data: 4KB 节点数据（通常来自 mmap）

返回： 

*BTreeNode: 反序列化后的节点

零拷贝优化：

  • 直接从 mmap 数据读取，不复制整个节点
  • 只复制必要的字段（Keys, Children, DataOffsets, DataSizes）

func (*BTreeNode) AddChild 

func (n *BTreeNode) AddChild(offset int64) error

AddChild 添加子节点 (仅用于内部节点)

func (*BTreeNode) AddData 

func (n *BTreeNode) AddData(key int64, offset int64, size int32) error

AddData 添加数据位置 (仅用于叶子节点)

func (*BTreeNode) AddKey 

func (n *BTreeNode) AddKey(key int64)

AddKey 添加 key (仅用于构建)

func (*BTreeNode) IsFull 

func (n *BTreeNode) IsFull() bool

IsFull 检查节点是否已满

func (*BTreeNode) Marshal 

func (n *BTreeNode) Marshal() []byte

Marshal 序列化节点到 4 KB

布局： 

[Header: 32B]
[Keys: KeyCount * 8B]
[Values: 取决于节点类型]
  - Internal: Children (KeyCount+1) * 8B
  - Leaf: 交错存储 (Offset, Size) 对，每对 12B，共 KeyCount * 12B

示例（叶子节点，KeyCount=3）： 

Offset | Size | Content
-------|------|----------------------------------
0      | 1    | NodeType = 1 (Leaf)
1      | 2    | KeyCount = 3
3      | 1    | Level = 0
4      | 28   | Reserved
32     | 24   | Keys [100, 200, 300]
56     | 8    | DataOffset0 = 1000
64     | 4    | DataSize0 = 50
68     | 8    | DataOffset1 = 2000
76     | 4    | DataSize1 = 60
80     | 8    | DataOffset2 = 3000
88     | 4    | DataSize2 = 70
92     | 4004 | Padding (unused)

type BTreeReader 

type BTreeReader struct {
	// contains filtered or unexported fields
}

BTreeReader 用于查询 B+Tree (mmap)

查询流程：

  1. 从根节点开始
  2. 如果是内部节点： - 二分查找确定子节点 - 跳转到子节点继续查找
  3. 如果是叶子节点： - 二分查找 key - 返回 (dataOffset, dataSize)

性能优化：

  • mmap 零拷贝：直接从内存映射读取节点
  • 二分查找：O(log KeyCount) 在节点内查找
  • 总复杂度：O(log n) = O(height * log Order)

示例（100万条数据，Order=200）：

  • 高度: log₂₀₀(1000000) ≈ 3
  • 查询次数: 3 次节点读取 + 3 次二分查找

func NewBTreeReader 

func NewBTreeReader(mmap mmap.MMap, rootOffset int64) *BTreeReader

NewBTreeReader 创建查询器

func (*BTreeReader) ForEach 

func (r *BTreeReader) ForEach(callback KeyCallback)

ForEach 升序迭代所有 key（支持提前终止）

使用场景：

  • 需要遍历数据但不想一次性加载所有 keys（节省内存）
  • 支持条件过滤，找到目标后提前终止
  • 支持外部自定义处理逻辑

示例： 

// 找到第一个 > 100 的 key
reader.ForEach(func(key int64, offset int64, size int32) bool {
    if key > 100 {
        fmt.Printf("Found: %d\n", key)
        return false // 停止迭代
    }
    return true // 继续
})

func (*BTreeReader) ForEachDesc 

func (r *BTreeReader) ForEachDesc(callback KeyCallback)

ForEachDesc 降序迭代所有 key（支持提前终止）

使用场景：

  • 从最新数据开始遍历（时序数据库常见需求）
  • 查找最近的 N 条记录
  • 支持条件过滤和提前终止

示例： 

// 获取最新的 10 条记录
count := 0
reader.ForEachDesc(func(key int64, offset int64, size int32) bool {
    fmt.Printf("Key: %d\n", key)
    count++
    return count < 10 // 找到 10 条后停止
})

func (*BTreeReader) Get 

func (r *BTreeReader) Get(key int64) (dataOffset int64, dataSize int32, found bool)

Get 查询 key，返回数据位置

参数： 

key: 要查询的 key

返回： 

dataOffset: 数据块的文件偏移量
dataSize: 数据块的大小
found: 是否找到

查询流程：

  1. 从根节点开始遍历
  2. 内部节点：二分查找确定子节点，跳转
  3. 叶子节点：二分查找 key，返回数据位置

func (*BTreeReader) GetAllKeys 

func (r *BTreeReader) GetAllKeys() []int64

GetAllKeys 获取 B+Tree 中所有的 key（按升序）

func (*BTreeReader) GetAllKeysDesc 

func (r *BTreeReader) GetAllKeysDesc() []int64

GetAllKeysDesc 获取 B+Tree 中所有的 key（按降序）

性能优化：

  • 从右到左遍历叶子节点
  • 每个叶子节点内从后往前读取 keys
  • 避免额外的排序操作

type CompactionManager 

type CompactionManager struct {
	// contains filtered or unexported fields
}

CompactionManager 管理 Compaction 流程

func NewCompactionManager 

func NewCompactionManager(sstDir string, versionSet *VersionSet, sstManager *SSTableManager) *CompactionManager

NewCompactionManager 创建新的 Compaction Manager（使用默认配置）

func (*CompactionManager) ApplyConfig 

func (m *CompactionManager) ApplyConfig(opts *Options)

ApplyConfig 应用数据库级配置（从 Database Options）

func (*CompactionManager) CleanupOrphanFiles 

func (m *CompactionManager) CleanupOrphanFiles()

CleanupOrphanFiles 手动触发孤儿文件清理（可在启动时调用）

func (*CompactionManager) DoCompaction 

func (m *CompactionManager) DoCompaction(task *CompactionTask) error

DoCompaction 执行一次 Compaction（兼容旧接口）

func (*CompactionManager) DoCompactionWithVersion 

func (m *CompactionManager) DoCompactionWithVersion(task *CompactionTask, version *Version) error

DoCompactionWithVersion 使用指定的版本执行 Compaction

func (*CompactionManager) GetLevelSizeLimit 

func (m *CompactionManager) GetLevelSizeLimit(level int) int64

GetLevelSizeLimit 获取指定层级的大小限制（公开方法，供 WebUI 等外部使用） 注意：Options 是不可变的，配置在 ApplyConfig 后不会改变，因此不需要加锁

func (*CompactionManager) GetLevelStats 

func (m *CompactionManager) GetLevelStats() []LevelStats

GetLevelStats 获取每层的统计信息

func (*CompactionManager) GetPicker 

func (m *CompactionManager) GetPicker() *Picker

GetPicker 获取 Compaction Picker

func (*CompactionManager) GetStats 

func (m *CompactionManager) GetStats() *CompactionStats

GetStats 获取 Compaction 统计信息

func (*CompactionManager) MaybeCompact 

func (m *CompactionManager) MaybeCompact()

MaybeCompact 检查是否需要 Compaction 并执行（公开方法，供外部调用） 非阻塞：如果已有 compaction 在执行，直接返回

func (*CompactionManager) SetSchema 

func (m *CompactionManager) SetSchema(schema *Schema)

SetSchema 设置 Schema（用于优化 SST 文件读写）

func (*CompactionManager) Start 

func (m *CompactionManager) Start()

Start 启动后台 Compaction 和垃圾回收

func (*CompactionManager) Stop 

func (m *CompactionManager) Stop()

Stop 停止后台 Compaction

func (*CompactionManager) TriggerCompaction 

func (m *CompactionManager) TriggerCompaction() error

TriggerCompaction 手动触发一次 Compaction（遍历所有阶段）

type CompactionStats 

type CompactionStats struct {
	TotalCompactions   int64     `json:"total_compactions"`    // 总 compaction 次数
	LastCompactionTime time.Time `json:"last_compaction_time"` // 最后一次 compaction 时间
}

CompactionStats Compaction 统计信息

type CompactionTask 

type CompactionTask struct {
	Level       int             // 源层级
	InputFiles  []*FileMetadata // 需要合并的输入文件
	OutputLevel int             // 输出层级
}

CompactionTask 表示一个 Compaction 任务

type Compactor 

type Compactor struct {
	// contains filtered or unexported fields
}

Compactor 负责执行 Compaction

func NewCompactor 

func NewCompactor(sstDir string, versionSet *VersionSet) *Compactor

NewCompactor 创建新的 Compactor

func (*Compactor) DoCompaction 

func (c *Compactor) DoCompaction(task *CompactionTask, version *Version) (*VersionEdit, error)

DoCompaction 执行一次 Compaction 返回: VersionEdit (记录变更), error

func (*Compactor) GetPicker 

func (c *Compactor) GetPicker() *Picker

GetPicker 获取 Picker

func (*Compactor) SetLogger 

func (c *Compactor) SetLogger(logger *slog.Logger)

SetLogger 设置 Logger

func (*Compactor) SetSchema 

func (c *Compactor) SetSchema(schema *Schema)

SetSchema 设置 Schema（用于读取 SST 文件）

type Database 

type Database struct {
	// contains filtered or unexported fields
}

Database 数据库，管理多个表

func Open 

func Open(dir string) (*Database, error)

Open 打开数据库（向后兼容，使用默认配置）

func OpenWithOptions 

func OpenWithOptions(opts *Options) (*Database, error)

OpenWithOptions 使用指定配置打开数据库

func (*Database) Clean 

func (db *Database) Clean() error

Clean 清除所有表的数据（保留表结构和 Database 可用）

func (*Database) CleanTable 

func (db *Database) CleanTable(name string) error

CleanTable 清除指定表的数据（保留表结构）

func (*Database) Close 

func (db *Database) Close() error

Close 关闭数据库

func (*Database) CreateTable 

func (db *Database) CreateTable(name string, schema *Schema) (*Table, error)

CreateTable 创建表

func (*Database) Destroy 

func (db *Database) Destroy() error

Destroy 销毁整个数据库并删除所有数据文件

func (*Database) DestroyTable 

func (db *Database) DestroyTable(name string) error

DestroyTable 销毁指定表并从 Database 中删除

func (*Database) DropTable 

func (db *Database) DropTable(name string) error

DropTable 删除表

func (*Database) GetAllTablesInfo 

func (db *Database) GetAllTablesInfo() map[string]*Table

GetAllTablesInfo 获取所有表的信息（用于 WebUI）

func (*Database) GetTable 

func (db *Database) GetTable(name string) (*Table, error)

GetTable 获取表

func (*Database) ListTables 

func (db *Database) ListTables() []string

ListTables 列出所有表

type EditType 

type EditType byte

EditType 变更类型 

const (
	EditTypeAddFile     EditType = 1 // 添加文件
	EditTypeDeleteFile  EditType = 2 // 删除文件
	EditTypeSetNextFile EditType = 3 // 设置下一个文件编号
	EditTypeSetLastSeq  EditType = 4 // 设置最后序列号
)

type ErrCode 

type ErrCode int

ErrCode 错误码类型 

const (
	// 通用错误 (1000-1999)
	ErrCodeNotFound     ErrCode = 1000 // 数据未找到
	ErrCodeClosed       ErrCode = 1001 // 对象已关闭
	ErrCodeInvalidData  ErrCode = 1002 // 无效数据
	ErrCodeCorrupted    ErrCode = 1003 // 数据损坏
	ErrCodeExists       ErrCode = 1004 // 对象已存在
	ErrCodeInvalidParam ErrCode = 1005 // 无效参数

	// 数据库错误 (2000-2999)
	ErrCodeDatabaseNotFound ErrCode = 2000 // 数据库不存在
	ErrCodeDatabaseExists   ErrCode = 2001 // 数据库已存在
	ErrCodeDatabaseClosed   ErrCode = 2002 // 数据库已关闭

	// 表错误 (3000-3999)
	ErrCodeTableNotFound ErrCode = 3000 // 表不存在
	ErrCodeTableExists   ErrCode = 3001 // 表已存在
	ErrCodeTableClosed   ErrCode = 3002 // 表已关闭

	// Schema 错误 (4000-4999)
	ErrCodeSchemaNotFound         ErrCode = 4000 // Schema 不存在
	ErrCodeSchemaInvalid          ErrCode = 4001 // Schema 无效
	ErrCodeSchemaMismatch         ErrCode = 4002 // Schema 不匹配
	ErrCodeSchemaValidationFailed ErrCode = 4003 // Schema 验证失败
	ErrCodeSchemaChecksumMismatch ErrCode = 4004 // Schema 校验和不匹配

	// 字段错误 (5000-5999)
	ErrCodeFieldNotFound     ErrCode = 5000 // 字段不存在
	ErrCodeFieldTypeMismatch ErrCode = 5001 // 字段类型不匹配
	ErrCodeFieldRequired     ErrCode = 5002 // 必填字段缺失

	// 索引错误 (6000-6999)
	ErrCodeIndexNotFound  ErrCode = 6000 // 索引不存在
	ErrCodeIndexExists    ErrCode = 6001 // 索引已存在
	ErrCodeIndexNotReady  ErrCode = 6002 // 索引未就绪
	ErrCodeIndexCorrupted ErrCode = 6003 // 索引损坏

	// 文件格式错误 (7000-7999)
	ErrCodeInvalidFormat      ErrCode = 7000 // 无效的文件格式
	ErrCodeUnsupportedVersion ErrCode = 7001 // 不支持的版本
	ErrCodeInvalidMagicNumber ErrCode = 7002 // 无效的魔数
	ErrCodeChecksumMismatch   ErrCode = 7003 // 校验和不匹配

	// WAL 错误 (8000-8999)
	ErrCodeWALCorrupted ErrCode = 8000 // WAL 文件损坏
	ErrCodeWALClosed    ErrCode = 8001 // WAL 已关闭

	// SSTable 错误 (9000-9999)
	ErrCodeSSTableNotFound  ErrCode = 9000 // SSTable 文件不存在
	ErrCodeSSTableCorrupted ErrCode = 9001 // SSTable 文件损坏

	// Compaction 错误 (10000-10999)
	ErrCodeCompactionInProgress ErrCode = 10000 // Compaction 正在进行
	ErrCodeNoCompactionNeeded   ErrCode = 10001 // 不需要 Compaction

	// 编解码错误 (11000-11999)
	ErrCodeEncodeFailed ErrCode = 11000 // 编码失败
	ErrCodeDecodeFailed ErrCode = 11001 // 解码失败
)

错误码定义

func GetErrorCode 

func GetErrorCode(err error) ErrCode

GetErrorCode 获取错误码

type Error 

type Error struct {
	Code    ErrCode // 错误码
	Message string  // 错误消息
	Cause   error   // 原始错误
}

Error 错误类型

func NewError 

func NewError(code ErrCode, cause error) *Error

NewError 创建新错误

func NewErrorf 

func NewErrorf(code ErrCode, format string, args ...any) *Error

NewErrorf 创建带格式化消息的错误 注意：如果 args 中最后一个参数是 error 类型，它会被设置为 Cause

func (*Error) Error 

func (e *Error) Error() string

Error 实现 error 接口

func (*Error) Is 

func (e *Error) Is(target error) bool

Is 判断错误码是否相同

func (*Error) Unwrap 

func (e *Error) Unwrap() error

Unwrap 支持 errors.Is 和 errors.As

type Expr 

type Expr interface {
	Match(fs Fieldset) bool
}

func And 

func And(exprs ...Expr) Expr

func Between 

func Between(field string, min, max any) Expr

func Contains 

func Contains(field string, pattern string) Expr

func EndsWith 

func EndsWith(field string, suffix string) Expr

func Eq 

func Eq(field string, value any) Expr

func Gt 

func Gt(field string, value any) Expr

func Gte 

func Gte(field string, value any) Expr

func In 

func In(field string, values []any) Expr

func IsNull 

func IsNull(field string) Expr

func Lt 

func Lt(field string, value any) Expr

func Lte 

func Lte(field string, value any) Expr

func Not 

func Not(expr Expr) Expr

func NotBetween 

func NotBetween(field string, min, max any) Expr

func NotContains 

func NotContains(field string, pattern string) Expr

func NotEndsWith 

func NotEndsWith(field string, suffix string) Expr

func NotEq 

func NotEq(field string, value any) Expr

func NotIn 

func NotIn(field string, values []any) Expr

func NotNull 

func NotNull(field string) Expr

func NotStartsWith 

func NotStartsWith(field string, prefix string) Expr

func Or 

func Or(exprs ...Expr) Expr

func StartsWith 

func StartsWith(field string, prefix string) Expr

type Field 

type Field struct {
	Name     string    // 字段名
	Type     FieldType // 字段类型
	Indexed  bool      // 是否建立索引
	Nullable bool      // 是否允许 NULL 值
	Comment  string    // 注释
}

Field 字段定义

func StructToFields 

func StructToFields(v any) ([]Field, error)

StructToFields 从 Go 结构体生成 Field 列表

支持的 struct tag 格式：

  • `srdb:"name"` - 指定字段名（默认使用 snake_case 转换）
  • `srdb:"name;indexed"` - 指定字段名并标记为索引
  • `srdb:"name;nullable"` - 指定字段名并标记为可空
  • `srdb:"name;indexed;nullable;comment:用户名"` - 完整格式
  • `srdb:"-"` - 忽略该字段

Tag 格式说明：

  • 使用分号 `;` 分隔不同的部分
  • 第一部分是字段名（可选，默认使用 snake_case 转换结构体字段名）
  • `indexed` 标记该字段需要索引
  • `nullable` 标记该字段允许 NULL 值
  • `comment:注释内容` 指定字段注释

默认字段名转换示例：

  • UserName -> user_name
  • EmailAddress -> email_address
  • IsActive -> is_active

类型映射（精确映射到 Go 基础类型）：

  • int -> FieldTypeInt
  • int8 -> Int8
  • int16 -> Int16
  • int32 -> Int32
  • int64 -> Int64
  • uint -> Uint
  • uint8 (byte) -> Uint8 或 Byte
  • uint16 -> Uint16
  • uint32 -> Uint32
  • uint64 -> Uint64
  • float32 -> Float32
  • float64 -> Float64
  • string -> String
  • bool -> Bool
  • rune -> Rune
  • decimal.Decimal -> Decimal

示例： 

type User struct {
    Name  string  `srdb:"field:name;indexed;comment:用户名"`
    Age   int64   `srdb:"field:age;comment:年龄"`
    Email *string `srdb:"field:email;nullable;comment:邮箱（可选）"`
}
fields, err := StructToFields(User{})

参数：

  • v: 结构体实例或指针

返回：

  • []Field: 字段列表
  • error: 错误信息

type FieldType 

type FieldType int

FieldType 字段类型（对应 Go 基础类型） 

const (

	// 有符号整数类型
	Int FieldType
	Int8
	Int16
	Int32
	Int64

	// 无符号整数类型
	Uint
	Uint8
	Uint16
	Uint32
	Uint64

	// 浮点类型
	Float32
	Float64

	// 字符串类型
	String

	// 布尔类型
	Bool

	// Byte 和 Rune 类型（独立类型，语义上对应 Go 的 byte 和 rune）
	Byte // byte 类型（底层为 uint8）
	Rune // rune 类型（底层为 int32）

	// Decimal 类型（高精度十进制，用于金融计算）
	Decimal

	// 时间类型
	Time     // time.Time 时间戳
	Duration // time.Duration 时间间隔

	// 复杂类型
	Object // map[string]xxx、struct{}、*struct{}
	Array  // 切片类型 []xxx
)

func (FieldType) String 

func (t FieldType) String() string

type Fieldset 

type Fieldset interface {
	Get(key string) (field Field, value any, err error)
}

type FileMetadata 

type FileMetadata struct {
	FileNumber int64 // 文件编号
	Level      int   // 所在层级 (0-3)
	FileSize   int64 // 文件大小
	MinKey     int64 // 最小 key
	MaxKey     int64 // 最大 key
	RowCount   int64 // 行数
}

FileMetadata SST 文件元数据

type ImmutableMemTable 

type ImmutableMemTable struct {
	*MemTable
	WALNumber int64 // 对应的 WAL 编号
}

ImmutableMemTable 不可变的 MemTable

type IndexBTreeReader 

type IndexBTreeReader struct {
	// contains filtered or unexported fields
}

IndexBTreeReader 使用 B+Tree 读取索引

读取流程：

  1. mmap 映射整个文件（零拷贝）
  2. 读取 Header
  3. 创建 BTreeReader (指向 RootOffset)
  4. Get(value): a. value → key (MD5 哈希) b. BTree.Get(key) → (offset, size) c. 读取 mmap[offset:offset+size]（零拷贝） d. 解码并验证原始 value e. 返回 seqs

性能优化：

  • mmap 零拷贝：不需要加载整个文件到内存
  • B+Tree 索引：O(log n) 查询
  • 按需读取：只读取需要的数据块

func NewIndexBTreeReader 

func NewIndexBTreeReader(file *os.File) (*IndexBTreeReader, error)

NewIndexBTreeReader 创建索引读取器

func (*IndexBTreeReader) Close 

func (r *IndexBTreeReader) Close() error

Close 关闭读取器 注意：不关闭 file，因为它是从外部传入的，应该由调用者关闭

func (*IndexBTreeReader) ForEach 

func (r *IndexBTreeReader) ForEach(callback IndexEntryCallback)

ForEach 升序迭代所有索引条目 callback 返回 false 时停止迭代，支持提前终止

func (*IndexBTreeReader) ForEachDesc 

func (r *IndexBTreeReader) ForEachDesc(callback IndexEntryCallback)

ForEachDesc 降序迭代所有索引条目 callback 返回 false 时停止迭代，支持提前终止

func (*IndexBTreeReader) Get 

func (r *IndexBTreeReader) Get(value string) ([]int64, error)

Get 查询字段值对应的 seq 列表（零拷贝）

参数： 

value: 字段值（例如 "Alice"）

返回： 

seqs: seq 列表（例如 [1, 5, 10]）
err: 查询错误

查询流程：

  1. value → key (MD5 哈希)
  2. B+Tree.Get(key) → (offset, size)
  3. 读取 mmap[offset:offset+size]（零拷贝）
  4. 解码并验证原始 value（处理哈希冲突）
  5. 返回 seqs

哈希冲突处理：

  • 如果 storedValue != value，说明发生哈希冲突
  • 返回 nil（表示未找到）
  • 冲突概率极低（MD5 64位空间）

func (*IndexBTreeReader) GetMetadata 

func (r *IndexBTreeReader) GetMetadata() IndexMetadata

GetMetadata 获取元数据

type IndexBTreeWriter 

type IndexBTreeWriter struct {
	// contains filtered or unexported fields
}

IndexBTreeWriter 使用 B+Tree 写入索引

写入流程：

  1. Add(): 收集所有 (value, seqs) 到内存
  2. Build(): a. 计算所有 value 的 key (MD5 哈希) b. 按 key 排序（B+Tree 要求有序） c. 编码所有条目为二进制格式 d. 构建 B+Tree 索引 e. 写入 Header + B+Tree + 数据块

文件布局： 

[Header] → [B+Tree] → [Data Blocks]

func NewIndexBTreeWriter 

func NewIndexBTreeWriter(file *os.File, metadata IndexMetadata) *IndexBTreeWriter

NewIndexBTreeWriter 创建索引写入器

func (*IndexBTreeWriter) Add 

func (w *IndexBTreeWriter) Add(value string, seqs []int64)

Add 添加索引条目

func (*IndexBTreeWriter) Build 

func (w *IndexBTreeWriter) Build() error

Build 构建并写入索引文件

type IndexEntryCallback 

type IndexEntryCallback func(value string, seqs []int64) bool

IndexEntryCallback 索引条目回调函数 参数：value 字段值，seqs 对应的 seq 列表 返回：true 继续迭代，false 停止迭代

type IndexHeader 

type IndexHeader struct {
	Magic         uint32    // 魔数 "IDXB"
	FormatVersion uint32    // 文件格式版本号
	IndexVersion  int64     // 索引版本号（对应 IndexMetadata.Version）
	RootOffset    int64     // B+Tree 根节点偏移
	DataStart     int64     // 数据块起始位置
	MinSeq        int64     // 最小 seq
	MaxSeq        int64     // 最大 seq
	RowCount      int64     // 总行数
	CreatedAt     int64     // 创建时间
	UpdatedAt     int64     // 更新时间
	Reserved      [184]byte // 预留空间（减少 8 字节给 IndexVersion，减少 8 字节调整对齐）
}

IndexHeader 索引文件头

func UnmarshalIndexHeader 

func UnmarshalIndexHeader(data []byte) *IndexHeader

UnmarshalIndexHeader 反序列化 Header

func (*IndexHeader) Marshal 

func (h *IndexHeader) Marshal() []byte

Marshal 序列化 Header

type IndexManager 

type IndexManager struct {
	// contains filtered or unexported fields
}

IndexManager 索引管理器

func NewIndexManager 

func NewIndexManager(dir string, schema *Schema) *IndexManager

NewIndexManager 创建索引管理器

func (*IndexManager) AddToIndexes 

func (m *IndexManager) AddToIndexes(data map[string]any, seq int64) error

AddToIndexes 添加到所有索引

func (*IndexManager) BuildAll 

func (m *IndexManager) BuildAll() error

BuildAll 构建所有索引

func (*IndexManager) Close 

func (m *IndexManager) Close() error

Close 关闭所有索引

func (*IndexManager) CreateIndex 

func (m *IndexManager) CreateIndex(field string) error

CreateIndex 创建索引

func (*IndexManager) DropIndex 

func (m *IndexManager) DropIndex(field string) error

DropIndex 删除索引

func (*IndexManager) GetIndex 

func (m *IndexManager) GetIndex(field string) (*SecondaryIndex, bool)

GetIndex 获取索引

func (*IndexManager) GetIndexMetadata 

func (m *IndexManager) GetIndexMetadata() map[string]IndexMetadata

GetIndexMetadata 获取所有索引的元数据

func (*IndexManager) ListIndexes 

func (m *IndexManager) ListIndexes() []string

ListIndexes 列出所有索引

func (*IndexManager) VerifyAndRepair 

func (m *IndexManager) VerifyAndRepair(currentMaxSeq int64, getData func(int64) (map[string]any, error)) error

VerifyAndRepair 验证并修复所有索引

type IndexMetadata 

type IndexMetadata struct {
	Version   int64 // 索引版本号
	MaxSeq    int64 // 索引包含的最大 seq
	MinSeq    int64 // 索引包含的最小 seq
	RowCount  int64 // 索引包含的行数
	CreatedAt int64 // 创建时间
	UpdatedAt int64 // 更新时间
}

IndexMetadata 索引元数据

type KeyCallback 

type KeyCallback func(key int64, dataOffset int64, dataSize int32) bool

KeyCallback 迭代回调函数

参数：

  • key: 当前的 key（序列号）
  • dataOffset: 数据块的文件偏移量
  • dataSize: 数据块的大小

返回：

  • true: 继续迭代
  • false: 停止迭代

type LevelStats 

type LevelStats struct {
	Level     int     `json:"level"`      // 层级编号 (0-3)
	FileCount int     `json:"file_count"` // 文件数量
	TotalSize int64   `json:"total_size"` // 总大小（字节）
	Score     float64 `json:"score"`      // Compaction 得分
}

LevelStats 层级统计信息

type ManifestReader 

type ManifestReader struct {
	// contains filtered or unexported fields
}

ManifestReader MANIFEST 读取器

func NewManifestReader 

func NewManifestReader(file io.Reader) *ManifestReader

NewManifestReader 创建 MANIFEST 读取器

func (*ManifestReader) ReadEdit 

func (r *ManifestReader) ReadEdit() (*VersionEdit, error)

ReadEdit 读取版本变更

type ManifestWriter 

type ManifestWriter struct {
	// contains filtered or unexported fields
}

ManifestWriter MANIFEST 写入器

func NewManifestWriter 

func NewManifestWriter(file io.Writer) *ManifestWriter

NewManifestWriter 创建 MANIFEST 写入器

func (*ManifestWriter) WriteEdit 

func (w *ManifestWriter) WriteEdit(edit *VersionEdit) error

WriteEdit 写入版本变更

type MemTable 

type MemTable struct {
	// contains filtered or unexported fields
}

MemTable 内存表

func NewMemTable 

func NewMemTable() *MemTable

NewMemTable 创建 MemTable

func (*MemTable) Clear 

func (m *MemTable) Clear()

Clear 清空 MemTable

func (*MemTable) Count 

func (m *MemTable) Count() int

Count 获取条目数量

func (*MemTable) Get 

func (m *MemTable) Get(key int64) ([]byte, bool)

Get 查询数据

func (*MemTable) Keys 

func (m *MemTable) Keys() []int64

Keys 获取所有 keys 的副本（已排序）

func (*MemTable) NewIterator 

func (m *MemTable) NewIterator() *MemTableIterator

NewIterator 创建迭代器

func (*MemTable) Put 

func (m *MemTable) Put(key int64, value []byte)

Put 插入数据

func (*MemTable) Size 

func (m *MemTable) Size() int64

Size 获取大小

type MemTableIterator 

type MemTableIterator struct {
	// contains filtered or unexported fields
}

MemTableIterator 迭代器

func (*MemTableIterator) Key 

func (it *MemTableIterator) Key() int64

Key 当前 key

func (*MemTableIterator) Next 

func (it *MemTableIterator) Next() bool

Next 移动到下一个

func (*MemTableIterator) Reset 

func (it *MemTableIterator) Reset()

Reset 重置迭代器

func (*MemTableIterator) Value 

func (it *MemTableIterator) Value() []byte

Value 当前 value

type MemTableManager 

type MemTableManager struct {
	// contains filtered or unexported fields
}

MemTableManager MemTable 管理器

func NewMemTableManager 

func NewMemTableManager(maxSize int64) *MemTableManager

NewMemTableManager 创建 MemTable 管理器

func (*MemTableManager) Clear 

func (m *MemTableManager) Clear()

Clear 清空所有 MemTables（用于测试）

func (*MemTableManager) Get 

func (m *MemTableManager) Get(key int64) ([]byte, bool)

Get 查询数据（先查 Active，再查 Immutables）

func (*MemTableManager) GetActive 

func (m *MemTableManager) GetActive() *MemTable

GetActive 获取 Active MemTable（用于 Flush 时读取）

func (*MemTableManager) GetActiveCount 

func (m *MemTableManager) GetActiveCount() int

GetActiveCount 获取 Active MemTable 条目数

func (*MemTableManager) GetActiveSize 

func (m *MemTableManager) GetActiveSize() int64

GetActiveSize 获取 Active MemTable 大小

func (*MemTableManager) GetImmutableCount 

func (m *MemTableManager) GetImmutableCount() int

GetImmutableCount 获取 Immutable MemTable 数量

func (*MemTableManager) GetImmutables 

func (m *MemTableManager) GetImmutables() []*ImmutableMemTable

GetImmutables 获取所有 Immutable MemTables（副本）

func (*MemTableManager) GetStats 

func (m *MemTableManager) GetStats() *MemTableStats

GetStats 获取统计信息

func (*MemTableManager) NewIterator 

func (m *MemTableManager) NewIterator() *MemTableIterator

NewIterator 创建 Active MemTable 的迭代器

func (*MemTableManager) Put 

func (m *MemTableManager) Put(key int64, value []byte)

Put 写入数据到 Active MemTable

func (*MemTableManager) RemoveImmutable 

func (m *MemTableManager) RemoveImmutable(target *ImmutableMemTable)

RemoveImmutable 移除指定的 Immutable MemTable

func (*MemTableManager) SetActiveWAL 

func (m *MemTableManager) SetActiveWAL(walNumber int64)

SetActiveWAL 设置 Active MemTable 对应的 WAL 编号

func (*MemTableManager) ShouldSwitch 

func (m *MemTableManager) ShouldSwitch() bool

ShouldSwitch 检查是否需要切换 MemTable

func (*MemTableManager) Switch 

func (m *MemTableManager) Switch(newWALNumber int64) (oldWALNumber int64, immutable *ImmutableMemTable)

Switch 切换 MemTable（Active → Immutable，创建新 Active） 返回：旧的 WAL 编号，新的 Active MemTable

func (*MemTableManager) TotalCount 

func (m *MemTableManager) TotalCount() int

TotalCount 获取总条目数（Active + Immutables）

func (*MemTableManager) TotalSize 

func (m *MemTableManager) TotalSize() int64

TotalSize 获取总大小（Active + Immutables）

type MemTableStats 

type MemTableStats struct {
	ActiveSize      int64
	ActiveCount     int
	ImmutableCount  int
	ImmutablesSize  int64
	ImmutablesTotal int
	TotalSize       int64
	TotalCount      int
}

MemTableStats 统计信息

type Metadata 

type Metadata struct {
	Version int         `json:"version"`
	Tables  []TableInfo `json:"tables"`
}

Metadata 数据库元数据

type Neginative 

type Neginative struct {
	// contains filtered or unexported fields
}

func (Neginative) Match 

func (n Neginative) Match(fs Fieldset) bool

type Options 

type Options struct {
	// ========== 基础配置 ==========
	Dir    string       // 数据库目录（必需）
	Logger *slog.Logger // 日志器（可选，nil 表示不输出日志）

	// ========== MemTable 配置 ==========
	MemTableSize     int64         // MemTable 大小限制（字节），默认 64MB
	AutoFlushTimeout time.Duration // 自动 flush 超时时间，默认 30s，0 表示禁用

	// ========== Compaction 配置 ==========
	// 层级大小限制
	Level0SizeLimit int64 // L0 层大小限制，默认 64MB
	Level1SizeLimit int64 // L1 层大小限制，默认 256MB
	Level2SizeLimit int64 // L2 层大小限制，默认 512MB
	Level3SizeLimit int64 // L3 层大小限制，默认 1GB

	// 后台任务间隔
	CompactionInterval time.Duration // Compaction 检查间隔，默认 10s
	GCInterval         time.Duration // 垃圾回收检查间隔，默认 5min

	// ========== 高级配置（可选）==========
	DisableAutoCompaction bool          // 禁用自动 Compaction，默认 false
	DisableGC             bool          // 禁用垃圾回收，默认 false
	GCFileMinAge          time.Duration // GC 文件最小年龄，默认 1min
}

Options 数据库配置选项

func DefaultOptions 

func DefaultOptions(dir string) *Options

DefaultOptions 返回默认配置

func (*Options) Validate 

func (opts *Options) Validate() error

Validate 验证配置的有效性

type Picker 

type Picker struct {
	// contains filtered or unexported fields
}

Picker 负责选择需要 Compaction 的文件

func NewPicker 

func NewPicker() *Picker

NewPicker 创建新的 Compaction Picker（使用默认值）

func (*Picker) GetCurrentStage 

func (p *Picker) GetCurrentStage() int

GetCurrentStage 获取当前阶段（用于测试和调试）

func (*Picker) GetLevelScore 

func (p *Picker) GetLevelScore(version *Version, level int) float64

GetLevelScore 获取每层的 Compaction 得分 (用于优先级排序) 得分越高，越需要 Compaction

func (*Picker) PickCompaction 

func (p *Picker) PickCompaction(version *Version) []*CompactionTask

PickCompaction 选择需要 Compaction 的任务（按阶段返回，阶段内并发执行） 返回空切片表示当前阶段不需要 Compaction

执行策略（4 阶段串行 + 阶段内并发）： 1. Stage 0 - L0 合并：小文件合并，减少 L0 文件数（可能保持在 L0） 2. Stage 1 - L0 升级：大文件或已合并文件升级到 L1 3. Stage 2 - L1 升级：L1 文件升级到 L2 4. Stage 3 - L2 升级：L2 文件升级到 L3

阶段控制： - 使用 currentStage 跟踪当前应该执行哪个阶段（0-3） - 每次调用返回当前阶段的任务，然后自动推进到下一阶段 - 调用者应该循环调用此方法以确保所有阶段都被尝试

为什么阶段内可以并发？ - 同一阶段的任务处理不同的文件批次（按 seq 连续划分） - 这些批次的文件不重叠，可以安全并发

为什么阶段间要串行？ - L0 执行后可能产生新文件，影响下一阶段的任务计算 - 必须基于最新的 version 重新计算下一阶段的任务

func (*Picker) ShouldCompact 

func (p *Picker) ShouldCompact(version *Version) bool

ShouldCompact 判断是否需要 Compaction（只检查，不推进阶段）

func (*Picker) UpdateLevelLimits 

func (p *Picker) UpdateLevelLimits(l0, l1, l2, l3 int64)

UpdateLevelLimits 更新层级大小限制（由 CompactionManager 调用）

type QueryBuilder 

type QueryBuilder struct {
	// contains filtered or unexported fields
}

func (*QueryBuilder) Between 

func (qb *QueryBuilder) Between(field string, start, end any) *QueryBuilder

func (*QueryBuilder) Contains 

func (qb *QueryBuilder) Contains(field string, pattern string) *QueryBuilder

func (*QueryBuilder) EndsWith 

func (qb *QueryBuilder) EndsWith(field string, pattern string) *QueryBuilder

func (*QueryBuilder) Eq 

func (qb *QueryBuilder) Eq(field string, value any) *QueryBuilder

func (*QueryBuilder) First 

func (qb *QueryBuilder) First() (*Row, error)

First 返回第一个匹配的数据

func (*QueryBuilder) Gt 

func (qb *QueryBuilder) Gt(field string, value any) *QueryBuilder

func (*QueryBuilder) Gte 

func (qb *QueryBuilder) Gte(field string, value any) *QueryBuilder

func (*QueryBuilder) In 

func (qb *QueryBuilder) In(field string, values []any) *QueryBuilder

func (*QueryBuilder) IsNull 

func (qb *QueryBuilder) IsNull(field string) *QueryBuilder

func (*QueryBuilder) Last 

func (qb *QueryBuilder) Last() (*Row, error)

Last 返回最后一个匹配的数据

func (*QueryBuilder) Limit 

func (qb *QueryBuilder) Limit(n int) *QueryBuilder

Limit 设置返回的最大记录数 用于分页查询，最多返回 n 条记录 n = 0 表示无限制

func (*QueryBuilder) Lt 

func (qb *QueryBuilder) Lt(field string, value any) *QueryBuilder

func (*QueryBuilder) Lte 

func (qb *QueryBuilder) Lte(field string, value any) *QueryBuilder

func (*QueryBuilder) Match 

func (qb *QueryBuilder) Match(data map[string]any) bool

Match 检查数据是否匹配所有条件

func (*QueryBuilder) NotBetween 

func (qb *QueryBuilder) NotBetween(field string, start, end any) *QueryBuilder

func (*QueryBuilder) NotContains 

func (qb *QueryBuilder) NotContains(field string, pattern string) *QueryBuilder

func (*QueryBuilder) NotEndsWith 

func (qb *QueryBuilder) NotEndsWith(field string, pattern string) *QueryBuilder

func (*QueryBuilder) NotEq 

func (qb *QueryBuilder) NotEq(field string, value any) *QueryBuilder

func (*QueryBuilder) NotIn 

func (qb *QueryBuilder) NotIn(field string, values []any) *QueryBuilder

func (*QueryBuilder) NotNull 

func (qb *QueryBuilder) NotNull(field string) *QueryBuilder

func (*QueryBuilder) NotStartsWith 

func (qb *QueryBuilder) NotStartsWith(field string, pattern string) *QueryBuilder

func (*QueryBuilder) Offset 

func (qb *QueryBuilder) Offset(n int) *QueryBuilder

Offset 设置跳过的记录数 用于分页查询，跳过前 n 条记录

func (*QueryBuilder) OrderBy 

func (qb *QueryBuilder) OrderBy(field string) *QueryBuilder

OrderBy 设置排序字段（升序） 仅支持 "_seq" 或有索引的字段，使用其他字段会返回错误

func (*QueryBuilder) OrderByDesc 

func (qb *QueryBuilder) OrderByDesc(field string) *QueryBuilder

OrderByDesc 设置排序字段（降序） 仅支持 "_seq" 或有索引的字段，使用其他字段会返回错误

func (*QueryBuilder) Paginate 

func (qb *QueryBuilder) Paginate(page, pageSize int) (rows *Rows, total int, err error)

Paginate 执行分页查询并返回结果、总记录数和错误 page: 页码，从 1 开始 pageSize: 每页记录数 返回值：

  • rows: 当前页的数据
  • total: 满足条件的总记录数（用于计算总页数）
  • err: 错误信息

注意：此方法会执行两次查询，第一次获取总数，第二次获取分页数据

func (*QueryBuilder) Rows 

func (qb *QueryBuilder) Rows() (*Rows, error)

Rows 返回所有匹配的数据（游标模式 - 惰性加载）

func (*QueryBuilder) Scan 

func (qb *QueryBuilder) Scan(value any) error

Scan 扫描结果到指定的变量

func (*QueryBuilder) Select 

func (qb *QueryBuilder) Select(fields ...string) *QueryBuilder

Select 指定要选择的字段，如果不调用则返回所有字段

func (*QueryBuilder) StartsWith 

func (qb *QueryBuilder) StartsWith(field string, pattern string) *QueryBuilder

func (*QueryBuilder) Where 

func (qb *QueryBuilder) Where(exprs ...Expr) *QueryBuilder

type Row 

type Row struct {
	// contains filtered or unexported fields
}

func (*Row) Data 

func (r *Row) Data() map[string]any

Data 获取行数据（根据 Select 过滤字段）

func (*Row) Scan 

func (r *Row) Scan(value any) error

Scan 扫描行数据到指定的变量 支持使用 srdb tag 进行字段映射

func (*Row) Seq 

func (r *Row) Seq() int64

Seq 获取行序列号

type Rows 

type Rows struct {
	// contains filtered or unexported fields
}

Rows 游标模式的结果集（惰性加载）

func (*Rows) Close 

func (r *Rows) Close() error

Close 关闭游标

func (*Rows) Collect 

func (r *Rows) Collect() []map[string]any

Collect 收集所有结果到切片

func (*Rows) Count 

func (r *Rows) Count() int

Count 返回总行数（别名）

func (*Rows) Data 

func (r *Rows) Data() []map[string]any

Data 获取所有行的数据（向后兼容）

func (*Rows) Err 

func (r *Rows) Err() error

Err 返回错误

func (*Rows) First 

func (r *Rows) First() (*Row, error)

First 获取第一行

func (*Rows) Last 

func (r *Rows) Last() (*Row, error)

Last 获取最后一行

func (*Rows) Len 

func (r *Rows) Len() int

Len 返回总行数（需要完全扫描）

func (*Rows) Next 

func (r *Rows) Next() bool

Next 移动到下一行，返回是否还有数据

func (*Rows) Row 

func (r *Rows) Row() *Row

Row 获取当前行

func (*Rows) Scan 

func (r *Rows) Scan(value any) error

Scan 扫描所有行数据到指定的变量 智能判断目标类型：

  • 如果目标是切片：扫描所有行
  • 如果目标是结构体/指针：只扫描第一行

支持使用 srdb tag 进行字段映射

type SSTableHeader 

type SSTableHeader struct {
	// 基础信息 (32 bytes)
	Magic       uint32 // Magic Number: 0x53535433
	Version     uint32 // 版本号
	Compression uint8  // 压缩类型（保留字段用于向后兼容）
	Reserved1   [3]byte
	Flags       uint32 // 标志位
	Reserved2   [16]byte

	// 索引信息 (32 bytes)
	IndexOffset int64 // B+Tree 索引起始位置
	IndexSize   int64 // B+Tree 索引大小
	RootOffset  int64 // B+Tree 根节点位置
	Reserved3   [8]byte

	// 数据信息 (32 bytes)
	DataOffset int64 // 数据块起始位置
	DataSize   int64 // 数据块总大小
	RowCount   int64 // 行数
	Reserved4  [8]byte

	// 统计信息 (32 bytes)
	MinKey  int64 // 最小 key (_seq)
	MaxKey  int64 // 最大 key (_seq)
	MinTime int64 // 最小时间戳
	MaxTime int64 // 最大时间戳

	// CRC 校验 (8 bytes)
	CRC32     uint32 // Header CRC32
	Reserved5 [4]byte

	// 预留空间 (120 bytes)
	Reserved6 [120]byte
}

SSTableHeader SST 文件头 (256 bytes)

func UnmarshalSSTableHeader 

func UnmarshalSSTableHeader(data []byte) *SSTableHeader

Unmarshal 反序列化 Header

func (*SSTableHeader) Marshal 

func (h *SSTableHeader) Marshal() []byte

Marshal 序列化 Header

func (*SSTableHeader) Validate 

func (h *SSTableHeader) Validate() bool

Validate 验证 Header

type SSTableManager 

type SSTableManager struct {
	// contains filtered or unexported fields
}

SSTableManager SST 文件管理器

func NewSSTableManager 

func NewSSTableManager(dir string) (*SSTableManager, error)

NewSSTableManager 创建 SST 管理器

func (*SSTableManager) AddReader 

func (m *SSTableManager) AddReader(reader *SSTableReader)

AddReader 添加 reader 到管理器（用于 compaction 创建的新文件）

func (*SSTableManager) Close 

func (m *SSTableManager) Close() error

Close 关闭所有 SST Readers

func (*SSTableManager) Count 

func (m *SSTableManager) Count() int

Count 获取 SST 文件数量

func (*SSTableManager) CreateSST 

func (m *SSTableManager) CreateSST(fileNumber int64, rows []*SSTableRow) (*SSTableReader, error)

CreateSST 创建新的 SST 文件 fileNumber: 文件编号（由 VersionSet 分配）

func (*SSTableManager) CreateSSTWithLevel 

func (m *SSTableManager) CreateSSTWithLevel(fileNumber int64, rows []*SSTableRow, level int) (*SSTableReader, error)

CreateSSTWithLevel 创建新的 SST 文件到指定层级 fileNumber: 文件编号（由 VersionSet 分配）

func (*SSTableManager) Get 

func (m *SSTableManager) Get(seq int64) (*SSTableRow, error)

Get 从所有 SST 文件中查找数据

func (*SSTableManager) GetMaxSeq 

func (m *SSTableManager) GetMaxSeq() int64

GetMaxSeq 获取所有 SST 中的最大 seq

func (*SSTableManager) GetPartial 

func (m *SSTableManager) GetPartial(seq int64, fields []string) (*SSTableRow, error)

GetPartial 从所有 SST 文件中按需查找数据（只读取指定字段）

func (*SSTableManager) GetReaders 

func (m *SSTableManager) GetReaders() []*SSTableReader

GetReaders 获取所有 Readers（用于扫描）

func (*SSTableManager) GetStats 

func (m *SSTableManager) GetStats() *SSTableStats

GetStats 获取统计信息

func (*SSTableManager) ListFiles 

func (m *SSTableManager) ListFiles() []string

ListFiles 列出所有 SST 文件

func (*SSTableManager) RemoveReader 

func (m *SSTableManager) RemoveReader(fileNumber int64) error

RemoveReader 移除指定文件编号的 reader（用于 compaction）

func (*SSTableManager) SetSchema 

func (m *SSTableManager) SetSchema(schema *Schema)

SetSchema 设置 Schema（用于优化编解码）

type SSTableReader 

type SSTableReader struct {
	// contains filtered or unexported fields
}

SSTableReader SST 文件读取器

func NewSSTableReader 

func NewSSTableReader(path string) (*SSTableReader, error)

NewSSTableReader 创建 SST 读取器

func (*SSTableReader) Close 

func (r *SSTableReader) Close() error

Close 关闭读取器

func (*SSTableReader) ForEach 

func (r *SSTableReader) ForEach(callback KeyCallback)

ForEach 升序迭代所有 key-offset-size 对 callback 返回 false 时停止迭代，支持提前终止

func (*SSTableReader) ForEachDesc 

func (r *SSTableReader) ForEachDesc(callback KeyCallback)

ForEachDesc 降序迭代所有 key-offset-size 对 callback 返回 false 时停止迭代，支持提前终止

func (*SSTableReader) Get 

func (r *SSTableReader) Get(key int64) (*SSTableRow, error)

Get 查询一行数据

func (*SSTableReader) GetAllKeys 

func (r *SSTableReader) GetAllKeys() []int64

GetAllKeys 获取文件中所有的 key（按顺序）

func (*SSTableReader) GetHeader 

func (r *SSTableReader) GetHeader() *SSTableHeader

GetHeader 获取文件头信息

func (*SSTableReader) GetPartial 

func (r *SSTableReader) GetPartial(key int64, fields []string) (*SSTableRow, error)

GetPartial 按需查询一行数据（只读取指定字段）

func (*SSTableReader) GetPath 

func (r *SSTableReader) GetPath() string

GetPath 获取文件路径

func (*SSTableReader) SetSchema 

func (r *SSTableReader) SetSchema(schema *Schema)

SetSchema 设置 Schema（用于优化编解码）

type SSTableRow 

type SSTableRow struct {
	Seq  int64          // _seq
	Time int64          // _time
	Data map[string]any // 用户数据
}

SSTableRow 表示一行数据

type SSTableStats 

type SSTableStats struct {
	FileCount int
	TotalSize int64
	MinSeq    int64
	MaxSeq    int64
}

SSTableStats 统计信息

type SSTableWriter 

type SSTableWriter struct {
	// contains filtered or unexported fields
}

SSTableWriter SST 文件写入器

func NewSSTableWriter 

func NewSSTableWriter(file *os.File, schema *Schema) *SSTableWriter

NewSSTableWriter 创建 SST 写入器

func (*SSTableWriter) Add 

func (w *SSTableWriter) Add(row *SSTableRow) error

Add 添加一行数据

func (*SSTableWriter) Finish 

func (w *SSTableWriter) Finish() error

Finish 完成写入

type Schema 

type Schema struct {
	Name   string  // Schema 名称
	Fields []Field // 字段列表
}

Schema 表结构定义

func NewSchema 

func NewSchema(name string, fields []Field) (*Schema, error)

NewSchema 创建 Schema 参数：

  • name: Schema 名称，不能为空
  • fields: 字段列表，至少需要 1 个字段

返回：

  • *Schema: Schema 实例
  • error: 错误信息

func (*Schema) ComputeChecksum 

func (s *Schema) ComputeChecksum() (string, error)

ComputeChecksum 计算 Schema 的 SHA256 校验和 使用确定性的字符串拼接算法，不依赖 json.Marshal 这样即使 Schema struct 添加新字段，只要核心内容（Name、Fields）不变，checksum 就不会变 重要：字段顺序不影响 checksum，会先按字段名排序 格式: "name:<name>;fields:<field1_name>:<field1_type>:<field1_indexed>:<field1_comment>,<field2>..."

func (*Schema) ExtractIndexValue 

func (s *Schema) ExtractIndexValue(field string, data map[string]any) (any, error)

ExtractIndexValue 提取索引值（支持类型转换）

func (*Schema) GetField 

func (s *Schema) GetField(name string) (*Field, error)

GetField 获取字段定义

func (*Schema) GetIndexedFields 

func (s *Schema) GetIndexedFields() []Field

GetIndexedFields 获取所有需要索引的字段

func (*Schema) Validate 

func (s *Schema) Validate(data map[string]any) error

Validate 验证数据是否符合 Schema

func (*Schema) ValidateType 

func (s *Schema) ValidateType(typ FieldType, value any) error

ValidateType 验证值的类型（导出方法）

type SchemaFile 

type SchemaFile struct {
	Version   int     `json:"version"`   // 文件格式版本
	Timestamp int64   `json:"timestamp"` // 保存时间戳
	Checksum  string  `json:"checksum"`  // Schema 内容的 SHA256 校验和
	Schema    *Schema `json:"schema"`    // Schema 内容
}

SchemaFile Schema 文件格式（带校验）

func NewSchemaFile 

func NewSchemaFile(schema *Schema) (*SchemaFile, error)

NewSchemaFile 创建带校验和的 Schema 文件

func (*SchemaFile) Verify 

func (sf *SchemaFile) Verify() error

Verify 验证 Schema 文件的完整性

type SecondaryIndex 

type SecondaryIndex struct {
	// contains filtered or unexported fields
}

SecondaryIndex 二级索引

func NewSecondaryIndex 

func NewSecondaryIndex(dir, field string, fieldType FieldType) (*SecondaryIndex, error)

NewSecondaryIndex 创建二级索引

func (*SecondaryIndex) Add 

func (idx *SecondaryIndex) Add(value any, seq int64) error

Add 添加索引条目（增量更新元数据）

func (*SecondaryIndex) Build 

func (idx *SecondaryIndex) Build() error

Build 构建索引并持久化（B+Tree 格式）

func (*SecondaryIndex) Close 

func (idx *SecondaryIndex) Close() error

Close 关闭索引

func (*SecondaryIndex) ForEach 

func (idx *SecondaryIndex) ForEach(callback IndexEntryCallback) error

ForEach 升序迭代所有索引条目 callback 返回 false 时停止迭代，支持提前终止 注意：只能迭代已持久化的数据（B+Tree），不包括内存中未持久化的数据

func (*SecondaryIndex) ForEachDesc 

func (idx *SecondaryIndex) ForEachDesc(callback IndexEntryCallback) error

ForEachDesc 降序迭代所有索引条目 callback 返回 false 时停止迭代，支持提前终止 注意：只能迭代已持久化的数据（B+Tree），不包括内存中未持久化的数据

func (*SecondaryIndex) Get 

func (idx *SecondaryIndex) Get(value any) ([]int64, error)

Get 查询索引（优先查内存，然后查磁盘，合并结果）

func (*SecondaryIndex) GetMetadata 

func (idx *SecondaryIndex) GetMetadata() IndexMetadata

GetMetadata 获取元数据

func (*SecondaryIndex) IncrementalUpdate 

func (idx *SecondaryIndex) IncrementalUpdate(getData func(int64) (map[string]any, error), fromSeq, toSeq int64) error

IncrementalUpdate 增量更新索引

func (*SecondaryIndex) IsReady 

func (idx *SecondaryIndex) IsReady() bool

IsReady 索引是否就绪

func (*SecondaryIndex) NeedsUpdate 

func (idx *SecondaryIndex) NeedsUpdate(currentMaxSeq int64) bool

NeedsUpdate 检查是否需要更新

type Table 

type Table struct {
	// contains filtered or unexported fields
}

Table 表

func OpenTable 

func OpenTable(opts *TableOptions) (*Table, error)

OpenTable 打开数据库

func (*Table) BuildIndexes 

func (t *Table) BuildIndexes() error

BuildIndexes 构建所有索引

func (*Table) Clean 

func (t *Table) Clean() error

Clean 清除所有数据（保留 Table 可用）

func (*Table) Close 

func (t *Table) Close() error

Close 关闭引擎

func (*Table) CreateIndex 

func (t *Table) CreateIndex(field string) error

CreateIndex 创建索引

func (*Table) Destroy 

func (t *Table) Destroy() error

Destroy 销毁 Table 并删除所有数据文件

func (*Table) DropIndex 

func (t *Table) DropIndex(field string) error

DropIndex 删除索引

func (*Table) Flush 

func (t *Table) Flush() error

Flush 手动刷新 Active MemTable 到磁盘

func (*Table) Get 

func (t *Table) Get(seq int64) (*SSTableRow, error)

Get 查询数据

func (*Table) GetCompactionManager 

func (t *Table) GetCompactionManager() *CompactionManager

GetCompactionManager 获取 Compaction Manager（用于高级操作）

func (*Table) GetDir 

func (t *Table) GetDir() string

GetDir 获取表目录

func (*Table) GetIndex 

func (t *Table) GetIndex(field string) (*SecondaryIndex, bool)

GetIndex 获取指定字段的索引

func (*Table) GetIndexMetadata 

func (t *Table) GetIndexMetadata() map[string]IndexMetadata

GetIndexMetadata 获取索引元数据

func (*Table) GetMaxSeq 

func (t *Table) GetMaxSeq() int64

GetMaxSeq 获取当前最大的 seq 号

func (*Table) GetMemtableManager 

func (t *Table) GetMemtableManager() *MemTableManager

GetMemtableManager 获取 Memtable Manager

func (*Table) GetName 

func (t *Table) GetName() string

GetName 获取表名

func (*Table) GetPartial 

func (t *Table) GetPartial(seq int64, fields []string) (*SSTableRow, error)

GetPartial 按需查询数据（只读取指定字段）

func (*Table) GetSSTManager 

func (t *Table) GetSSTManager() *SSTableManager

GetSSTManager 获取 SST Manager

func (*Table) GetSchema 

func (t *Table) GetSchema() *Schema

GetSchema 获取 Schema

func (*Table) GetVersionSet 

func (t *Table) GetVersionSet() *VersionSet

GetVersionSet 获取 VersionSet（用于高级操作）

func (*Table) Insert 

func (t *Table) Insert(data any) error

Insert 插入数据（支持单条或批量） 支持的类型：

  • map[string]any: 单条数据
  • []map[string]any: 批量数据
  • *struct{}: 单个结构体指针
  • []struct{}: 结构体切片
  • []*struct{}: 结构体指针切片

func (*Table) ListIndexes 

func (t *Table) ListIndexes() []string

ListIndexes 列出所有索引

func (*Table) Query 

func (t *Table) Query() *QueryBuilder

Query 创建查询构建器

func (*Table) RepairIndexes 

func (t *Table) RepairIndexes() error

RepairIndexes 手动修复索引

func (*Table) SetLogger 

func (t *Table) SetLogger(logger *slog.Logger)

SetLogger 设置 logger（由 Database 调用）

func (*Table) Stats 

func (t *Table) Stats() *TableStats

Stats 获取统计信息

type TableInfo 

type TableInfo struct {
	Name      string `json:"name"`
	Dir       string `json:"dir"`
	CreatedAt int64  `json:"created_at"`
}

TableInfo 表信息

type TableOptions 

type TableOptions struct {
	Dir              string
	MemTableSize     int64
	Name             string        // 表名
	Fields           []Field       // 字段列表（可选）
	AutoFlushTimeout time.Duration // 自动 flush 超时时间，0 表示禁用
}

TableOptions 配置选项

type TableStats 

type TableStats struct {
	MemTableSize  int64
	MemTableCount int
	SSTCount      int
	TotalRows     int64
}

TableStats 统计信息

type Version 

type Version struct {
	// 分层存储 SST 文件 (L0-L3)
	Levels [NumLevels][]*FileMetadata

	// 下一个文件编号
	NextFileNumber int64

	// 最后序列号
	LastSequence int64

	// 版本号
	VersionNumber int64
	// contains filtered or unexported fields
}

Version 数据库的一个版本快照

func NewVersion 

func NewVersion() *Version

NewVersion 创建新版本

func (*Version) Apply 

func (v *Version) Apply(edit *VersionEdit)

Apply 应用版本变更

func (*Version) Clone 

func (v *Version) Clone() *Version

Clone 克隆版本

func (*Version) GetFileCount 

func (v *Version) GetFileCount() int

GetFileCount 获取文件数量

func (*Version) GetLastSequence 

func (v *Version) GetLastSequence() int64

GetLastSequence 获取最后序列号

func (*Version) GetLevel 

func (v *Version) GetLevel(level int) []*FileMetadata

GetLevel 获取指定层级的文件

func (*Version) GetLevelFileCount 

func (v *Version) GetLevelFileCount(level int) int

GetLevelFileCount 获取指定层级的文件数量

func (*Version) GetNextFileNumber 

func (v *Version) GetNextFileNumber() int64

GetNextFileNumber 获取下一个文件编号

func (*Version) GetSSTFiles 

func (v *Version) GetSSTFiles() []*FileMetadata

GetSSTFiles 获取所有 SST 文件（副本，兼容旧接口）

type VersionEdit 

type VersionEdit struct {
	// 添加的文件
	AddedFiles []*FileMetadata

	// 删除的文件（文件编号列表）
	DeletedFiles []int64

	// 下一个文件编号
	NextFileNumber *int64

	// 最后序列号
	LastSequence *int64
}

VersionEdit 版本变更记录

func NewVersionEdit 

func NewVersionEdit() *VersionEdit

NewVersionEdit 创建版本变更

func (*VersionEdit) AddFile 

func (e *VersionEdit) AddFile(file *FileMetadata)

AddFile 添加文件

func (*VersionEdit) Decode 

func (e *VersionEdit) Decode(data []byte) error

Decode 从字节解码

func (*VersionEdit) DeleteFile 

func (e *VersionEdit) DeleteFile(fileNumber int64)

DeleteFile 删除文件

func (*VersionEdit) Encode 

func (e *VersionEdit) Encode() ([]byte, error)

Encode 编码为字节

func (*VersionEdit) SetLastSequence 

func (e *VersionEdit) SetLastSequence(seq int64)

SetLastSequence 设置最后序列号

func (*VersionEdit) SetNextFileNumber 

func (e *VersionEdit) SetNextFileNumber(num int64)

SetNextFileNumber 设置下一个文件编号

type VersionSet 

type VersionSet struct {
	// contains filtered or unexported fields
}

VersionSet 版本集合管理器

func NewVersionSet 

func NewVersionSet(dir string) (*VersionSet, error)

NewVersionSet 创建版本集合

func (*VersionSet) AllocateFileNumber 

func (vs *VersionSet) AllocateFileNumber() int64

AllocateFileNumber 分配文件编号

func (*VersionSet) Close 

func (vs *VersionSet) Close() error

Close 关闭 VersionSet

func (*VersionSet) GetCurrent 

func (vs *VersionSet) GetCurrent() *Version

GetCurrent 获取当前版本

func (*VersionSet) GetLastSequence 

func (vs *VersionSet) GetLastSequence() int64

GetLastSequence 获取最后序列号

func (*VersionSet) GetNextFileNumber 

func (vs *VersionSet) GetNextFileNumber() int64

GetNextFileNumber 获取下一个文件编号

func (*VersionSet) LogAndApply 

func (vs *VersionSet) LogAndApply(edit *VersionEdit) error

LogAndApply 记录并应用版本变更

func (*VersionSet) SetLastSequence 

func (vs *VersionSet) SetLastSequence(seq int64)

SetLastSequence 设置最后序列号

type WAL 

type WAL struct {
	// contains filtered or unexported fields
}

WAL Write-Ahead Log

func OpenWAL 

func OpenWAL(path string) (*WAL, error)

OpenWAL 打开 WAL 文件

func (*WAL) Append 

func (w *WAL) Append(entry *WALEntry) error

Append 追加一条记录

func (*WAL) Close 

func (w *WAL) Close() error

Close 关闭 WAL

func (*WAL) Sync 

func (w *WAL) Sync() error

Sync 同步到磁盘

func (*WAL) Truncate 

func (w *WAL) Truncate() error

Truncate 清空 WAL

type WALEntry 

type WALEntry struct {
	Type  byte   // 操作类型
	Seq   int64  // _seq
	Data  []byte // 数据
	CRC32 uint32 // 校验和
}

WALEntry WAL 条目

type WALManager 

type WALManager struct {
	// contains filtered or unexported fields
}

WALManager WAL 管理器，管理多个 WAL 文件

func NewWALManager 

func NewWALManager(dir string) (*WALManager, error)

NewWALManager 创建 WAL 管理器

func (*WALManager) Append 

func (m *WALManager) Append(entry *WALEntry) error

Append 追加记录到当前 WAL

func (*WALManager) Close 

func (m *WALManager) Close() error

Close 关闭 WAL 管理器

func (*WALManager) Delete 

func (m *WALManager) Delete(number int64) error

Delete 删除指定的 WAL 文件

func (*WALManager) GetCurrentNumber 

func (m *WALManager) GetCurrentNumber() int64

GetCurrentNumber 获取当前 WAL 编号

func (*WALManager) ListWALFiles 

func (m *WALManager) ListWALFiles() ([]string, error)

ListWALFiles 列出所有 WAL 文件

func (*WALManager) RecoverAll 

func (m *WALManager) RecoverAll() ([]*WALEntry, error)

RecoverAll 恢复所有 WAL 文件

func (*WALManager) Rotate 

func (m *WALManager) Rotate() (int64, error)

Rotate 切换到新的 WAL 文件

func (*WALManager) Sync 

func (m *WALManager) Sync() error

Sync 同步当前 WAL 到磁盘

type WALReader 

type WALReader struct {
	// contains filtered or unexported fields
}

WALReader WAL 读取器

func NewWALReader 

func NewWALReader(path string) (*WALReader, error)

NewWALReader 创建 WAL 读取器

func (*WALReader) Close 

func (r *WALReader) Close() error

Close 关闭读取器

func (*WALReader) Read 

func (r *WALReader) Read() ([]*WALEntry, error)

Read 读取所有 Entry

Source Files

View all Source files

Directories

Path Synopsis
examples
complex command
webui command
webui/commands

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.