rust部分推进：进程间通信（Windows平台命名管线）、内存页表、B+树、WAL恢复系统、动态配置

chusql-storage/tests/btree_test.rs

@@ -0,0 +1,150 @@
+use chusql_storage::btree::DiskBTree;
+use chusql_storage::config::{DEFAULT_BTREE_ORDER, DEFAULT_PAGE_SIZE};
+
+// B+ 树测试：空树查询、插入后查找、重开文件数据仍在、覆盖同一个键、升序遍历、
+// 倒序插入 500 个键、页大小 / order 可以配置、配置和文件头对不上时报错。
+
+/// 空树的 get 返回 None，遍历返回空。
+#[test]
+fn empty_tree_get() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = DiskBTree::open(
+        dir.path().join("t.idx"),
+        DEFAULT_PAGE_SIZE,
+        DEFAULT_BTREE_ORDER,
+    )
+    .unwrap();
+    assert_eq!(t.get(1).unwrap(), None);
+    assert_eq!(t.iter_all().unwrap(), vec![]);
+}
+
+/// 插 100 个键，每个都能按 key 查回来。
+#[test]
+fn insert_then_get() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = DiskBTree::open(
+        dir.path().join("t.idx"),
+        DEFAULT_PAGE_SIZE,
+        DEFAULT_BTREE_ORDER,
+    )
+    .unwrap();
+    for i in 0..100 {
+        t.insert(i, i as u64 * 10).unwrap();
+    }
+    for i in 0..100 {
+        assert_eq!(t.get(i).unwrap(), Some(i as u64 * 10));
+    }
+}
+
+/// 关掉再打开同一个索引文件，数据还在。
+#[test]
+fn reopen_persists() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.idx");
+    {
+        let mut t = DiskBTree::open(&path, DEFAULT_PAGE_SIZE, DEFAULT_BTREE_ORDER).unwrap();
+        for i in 0..50 {
+            t.insert(i, i as u64).unwrap();
+        }
+    }
+    let mut t = DiskBTree::open(&path, DEFAULT_PAGE_SIZE, DEFAULT_BTREE_ORDER).unwrap();
+    for i in 0..50 {
+        assert_eq!(t.get(i).unwrap(), Some(i as u64));
+    }
+}
+
+/// 同一个键插两次，后写的值生效。
+#[test]
+fn update_existing() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = DiskBTree::open(
+        dir.path().join("t.idx"),
+        DEFAULT_PAGE_SIZE,
+        DEFAULT_BTREE_ORDER,
+    )
+    .unwrap();
+    t.insert(5, 100).unwrap();
+    t.insert(5, 200).unwrap();
+    assert_eq!(t.get(5).unwrap(), Some(200));
+}
+
+/// 倒序插入后遍历，结果仍按 key 升序。
+#[test]
+fn iter_all_sorted() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = DiskBTree::open(
+        dir.path().join("t.idx"),
+        DEFAULT_PAGE_SIZE,
+        DEFAULT_BTREE_ORDER,
+    )
+    .unwrap();
+    for i in (0..50).rev() {
+        t.insert(i, i as u64).unwrap();
+    }
+    let all = t.iter_all().unwrap();
+    assert_eq!(all.len(), 50);
+    for (i, (k, _)) in all.iter().enumerate() {
+        assert_eq!(*k, i as i64);
+    }
+}
+
+/// 倒序插入 500 个键（必然多次分裂），每个键都能查到。
+#[test]
+fn reverse_order_insert() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = DiskBTree::open(
+        dir.path().join("t.idx"),
+        DEFAULT_PAGE_SIZE,
+        DEFAULT_BTREE_ORDER,
+    )
+    .unwrap();
+    for i in (0..500).rev() {
+        t.insert(i, i as u64).unwrap();
+    }
+    for i in 0..500 {
+        assert_eq!(t.get(i).unwrap(), Some(i as u64));
+    }
+}
+
+/// 页大小和 order 都可以配置：512 字节的页 + 8 个孩子照样能插能查。
+#[test]
+fn custom_page_size_and_order() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = DiskBTree::open(dir.path().join("t.idx"), 512, 8).unwrap();
+    for i in 0..200 {
+        t.insert(i, i as u64 + 1).unwrap();
+    }
+    for i in 0..200 {
+        assert_eq!(t.get(i).unwrap(), Some(i as u64 + 1));
+    }
+}
+
+/// 文件头里记着页大小和 order：换配置再打开要报错，而不是读出乱七八糟的东西。
+#[test]
+fn config_mismatch_errors() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.idx");
+    {
+        let mut t = DiskBTree::open(&path, DEFAULT_PAGE_SIZE, DEFAULT_BTREE_ORDER).unwrap();
+        t.insert(1, 1).unwrap();
+    }
+    assert!(DiskBTree::open(&path, DEFAULT_PAGE_SIZE, 8).is_err());
+    assert!(DiskBTree::open(&path, 8192, DEFAULT_BTREE_ORDER).is_err());
+    assert!(DiskBTree::open(&path, DEFAULT_PAGE_SIZE, DEFAULT_BTREE_ORDER).is_ok());
+}
+
+/// 不是本项目的索引文件（比如随便一个空文件）要报错。
+#[test]
+fn not_an_index_file_errors() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("junk.idx");
+    std::fs::write(&path, vec![7u8; DEFAULT_PAGE_SIZE]).unwrap();
+    assert!(DiskBTree::open(&path, DEFAULT_PAGE_SIZE, DEFAULT_BTREE_ORDER).is_err());
+}
+
+/// order 放不进一页时直接拒绝。
+#[test]
+fn order_too_large_for_page_errors() {
+    let dir = tempfile::tempdir().unwrap();
+    assert!(DiskBTree::open(dir.path().join("t.idx"), 512, 300).is_err());
+}

chusql-storage/tests/catalog_test.rs

@@ -0,0 +1,59 @@
+use chusql_storage::catalog::Catalog;
+use chusql_storage::protocol::{ColumnType, Row};
+use serde_json::json;
+
+fn row(pairs: &[(&str, serde_json::Value)]) -> Row {
+    let mut m = Row::new();
+    for (k, v) in pairs {
+        m.insert((*k).to_string(), v.clone());
+    }
+    m
+}
+
+#[test]
+fn empty_file_gives_empty_catalog() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("catalog.json");
+    let c = Catalog::load(&path).unwrap();
+    assert_eq!(c.table_names().len(), 0);
+}
+
+#[test]
+fn ensure_then_describe() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("catalog.json");
+
+    let mut c = Catalog::load(&path).unwrap();
+    c.ensure_columns("users", &row(&[("id", json!(1)), ("name", json!("Alice"))]));
+    c.save(&path).unwrap();
+
+    let c2 = Catalog::load(&path).unwrap();
+    let s = c2.describe("users").unwrap();
+    assert_eq!(s.columns.len(), 2);
+    let names: Vec<&str> = s.columns.iter().map(|c| c.name.as_str()).collect();
+    assert!(names.contains(&"id"));
+    assert!(names.contains(&"name"));
+    let id_col = s.columns.iter().find(|c| c.name == "id").unwrap();
+    assert_eq!(id_col.ty, ColumnType::Int);
+    let name_col = s.columns.iter().find(|c| c.name == "name").unwrap();
+    assert_eq!(name_col.ty, ColumnType::Str);
+}
+
+#[test]
+fn second_insert_does_not_duplicate_columns() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("catalog.json");
+
+    let mut c = Catalog::load(&path).unwrap();
+    c.ensure_columns("users", &row(&[("id", json!(1))]));
+    c.ensure_columns("users", &row(&[("id", json!(2))]));
+    assert_eq!(c.describe("users").unwrap().columns.len(), 1);
+}
+
+#[test]
+fn describe_unknown_returns_none() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("catalog.json");
+    let c = Catalog::load(&path).unwrap();
+    assert!(c.describe("nope").is_none());
+}

chusql-storage/tests/config_test.rs

@@ -0,0 +1,131 @@
+use std::path::PathBuf;
+
+use chusql_storage::config::{
+    self, Config, DEFAULT_BTREE_ORDER, DEFAULT_DATA_DIR, DEFAULT_PAGE_SIZE, DEFAULT_PIPE_NAME,
+    Origin,
+};
+use chusql_storage::log::Level;
+
+// 配置测试：没有文件时全默认、文件里写了才覆盖、环境变量优先于文件、
+// 非法值 / 未知键要报错、每个选项的来源都记得下来。
+
+/// 没有配置文件、没有环境变量：全部走内置默认值。
+#[test]
+fn defaults_without_file() {
+    let loaded = config::resolve(None, None, &|_| None).unwrap();
+    assert_eq!(loaded.config, Config::default());
+    assert!(loaded.config_path.is_none());
+    assert!(loaded.origins.iter().all(|(_, _, o)| *o == Origin::Default));
+    assert_eq!(loaded.config.page_size, DEFAULT_PAGE_SIZE);
+    assert_eq!(loaded.config.btree_order, DEFAULT_BTREE_ORDER);
+    assert_eq!(loaded.config.data_dir, PathBuf::from(DEFAULT_DATA_DIR));
+    assert_eq!(loaded.config.pipe_name, DEFAULT_PIPE_NAME);
+    assert_eq!(loaded.config.log_level, Level::Info);
+}
+
+/// 文件里只写了一项：这一项生效，其余回退默认（并且来源记得清清楚楚）。
+#[test]
+fn file_overrides_only_written_keys() {
+    let path = PathBuf::from("t.toml");
+    let loaded = config::resolve(Some("[page]\nsize = 8192\n"), Some(path.clone()), &|_| None)
+        .unwrap();
+
+    assert_eq!(loaded.config.page_size, 8192);
+    assert_eq!(loaded.config.btree_order, DEFAULT_BTREE_ORDER);
+    assert_eq!(loaded.config.data_dir, PathBuf::from(DEFAULT_DATA_DIR));
+    assert_eq!(loaded.config_path, Some(path.clone()));
+
+    let page = loaded.origins.iter().find(|(n, _, _)| *n == "page.size").unwrap();
+    assert_eq!(page.2, Origin::File(path));
+    let order = loaded.origins.iter().find(|(n, _, _)| *n == "btree.order").unwrap();
+    assert_eq!(order.2, Origin::Default);
+}
+
+/// 五项全写：值都生效，来源都是文件。
+#[test]
+fn file_all_keys() {
+    let text = "[page]\nsize = 8192\n[btree]\norder = 32\n[storage]\ndata_dir = \"mydata\"\n[server]\npipe_name = \"mypipe\"\n[log]\nlevel = \"debug\"\n";
+    let path = PathBuf::from("t.toml");
+    let loaded = config::resolve(Some(text), Some(path.clone()), &|_| None).unwrap();
+
+    assert_eq!(loaded.config.page_size, 8192);
+    assert_eq!(loaded.config.btree_order, 32);
+    assert_eq!(loaded.config.data_dir, PathBuf::from("mydata"));
+    assert_eq!(loaded.config.pipe_name, "mypipe");
+    assert_eq!(loaded.config.log_level, Level::Debug);
+    assert!(
+        loaded
+            .origins
+            .iter()
+            .all(|(_, _, o)| *o == Origin::File(path.clone()))
+    );
+}
+
+/// 环境变量优先于文件。
+#[test]
+fn env_beats_file() {
+    let text = "[storage]\ndata_dir = \"from-file\"\n";
+    let env = |k: &str| (k == "CHUSQL_DATA_DIR").then(|| "from-env".to_string());
+    let loaded = config::resolve(Some(text), Some(PathBuf::from("t.toml")), &env).unwrap();
+
+    assert_eq!(loaded.config.data_dir, PathBuf::from("from-env"));
+    let dir = loaded
+        .origins
+        .iter()
+        .find(|(n, _, _)| *n == "storage.data_dir")
+        .unwrap();
+    assert_eq!(dir.2, Origin::Env("CHUSQL_DATA_DIR"));
+}
+
+/// 日志等级写错要报错，而不是悄悄按默认跑。
+#[test]
+fn rejects_bad_log_level() {
+    let err = config::resolve(Some("[log]\nlevel = \"loud\"\n"), None, &|_| None).unwrap_err();
+    assert!(err.contains("log.level"), "got {}", err);
+}
+
+/// 页大小必须是 512..65536 之间的 2 的幂。
+#[test]
+fn rejects_bad_page_size() {
+    let err = config::resolve(Some("[page]\nsize = 3000\n"), None, &|_| None).unwrap_err();
+    assert!(err.contains("page.size"), "got {}", err);
+
+    let err = config::resolve(Some("[page]\nsize = 128\n"), None, &|_| None).unwrap_err();
+    assert!(err.contains("page.size"), "got {}", err);
+}
+
+/// order 太小、或者放不进一页，都要报错。
+#[test]
+fn rejects_bad_btree_order() {
+    let err = config::resolve(Some("[btree]\norder = 2\n"), None, &|_| None).unwrap_err();
+    assert!(err.contains("btree.order"), "got {}", err);
+
+    let err = config::resolve(Some("[btree]\norder = 300\n"), None, &|_| None).unwrap_err();
+    assert!(err.contains("does not fit"), "got {}", err);
+}
+
+/// 配置里出现认不出来的键要报错（拼错了不能当没看见）。
+#[test]
+fn rejects_unknown_key() {
+    let err = config::resolve(Some("[page]\nsizes = 4096\n"), None, &|_| None).unwrap_err();
+    assert!(err.contains("bad config"), "got {}", err);
+}
+
+/// 环境变量给了非法值也要报错。
+#[test]
+fn rejects_bad_env_value() {
+    let env = |k: &str| (k == "CHUSQL_PAGE_SIZE").then(|| "big".to_string());
+    let err = config::resolve(None, None, &env).unwrap_err();
+    assert!(err.contains("CHUSQL_PAGE_SIZE"), "got {}", err);
+}
+
+/// 来源文案要能说清"哪来的"。
+#[test]
+fn origin_description() {
+    assert_eq!(Origin::Default.describe(), "default");
+    assert_eq!(Origin::Env("CHUSQL_PIPE").describe(), "env CHUSQL_PIPE");
+    assert_eq!(
+        Origin::File(PathBuf::from("a.toml")).describe(),
+        format!("file {}", PathBuf::from("a.toml").display())
+    );
+}

chusql-storage/tests/heap_test.rs

@@ -0,0 +1,143 @@
+use chusql_storage::config::DEFAULT_PAGE_SIZE;
+use chusql_storage::heap::HeapTable;
+use chusql_storage::protocol::Row;
+use serde_json::json;
+
+// 堆表测试：插入 + 全表扫描、跨页多行、大行、超大行报错、重开文件后数据还在、自定义页大小。
+
+/// 造一行测试数据（列名 → JSON 值）。
+fn row(pairs: &[(&str, serde_json::Value)]) -> Row {
+    let mut m = Row::new();
+    for (k, v) in pairs {
+        m.insert((*k).to_string(), v.clone());
+    }
+    m
+}
+
+/// 插一行再扫描，能原样读回来。
+#[test]
+fn insert_and_scan_one_row() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.db");
+    let mut t = HeapTable::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    t.insert(&row(&[("id", json!(1)), ("name", json!("Alice"))]))
+        .unwrap();
+
+    let rows = t.scan().unwrap();
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0]["id"], json!(1));
+    assert_eq!(rows[0]["name"], json!("Alice"));
+}
+
+/// 插 500 行（必然跨多页），扫描回来的行数和顺序都要对。
+#[test]
+fn insert_many_rows_cross_pages() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.db");
+    let mut t = HeapTable::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    for i in 0..500 {
+        t.insert(&row(&[("id", json!(i))])).unwrap();
+    }
+
+    let rows = t.scan().unwrap();
+    assert_eq!(rows.len(), 500);
+    // 顺序保持
+    for (i, r) in rows.iter().enumerate() {
+        assert_eq!(r["id"], json!(i as i64));
+    }
+}
+
+/// 约 2KB 的大行也要能放进一页。
+#[test]
+fn large_row_still_fits() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.db");
+    let mut t = HeapTable::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    let big = "x".repeat(2000);
+    t.insert(&row(&[("data", json!(big.clone()))])).unwrap();
+
+    let rows = t.scan().unwrap();
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0]["data"], json!(big));
+}
+
+/// 超过一页容量的行要报错，而不是悄悄写坏。
+#[test]
+fn row_too_large_errors() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.db");
+    let mut t = HeapTable::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    let huge = "x".repeat(10_000);
+    let err = t.insert(&row(&[("data", json!(huge))]));
+    assert!(err.is_err());
+}
+
+/// 关掉再重新打开同一个文件，之前插入的数据还在。
+#[test]
+fn reopen_and_scan() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("t.db");
+
+    {
+        let mut t = HeapTable::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+        t.insert(&row(&[("id", json!(1))])).unwrap();
+        t.insert(&row(&[("id", json!(2))])).unwrap();
+    }
+
+    let mut t = HeapTable::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+    let rows = t.scan().unwrap();
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0]["id"], json!(1));
+    assert_eq!(rows[1]["id"], json!(2));
+}
+
+/// 页大小可以配置：512 字节的页装得下小行、放不下大行，行数不变。
+#[test]
+fn custom_page_size() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("small.db");
+    let mut t = HeapTable::open(&path, 512).unwrap();
+
+    for i in 0..50 {
+        t.insert(&row(&[("id", json!(i))])).unwrap();
+    }
+    assert_eq!(t.scan().unwrap().len(), 50);
+
+    let big = "x".repeat(600);
+    assert!(t.insert(&row(&[("data", json!(big))])).is_err());
+}
+
+/// 整表改写之后索引必须跟着重建：旧键查不到，新行按 id 能查到。
+#[test]
+fn replace_all_rebuilds_index() {
+    let dir = tempfile::tempdir().unwrap();
+    let mut t = HeapTable::open_indexed(
+        dir.path().join("t.db"),
+        dir.path().join("t.idx"),
+        DEFAULT_PAGE_SIZE,
+        chusql_storage::config::DEFAULT_BTREE_ORDER,
+    )
+    .unwrap();
+
+    t.insert_keyed(&row(&[("id", json!(1)), ("name", json!("Alice"))]), 1)
+        .unwrap();
+    t.insert_keyed(&row(&[("id", json!(2)), ("name", json!("Bob"))]), 2)
+        .unwrap();
+    assert!(t.get_by_key(1).unwrap().is_some());
+
+    t.replace_all(&[
+        row(&[("id", json!(7)), ("name", json!("Zoe"))]),
+        row(&[("name", json!("NoId"))]),
+    ])
+    .unwrap();
+
+    assert!(t.get_by_key(1).unwrap().is_none(), "旧键必须作废");
+    assert!(t.get_by_key(2).unwrap().is_none());
+    let got = t.get_by_key(7).unwrap().expect("新行应该按 id 建好索引");
+    assert_eq!(got["name"], json!("Zoe"));
+    assert_eq!(t.scan().unwrap().len(), 2);
+}

chusql-storage/tests/page_test.rs

@@ -0,0 +1,129 @@
+use chusql_storage::config::DEFAULT_PAGE_SIZE;
+use chusql_storage::page::{Page, PageFile};
+
+// 页文件测试：一页的读写、页号越界报错、追加页让文件变长、多页互不干扰、覆写同一页、
+// 自定义页大小、页大小和文件对不上时报错。
+
+/// 写入一页再读回来，内容和长度都应该一致。
+#[test]
+fn write_then_read_page() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("test.db");
+
+    let mut pf = PageFile::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    let mut p = Page::new(0, DEFAULT_PAGE_SIZE);
+    p.data[0] = 42;
+    p.data[DEFAULT_PAGE_SIZE - 1] = 7;
+    pf.write_page(&p).unwrap();
+
+    let read = pf.read_page(0).unwrap();
+    assert_eq!(read.data[0], 42);
+    assert_eq!(read.data[DEFAULT_PAGE_SIZE - 1], 7);
+    assert_eq!(read.data.len(), DEFAULT_PAGE_SIZE);
+}
+
+/// 空文件读第 0 页应该报错。
+#[test]
+fn read_out_of_range_returns_error() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("test.db");
+
+    let mut pf = PageFile::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+    assert!(pf.read_page(0).is_err());
+}
+
+/// 每 append 一页，num_pages 就加一。
+#[test]
+fn append_grows_file() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("test.db");
+
+    let mut pf = PageFile::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+    assert_eq!(pf.num_pages().unwrap(), 0);
+
+    pf.append_page().unwrap();
+    assert_eq!(pf.num_pages().unwrap(), 1);
+
+    pf.append_page().unwrap();
+    pf.append_page().unwrap();
+    assert_eq!(pf.num_pages().unwrap(), 3);
+}
+
+/// 页 0 和页 1 的内容互不影响。
+#[test]
+fn two_pages_independent() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("test.db");
+
+    let mut pf = PageFile::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    let mut a = Page::new(0, DEFAULT_PAGE_SIZE);
+    a.data[0] = 1;
+    let mut b = Page::new(1, DEFAULT_PAGE_SIZE);
+    b.data[0] = 2;
+    pf.write_page(&a).unwrap();
+    pf.write_page(&b).unwrap();
+
+    assert_eq!(pf.read_page(0).unwrap().data[0], 1);
+    assert_eq!(pf.read_page(1).unwrap().data[0], 2);
+}
+
+/// 覆写同一页：读到的是新内容，页数不变。
+#[test]
+fn overwrite_page() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("test.db");
+
+    let mut pf = PageFile::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+
+    let mut a = Page::new(0, DEFAULT_PAGE_SIZE);
+    a.data[0] = 1;
+    pf.write_page(&a).unwrap();
+
+    let mut b = Page::new(0, DEFAULT_PAGE_SIZE);
+    b.data[0] = 99;
+    pf.write_page(&b).unwrap();
+
+    assert_eq!(pf.read_page(0).unwrap().data[0], 99);
+    assert_eq!(pf.num_pages().unwrap(), 1);
+}
+
+/// 页大小可以配置：512 字节的页照样读写，文件按 512 字节对齐。
+#[test]
+fn custom_page_size() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("small.db");
+
+    let mut pf = PageFile::open(&path, 512).unwrap();
+    assert_eq!(pf.page_size(), 512);
+
+    let mut p = Page::new(0, 512);
+    p.data[511] = 9;
+    pf.write_page(&p).unwrap();
+
+    assert_eq!(pf.read_page(0).unwrap().data[511], 9);
+    assert_eq!(pf.num_pages().unwrap(), 1);
+    assert_eq!(std::fs::metadata(&path).unwrap().len(), 512);
+}
+
+/// 文件长度不是页大小整数倍（比如页大小被改过）要报错，而不是算出错误的页数。
+#[test]
+fn mismatched_file_length_errors() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("odd.db");
+    std::fs::write(&path, vec![0u8; 100]).unwrap();
+
+    let mut pf = PageFile::open(&path, DEFAULT_PAGE_SIZE).unwrap();
+    assert!(pf.num_pages().is_err());
+}
+
+/// 页大小对不上的页不许写进去。
+#[test]
+fn write_wrong_sized_page_errors() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("test.db");
+
+    let mut pf = PageFile::open(&path, 512).unwrap();
+    assert!(pf.write_page(&Page::new(0, 1024)).is_err());
+}

chusql-storage/tests/pipe_test.rs

@@ -0,0 +1,284 @@
+use std::io::{BufRead, BufReader, Write};
+use std::process::{Child, Command, Stdio};
+use std::thread;
+use std::time::Duration;
+
+use interprocess::local_socket::{
+    prelude::*,
+    GenericNamespaced
+};
+use interprocess::TryClone;
+
+// 命名管道集成测试：起 server 子进程，用唯一管道名，测试之间互不干扰。
+
+/// 生成唯一管道名，避免测试之间抢占。
+fn unique_pipe_name() -> String {
+    let id = std::process::id();
+    let ns = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    format!("chusql-test-{}-{}", id, ns)
+}
+
+/// 持有 server 子进程，Drop 时杀掉。
+struct ServerProc(Child);
+
+impl Drop for ServerProc {
+    /// 测试结束时杀掉子进程并回收，避免留下孤儿进程。
+    fn drop(&mut self) {
+        let _ = self.0.kill();
+        let _ = self.0.wait();
+    }
+}
+
+/// 启动 server 子进程，并等管道可连（最多 5 秒）。
+fn start_server(pipe: &str) -> (ServerProc, tempfile::TempDir) {
+    let data = tempfile::tempdir().unwrap();
+
+    let child = Command::new(env!("CARGO_BIN_EXE_server"))
+        .env("CHUSQL_PIPE", pipe)
+        .env("CHUSQL_DATA_DIR", data.path())
+        .env("CHUSQL_PAGE_SIZE", "4096")
+        .env("CHUSQL_BTREE_ORDER", "4")
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to spawn server");
+
+    let srv = ServerProc(child);
+
+    for _ in 0..100 {
+        if connect(pipe).is_ok() {
+            return (srv, data);
+        }
+        thread::sleep(Duration::from_millis(50));
+    }
+    panic!("server did not start within 5s");
+}
+
+/// 连到指定管道。
+fn connect(pipe: &str) -> std::io::Result<LocalSocketStream> {
+    let name = pipe
+        .to_ns_name::<GenericNamespaced>()
+        .map_err(|e| std::io::Error::other(e.to_string()))?;
+    LocalSocketStream::connect(name)
+}
+
+/// 发一行请求，读一行响应。
+fn send(stream: &mut LocalSocketStream, line: &str) -> String {
+    stream.write_all(line.as_bytes()).unwrap();
+    stream.write_all(b"\n").unwrap();
+    stream.flush().unwrap();
+
+    let mut reader = BufReader::new(stream.try_clone().unwrap());
+    let mut buf = String::new();
+    reader.read_line(&mut buf).unwrap();
+    buf.trim().to_string()
+}
+
+/// ping 应该回 pong。
+#[test]
+fn ping_pong() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+
+    let mut c = connect(&pipe).unwrap();
+    assert_eq!(send(&mut c, r#"{"method":"ping"}"#), r#"{"status":"pong"}"#);
+}
+
+/// 插一行再 scan，能扫到刚插进去的数据。
+#[test]
+fn insert_then_scan() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+    let mut c = connect(&pipe).unwrap();
+
+    let r1 = send(
+        &mut c,
+        r#"{"method":"insert","table":"users","row":{"id":1,"name":"Alice"}}"#,
+    );
+    assert!(r1.contains(r#""status":"ok""#), "insert response: {}", r1);
+
+    let r2 = send(&mut c, r#"{"method":"scan","table":"users"}"#);
+    assert!(r2.contains("Alice"), "scan response: {}", r2);
+}
+
+#[test]
+fn scan_unknown_table_errors() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+    let mut c = connect(&pipe).unwrap();
+
+    let r = send(&mut c, r#"{"method":"scan","table":"nope"}"#);
+    assert!(r.contains(r#""status":"error""#), "got {}", r);
+    assert!(r.contains("unknown table"), "got {}", r);
+}
+
+#[test]
+fn list_tables_returns_created_tables() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+    let mut c = connect(&pipe).unwrap();
+
+    send(&mut c, r#"{"method":"insert","table":"users","row":{"id":1}}"#);
+    send(&mut c, r#"{"method":"insert","table":"orders","row":{"id":1}}"#);
+
+    let r = send(&mut c, r#"{"method":"list_tables"}"#);
+    assert!(r.contains("users"), "got {}", r);
+    assert!(r.contains("orders"), "got {}", r);
+}
+
+#[test]
+fn replace_all_replaces_rows() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+    let mut c = connect(&pipe).unwrap();
+
+    send(&mut c, r#"{"method":"insert","table":"users","row":{"id":1,"name":"Alice"}}"#);
+    send(&mut c, r#"{"method":"insert","table":"users","row":{"id":2,"name":"Bob"}}"#);
+
+    let r = send(
+        &mut c,
+        r#"{"method":"replace_all","table":"users","rows":[{"id":9,"name":"Zoe"}]}"#,
+    );
+    assert!(r.contains(r#""status":"ok""#), "replace_all response: {}", r);
+
+    let r = send(&mut c, r#"{"method":"scan","table":"users"}"#);
+    assert!(r.contains("Zoe"), "got {}", r);
+    assert!(!r.contains("Alice"), "old row should be gone: {}", r);
+}
+
+#[test]
+fn insert_with_key_then_lookup() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+    let mut c = connect(&pipe).unwrap();
+
+    // 带索引键插三行
+    for (id, name) in [(1, "Alice"), (2, "Bob"), (3, "Carol")] {
+        let req = format!(
+            r#"{{"method":"insert","table":"idx_users","row":{{"id":{},"name":"{}"}},"key":{}}}"#,
+            id, name, id
+        );
+        let r = send(&mut c, &req);
+        assert!(r.contains(r#""status":"ok""#), "insert: {}", r);
+    }
+
+    // 命中
+    let r = send(&mut c, r#"{"method":"lookup_by_index","table":"idx_users","key":2}"#);
+    assert!(r.contains("Bob"), "lookup: {}", r);
+
+    // 未命中
+    let r = send(&mut c, r#"{"method":"lookup_by_index","table":"idx_users","key":99}"#);
+    assert!(r.contains(r#""rows":[]"#), "miss: {}", r);
+}
+
+#[test]
+fn insert_without_key_does_not_index() {
+    let pipe = unique_pipe_name();
+    let (_srv, _data) = start_server(&pipe);
+    let mut c = connect(&pipe).unwrap();
+
+    send(&mut c, r#"{"method":"insert","table":"nokey","row":{"id":1}}"#);
+    let r = send(&mut c, r#"{"method":"lookup_by_index","table":"nokey","key":1}"#);
+    assert!(r.contains(r#""rows":[]"#), "got: {}", r);
+}
+
+#[test]
+fn lookup_survives_reopen() {
+    let pipe = unique_pipe_name();
+    let data = tempfile::tempdir().unwrap();
+
+    // 第一次：写 3 行带 key
+    {
+        let exe = env!("CARGO_BIN_EXE_server");
+        let child = Command::new(exe)
+            .env("CHUSQL_PIPE", &pipe)
+            .env("CHUSQL_DATA_DIR", data.path())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .unwrap();
+        let srv = ServerProc(child);
+        for _ in 0..100 {
+            if connect(&pipe).is_ok() { break; }
+            thread::sleep(Duration::from_millis(50));
+        }
+        let mut c = connect(&pipe).unwrap();
+        for (id, name) in [(1, "Alice"), (2, "Bob"), (3, "Carol")] {
+            let req = format!(
+                r#"{{"method":"insert","table":"persist","row":{{"id":{},"name":"{}"}},"key":{}}}"#,
+                id, name, id
+            );
+            send(&mut c, &req);
+        }
+        drop(srv);  // 杀 server
+    }
+
+    // 等一下，让文件句柄真正释放
+    thread::sleep(Duration::from_millis(200));
+
+    // 第二次：重开 server，从索引查到
+    let (_srv, _data) = {
+        let child = Command::new(env!("CARGO_BIN_EXE_server"))
+            .env("CHUSQL_PIPE", &pipe)
+            .env("CHUSQL_DATA_DIR", data.path())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .unwrap();
+        let srv = ServerProc(child);
+        for _ in 0..100 {
+            if connect(&pipe).is_ok() { break; }
+            thread::sleep(Duration::from_millis(50));
+        }
+        (srv, data)
+    };
+
+    let mut c = connect(&pipe).unwrap();
+    let r = send(&mut c, r#"{"method":"lookup_by_index","table":"persist","key":2}"#);
+    assert!(r.contains("Bob"), "persist lookup: {}", r);
+}
+
+/// 配置文件里的管道名和数据目录要真的生效（这里不设 CHUSQL_PIPE / CHUSQL_DATA_DIR）。
+#[test]
+fn config_file_is_used() {
+    let dir = tempfile::tempdir().unwrap();
+    let pipe = unique_pipe_name();
+    let data_dir = dir.path().join("data");
+    let config_path = dir.path().join("chusql-storage.toml");
+
+    // TOML 里写正斜杠，省得转义 Windows 路径
+    let text = format!(
+        "[server]\npipe_name = \"{}\"\n[storage]\ndata_dir = \"{}\"\n[log]\nlevel = \"debug\"\n",
+        pipe,
+        data_dir.display().to_string().replace('\\', "/")
+    );
+    std::fs::write(&config_path, text).unwrap();
+
+    let child = Command::new(env!("CARGO_BIN_EXE_server"))
+        .env("CHUSQL_CONFIG", &config_path)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to spawn server");
+    let _srv = ServerProc(child);
+    for _ in 0..100 {
+        if connect(&pipe).is_ok() {
+            break;
+        }
+        thread::sleep(Duration::from_millis(50));
+    }
+
+    let mut c = connect(&pipe).unwrap();
+    assert_eq!(send(&mut c, r#"{"method":"ping"}"#), r#"{"status":"pong"}"#);
+    let r = send(&mut c, r#"{"method":"insert","table":"cfg","row":{"id":1}}"#);
+    assert!(r.contains(r#""status":"ok""#), "insert: {}", r);
+
+    // 数据真的落在配置文件指的那个目录里
+    assert!(
+        data_dir.join("cfg.db").exists(),
+        "data dir from config file was not used"
+    );
+}

chusql-storage/tests/wal_test.rs

@@ -0,0 +1,119 @@
+use chusql_storage::protocol::Row;
+use chusql_storage::wal::{Wal, WalOp};
+use serde_json::json;
+
+fn row(pairs: &[(&str, serde_json::Value)]) -> Row {
+    let mut m = Row::new();
+    for (k, v) in pairs {
+        m.insert((*k).to_string(), v.clone());
+    }
+    m
+}
+
+#[test]
+fn append_and_read_insert() {
+    let dir = tempfile::tempdir().unwrap();
+    let wal = Wal::new(dir.path().join("wal.log"));
+
+    let op = WalOp::Insert {
+        table: "users".into(),
+        row: row(&[("id", json!(1)), ("name", json!("Alice"))]),
+        key: Some(1),
+    };
+    wal.append(&op).unwrap();
+
+    let back = wal.read().unwrap().unwrap();
+    assert_eq!(back, op);
+}
+
+#[test]
+fn append_and_read_replace_all() {
+    let dir = tempfile::tempdir().unwrap();
+    let wal = Wal::new(dir.path().join("wal.log"));
+
+    let op = WalOp::ReplaceAll {
+        table: "users".into(),
+        rows: vec![
+            row(&[("id", json!(1)), ("name", json!("Alice"))]),
+            row(&[("id", json!(2)), ("name", json!("Bob"))]),
+        ],
+    };
+    wal.append(&op).unwrap();
+
+    let back = wal.read().unwrap().unwrap();
+    assert_eq!(back, op);
+}
+
+#[test]
+fn missing_file_returns_none() {
+    let dir = tempfile::tempdir().unwrap();
+    let wal = Wal::new(dir.path().join("wal.log"));
+    assert!(wal.read().unwrap().is_none());
+}
+
+#[test]
+fn empty_file_returns_none() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("wal.log");
+    std::fs::write(&path, b"").unwrap();
+    let wal = Wal::new(&path);
+    assert!(wal.read().unwrap().is_none());
+}
+
+#[test]
+fn clear_truncates() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("wal.log");
+    let wal = Wal::new(&path);
+
+    wal.append(&WalOp::Insert {
+        table: "t".into(),
+        row: row(&[("id", json!(1))]),
+        key: None,
+    })
+    .unwrap();
+    assert!(wal.read().unwrap().is_some());
+
+    wal.clear().unwrap();
+    assert!(wal.read().unwrap().is_none());
+    assert_eq!(std::fs::metadata(&path).unwrap().len(), 0);
+}
+
+#[test]
+fn truncated_tail_is_ignored() {
+    let dir = tempfile::tempdir().unwrap();
+    let path = dir.path().join("wal.log");
+    let wal = Wal::new(&path);
+
+    wal.append(&WalOp::Insert {
+        table: "users".into(),
+        row: row(&[("id", json!(1)), ("name", json!("Alice"))]),
+        key: Some(1),
+    })
+    .unwrap();
+
+    // 砍掉最后 5 个字节，模拟"写一半断电"
+    let full = std::fs::read(&path).unwrap();
+    std::fs::write(&path, &full[..full.len() - 5]).unwrap();
+
+    // 读回来应该当作"没有这条"
+    assert!(wal.read().unwrap().is_none());
+}
+
+#[test]
+fn overwrite_on_second_append_is_visible() {
+    // 简化版一次只允许一条，append 两次会叠在文件里——
+    // 但正常路径下 clear 先跑，所以实际不会叠加。
+    // 这个测试只验证 read 能解析最前面那一条。
+    let dir = tempfile::tempdir().unwrap();
+    let wal = Wal::new(dir.path().join("wal.log"));
+
+    wal.append(&WalOp::Insert {
+        table: "t".into(),
+        row: row(&[("id", json!(1))]),
+        key: None,
+    })
+    .unwrap();
+    let first = wal.read().unwrap().unwrap();
+    assert!(matches!(first, WalOp::Insert { .. }));
+}