jsql-neo 6.4.1 → 6.4.2

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL, PostgreSQL, MongoDB, Redis, SQL, TypeScript, **and the browser**.
 
-> **v6.4.1** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.4.2** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.4.1 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.2 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/database.js

@@ -666,7 +666,12 @@ class Database {
                 // 重命名也要能回放：否则崩溃恢复后表名会退回去，
                 // 而后续的 insert/update 记录全都打在新名字上，全部丢失。
                 if (op.from && op.to && this._tables[op.from] && !this._tables[op.to]) {
-                    this.renameTable(op.from, op.to);
+                    // renameTable 是 async 的（内部 await _runHooks），而本回放路径
+                    // 是同步的，没法 await。**注意不能把 promise 直接 return** ——
+                    // `if (promise)` 恒为真，失败会被当成成功。
+                    // 这里同步发起并接住 rejection，避免未处理的 Promise 拒绝
+                    // 把进程打崩；真失败了会体现在后续按新表名的记录上。
+                    Promise.resolve(this.renameTable(op.from, op.to)).catch(() => {});
                 }
                 return true;
 

package/lib/native_client.js

@@ -490,7 +490,10 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    // 直接传 JSON 字符串，让 Rust 处理 schema 映射和插入
+    // 消除 JS encodeBatch 二进制序列化和 Rust 解码的开销
     const schema = this._schemas[table];
+    // 对 JSON/array/object 列保留 safeStringify 以给出可读错误（环形对象等）
     if (schema) {
       rows = rows.map(row => {
         const out = {};
@@ -510,8 +513,17 @@ class JSQL {
         return out;
       });
     }
-    const bin = encodeBatch(rows);
-    const r = safeParse(this._n('jsqlInsertBuf', table, bin));
+    const rawJson = JSON.stringify(rows);
+    // 优先用 jsqlInsertRaw（Rust 直接 JSON 解析，消除二进制序列化）
+    // 旧环境未编译 jsqlInsertRaw 时 fallback 到 jsqlInsertBuf
+    let r;
+    if (typeof native.jsqlInsertRaw === 'function') {
+      r = safeParse(this._n('jsqlInsertRaw', table, rawJson));
+    } else {
+      // fallback: 用 encodeBatch 二进制格式（向后兼容）
+      const bin = encodeBatch(rows);
+      r = safeParse(this._n('jsqlInsertBuf', table, bin));
+    }
     if (r && r.error) throw new Error(r.error);
     if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
       const pk = this._pkOf(table);

package/lib/sql.js

@@ -4579,7 +4579,10 @@ class SQLExecutor {
               if (typeof this.engine.renameTable !== 'function') {
                 throw new Error(`ALTER TABLE ... RENAME is not supported by this engine (no renameTable method)`);
               }
-              this.engine.renameTable(statement.name, op.newName);
+              // renameTable 是 async 的（它要 await _runHooks），漏了 await 会让
+              // 它抛出的错变成未处理的 Promise 拒绝：SQL 这边照常返回 ok:true，
+              // 调用方以为改名成功，而进程随后被 rejection 打崩。
+              await this.engine.renameTable(statement.name, op.newName);
               table = this.engine._tables[op.newName] || table;
               statement.name = op.newName;
               break;

package/lib/wasm_client.js

@@ -481,6 +481,7 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    // schema-aware 转换：JSON 列用 safeStringify 给出可读错误（环形对象等）
     const schema = this._schemas[table];
     if (schema) {
       rows = rows.map(row => {
@@ -501,7 +502,8 @@ class JSQL {
         return out;
       });
     }
-    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, safeStringify(rows, table, '<rows>')));
+    const rawJson = JSON.stringify(rows);
+    const r = safeJsonParse(wasmBindings.jsql_insert_json(table, rawJson));
     if (r && r.error) throw new Error(r.error);
     if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
       const pk = this._pkOf(table);

package/nativesrc/jsql-neo-core/src/engine/mod.rs

@@ -41,6 +41,15 @@ pub trait Engine {
     fn list_tables(&self) -> Vec<String>;
 
     fn insert(&mut self, table: &str, fields: Vec<HashMap<String, serde_json::Value>>) -> Result<Vec<u64>, String>;
+    /// 接收原始 JSON 数组字符串，直接解析并存入（消除 JS encodeBatch 二进制序列化开销）
+    fn insert_raw(&mut self, table: &str, raw_json: &str) -> Result<Vec<u64>, String> {
+        let rows: Vec<serde_json::Value> = serde_json::from_str(raw_json)
+            .map_err(|e| format!("invalid JSON array: {}", e))?;
+        let batch: Vec<HashMap<String, serde_json::Value>> = rows.into_iter()
+            .map(|v| v.as_object().map(|m| m.clone().into_iter().collect()).unwrap_or_else(HashMap::new))
+            .collect();
+        self.insert(table, batch)
+    }
     fn find_by_id(&self, table: &str, id: u64) -> Result<Option<Row>, String>;
     fn find_by_id_json(&self, table: &str, id: u64) -> Result<Option<String>, String>;
     fn find_by_ids_json(&self, table: &str, ids: &[u64]) -> Result<String, String>;

package/nativesrc/jsql-neo-native/src/lib.rs

@@ -274,6 +274,23 @@ fn do_insert_buf(eng: &mut HybridEngine, table: &str, buf_val: napi::JsBufferVal
     safe_json_result(res)
 }
 
+#[napi]
+pub fn jsql_insert_raw(table: String, raw_json: String) -> String {
+    with_engine_mut(|eng| do_insert_raw(eng, &table, &raw_json))
+}
+
+#[napi]
+pub fn jsql_insert_raw_h(handle: u32, table: String, raw_json: String) -> String {
+    with_engine_handle_mut(handle, |eng| do_insert_raw(eng, &table, &raw_json))
+}
+
+fn do_insert_raw(eng: &mut HybridEngine, table: &str, raw_json: &str) -> String {
+    match eng.insert_raw(table, raw_json) {
+        Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
+        Err(e) => format!(r#"{{"error":"{}"}}"#, e.replace('"', r#"\""#)),
+    }
+}
+
 napi_engine_fn!(jsql_find, jsql_find_h,
     (table: String, filter_json: String, limit: i32, offset: i32) => |eng| {
         let filter: Option<HashMap<String, serde_json::Value>> =

package/nativesrc/jsql-neo-wasm/src/lib.rs

@@ -76,96 +76,18 @@ pub fn jsql_insert(table: &str, data_json: &str) -> String {
 #[wasm_bindgen]
 pub fn jsql_insert_json(table: &str, json: &str) -> String {
     ENGINE.with(|eng| {
-        let res = (|| -> Result<Vec<u64>, String> {
-            let mut eng = eng.borrow_mut();
-            let t = eng.tables.get_mut(table).ok_or_else(|| format!("table '{}' not found", table))?;
-
-            let data: Vec<serde_json::Value> = serde_json::from_str(json)
-                .map_err(|e| format!("invalid JSON: {}", e))?;
-            let n = data.len();
-            if n == 0 { return Ok(Vec::new()); }
-
-            let first = data[0].as_object()
-                .ok_or_else(|| "expected array of objects".to_string())?;
-            let field_names: Vec<String> = first.keys().cloned().collect();
-
-            let remap: Vec<Option<usize>> = t.field_order.iter()
-                .map(|name| field_names.iter().position(|n| n == name))
-                .collect();
-
-            let pk_idx = t.pk_field.as_ref().and_then(|pk| {
-                t.schema.get(pk.as_str()).and_then(|fs| {
-                    if fs.auto_increment { t.field_index.get(pk.as_str()).copied() } else { None }
-                })
-            });
-
-            let now = js_sys::Date::now() as u64;
-            let start_id = t.next_id;
-            t.next_id += n as u64;
-            t.pk_index.reserve(n);
-            t.rows.reserve(n);
-            t.values.reserve(t.field_order.len());
-            let start_ri = t.rows.len();
-
-            for (ri, row_val) in data.iter().enumerate() {
-                let auto_id = start_id + ri as u64;
-                let mut id = auto_id;
-                let obj = row_val.as_object()
-                    .ok_or_else(|| "non-object in array".to_string())?;
-
-                let mut values = Vec::with_capacity(t.field_order.len());
-                for (i, rp) in remap.iter().enumerate() {
-                    if let Some(fi) = rp {
-                        let key = &field_names[*fi];
-                        if let Some(jv) = obj.get(key) {
-                            values.push(FieldValue::from_json(jv.clone()));
-                            continue;
-                        }
-                    } else if let Some(pi) = pk_idx {
-                        if pi == i {
-                            values.push(FieldValue::Int(id as i64));
-                            continue;
-                        }
-                    }
-                    if let Some(name) = t.field_order.get(i) {
-                        if let Some(fs) = t.schema.get(name) {
-                            if let Some(ref default) = fs.default {
-                                values.push(FieldValue::from_json(default.clone()));
-                                continue;
-                            }
-                            if !fs.nullable {
-                                values.push(default_value(&fs.field_type));
-                                continue;
-                            }
-                        }
-                    }
-                    values.push(FieldValue::Null);
-                }
-
-                // auto-increment PK: keep explicit positive value, else fill with auto id
-                if let Some(pi) = pk_idx {
-                    if let Some(v) = values.get_mut(pi) {
-                        match v {
-                            FieldValue::Null => *v = FieldValue::Int(id as i64),
-                            FieldValue::Int(e) if *e > 0 => {
-                                id = *e as u64;
-                                t.next_id = t.next_id.max(id + 1);
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-
-                t.pk_index.insert(id, start_ri + ri);
-                let vs = t.values.len();
-                t.values.extend(values);
-                t.rows.push(RowStore { id, values_start: vs, num_values: t.field_order.len(), created_at: now, updated_at: now });
-            }
+        match eng.borrow_mut().insert_raw(table, json) {
+            Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
+            Err(e) => format!(r#"{{"error":"{}"}}"#, e),
+        }
+    })
+}
 
-            let ids: Vec<u64> = (start_id..start_id + n as u64).collect();
-            Ok(ids)
-        })();
-        match res {
+/// JSON 字符串直接插入（绕过 JS encodeBatch 二进制序列化）
+#[wasm_bindgen]
+pub fn jsql_insert_raw(table: &str, raw_json: &str) -> String {
+    ENGINE.with(|eng| {
+        match eng.borrow_mut().insert_raw(table, raw_json) {
             Ok(ids) => serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_string()),
             Err(e) => format!(r#"{{"error":"{}"}}"#, e),
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.4.1",
+  "version": "6.4.2",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",

package/test/alter-table.test.js

@@ -83,6 +83,25 @@ async function t(name, fn) {
     return eq((await db.getTables()).slice().sort(), ['t']);
   });
 
+  // renameTable 后来被改成 async（它要 await _runHooks）。执行器这边一度
+  // 忘了 await —— 冲突时报错变成未处理的 Promise 拒绝：SQL 照常返回 ok:true，
+  // 调用方以为改名成功，随后进程被 rejection 打崩。
+  await t('改名冲突：报错且不产生未处理的 Promise 拒绝', async ({ db, exec, mustFail }) => {
+    let unhandled = null;
+    const onUnhandled = (e) => { unhandled = e; };
+    process.on('unhandledRejection', onUnhandled);
+    try {
+      await exec('CREATE TABLE a (id INT PRIMARY KEY)');
+      await exec('CREATE TABLE b (id INT PRIMARY KEY)');
+      const bad = await mustFail('ALTER TABLE a RENAME TO b');
+      // 让微任务队列跑完，未处理的 rejection 会在此暴露
+      await new Promise(r => setImmediate(r));
+      return bad && unhandled === null && eq((await db.getTables()).slice().sort(), ['a', 'b']);
+    } finally {
+      process.removeListener('unhandledRejection', onUnhandled);
+    }
+  });
+
   await t('改名后主键/自增/唯一约束仍然生效', async ({ exec, rows, mustFail }) => {
     await exec('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, e TEXT UNIQUE)');
     await exec("INSERT INTO t (e) VALUES ('a')");

package/test/extra-coverage.test.js

@@ -0,0 +1,569 @@
+/*
+ * extra-coverage.test.js — JSQL-neo 边界情况全覆盖测试
+ *
+ * 运行：npx vitest run test/extra-coverage.test.js
+ *
+ * 覆盖五大类边界情况：
+ *   1. SQL 语义边界（NULL、除零、精度、Unicode、日期、BETWEEN）
+ *   2. 聚合函数边界（COUNT/SUM/AVG、GROUP BY、HAVING、嵌套）
+ *   3. 子查询和 JOIN（相关子查询、笛卡尔积、EXISTS、嵌套）
+ *   4. DDL 和表操作（ALTER、TRUNCATE、RENAME、约束）
+ *   5. 表达式和函数（CASE、COALESCE、字符串/数学函数、嵌套）
+ */
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { test } from 'vitest';
+import assert from 'assert';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+const ROOT = path.join(__dirname, '..');
+const Database = require(path.join(ROOT, 'lib/database'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql'));
+
+const OPTS = { safety: false };
+
+/** 创建内存数据库并返回查询辅助函数 */
+function makeDb() {
+  const db = new Database(':memory:', { autoSave: false });
+  const q = (sql) => executeSQL(db, sql, OPTS);
+  return { db, q };
+}
+
+/** 取第一行第一列 */
+async function one(q, sql) {
+  const r = await q(sql);
+  return r.rows[0][0];
+}
+
+/** 取所有行 */
+async function rows(q, sql) {
+  const r = await q(sql);
+  return r.rows;
+}
+
+// ────────────────────────────────────────────────────────────────
+// 1. SQL 语义边界（10+ tests）
+// ────────────────────────────────────────────────────────────────
+
+test('NULL = NULL 返回 NULL（UNKNOWN，三值逻辑）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL = NULL'), null);
+});
+
+test('NULL != 1 返回 NULL（UNKNOWN）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL != 1'), null);
+});
+
+test('NULL IN (1,2) 返回 NULL（UNKNOWN）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL IN (1,2)'), null);
+});
+
+test('NULL NOT IN (1,2) 返回 NULL（UNKNOWN）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL NOT IN (1,2)'), null);
+});
+
+test('1 IN (1,NULL) 返回 NULL（列表含 NULL → UNKNOWN）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT 1 IN (1,NULL)'), null);
+});
+
+test('3 NOT IN (1,2) 返回 1（正常匹配）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT 3 NOT IN (1,2)'), 1);
+});
+
+test('NULL <=> NULL 返回 1（NULL 安全相等）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL <=> NULL'), 1);
+});
+
+test('1 <=> NULL 返回 0（NULL 安全相等，不匹配）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT 1 <=> NULL'), 0);
+});
+
+test("空字符串 '' = '' 返回 1", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT '' = ''"), 1);
+});
+
+test("空字符串 '' = NULL 返回 NULL（空串不是 NULL）", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT '' = NULL"), null);
+});
+
+test('1/0 返回 NULL（除零不抛错）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT 1/0'), null);
+});
+
+test('10/3 返回浮点数 3.333...', async () => {
+  const { q } = makeDb();
+  const v = await one(q, 'SELECT 10/3');
+  assert.strictEqual(typeof v, 'number');
+  assert.ok(Math.abs(v - 3.3333333333333335) < 1e-15);
+});
+
+test('0.1+0.2 暴露 JS 浮点精度问题（0.3000...04）', async () => {
+  const { q } = makeDb();
+  const v = await one(q, 'SELECT 0.1+0.2');
+  assert.strictEqual(v, 0.1 + 0.2);
+  assert.notStrictEqual(v, 0.3);
+});
+
+test('大整数超出 JS 安全范围会抛错或返回非精确值', async () => {
+  const { q } = makeDb();
+  let result, error = null;
+  try {
+    result = await one(q, 'SELECT 9999999999999999');
+  } catch (e) {
+    error = e;
+  }
+  // 引擎内部用 BigInt，序列化会抛错；若未抛错则值不应精确
+  if (error) return;
+  assert.notStrictEqual(result, 9999999999999999);
+});
+
+test('-0.0 归一为 0（负零消失）', async () => {
+  const { q } = makeDb();
+  const v = await one(q, 'SELECT -0.0');
+  assert.ok(v === 0);
+});
+
+test('超长字符串 100000 字符正常处理', async () => {
+  const { q } = makeDb();
+  const long = 'x'.repeat(100000);
+  assert.strictEqual(await one(q, `SELECT LENGTH('${long}')`), 100000);
+});
+
+test('Unicode é 正确处理（LENGTH=5, UPPER 含重音）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT LENGTH('héllo')"), 5);
+  assert.strictEqual(await one(q, "SELECT UPPER('café')"), 'CAFÉ');
+});
+
+test('Emoji 按 UTF-16 单元计数（LENGTH=4）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT LENGTH('🚀🌟')"), 4);
+});
+
+test('Emoji UPPER 无变化', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT UPPER('🚀')"), '🚀');
+});
+
+test("DATE('0000-00-00') 返回 NULL（无效日期）", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT DATE('0000-00-00')"), null);
+});
+
+test("DATE('9999-12-31') 返回 '9999-12-31'", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT DATE('9999-12-31')"), '9999-12-31');
+});
+
+test("DATE('2024-02-29') 闰年正确", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT DATE('2024-02-29')"), '2024-02-29');
+});
+
+test("DATE('2026-02-29') 非法日期溢出修正为 '2026-03-01'", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT DATE('2026-02-29')"), '2026-03-01');
+});
+
+test("YEAR('9999-12-31') 返回 9999", async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT YEAR('9999-12-31')"), 9999);
+});
+
+test('BETWEEN 包含边界（5 BETWEEN 1 AND 5 → 1）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT 5 BETWEEN 1 AND 5'), 1);
+});
+
+test('BETWEEN NULL 返回 NULL（UNKNOWN）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL BETWEEN 1 AND 5'), null);
+});
+
+test('NOT BETWEEN NULL 返回 NULL（UNKNOWN）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT NULL NOT BETWEEN 1 AND 5'), null);
+});
+
+// ────────────────────────────────────────────────────────────────
+// 2. 聚合函数边界（8+ tests）
+// ────────────────────────────────────────────────────────────────
+
+test('COUNT(*) 计所有行（含 NULL）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,10),(2,NULL),(3,30)');
+  assert.strictEqual(await one(q, 'SELECT COUNT(*) FROM t'), 3);
+});
+
+test('COUNT(col) 跳过 NULL', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,10),(2,NULL),(3,30)');
+  assert.strictEqual(await one(q, 'SELECT COUNT(v) FROM t'), 2);
+});
+
+test('COUNT(DISTINCT col) 去重且跳过 NULL', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, s STRING)');
+  await q("INSERT INTO t VALUES (1,'a'),(2,'a'),(3,NULL),(4,'b')");
+  assert.strictEqual(await one(q, 'SELECT COUNT(DISTINCT s) FROM t'), 2);
+});
+
+test('SUM 跳过 NULL（不全为 NULL 时）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,10),(2,NULL),(3,30)');
+  assert.strictEqual(await one(q, 'SELECT SUM(v) FROM t'), 40);
+});
+
+test('SUM 全 NULL 返回 NULL', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,NULL),(2,NULL)');
+  assert.strictEqual(await one(q, 'SELECT SUM(v) FROM t'), null);
+});
+
+test('AVG 跳过 NULL（分母不含 NULL）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,10),(2,NULL),(3,30)');
+  assert.strictEqual(await one(q, 'SELECT AVG(v) FROM t'), 20);
+});
+
+test('GROUP BY 多列正确分组', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT, s STRING)');
+  await q("INSERT INTO t VALUES (1,1,'a'),(2,1,'a'),(3,2,'a'),(4,2,'b')");
+  const r = await rows(q, 'SELECT g, s, COUNT(*) AS cnt FROM t GROUP BY g, s ORDER BY g, s');
+  assert.strictEqual(r.length, 3);
+  assert.deepStrictEqual(r[0], [1, 'a', 2]);
+  assert.deepStrictEqual(r[1], [2, 'a', 1]);
+  assert.deepStrictEqual(r[2], [2, 'b', 1]);
+});
+
+test('HAVING 无 GROUP BY 时对整表聚合结果过滤', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,10),(2,20),(3,30)');
+  assert.strictEqual(await one(q, 'SELECT COUNT(*) FROM t HAVING COUNT(*) > 1'), 3);
+});
+
+test('聚合嵌套：SELECT COUNT(*) FROM (SELECT ...) t', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT)');
+  await q('INSERT INTO t VALUES (1,1),(2,1),(3,2),(4,2),(5,NULL)');
+  assert.strictEqual(
+    await one(q, 'SELECT COUNT(*) FROM (SELECT DISTINCT g FROM t) x'),
+    3
+  );
+});
+
+test('混合聚合和非聚合列（GROUP BY 覆盖非聚合列）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT, v INT)');
+  await q('INSERT INTO t VALUES (1,1,10),(2,1,20),(3,2,30)');
+  const r = await rows(q, 'SELECT g, v, COUNT(*) AS cnt FROM t GROUP BY g, v ORDER BY g, v');
+  assert.strictEqual(r.length, 3);
+  assert.deepStrictEqual(r[0], [1, 10, 1]);
+});
+
+// ────────────────────────────────────────────────────────────────
+// 3. 子查询和 JOIN（8+ tests）
+// ────────────────────────────────────────────────────────────────
+
+test('相关子查询：每行独立求值', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT, v INT)');
+  await q('INSERT INTO t VALUES (1,1,100),(2,1,5),(3,2,50),(4,2,200)');
+  // g=1 的 AVG=52.5，g=2 的 AVG=125
+  // g=1: 100>52.5 ✓, 5>52.5 ✗; g=2: 50>125 ✗, 200>125 ✓ → 共 2 行
+  const r = await rows(q, 'SELECT COUNT(*) FROM t a WHERE v > (SELECT AVG(v) FROM t b WHERE b.g = a.g)');
+  assert.strictEqual(r[0][0], 2);
+});
+
+test('子查询返回多列', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT, v INT)');
+  await q('INSERT INTO t VALUES (1,1,10),(2,2,20),(3,3,30)');
+  const r = await rows(q, 'SELECT * FROM (SELECT g, v FROM t WHERE v >= 20) x ORDER BY g');
+  assert.strictEqual(r.length, 2);
+  assert.deepStrictEqual(r[0], [2, 20]);
+});
+
+test('JOIN 无 ON 条件产生笛卡尔积', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE a (id INT PRIMARY KEY)');
+  await q('CREATE TABLE b (id INT PRIMARY KEY)');
+  await q('INSERT INTO a VALUES (1),(2)');
+  await q('INSERT INTO b VALUES (1),(2),(3)');
+  assert.strictEqual(await one(q, 'SELECT COUNT(*) FROM a JOIN b'), 6);
+});
+
+test('逗号连接产生笛卡尔积', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE a (id INT PRIMARY KEY)');
+  await q('CREATE TABLE b (id INT PRIMARY KEY)');
+  await q('INSERT INTO a VALUES (1),(2)');
+  await q('INSERT INTO b VALUES (1),(2),(3)');
+  assert.strictEqual(await one(q, 'SELECT COUNT(*) FROM a, b'), 6);
+});
+
+test('LEFT JOIN 右表无匹配时填 NULL', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE a (id INT PRIMARY KEY, name STRING)');
+  await q('CREATE TABLE b (id INT PRIMARY KEY, a_id INT, val STRING)');
+  await q("INSERT INTO a VALUES (1,'x'),(2,'y'),(3,'z')");
+  await q("INSERT INTO b VALUES (10,2,'matched')");
+  const r = await rows(q, 'SELECT a.id, a.name, b.val FROM a LEFT JOIN b ON a.id = b.a_id ORDER BY a.id');
+  assert.strictEqual(r.length, 3);
+  assert.deepStrictEqual(r[0], [1, 'x', null]);
+  assert.deepStrictEqual(r[2], [3, 'z', null]);
+});
+
+test('子查询在 SELECT 列表（标量子查询）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, v INT)');
+  await q('INSERT INTO t VALUES (1,10),(2,20),(3,30)');
+  assert.strictEqual(await one(q, 'SELECT MAX(v) FROM t'), 30);
+  const r = await one(q, 'SELECT (SELECT MAX(v) FROM t) FROM t LIMIT 1');
+  assert.strictEqual(r, 30);
+});
+
+test('嵌套子查询 3 层', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT)');
+  await q('INSERT INTO t VALUES (1,1),(2,1),(3,2),(4,3)');
+  assert.strictEqual(
+    await one(q, 'SELECT COUNT(*) FROM (SELECT g FROM (SELECT DISTINCT g FROM t) a) b'),
+    3
+  );
+});
+
+test('IN 子查询', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT, v INT)');
+  await q('INSERT INTO t VALUES (1,1,10),(2,1,20),(3,2,30)');
+  assert.strictEqual(
+    await one(q, 'SELECT COUNT(*) FROM t WHERE g IN (SELECT DISTINCT g FROM t WHERE g IS NOT NULL)'),
+    3
+  );
+});
+
+test('IN 子查询含 NULL 导致 UNKNOWN（返回 0 行）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT)');
+  await q('INSERT INTO t VALUES (1,1),(2,NULL)');
+  assert.strictEqual(
+    await one(q, 'SELECT COUNT(*) FROM t WHERE g IN (SELECT g FROM t)'),
+    0
+  );
+});
+
+test('EXISTS 子查询', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT)');
+  await q('INSERT INTO t VALUES (1,1),(2,2),(3,1)');
+  assert.strictEqual(
+    await one(q, 'SELECT COUNT(*) FROM t WHERE EXISTS (SELECT 1 FROM t WHERE t.g = g)'),
+    3
+  );
+});
+
+test('NOT EXISTS 子查询', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, g INT)');
+  await q('INSERT INTO t VALUES (1,1),(2,2),(3,1)');
+  // g=2 没有其他行同组，NOT EXISTS 为真
+  assert.strictEqual(
+    await one(q, 'SELECT COUNT(*) FROM t a WHERE NOT EXISTS (SELECT 1 FROM t b WHERE b.g = a.g AND b.id != a.id)'),
+    1
+  );
+});
+
+// ────────────────────────────────────────────────────────────────
+// 4. DDL 和表操作（6+ tests）
+// ────────────────────────────────────────────────────────────────
+
+test('CREATE TABLE 带 DEFAULT 值对新行生效', async () => {
+  const { q } = makeDb();
+  await q("CREATE TABLE t (id INT PRIMARY KEY, n STRING, extra STRING DEFAULT 'x')");
+  await q("INSERT INTO t (id, n) VALUES (1,'a')");
+  const r = await rows(q, 'SELECT extra FROM t');
+  assert.strictEqual(r[0][0], 'x');
+});
+
+test('ALTER TABLE ADD COLUMN 带 DEFAULT 子句（DEFAULT 对新行不生效，已知限制）', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, n STRING)');
+  await q("INSERT INTO t VALUES (1,'a')");
+  await q("ALTER TABLE t ADD COLUMN extra STRING DEFAULT 'x'");
+  await q("INSERT INTO t (id, n) VALUES (2,'b')");
+  const r = await rows(q, 'SELECT id, n, extra FROM t ORDER BY id');
+  // 已知限制：ALTER TABLE ADD COLUMN 的 DEFAULT 不应用到新行
+  assert.ok(r[1][2] == null); // null 或 undefined（序列化差异）
+});
+
+test('ALTER TABLE DROP COLUMN', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY, a STRING, b STRING)');
+  await q("INSERT INTO t VALUES (1,'x','y')");
+  await q('ALTER TABLE t DROP COLUMN b');
+  const r = await rows(q, 'SELECT * FROM t');
+  assert.deepStrictEqual(r[0], [1, 'x']);
+});
+
+test('CREATE TABLE 带各种约束（PK、UNIQUE、NOT NULL、DEFAULT）', async () => {
+  const { q } = makeDb();
+  await q("CREATE TABLE cons (id INT PRIMARY KEY, u STRING UNIQUE, nn INT NOT NULL, d INT DEFAULT 99)");
+  // 合法插入
+  await q("INSERT INTO cons (id, u, nn) VALUES (1, 'a', 1)");
+  // DEFAULT 生效
+  const r = await rows(q, 'SELECT d FROM cons WHERE id=1');
+  assert.strictEqual(r[0][0], 99);
+  // 违反 PK
+  await assert.rejects(() => q("INSERT INTO cons (id, u, nn) VALUES (1, 'c', 3)"));
+  // 违反 UNIQUE
+  await assert.rejects(() => q("INSERT INTO cons (id, u, nn) VALUES (2, 'a', 4)"));
+  // 违反 NOT NULL
+  await assert.rejects(() => q("INSERT INTO cons (id, u, nn) VALUES (3, 'b', NULL)"));
+});
+
+test('TRUNCATE 后自增重置', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE t (id INT PRIMARY KEY AUTO_INCREMENT, n STRING)');
+  await q("INSERT INTO t (n) VALUES ('a'),('b'),('c')");
+  await q('TRUNCATE TABLE t');
+  assert.strictEqual(await one(q, 'SELECT COUNT(*) FROM t'), 0);
+  await q("INSERT INTO t (n) VALUES ('z')");
+  const r = await rows(q, 'SELECT id FROM t');
+  assert.strictEqual(r[0][0], 1); // 自增重置
+});
+
+test('RENAME TABLE 后旧名不可用', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE old (id INT PRIMARY KEY)');
+  await q('ALTER TABLE old RENAME TO new');
+  await q('INSERT INTO new VALUES (1)');
+  assert.strictEqual(await one(q, 'SELECT COUNT(*) FROM new'), 1);
+  await assert.rejects(() => q('SELECT COUNT(*) FROM old'));
+});
+
+test('创建重复表名报错', async () => {
+  const { q } = makeDb();
+  await q('CREATE TABLE dup (id INT PRIMARY KEY)');
+  await assert.rejects(() => q('CREATE TABLE dup (id INT PRIMARY KEY)'));
+});
+
+// ────────────────────────────────────────────────────────────────
+// 5. 表达式和函数（6+ tests）
+// ────────────────────────────────────────────────────────────────
+
+test('CASE WHEN 搜索形式', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(
+    await one(q, "SELECT CASE WHEN 1=1 THEN 'yes' ELSE 'no' END"),
+    'yes'
+  );
+});
+
+test('CASE 简单形式', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(
+    await one(q, "SELECT CASE 2 WHEN 1 THEN 'a' WHEN 2 THEN 'b' ELSE 'c' END"),
+    'b'
+  );
+});
+
+test('CASE 无匹配且无 ELSE 返回 NULL', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(
+    await one(q, "SELECT CASE WHEN 0=1 THEN 'yes' END"),
+    null
+  );
+});
+
+test('CASE 条件为 NULL 时走 ELSE', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(
+    await one(q, "SELECT CASE NULL WHEN 1 THEN 'a' ELSE 'b' END"),
+    'b'
+  );
+});
+
+test('COALESCE / NULLIF / IFNULL', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT COALESCE(NULL, NULL, 3)'), 3);
+  assert.strictEqual(await one(q, 'SELECT NULLIF(1, 1)'), null);
+  assert.strictEqual(await one(q, 'SELECT NULLIF(1, 2)'), 1);
+  assert.strictEqual(await one(q, 'SELECT IFNULL(NULL, 9)'), 9);
+});
+
+test('字符串函数：LENGTH / UPPER / LOWER / TRIM / CONCAT / SUBSTR', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT LENGTH('hello')"), 5);
+  assert.strictEqual(await one(q, "SELECT UPPER('hi')"), 'HI');
+  assert.strictEqual(await one(q, "SELECT LOWER('HI')"), 'hi');
+  assert.strictEqual(await one(q, "SELECT TRIM('  x  ')"), 'x');
+  assert.strictEqual(await one(q, "SELECT CONCAT('a', 'b', 'c')"), 'abc');
+  assert.strictEqual(await one(q, "SELECT SUBSTR('hello', 2, 3)"), 'ell');
+});
+
+test('数学函数：ABS / CEIL / FLOOR / ROUND / POWER / SQRT', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT ABS(-5)'), 5);
+  assert.strictEqual(await one(q, 'SELECT CEIL(2.1)'), 3);
+  assert.strictEqual(await one(q, 'SELECT FLOOR(2.9)'), 2);
+  assert.strictEqual(await one(q, 'SELECT ROUND(2.5)'), 3);
+  assert.strictEqual(await one(q, 'SELECT ROUND(-2.5)'), -3); // 半远离零
+  assert.strictEqual(await one(q, 'SELECT POWER(2, 3)'), 8);
+  assert.strictEqual(await one(q, 'SELECT SQRT(16)'), 4);
+});
+
+test('SQRT 负数返回 NaN', async () => {
+  const { q } = makeDb();
+  const v = await one(q, 'SELECT SQRT(-1)');
+  assert.ok(Number.isNaN(v));
+});
+
+test('REPLACE 函数', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT REPLACE('hello', 'l', 'r')"), 'herro');
+});
+
+test('嵌套函数调用', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT UPPER(TRIM('  hi  '))"), 'HI');
+  assert.strictEqual(await one(q, "SELECT LENGTH(CONCAT('a', 'b', 'c'))"), 3);
+});
+
+test('ABS 无参数返回 NULL', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, 'SELECT ABS()'), null);
+});
+
+test('LENGTH 多参数只取第一个', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT LENGTH('ab', 'cd')"), 2);
+});
+
+test('IF 函数三值行为（NULL / 0 / 空串均为假）', async () => {
+  const { q } = makeDb();
+  assert.strictEqual(await one(q, "SELECT IF(NULL, 'a', 'b')"), 'b');
+  assert.strictEqual(await one(q, "SELECT IF(0, 'a', 'b')"), 'b');
+  assert.strictEqual(await one(q, "SELECT IF('', 'a', 'b')"), 'b');
+  assert.strictEqual(await one(q, "SELECT IF(1, 'a', 'b')"), 'a');
+});