企业官网建设流程全解析

简介：本资源是一份完整的《数据库系统原理》课程设计报告，面向计算机相关专业本科生及数据库初学者，聚焦批发企业信息管理系统的数据库设计与实现。报告覆盖需求分析、E-R模型构建、关系模式转换、表结构定义、Java Swing界面开发及基础CRUD功能演示，完整呈现数据库系统开发全流程。压缩包为单个Word文档（.doc），大小598KB，内容包含成绩单、评分标准、实体关系说明、E-R图与关系模型对照、系统主界面及各数据表操作截图，以及部分Java源码片段，便于理解前后端衔接逻辑。已有1059人学习下载，适合课程设计参考、数据库建模练习与小型管理系统开发入门。

1. 这不是课程作业交差，而是用真实数据库引擎逻辑重写一个“能跑通、能调参、能查错”的最小可运行DBMS内核

《数据库系统原理课程设计报告》这个标题在高校教学场景里常被误解为“Word排版+伪代码+截图拼凑”的结课材料。但真正做过工业级存储引擎或参与过开源数据库二次开发的工程师都知道：一次合格的课程设计，本质是用 C/C++ 或 Rust 手搓一个带 WAL、B+ 树索引、事务隔离（至少实现 Read Committed）、支持基本 SQL 解析（SELECT/INSERT/UPDATE）的微型 DBMS 内核原型。它不追求功能完整，但必须能从零启动、接受 TCP 连接、执行语句、落盘持久、崩溃后可恢复——也就是把《Database System Concepts》第六章到第十章的抽象模型，变成./dbserver --port=8080后真能mysql -h127.0.0.1 -P8080 -uuser -p连上去执行CREATE TABLE t(a INT); INSERT INTO t VALUES(42); SELECT * FROM t;并返回正确结果。适合两类人：一是想摆脱“只会调库不会造轮子”困境的高年级本科生；二是准备面试数据库岗、需要在简历上写出“手写过 MVCC 事务管理器”的应届生。本篇不讲 LaTeX 排版技巧，只聚焦如何用 3 天时间，在 Linux 环境下从空目录开始，构建一个可 gdb 调试、可加断点看锁等待、可改参数验证隔离级别效果的可执行体。所有代码均基于 POSIX API 实现，不依赖 SQLite 或 LevelDB 等黑盒封装，每行关键逻辑都对应教材里的算法描述。

2. 从零搭建存储层：WAL 日志 + 内存页缓存 + B+ 树索引的三件套落地

课程设计最容易翻车的环节，就是把“存储管理”当成配置文件一写就完。实际动手时你会发现：没有 WAL，事务原子性就是纸糊的；没有页缓存，每次读写都直击磁盘，QPS 不到 5；没有 B+ 树，WHERE 条件一加就全表扫描。这三者不是可选模块，而是构成 ACID 底座的刚性依赖。下面按真实开发顺序展开，每一步都附可粘贴运行的代码片段和参数说明。

2.1 WAL 日志模块：用 mmap 实现低延迟日志追加与崩溃恢复

WAL 的核心诉求是：写日志比写数据页快，且日志写成功 = 事务提交成功。很多同学用fopen("wal.log", "a")配合fflush()，这在高并发下会因 stdio 缓冲导致日志丢失。正确做法是绕过 libc，直接用mmap映射一块固定大小（如 64MB）的文件区域，用无锁环形缓冲区管理写入位置。

// wal.h typedef struct { int fd; void *addr; // mmap 地址 size_t file_size; // 64 * 1024 * 1024 off_t write_pos; // 当前写入偏移（原子操作） off_t flush_pos; // 已刷盘偏移（原子操作） } wal_t; // wal.c wal_t* wal_open(const char *path) { wal_t *w = calloc(1, sizeof(wal_t)); w->file_size = 64ULL * 1024 * 1024; w->fd = open(path, O_RDWR | O_CREAT, 0644); ftruncate(w->fd, w->file_size); w->addr = mmap(NULL, w->file_size, PROT_READ | PROT_WRITE, MAP_SHARED, w->fd, 0); // 初始化头部：magic number + version + start_lsn uint64_t *hdr = (uint64_t*)w->addr; hdr[0] = 0x57414C46454C4544ULL; // "WALFELD" ASCII hdr[1] = 1; // version hdr[2] = 0; // lsn_start __atomic_store_n(&w->write_pos, 3 * sizeof(uint64_t), __ATOMIC_RELAXED); __atomic_store_n(&w->flush_pos, 3 * sizeof(uint64_t), __ATOMIC_RELAXED); return w; }

提示：mmap映射后，write_pos指向日志正文起始位置（跳过 24 字节头）。每次写入前需检查剩余空间是否足够（if (write_pos + len > file_size) { rotate_log(); }），日志轮转时需原子更新文件名并重建映射。__atomic_store_n保证多线程写入时write_pos不被覆盖，这是 WAL 线程安全的基石。

2.2 页面缓存管理器：LRU-K 替换策略 + pin 计数防误淘汰

内存页缓存不是简单哈希表。真实场景中，一个页面可能被多个查询同时访问（如索引页被 SELECT 和 UPDATE 共享），必须用 pin 计数阻止其被 LRU 替换；而传统 LRU 在扫描型负载下会污染缓存，需升级为 LRU-K（记录最近 K 次访问时间戳）。我们实现一个简化版 LRU-2：

// buffer_pool.h typedef struct { uint32_t page_id; // 页号（如 0 表示 root index page） uint8_t *frame; // 指向 mmap 的页帧地址 uint32_t pin_count; // 当前持有该页的线程数 uint64_t last_access[2]; // LRU-2：记录倒数第1、2次访问时间戳 bool dirty; // 是否修改未刷盘 } buf_page_t; typedef struct { buf_page_t *pages; size_t capacity; // 总页数（如 1024） pthread_mutex_t lock; // LRU-2 链表头尾（双向链表指针存于 pages[i] 中） int head, tail; } buf_pool_t; // buffer_pool.c int buf_pool_read_page(buf_pool_t *bp, uint32_t page_id, uint8_t **out_frame) { pthread_mutex_lock(&bp->lock); // 1. 查哈希表找是否已加载 int idx = hash_lookup(bp, page_id); if (idx != -1) { buf_page_t *p = &bp->pages[idx]; p->pin_count++; p->last_access[1] = p->last_access[0]; p->last_access[0] = get_timestamp_ns(); *out_frame = p->frame; pthread_mutex_unlock(&bp->lock); return 0; } // 2. 未命中：选 victim（LRU-2：选 last_access[1] 最小的） int victim = find_lru2_victim(bp); if (bp->pages[victim].dirty) { // 刷脏页：pwrite(fd_data, frame, PAGE_SIZE, victim * PAGE_SIZE) flush_page_to_disk(bp->pages[victim]); } // 3. 加载新页：pread(fd_data, frame, PAGE_SIZE, page_id * PAGE_SIZE) load_page_from_disk(bp->pages[victim], page_id); bp->pages[victim].page_id = page_id; bp->pages[victim].pin_count = 1; bp->pages[victim].dirty = false; bp->pages[victim].last_access[0] = get_timestamp_ns(); bp->pages[victim].last_access[1] = 0; *out_frame = bp->pages[victim].frame; pthread_mutex_unlock(&bp->lock); return 0; }

参数说明：capacity建议设为sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE) / (16 * 1024 * 1024)（即物理内存的 1/16），避免 OOM；PAGE_SIZE固定为 4096 字节，与 x86 页对齐；get_timestamp_ns()用clock_gettime(CLOCK_MONOTONIC, &ts)实现，精度达纳秒级，确保 LRU-2 排序可靠。

2.3 B+ 树索引实现：支持范围查询的非递归插入与分裂

课程设计常犯的错误是照抄教科书递归 B+ 树，导致栈溢出或难以调试。生产级实现必须用迭代（iterative）方式处理插入与分裂，并显式维护父节点指针。我们采用固定阶数（order=4）的 B+ 树，每个内部节点最多 4 个键、5 个子指针，叶子节点存 key-value 对（key 是主键，value 是行号 RID）。

// bplus_tree.h #define BPLUS_ORDER 4 typedef struct bplus_node { bool is_leaf; int nkeys; // 当前键数量 uint64_t keys[BPLUS_ORDER]; // 键数组（升序） struct bplus_node *children[BPLUS_ORDER + 1]; // 子节点（仅内部节点用） rid_t *values[BPLUS_ORDER]; // 值数组（仅叶子节点用） struct bplus_node *next; // 叶子链表后继 } bplus_node_t; // bplus_tree.c int bplus_insert(bplus_tree_t *t, uint64_t key, rid_t value) { if (!t->root) { t->root = bplus_new_leaf(); bplus_leaf_insert(t->root, key, value); return 0; } // 迭代查找插入位置 bplus_node_t *cur = t->root; bplus_node_t *parent = NULL; while (!cur->is_leaf) { int i = 0; while (i < cur->nkeys && key >= cur->keys[i]) i++; parent = cur; cur = cur->children[i]; } // 在叶子节点插入 int ins_ret = bplus_leaf_insert(cur, key, value); if (ins_ret == 0) return 0; // 插入成功 // 叶子满：分裂 bplus_node_t *new_leaf = bplus_split_leaf(cur); if (parent == NULL) { // 根分裂：新建根 bplus_node_t *new_root = bplus_new_internal(); new_root->children[0] = cur; new_root->children[1] = new_leaf; new_root->keys[0] = new_leaf->keys[0]; new_root->nkeys = 1; t->root = new_root; } else { // 非根分裂：在父节点插入新键和子指针 bplus_internal_insert(parent, new_leaf->keys[0], new_leaf); } return 0; } // 分裂函数核心逻辑（省略内存分配细节） bplus_node_t* bplus_split_leaf(bplus_node_t *leaf) { bplus_node_t *new_leaf = bplus_new_leaf(); int mid = leaf->nkeys / 2; // 将后半部分键值迁移到新叶子 for (int i = mid; i < leaf->nkeys; i++) { new_leaf->keys[i - mid] = leaf->keys[i]; new_leaf->values[i - mid] = leaf->values[i]; } new_leaf->nkeys = leaf->nkeys - mid; leaf->nkeys = mid; // 链接叶子链表 new_leaf->next = leaf->next; leaf->next = new_leaf; return new_leaf; }

关键设计点：bplus_split_leaf返回新叶子节点，由上层决定如何插入父节点；bplus_internal_insert需处理父节点满时的递归分裂，但因树高通常 ≤3，实际不会栈溢出；所有节点分配用malloc，不预分配池，便于 gdb 观察内存布局。

3. 事务与并发控制：基于锁表的两阶段锁（2PL）与 Read Committed 隔离实现

ACID 中最难落地的是 I（Isolation）。课程设计若只实现串行化（Serializable），等于放弃并发能力；若用乐观锁又过于超前。Read Committed 是工业界最常用、课程设计最易验证的起点——它要求：1）事务中每次 SELECT 都读取已提交版本；2）写操作加行锁，直到事务结束才释放。我们用哈希表实现锁表（Lock Table），键为page_id + slot_offset，值为锁类型（S/X）和持有事务 ID。

3.1 锁表结构与加锁流程：避免死锁的等待图检测

锁表不是简单pthread_mutex_t数组，而是支持 S/X 兼容判断、事务粒度管理、死锁检测的动态结构：

// lock_table.h typedef enum { LOCK_S, LOCK_X } lock_type_t; typedef struct { uint32_t page_id; uint16_t slot_no; // 行在页内的偏移 } lock_key_t; typedef struct { uint64_t txn_id; // 事务唯一 ID（用 nanosecond 时间戳生成） lock_type_t type; bool granted; // 是否已获锁 struct list_head waiters; // 等待此锁的事务链表 } lock_request_t; typedef struct { hashtable_t *ht; // lock_key_t → list_head_t（锁请求链表） pthread_mutex_t mutex; } lock_table_t; // lock_table.c int lock_acquire(lock_table_t *lt, uint32_t page_id, uint16_t slot_no, lock_type_t type, uint64_t txn_id) { lock_key_t key = {.page_id = page_id, .slot_no = slot_no}; pthread_mutex_lock(&lt->mutex); list_head_t *bucket = hashtable_get(lt->ht, &key); if (!bucket) { bucket = malloc(sizeof(list_head_t)); INIT_LIST_HEAD(bucket); hashtable_put(lt->ht, &key, bucket); } // 检查兼容性：S 锁可共存，X 锁互斥 bool compatible = true; list_for_each_entry(req, bucket, list) { if (req->granted && ((type == LOCK_X) || (req->type == LOCK_X && type == LOCK_S))) { compatible = false; break; } } if (compatible) { // 立即授予 lock_request_t *req = malloc(sizeof(lock_request_t)); req->txn_id = txn_id; req->type = type; req->granted = true; list_add_tail(&req->list, bucket); pthread_mutex_unlock(&lt->mutex); return 0; } // 不兼容：加入等待队列，触发死锁检测 lock_request_t *req = malloc(sizeof(lock_request_t)); req->txn_id = txn_id; req->type = type; req->granted = false; list_add_tail(&req->list, bucket); if (deadlock_detect(lt, txn_id)) { pthread_mutex_unlock(&lt->mutex); return -1; // 死锁，回滚当前事务 } pthread_mutex_unlock(&lt->mutex); // 阻塞等待（实际用条件变量，此处简化） wait_on_lock(req); return 0; }

注意：deadlock_detect用等待图（Wait-for Graph）算法：以事务为顶点，若 T1 等待 T2 持有的锁，则加边 T1→T2；若图中存在环，则选环中txn_id最大的事务回滚。这是课程设计中唯一需要图遍历的模块，但代码量可控（<50 行 DFS）。

3.2 Read Committed 的 MVCC 快照机制：用事务开始时间戳过滤可见版本

Read Committed 不需要完整 MVCC（如 PostgreSQL 的 xmin/xmax），只需在读取行时，检查该行的commit_ts是否 ≤ 当前事务的start_ts。我们在每行末尾增加 8 字节commit_ts字段（0 表示未提交）：

// record.h #pragma pack(push, 1) typedef struct { uint32_t len; // 行总长度 uint32_t key_len; // 主键长度 uint64_t commit_ts; // 提交时间戳（纳秒），0=未提交 uint8_t data[]; // 主键 + 列数据 } record_t; #pragma pack(pop) // executor.c（SELECT 执行器） int exec_select(executor_t *e, const char *table_name, condition_t *cond, result_set_t *rs) { // 获取当前事务 start_ts（在事务 begin 时记录） uint64_t my_start_ts = e->txn->start_ts; // 遍历表中所有页，对每行检查 commit_ts for (uint32_t pid = 0; pid < table->n_pages; pid++) { uint8_t *page; buf_pool_read_page(e->bp, pid, &page); for (int slot = 0; slot < PAGE_SLOT_COUNT; slot++) { record_t *r = get_record_at_slot(page, slot); if (r == NULL || r->commit_ts == 0) continue; // 未提交或空槽 if (r->commit_ts <= my_start_ts) { // 可见 if (condition_match(r, cond)) { result_set_add(rs, r); } } } } return 0; }

玄学参数：commit_ts用clock_gettime(CLOCK_MONOTONIC, &ts)获取，确保严格递增；start_ts在BEGIN时获取，而非SELECT时，这是 Read Committed 语义的关键——同一事务内多次 SELECT 看到不同快照是允许的，但每次 SELECT 都必须看到“截至那一刻已提交”的数据。

3.3 两阶段锁（2PL）协议：锁的获取与释放时机控制

2PL 要求：1）事务在释放任何锁前，不能再获取新锁（增长阶段）；2）一旦开始释放锁，就不能再获取（收缩阶段）。我们在事务结构体中显式标记阶段：

// transaction.h typedef struct { uint64_t id; uint64_t start_ts; bool in_growth_phase; // true 表示仍可加锁 bool committed; list_head_t locks_held; // 持有锁的链表（用于回滚时释放） } txn_t; // transaction.c int txn_lock_row(txn_t *t, uint32_t page_id, uint16_t slot_no, lock_type_t type) { if (!t->in_growth_phase) { return -1; // 违反 2PL，拒绝加锁 } int ret = lock_acquire(g_lock_table, page_id, slot_no, type, t->id); if (ret == 0) { // 记录到事务锁列表，便于 rollback 时释放 lock_request_t *req = malloc(sizeof(lock_request_t)); req->page_id = page_id; req->slot_no = slot_no; req->type = type; list_add_tail(&req->list, &t->locks_held); } return ret; } int txn_commit(txn_t *t) { // 1. 将所有修改行的 commit_ts 设为当前时间 update_commit_timestamps(t); // 2. 释放所有锁（进入收缩阶段） release_all_locks(t); t->in_growth_phase = false; t->committed = true; return 0; }

血泪经验：in_growth_phase必须在COMMIT或ROLLBACK时才置 false，不能在SELECT后就关闭——因为UPDATE可能在SELECT之后执行，仍需加 X 锁。这是学生实现中最常漏掉的状态机转移。

4. SQL 执行引擎：从词法分析到物理算子的极简实现路径

课程设计常陷入“先做 Parser 再做 Executor”的误区，结果花 3 天写完 ANTLR 语法树，最后没时间实现 JOIN。真实高效路径是：先硬编码支持SELECT * FROM t WHERE a=42和INSERT INTO t VALUES(42)，再逐步扩展。我们用正则提取关键 token，跳过复杂语法树，直奔物理执行。

4.1 词法解析器：用 strsep 拆分 SQL 字符串的轻量方案

不用 lex/yacc，用 C 标准库strsep按空格分割，再用strncmp匹配关键词：

// parser.h typedef struct { char *table_name; char *column_name; int op; // 0=EQ, 1=GT, 2=LT int64_t value; bool has_where; } parse_result_t; // parser.c parse_result_t* parse_select(const char *sql) { parse_result_t *r = calloc(1, sizeof(parse_result_t)); char *sql_copy = strdup(sql); char *tok, *rest = sql_copy; // 提取 SELECT * FROM t tok = strsep(&rest, " "); if (strcasecmp(tok, "SELECT") != 0) goto error; tok = strsep(&rest, " "); if (strcmp(tok, "*") != 0) goto error; tok = strsep(&rest, " "); if (strcasecmp(tok, "FROM") != 0) goto error; tok = strsep(&rest, " \n\t;"); if (!tok) goto error; r->table_name = strdup(tok); // 提取 WHERE a=42 tok = strsep(&rest, " "); if (tok && strcasecmp(tok, "WHERE") == 0) { r->has_where = true; tok = strsep(&rest, " =\n\t;"); if (!tok) goto error; r->column_name = strdup(tok); tok = strsep(&rest, " \n\t;"); if (!tok) goto error; r->value = atoll(tok); r->op = 0; // EQ } free(sql_copy); return r; error: free(sql_copy); free_parse_result(r); return NULL; }

为什么够用：课程设计验收重点是“能否执行条件查询”，不是“能否解析嵌套子查询”。strsep方案 50 行搞定，且gdb下可直接print rest查看剩余字符串，调试成本远低于 AST 遍历。

4.2 物理执行算子：TableScan + Filter 的组合式执行

执行器不建 Pipeline，用函数指针组合算子：

// executor.h typedef struct { int (*next)(void *state, row_t **out_row); void *state; } executor_t; // table_scan.c typedef struct { table_t *t; uint32_t cur_page; uint16_t cur_slot; } table_scan_state_t; int table_scan_next(void *state, row_t **out_row) { table_scan_state_t *s = (table_scan_state_t*)state; while (s->cur_page < s->t->n_pages) { uint8_t *page; buf_pool_read_page(g_buf_pool, s->cur_page, &page); while (s->cur_slot < PAGE_SLOT_COUNT) { record_t *r = get_record_at_slot(page, s->cur_slot); if (r && r->commit_ts > 0) { // 已提交行 *out_row = convert_record_to_row(r); s->cur_slot++; return 0; } s->cur_slot++; } s->cur_slot = 0; s->cur_page++; } return -1; // EOF } // filter.c typedef struct { executor_t *child; const char *col_name; int op; int64_t value; } filter_state_t; int filter_next(void *state, row_t **out_row) { filter_state_t *s = (filter_state_t*)state; row_t *row; while (s->child->next(s->child->state, &row) == 0) { if (row_matches_condition(row, s->col_name, s->op, s->value)) { *out_row = row; return 0; } } return -1; } // executor.c（组装） executor_t* exec_select_plan(parse_result_t *p) { table_scan_state_t *scan_state = malloc(sizeof(table_scan_state_t)); scan_state->t = get_table(p->table_name); scan_state->cur_page = 0; scan_state->cur_slot = 0; executor_t *scan = malloc(sizeof(executor_t)); scan->next = table_scan_next; scan->state = scan_state; if (p->has_where) { filter_state_t *filter_state = malloc(sizeof(filter_state_t)); filter_state->child = scan; filter_state->col_name = p->column_name; filter_state->op = p->op; filter_state->value = p->value; executor_t *filter = malloc(sizeof(executor_t)); filter->next = filter_next; filter->state = filter_state; return filter; } return scan; }

可验证性：table_scan_next中buf_pool_read_page会触发 WAL 和缓存逻辑，gdb下设断点可观察页加载、锁获取、时间戳检查全过程。这是课程设计答辩时最硬核的演示点。

5. 避坑指南：课程设计中 5 个高频翻车点与现场急救方案

课程设计最后 24 小时，90% 的失败源于以下具体问题。这里按“现象→原因→解决”给出可立即执行的方案，不讲理论，只给命令和代码补丁。

5.1 现象：INSERT后SELECT查不到数据，但cat data.db | hexdump -C显示数据已写入

原因：WAL 日志写了，但数据页未刷盘（dirty=true但flush_page_to_disk()未调用），且事务COMMIT时只更新了 WAL 中的 commit record，忘了将对应数据页标记为 clean。
解决：在txn_commit()中，遍历该事务修改过的所有页（需在UPDATE/INSERT时记录modified_pages[]数组），强制调用buf_pool_flush_page()：

// 在 txn_commit() 中追加： for (int i = 0; i < t->n_modified_pages; i++) { buf_pool_flush_page(g_buf_pool, t->modified_pages[i]); }

验证命令：grep -a "commit" wal.log | tail -5确认 WAL 有 commit record；ls -la *.db看 data.db 修改时间是否更新。

5.2 现象：并发SELECT时程序 core dump，gdb显示 segmentation fault 在bplus_search()的cur->children[i]

原因：B+ 树节点被其他线程分裂后，原指针cur指向的内存已被free()，但当前线程未重新buf_pool_read_page()加载新节点。
解决：在bplus_search()循环内，每次访问cur->children[i]前，加原子检查：

// 在 bplus_search() 内部循环中： if (__atomic_load_n(&cur->refcount, __ATOMIC_ACQUIRE) == 0) { // 节点已被释放，重新从缓存加载 buf_pool_read_page(g_buf_pool, cur->page_id, (uint8_t**)&cur); }

注意：需在bplus_node_t中增加uint32_t refcount字段，并在bplus_split_*时__atomic_fetch_add(&old_node->refcount, -1, __ATOMIC_ACQ_REL)。

5.3 现象：make报错undefined reference to 'clock_gettime'

原因：clock_gettime在librt.so中，但链接时未加-lrt。
解决：修改Makefile的LDFLAGS：

LDFLAGS = -lpthread -lrt -lm

验证：ldd ./dbserver | grep rt应输出librt.so.1 => /lib/x86_64-linux-gnu/librt.so.1。

5.4 现象：SELECT返回重复行，或漏掉某行

原因：B+ 树叶子链表next指针在分裂时未正确更新，导致遍历时跳过整个叶子页。
解决：在bplus_split_leaf()末尾，强制刷新next指针到磁盘（因叶子页是数据页，需持久化）：

// 在 bplus_split_leaf() 中： // ... 分裂完成后 buf_pool_mark_dirty(g_buf_pool, leaf->page_id); buf_pool_mark_dirty(g_buf_pool, new_leaf->page_id); // 强制刷盘（避免缓存未同步） buf_pool_flush_page(g_buf_pool, leaf->page_id); buf_pool_flush_page(g_buf_pool, new_leaf->page_id);

5.5 现象：gdb调试时step进入malloc或pthread_mutex_lock，无法看到业务逻辑

原因：未编译调试符号，或使用了-O2优化导致代码重排。
解决：Makefile中强制指定：

CFLAGS = -g -O0 -Wall -Wextra -std=gnu11

进阶技巧：在main()开头加raise(SIGSTOP)，然后gdb ./dbserver $(pidof dbserver)附加，可跳过启动阶段直接调试 SQL 执行。

6. 验证与调优：用真实 workload 测试你的 DBMS 内核是否“真可用”

课程设计报告的价值，不在于写了多少页，而在于能否用三组实测数据证明：1）它比文件系统直写快；2）它满足 ACID；3）它能应对并发。下面给出可直接运行的验证脚本和参数调整建议，每项测试 5 分钟内出结果。

6.1 基准性能测试：对比fwrite直写与你的 WAL 写入吞吐

写一个benchmark_wal.c，用clock_gettime测量 10000 次 128 字节日志写入耗时：

// benchmark_wal.c #include "wal.h" int main() { wal_t *w = wal_open("bench.wal"); struct timespec start, end; clock_gettime(CLOCK_MONOTONIC, &start); for (int i = 0; i < 10000; i++) { wal_write(w, "hello world", 12); // wal_write 实现见 2.1 节 } clock_gettime(CLOCK_MONOTONIC, &end); double ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec); printf("WAL 10000 writes: %.2f us\n", ns / 1000); wal_close(w); return 0; }

预期结果：WAL 应 ≤ 50000 us（即 5ms），而同等条件下fwrite+fflush通常 > 200000 us。若超时，检查是否用了fsync()—— WAL 只需msync(MS_ASYNC)。

6.2 ACID 验证实验：用kill -9模拟崩溃后数据一致性

这是答辩时最震撼的演示。步骤：

1. 启动./dbserver；
2. 执行INSERT INTO t VALUES(1),(2),(3);；
3. kill -9 $(pgrep dbserver)强杀进程；
4. 重启./dbserver；
5. 执行SELECT * FROM t;。

合格标准：必须返回(1),(2),(3)三行，且无乱码。若少于 3 行，说明 WAL 恢复逻辑缺失；若多出(0)等脏数据，说明commit_ts未清零。
调试方法：在main()启动时加wal_recover()函数，遍历 WAL 文件，对每个INSERTrecord，检查其commit_ts是否非零，若是则重放。

6.3 并发正确性测试：用ab压测下的锁冲突率监控

安装 Apache Bench：sudo apt install apache2-utils。
启动服务后执行：

ab -n 1000 -c 10 "http://127.0.0.1:8080/query?sql=SELECT%20*%20FROM%20t"

关键指标：关注Failed requests和Concurrency Level。若Failed requests> 0，检查锁表中是否有granted=false的长期等待项（gdb附加后p *lt->ht查看）。理想值：Failed requests: 0，Requests per second: ≥ 200（单核 VM）。

6.4 参数调优对照表：影响性能的 4 个核心参数实测值

本文还有配套的精品资源，点击获取