从零开始用Go写一个关系型数据库：新手也能看懂的10步教程

第一章：从零开始构建Go语言关系型数据库概述

在现代后端开发中，数据库是系统核心组件之一。使用 Go 语言从零构建一个轻量级的关系型数据库，不仅能深入理解数据库内部机制，还能锻炼并发处理、文件存储与查询解析等关键能力。本章将引导你认识项目整体架构设计思路，并为后续实现打下基础。

设计目标与核心模块

该项目旨在实现一个支持基本 SQL 操作（如 CREATE、INSERT、SELECT）的嵌入式关系型数据库，不依赖外部依赖库，数据持久化至本地文件。核心模块包括：

• SQL 解析器：将 SQL 字符串解析为抽象语法树（AST）
• 执行引擎：根据 AST 执行具体操作
• 存储引擎：管理数据的读写与索引
• 事务支持：提供基础 ACID 特性保障

整个系统采用分层架构，各模块职责清晰，便于扩展和测试。

开发环境准备

确保已安装 Go 1.20 或更高版本。初始化项目：

mkdir go-sql-db && cd go-sql-db
go mod init db

项目目录结构建议如下：

目录	用途
/parser	SQL 解析逻辑
/engine	查询执行与调度
/storage	数据页管理与磁盘持久化
/catalog	元数据与表结构管理

核心数据结构定义

数据库中最基础的数据单元是“表”，可用 Go 结构体表示：

type Column struct {
    Name string
    Type string // 如 "INT", "VARCHAR"
}

type Table struct {
    Name    string
    Columns []Column
    Rows    [][]interface{} // 实际数据行
}

该结构将在内存中维护表的模式与记录，后续结合 B+ 树或 LSM 树优化存储性能。

通过本架构设计，可逐步实现一个具备基本功能的原生 Go 数据库引擎。

第二章：数据库核心概念与Go基础实现

2.1 关系型数据模型与Go结构体映射

在Go语言开发中，将关系型数据库的表结构映射为Go结构体是构建数据访问层的核心步骤。通过结构体字段与数据库列的对应，实现数据的自然转换。

结构体标签（Struct Tags）的作用

使用struct tag将结构体字段关联到数据库列名，例如：

type User struct {
    ID   int64  `db:"id"`
    Name string `db:"name"`
    Email string `db:"email"`
}

上述代码中，db标签指明了字段在数据库中的列名。这使得ORM或数据库映射工具能正确解析字段来源，避免命名差异带来的映射错误。

映射规则与常见模式

• 字段首字母大写以导出（public），否则无法被外部库读取
• 零值处理：int默认0，string为空字符串，可结合sql.NullString处理可空列

表格映射示例

数据库表 users	Go结构体字段
id	ID int64
name	Name string
email	Email string

该映射机制为后续的数据查询与持久化操作奠定了基础。

2.2 数据库连接池的设计与并发控制实践

在高并发系统中，数据库连接的创建与销毁开销显著影响性能。连接池通过预创建并复用连接，有效降低资源消耗。核心设计需考虑连接的生命周期管理、空闲回收策略及并发访问安全。

连接获取与归还机制

采用线程安全的阻塞队列管理空闲连接，确保多线程环境下连接分配的原子性。当连接请求超过最大容量时，线程可选择阻塞或快速失败。

public Connection getConnection() throws InterruptedException {
    synchronized (pool) {
        while (pool.isEmpty()) {
            pool.wait(); // 等待连接归还
        }
        return pool.remove(pool.size() - 1);
    }
}

上述代码通过 synchronized 保证对连接池的互斥访问，wait() 配合 notifyAll() 实现线程唤醒机制，避免忙等待。

并发控制策略对比

策略	吞吐量	响应延迟	适用场景
固定大小池	高	低	稳定负载
动态扩容	中	中	波动流量
无池化直连	低	高	低频调用

资源竞争优化

引入分段锁或CAS操作可进一步提升并发性能，减少锁粒度，避免成为系统瓶颈。

2.3 SQL解析基础：词法与语法分析入门

SQL解析是数据库执行查询的核心前置步骤，其本质是将文本化的SQL语句转换为可被后续模块处理的内部结构。该过程分为两个关键阶段：词法分析和语法分析。

词法分析：从字符流到Token序列

词法分析器（Lexer）将原始SQL字符串拆解为具有语义意义的标记（Token），如关键字、标识符、操作符等。例如，SELECT name FROM users 被分解为：

• SELECT → 关键字
• name → 标识符
• FROM → 关键字
• users → 标识符

语法分析：构建抽象语法树

语法分析器（Parser）依据预定义的文法规则，将Token序列组织成抽象语法树（AST）。该树结构清晰表达查询逻辑层次。

-- 示例SQL语句
SELECT id, name FROM employees WHERE age > 30;

上述语句经解析后生成的AST根节点为SELECT，子节点分别对应字段列表、表名和条件表达式。其中WHERE子句中的age > 30被构造成二元操作节点。

解析流程可视化

graph TD
    A[SQL文本] --> B(词法分析)
    B --> C[Token流]
    C --> D(语法分析)
    D --> E[抽象语法树AST]

2.4 执行引擎初步：构建简单的查询执行流程

在数据库系统中，执行引擎是将解析后的查询计划转化为实际数据操作的核心组件。构建一个简单的执行流程，有助于理解后续复杂优化机制的基础。

查询执行的基本阶段

一个基础的查询执行流程通常包括以下几个阶段：

• 计划解析：接收由查询优化器生成的执行计划树；
• 算子执行：按树节点逐层调用对应的数据访问或处理算子；
• 结果组装：将底层存储返回的原始数据格式化为结果集。

执行流程示意图

graph TD
    A[SQL查询] --> B(查询解析)
    B --> C[生成执行计划]
    C --> D{执行引擎}
    D --> E[扫描表数据]
    E --> F[应用过滤条件]
    F --> G[投影字段]
    G --> H[返回结果]

该流程展示了从原始SQL到结果输出的线性执行路径。

简单执行器代码示例

class SimpleExecutor:
    def __init__(self, plan):
        self.plan = plan  # 执行计划，如 {"type": "SeqScan", "table": "users"}

    def execute(self):
        node = self.plan
        if node["type"] == "SeqScan":
            return self._seq_scan(node["table"])

    def _seq_scan(self, table_name):
        # 模拟全表扫描，返回模拟数据
        print(f"执行全表扫描: {table_name}")
        return [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]

上述代码定义了一个极简的执行器类，execute 方法根据计划类型分发执行任务，_seq_scan 模拟从指定表读取数据的过程。参数 plan 是一个字典结构，描述了要执行的操作类型和目标表名，便于扩展更多算子类型。

2.5 存储抽象层：使用Go接口管理数据持久化

在构建可扩展的后端服务时，存储抽象层是解耦业务逻辑与具体数据库实现的关键。通过Go语言的接口机制，可以定义统一的数据访问契约。

定义数据持久化接口

type UserRepository interface {
    Save(user *User) error      // 持久化用户对象
    FindByID(id string) (*User, error) // 根据ID查找用户
    Delete(id string) error     // 删除指定用户
}

该接口屏蔽了底层存储细节，Save 方法接收用户指针并返回错误状态，便于上层调用者处理异常。

多实现支持

实现类型	数据库	适用场景
MySQLUserRepo	关系型数据库	强一致性需求
MemoryUserRepo	内存存储	单元测试
MongoDBUserRepo	NoSQL	高并发写入

运行时依赖注入

func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

通过依赖注入，服务层无需关心具体实现，提升可测试性与灵活性。

架构演进示意

graph TD
    A[业务逻辑] --> B[UserRepository接口]
    B --> C[MySQL实现]
    B --> D[MongoDB实现]
    B --> E[内存模拟]

接口作为抽象边界，支撑多存储方案动态切换，实现架构解耦。

第三章：数据存储与检索机制实现

3.1 基于磁盘的B树索引设计与Go实现

B树是为磁盘等外部存储设备优化的经典数据结构，其核心思想是通过降低树的高度来减少I/O次数。每个节点通常对应一个磁盘页，包含多个键值对和子节点指针。

节点结构设计

type BTreeNode struct {
    Keys     []int64       // 键数组
    Values   [][]byte      // 值数组
    Children []int64       // 子节点在磁盘中的偏移量
    IsLeaf   bool          // 是否为叶子节点
}

该结构适配固定大小页存储，Keys 和 Values 在叶子节点中保存数据记录，非叶子节点仅用于路由查找路径。

插入操作流程

• 若根节点满，则分裂并提升中间键生成新根；
• 自顶向下递归查找插入位置；
• 节点满时提前分裂，保证插入路径上的节点均有空位。

磁盘持久化策略

使用 mmap 将节点映射到文件偏移，通过 LRU 缓存频繁访问的页面，减少直接读写开销。

graph TD
    A[开始插入] --> B{根节点已满?}
    B -->|是| C[分裂根, 创建新根]
    B -->|否| D[查找插入路径]
    D --> E{当前节点满?}
    E -->|是| F[分裂节点, 更新父节点]
    E -->|否| G[插入键值对]

3.2 数据页管理与缓存机制（Buffer Pool）编码实战

数据库性能的核心在于高效的数据页管理，而 Buffer Pool 是实现这一目标的关键组件。它通过在内存中缓存数据页，减少磁盘I/O，提升查询响应速度。

缓冲池基本结构设计

typedef struct {
    char* data;           // 数据页内容
    uint32_t page_id;     // 页编号
    bool is_dirty;        // 是否被修改
    int pin_count;        // 引用计数
} BufferPage;

BufferPage buffer_pool[POOL_SIZE];

上述结构体定义了缓冲池中的每个页，pin_count用于控制并发访问时的锁定状态，is_dirty标识页是否需要回写磁盘。

LRU置换策略实现

使用双向链表维护页的访问顺序，最近使用的页移至头部，淘汰时从尾部移除：

• 访问命中：将页移到链表头
• 新页加载：插入链表头，超出容量时淘汰尾部页

页面读取流程图

graph TD
    A[请求页page_id] --> B{是否在Buffer Pool?}
    B -- 是 --> C[增加pin_count, 返回指针]
    B -- 否 --> D[选择待换出页]
    D --> E[若脏页则写回磁盘]
    E --> F[加载新页到内存]
    F --> G[插入LRU头部, pin_count=1]

该机制确保高频访问页常驻内存，显著降低物理读频率。

3.3 行存储格式定义与序列化处理

在分布式数据库中，行存储是传统关系型数据组织的核心方式。每一行数据按字段顺序连续存储，便于完整记录的读取与写入。

存储结构设计

行存储的基本单元是“行”，其格式通常包含：

• 字段值序列
• NULL位图（标识空值）
• 长度前缀（变长字段）

struct Row {
    uint32_t tuple_len;     // 元组总长度
    uint8_t null_bitmap[];  // 空值标记位图
    char data[];            // 实际字段数据
};

该结构通过预分配内存块实现紧凑布局。null_bitmap 每一位对应一个字段是否为空，避免使用特殊占位符；data 区采用顺序排列，支持按偏移快速定位字段。

序列化流程

数据在写入磁盘或网络传输前需序列化为字节流：

graph TD
    A[原始行数据] --> B{生成NULL位图}
    B --> C[拼接字段值]
    C --> D[添加长度头]
    D --> E[输出连续字节流]

该流程确保跨平台兼容性，同时保留解析所需的元信息。反序列化时可依此结构还原内存对象，提升IO效率。

第四章：SQL解析与查询执行引擎开发

4.1 使用Lex/Yacc工具生成SQL解析器（Go版本）

在构建数据库中间件时，SQL解析是核心环节。借助Lex和Yacc的Go语言实现（如golex与goyacc），可高效生成词法与语法分析器。

词法与语法规则定义

通过.l文件定义词法单元，例如：

%{
package parser
%}
%%
SELECT    return SELECT
FROM      return FROM
[a-zA-Z_][a-zA-Z0-9_]*  { return IDENT }
[ \t\n]                  ; /* 忽略空白 */
%%

该代码段识别SQL关键字与标识符，输出对应token类型，供Yacc进行语法匹配。

语法分析生成

使用.y文件描述SQL结构：

sql_stmt: SELECT columns FROM table_name {}
columns: IDENT | columns ',' IDENT

经go yacc处理后生成LALR解析器，自动构建抽象语法树（AST）。

工具	作用
golex	生成词法分析器
goyacc	生成语法分析器

整个流程通过声明式规则降低手动解析复杂度，提升开发效率与维护性。

4.2 构建AST并实现基本SELECT语句执行

在SQL解析阶段，首先需将原始SQL文本转换为抽象语法树（AST），以便后续遍历与执行。以 SELECT id, name FROM users 为例，其解析流程如下：

-- 示例输入SQL
SELECT id, name FROM users;

该语句被词法分析器拆分为 token 流，再由语法分析器构建成树形结构：

# 生成的AST节点示例（Python类表示）
class SelectStatement:
    def __init__(self, columns, table):
        self.columns = columns  # ['id', 'name']
        self.table = table      # 'users'

AST节点设计原则

• 每个节点代表一个语法单元，如列、表、操作符；
• 支持递归遍历，便于后续绑定与优化。

执行流程

通过遍历AST，提取目标表和列，从存储引擎获取数据集：

graph TD
    A[SQL字符串] --> B(词法分析)
    B --> C(语法分析)
    C --> D[构建AST]
    D --> E(语义验证)
    E --> F(执行引擎查询数据)

最终，执行器调用表扫描接口，返回结果集，完成基础SELECT执行闭环。

4.3 支持WHERE条件过滤与表达式求值

在SQL查询执行过程中，WHERE子句是实现数据过滤的核心机制。它通过布尔表达式对每一行数据进行求值，仅保留满足条件的记录。

表达式求值引擎设计

查询引擎需构建表达式树来解析和计算WHERE中的逻辑。例如：

SELECT * FROM users WHERE age > 25 AND status = 'active';

该条件被解析为二叉表达式树，其中>和=为操作节点，age、25、status、'active'为叶节点。求值时逐行绑定列值并递归计算。

运算符与类型匹配

支持的运算符包括：

• 比较类：=、!=、<、>
• 逻辑类：AND、OR、NOT
• 类型系统需保证比较合法性，如字符串不可与整数直接比较

左操作数	右操作数	是否允许
INT	INT	✅
STRING	STRING	✅
INT	STRING	❌

执行流程

graph TD
    A[读取一行数据] --> B{应用WHERE表达式}
    B --> C[计算条件结果]
    C --> D[若为真, 输出该行]
    C --> E[若为假, 跳过]

4.4 实现INSERT、UPDATE、DELETE操作逻辑

在数据库操作中，实现 INSERT、UPDATE、DELETE 的核心在于构造安全且高效的SQL语句，并通过参数化查询防止注入攻击。

基本操作映射

使用预编译语句将应用层操作映射到底层数据变更：

-- 插入新记录
INSERT INTO users (name, email) VALUES (?, ?);

-- 更新指定记录
UPDATE users SET name = ?, email = ? WHERE id = ?;

-- 删除指定记录
DELETE FROM users WHERE id = ?;

上述语句通过占位符 ? 绑定参数，确保输入数据被正确转义。例如，在Java PreparedStatement中，setString(1, name) 将值绑定到第一个占位符。

执行流程控制

操作执行需遵循事务一致性原则。典型流程如下：

graph TD
    A[开始事务] --> B{操作类型}
    B -->|INSERT| C[插入数据并获取主键]
    B -->|UPDATE| D[更新匹配行并返回影响行数]
    B -->|DELETE| E[删除指定记录]
    C --> F[提交事务]
    D --> F
    E --> F

每条语句执行后应检查返回的影响行数，以确认操作是否生效。批量操作可通过批处理提升性能，减少网络往返开销。

第五章：事务管理与ACID特性的工程落地挑战

在分布式系统和微服务架构日益普及的今天，事务管理已不再局限于单体数据库的本地事务范畴。尽管ACID（原子性、一致性、隔离性、持久性）理论为数据完整性提供了坚实基础，但在实际工程实践中，完全满足ACID要求面临诸多挑战。

本地事务与分布式事务的鸿沟

传统关系型数据库如MySQL通过InnoDB引擎天然支持ACID，借助redo log和undo log实现持久性与原子性。然而当业务拆分为多个服务后，一个订单创建可能涉及库存扣减、支付处理和物流调度，跨服务调用无法依赖单一数据库的事务机制。此时若使用两阶段提交（2PC），虽能保证强一致性，但存在同步阻塞、协调者单点故障等问题。例如某电商平台在大促期间因2PC导致大量请求堆积，最终引发超时熔断。

隔离级别的现实妥协

即使在单库环境下，完全串行化（Serializable）隔离级别因性能损耗过大而极少使用。多数系统选择读已提交（Read Committed）或可重复读（Repeatable Read）。以下为常见隔离级别对比：

隔离级别	脏读	不可重复读	幻读
读未提交	是	是	是
读已提交	否	是	是
可重复读	否	否	在MySQL中否
串行化	否	否	否

某金融系统曾因误设隔离级别为“读已提交”，在批量计息过程中出现同一账户被多次读取并计算利息的问题，造成资金偏差。

基于消息队列的最终一致性方案

为规避分布式事务复杂度，许多系统采用事件驱动架构。以订单支付为例，支付服务完成本地事务后发送MQ消息，下游服务消费消息执行扣减库存等操作。该模式需引入消息可靠性投递机制，如下图所示：

graph LR
    A[支付服务] -->|1. 执行本地事务+写入消息表| B(本地数据库)
    B -->|2. 投递消息到MQ| C[MQ Broker]
    C -->|3. 消费并ACK| D[库存服务]
    D -->|4. 更新状态| E[更新本地状态]

该方案依赖定时任务补偿未发送消息，并确保消费者幂等处理。

分布式事务中间件的选型困境

ShardingSphere-Transaction、Seata等框架提供AT、TCC、Saga模式。某物流平台初期选用Seata AT模式，虽开发成本低，但在高并发场景下全局锁竞争激烈，响应延迟从50ms飙升至800ms。后切换为TCC模式，通过Try-Confirm-Cancel显式控制资源，性能提升显著，但代码侵入性强，需为每个业务编写回滚逻辑。