jsql-neo 6.3.6 → 6.3.10

package/lib/sql.js

@@ -16,14 +16,22 @@ const DANGEROUS_SQL = [
 const DEFAULT_MAX_SQL_LENGTH = 64 * 1024 * 1024;
 
 function findDangerousSQL(tokens) {
-  for (let i = 0; i < tokens.length; i++) {
-    const t = tokens[i];
+  // 先把注释去掉，防止通过 /*comment*/DROP 绕过检测
+  const commentStripped = [];
+  let skip = false;
+  for (const t of tokens) {
+    if (t.type === 'comment') { skip = true; continue; }
+    if (!skip) commentStripped.push(t);
+    else skip = false;
+  }
+  for (let i = 0; i < commentStripped.length; i++) {
+    const t = commentStripped[i];
     if (t.type !== 'keyword' && t.type !== 'ident') continue;
     const upper = String(t.value).toUpperCase();
     for (const d of DANGEROUS_SQL) {
       if (d.re.test(upper)) {
         if (d.next) {
-          const nxt = tokens[i + 1];
+          const nxt = commentStripped[i + 1];
           if (nxt && d.next.test(String(nxt.value).toUpperCase())) {
             return d.name;
           }
@@ -69,6 +77,57 @@ const KEYWORDS = new Set([
   // 在语法层按上下文大小写不敏感地匹配，从而不破坏既有解析行为。
 ]);
 
+/**
+ * MySQL 里属于「非保留」的关键字 —— 可以不加反引号直接当表名/列名。
+ *
+ * 词法层为了识别语法把它们标成了 keyword（parseColumnDef 还依赖这一点来认类型），
+ * 但**在「期望一个名字」的位置必须放行**。否则下面这些最普通的写法都会被拒：
+ *     CREATE TABLE t (date DATE, text TEXT, count INT)
+ *     SELECT date, count FROM t
+ * 实测 64 个常见列名里有 31 个被拒，其中 `date` / `text` / `count` / `engine` /
+ * `first` / `after` 在 MySQL 里都不是保留字，用户没有理由必须加反引号。
+ *
+ * 这里的做法与文件末尾 OVER / PARTITION 那条注释同一个思路：
+ * 不让词法层去区分，改由语法层按上下文决定。真正的保留字
+ * （TABLE / SELECT / KEY / ORDER / INDEX / GROUP ...）仍然要求反引号。
+ */
+const NON_RESERVED_KEYWORDS = new Set([
+  // 数据类型
+  'DATE', 'DATETIME', 'TIME', 'TIMESTAMP', 'TEXT', 'BLOB', 'VARCHAR', 'CHAR',
+  'INT', 'INTEGER', 'BIGINT', 'SMALLINT', 'TINYINT', 'FLOAT', 'DOUBLE', 'REAL',
+  'NUMERIC', 'DECIMAL', 'BOOLEAN', 'BOOL', 'JSON', 'STRING', 'OBJECT', 'ARRAY', 'ANY',
+  // 列属性 / ALTER 的位置标记
+  'AFTER', 'FIRST', 'UNSIGNED', 'ZEROFILL', 'ENGINE', 'IGNORE', 'SPATIAL',
+  'AUTOINCREMENT', 'AUTO_INCREMENT', 'NOTNULL',
+  // 其余非保留字（含库名/describe 这类信息模式用语）
+  'START', 'WORK', 'TRANSACTION', 'DUPLICATE', 'MODIFY', 'CHANGE', 'CONSTRAINT',
+  'COLLATE', 'CHARACTER', 'DATABASE', 'DATABASES', 'TABLES', 'SHOW', 'DESCRIBE',
+  'RAISE', 'PRAGMA', 'REGEXP', 'RLIKE',
+  // 聚合函数名：MySQL 里它们根本不是关键字
+  'COUNT', 'SUM', 'AVG', 'MIN', 'MAX',
+]);
+
+/**
+ * 这个 token 能不能当作一个名字（表名 / 列名）。
+ * ident 自然可以；上面那张表里的 keyword 也可以；其余 keyword 不行。
+ */
+function isUsableNameToken(t) {
+  if (!t) return false;
+  if (t.type === 'ident') return true;
+  return t.type === 'keyword' && NON_RESERVED_KEYWORDS.has(String(t.value).toUpperCase());
+}
+
+/**
+ * 取一个名字 token 的拼写。
+ *
+ * 关键字 token 的 value 在词法层被统一大写了（'date' → 'DATE'），
+ * 拿它当列名会让 `CREATE TABLE t (date TEXT)` 建出名为 DATE 的列。
+ * 所以优先用词法层留下的原样文本。
+ */
+function nameOfToken(t) {
+  return t && t.text !== undefined ? t.text : (t ? t.value : undefined);
+}
+
 function tokenize(sql) {
   const tokens = [];
   let i = 0;
@@ -129,10 +188,13 @@ function tokenize(sql) {
     if (/[0-9]/.test(c) || (c === '.' && /[0-9]/.test(sql[i + 1] || ''))) {
       let j = i;
       let isFloat = false;
+      let dotCount = 0;
       while (j < n && /[0-9.]/.test(sql[j])) {
-        if (sql[j] === '.') isFloat = true;
+        if (sql[j] === '.') { isFloat = true; dotCount++; }
         j++;
       }
+      // P2-2: SELECT 1.2.3 静默返回 1.2——多个点的数字字面量应报错
+      if (dotCount > 1) throw new Error(`Invalid number literal: ${sql.slice(i, j)}`);
       if (sql[j] === 'e' || sql[j] === 'E') {
         j++;
         if (sql[j] === '+' || sql[j] === '-') j++;
@@ -140,7 +202,16 @@ function tokenize(sql) {
         isFloat = true;
       }
       const raw = sql.slice(i, j);
-      tokens.push(new SQLToken('number', isFloat ? parseFloat(raw) : parseInt(raw, 10), i));
+      // parseInt 会错误处理某些前导零（'07' 在非严格模式被当八进制），
+      // 大数 parseInt 也丢失精度。统一用 Number()（bigint 用 BigInt()）。
+      let numVal;
+      if (raw.includes('.') || raw.includes('e') || raw.includes('E')) {
+        numVal = parseFloat(raw);
+      } else {
+        const n = BigInt(raw);
+        numVal = n <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(n) : n;
+      }
+      tokens.push(new SQLToken('number', numVal, i));
       i = j;
       continue;
     }
@@ -150,11 +221,15 @@ function tokenize(sql) {
       while (j < n && /[a-zA-Z0-9_$]/.test(sql[j])) j++;
       const word = sql.slice(i, j);
       const upper = word.toUpperCase();
-      tokens.push(new SQLToken(KEYWORDS.has(upper) ? 'keyword' : 'ident', upper === word ? word : word, i));
+      const tok = new SQLToken(KEYWORDS.has(upper) ? 'keyword' : 'ident', word, i);
+      // 原样拼写要留下来：关键字被当作列名/表名时（date、count、first…）
+      // 得还原成用户写的大小写，否则列名会变成 DATE 而用户写的是 date。
+      tok.text = word;
       if (KEYWORDS.has(upper)) {
-        tokens[tokens.length - 1].value = upper;
-        tokens[tokens.length - 1].isKeyword = true;
+        tok.value = upper;
+        tok.isKeyword = true;
       }
+      tokens.push(tok);
       i = j;
       continue;
     }
@@ -203,7 +278,7 @@ function tokenize(sql) {
       let j = i + 1;
       let num = '';
       while (j < n && sql[j] >= '0' && sql[j] <= '9') { num += sql[j]; j++; }
-      tokens.push(new SQLToken('param', num ? parseInt(num, 10) : null, i));
+      tokens.push(new SQLToken('param', num ? Number(num) : null, i));
       i = j;
       continue;
     }
@@ -467,16 +542,16 @@ class Parser {
 
   parseTableName() {
     const t = this.next();
-    if (t.type !== 'ident') throw new Error(`Expected table name, got '${t.value}'`);
+    if (!isUsableNameToken(t)) throw new Error(`Expected table name, got '${t.value}'`);
     if (this.peek().type === 'op' && this.peek().value === '.') {
       this.next();
       const t2 = this.next();
-      if (t2.type !== 'ident' && !(t2.type === 'keyword' && this._isSchemaView(t2.value))) {
+      if (!isUsableNameToken(t2) && !(t2.type === 'keyword' && this._isSchemaView(t2.value))) {
         throw new Error(`Expected table name after '.', got '${t2.value}'`);
       }
-      return t.value + '.' + t2.value;
+      return nameOfToken(t) + '.' + nameOfToken(t2);
     }
-    return t.value;
+    return nameOfToken(t);
   }
 
   _isSchemaView(v) {
@@ -535,7 +610,22 @@ class Parser {
       } else if (this.isWord('FOREIGN') || this.isWord('CHECK') ||
                  t.type === 'keyword' && (t.value === 'KEY' || t.value === 'INDEX')) {
         // 表级约束：FOREIGN KEY ... REFERENCES ... / CHECK (...) / KEY name (cols)
-        this._parseTableConstraint(schema);
+        // P1-24: CREATE TABLE t (key TEXT) 报错——key 被当作表级约束
+        // 如果 KEY/INDEX 后面跟着列类型（TEXT/INT/VARCHAR 等），应解析为列定义
+        if (t.type === 'keyword' && (t.value === 'KEY' || t.value === 'INDEX')) {
+          const nextTok = this.peek(1);
+          if (nextTok && (nextTok.type === 'ident' || nextTok.type === 'keyword') &&
+              ['TEXT', 'INT', 'INTEGER', 'VARCHAR', 'CHAR', 'DATE', 'DATETIME', 'TIMESTAMP', 'BOOLEAN', 'BOOL', 'FLOAT', 'DOUBLE', 'DECIMAL', 'BLOB', 'JSON'].includes(String(nextTok.value).toUpperCase())) {
+            const col = this.parseTableName();
+            const def = this.parseColumnDef();
+            schema[col] = def;
+            if (def.primaryKey) hasPk = true;
+          } else {
+            this._parseTableConstraint(schema);
+          }
+        } else {
+          this._parseTableConstraint(schema);
+        }
       } else if (t.type === 'eof' || (t.type === 'op' && t.value === ')')) {
         break;
       } else {
@@ -917,6 +1007,18 @@ class Parser {
       if (num.type !== 'number') throw new Error('Expected number after +');
       return num.value;
     }
+    // P1-19/P2-3: parseValue 不支持表达式 RHS，如 col = col + 1
+    // 支持简单的二元表达式：left op right
+    if (t.type === 'ident') {
+      const left = this.parseColumnRef();
+      const opTok = this.peek();
+      if (opTok.type === 'op' && ['+', '-', '*', '/', '%', '<<', '>>', '&', '|', '^'].includes(opTok.value)) {
+        this.next();
+        const right = this.parseValue();
+        return { type: 'binary', op: opTok.value, left, right };
+      }
+      return left;
+    }
     throw new Error(`Expected value, got '${t.value}'`);
   }
 
@@ -946,6 +1048,9 @@ class Parser {
     if (this.isKeyword('RECURSIVE')) { this.next(); recursive = true; }
     const ctes = [];
     for (;;) {
+      // 部分方言把 RECURSIVE 放在第一个 CTE 之后（WITH a AS (...), RECURSIVE c AS (...)），
+      // 标准 SQL 里它是 WITH 后的可选关键字 —— 两种写法都接受。
+      if (!recursive && ctes.length && this.isKeyword('RECURSIVE')) { this.next(); recursive = true; ctes[0].recursive = true; }
       const nameTok = this.next();
       if (nameTok.type !== 'ident') throw new Error(`Expected CTE name, got '${nameTok.value}'`);
       let columns = null;
@@ -1064,7 +1169,11 @@ class Parser {
     let aggregate = null;
     while (true) {
       const t = this.peek();
-      if (t.type === 'keyword' && t.value === 'COUNT') {
+      // 只有后面紧跟 '(' 才算 COUNT(...) 聚合调用。
+      // MySQL 里 count 不是保留字，`SELECT count FROM t` 是合法的列引用；
+      // 光看词本身会让它误判成函数、进而要求 '('。
+      if (t.type === 'keyword' && t.value === 'COUNT' &&
+          this.peek(1).type === 'op' && this.peek(1).value === '(') {
         this.next();
         this.expect('op', '(');
         let aggDistinct = false;
@@ -1253,7 +1362,7 @@ class Parser {
       if (this.isWord('FIRST') || this.isWord('NEXT')) this.next();
       else throw new Error(`Expected FIRST or NEXT after FETCH, got '${this.peek().value}'`);
       const nTok = this.next();
-      const n = nTok.type === 'number' ? nTok.value : parseInt(String(nTok.value), 10);
+      const n = nTok.type === 'number' ? nTok.value : Number(nTok.value);
       if (!Number.isFinite(n)) throw new Error(`Expected row count after FETCH FIRST, got '${nTok.value}'`);
       limit = n;
       if (this.isWord('ROW') || this.isWord('ROWS')) this.next();
@@ -1328,7 +1437,10 @@ class Parser {
   parseAlias() {
     const t = this.next();
     if (t.type !== 'ident' && t.type !== 'keyword') throw new Error(`Expected alias, got '${t.value}'`);
-    return t.value;
+    // 用原样拼写：别名的 value 会被词法层大写（AS avg → 'AVG'），
+    // 而 ORDER BY avg / GROUP BY avg 引用时用的是原样拼写，两边必须一致，
+    // 否则按别名排序会静默失效。
+    return nameOfToken(t);
   }
 
   parseOptionalAlias() {
@@ -1339,14 +1451,14 @@ class Parser {
 
   parseColumnRef() {
     const t = this.next();
-    if (t.type !== 'ident') throw new Error(`Expected column name, got '${t.value}'`);
+    if (!isUsableNameToken(t)) throw new Error(`Expected column name, got '${t.value}'`);
     if (this.peek().type === 'op' && this.peek().value === '.') {
       this.next();
       const col = this.next();
-      if (col.type !== 'ident') throw new Error(`Expected column name after '.', got '${col.value}'`);
-      return t.value + '.' + col.value;
+      if (!isUsableNameToken(col)) throw new Error(`Expected column name after '.', got '${col.value}'`);
+      return nameOfToken(t) + '.' + nameOfToken(col);
     }
-    return t.value;
+    return nameOfToken(t);
   }
 
   parseUpdate() {
@@ -1516,8 +1628,21 @@ class Parser {
         case 'DROP': {
           if (this.isKeyword('COLUMN')) this.next();
           if (this.isKeyword('PRIMARY')) { this.expectKeyword('PRIMARY'); this.expectKeyword('KEY'); ops.push({ op: 'dropPrimary' }); break; }
-          if (this.isKeyword('FOREIGN')) { this.next(); this.expectKeyword('KEY'); if (this.peek().type === 'ident') this.next(); ops.push({ op: 'dropIndex' }); break; }
-          if (this.isKeyword('INDEX') || this.isKeyword('KEY')) { this.next(); if (this.peek().type === 'ident') this.next(); ops.push({ op: 'dropIndex' }); break; }
+          if (this.isKeyword('FOREIGN')) {
+            // 与 DROP INDEX 分开标记：两者都要名字，但执行器要给出不同的报错
+            this.next(); this.expectKeyword('KEY');
+            const fkName = this.peek().type === 'ident' ? this.next().value : null;
+            ops.push({ op: 'dropForeign', name: fkName });
+            break;
+          }
+          if (this.isKeyword('INDEX') || this.isKeyword('KEY')) {
+            // 名字必须留下来 —— 此前只是 next() 跳过、丢弃，
+            // 执行器拿到 name=undefined 就无从知道删哪个索引。
+            this.next();
+            const idxName = this.peek().type === 'ident' ? this.next().value : null;
+            ops.push({ op: 'dropIndex', name: idxName });
+            break;
+          }
           const column = this.parseTableName();
           ops.push({ op: 'dropColumn', column });
           break;
@@ -1534,7 +1659,28 @@ class Parser {
           break;
         }
         case 'RENAME': {
-          if (this.isKeyword('TO')) this.next();
+          // RENAME COLUMN old TO new —— SQL 标准写法。
+          // 此前这里不区分，直接把 COLUMN 当新表名去解析，
+          // 于是报 "Expected table name, got 'COLUMN'"。
+          if (this.isKeyword('COLUMN')) {
+            this.next();
+            const oldColumn = this.parseTableName();
+            if (this.isKeyword('TO') || this.isKeyword('AS')) this.next();
+            else throw new Error(`Expected TO after '${oldColumn}', got '${this.peek().value}'`);
+            const newColumn = this.parseTableName();
+            ops.push({ op: 'renameColumn', column: oldColumn, newColumn });
+            break;
+          }
+          // MySQL 的 RENAME INDEX/KEY 没实现 —— 明确报错，
+          // 不要落进 default 变成「返回成功但什么都没做」。
+          if (this.isKeyword('INDEX') || this.isKeyword('KEY')) {
+            throw new Error(
+              `ALTER TABLE ... RENAME INDEX is not supported. ` +
+              `Use DROP INDEX followed by CREATE INDEX instead.`
+            );
+          }
+          // RENAME TO new / RENAME AS new
+          if (this.isKeyword('TO') || this.isKeyword('AS')) this.next();
           const newName = this.parseTableName();
           ops.push({ op: 'rename', newName });
           break;
@@ -1937,6 +2083,15 @@ class Parser {
 
   parseOperand() {
     const t = this.next();
+    // P1-20: SELECT -col 报错——parseOperand 不处理负号
+    if (t.type === 'op' && t.value === '-') {
+      const operand = this.parseOperand();
+      return { type: 'negate', operand };
+    }
+    if (t.type === 'op' && t.value === '+') {
+      const operand = this.parseOperand();
+      return { type: 'negate', operand, positive: true };
+    }
     if (t.type === 'ident') {
       // 聚合函数名（GROUP_CONCAT / STDDEV / FIRST...）走 aggregate 节点，
       // 否则会被当作逐行标量函数：既返回 null，又不会折叠分组
@@ -1969,8 +2124,8 @@ class Parser {
         this.next();
         const col = this.next();
         if (col.type === 'op' && col.value === '*') return { type: 'star', alias: t.value };
-        if (col.type !== 'ident') throw new Error(`Expected column name after '.', got '${col.value}'`);
-        return { type: 'column', name: t.value + '.' + col.value };
+        if (!isUsableNameToken(col)) throw new Error(`Expected column name after '.', got '${col.value}'`);
+        return { type: 'column', name: nameOfToken(t) + '.' + nameOfToken(col) };
       }
       // CAST(expr AS type)
       if (String(t.value).toUpperCase() === 'CAST' && this.peek().type === 'op' && this.peek().value === '(') {
@@ -2115,7 +2270,9 @@ class Parser {
           !(this.peek().type === 'op' && (this.peek().value === '(' || this.peek().value === '.'))) {
         return { type: 'unit', name: String(t.value).toUpperCase() };
       }
-      return { type: 'column', name: t.value };
+      // 用原样拼写：关键字的 value 被词法层大写了，拿它当列名会让
+      // `SELECT date FROM t`（列名 date）取不到值。
+      return { type: 'column', name: nameOfToken(t) };
     }
     if (t.type === 'number' || t.type === 'string') return { type: 'value', value: t.value };
     if (t.type === 'sysvar') return { type: 'sysvar', name: t.value };
@@ -2150,7 +2307,8 @@ class Parser {
     // 也不满足上面的聚合调用分支（后面是 DESC 不是 '('），最终会抛 "got 'AVG'"。
     // ORDER BY 引用输出别名是标准 SQL 行为，SQLite / MySQL 都允许。
     if (t.type === 'keyword' && !(this.peek().type === 'op' && this.peek().value === '(')) {
-      return { type: 'column', name: t.value };
+      // 同样要用原样拼写，否则按别名排序/分组时会拿大写名去找而落空
+      return { type: 'column', name: nameOfToken(t) };
     }
     // 一元按位取反 ~x
     if (t.type === 'op' && t.value === '~') {
@@ -2193,8 +2351,15 @@ class Parser {
     }
     if (t.type === 'op' && (t.value === '-' || t.value === '+')) {
       const num = this.next();
-      if (num.type !== 'number') throw new Error('Expected number after sign');
-      return { type: 'value', value: t.value === '-' ? -num.value : num.value };
+      if (num.type === 'number') {
+        return { type: 'value', value: t.value === '-' ? -num.value : num.value };
+      }
+      // 负号/正号后面是列名或表达式：解析为 unary 运算符
+      if (num.type === 'column' || num.type === 'value') {
+        const operand = num.type === 'column' ? { type: 'column', name: num.value } : { type: 'value', value: num.value };
+        return { type: 'negate', operand };
+      }
+      throw new Error('Expected number or column after sign');
     }
     throw new Error(`Expected value or column, got '${t.value}'`);
   }
@@ -2621,23 +2786,51 @@ function resolveOperand(operand, row, ctx) {
           if (rn !== null) return rn;   // 左侧非数值按 0
           return 0;
         }
-        case '-': return Number(l) - Number(r);
-        case '*': return Number(l) * Number(r);
-        case '/': return r === 0 ? null : Number(l) / Number(r);
-        case '%': return r === 0 ? null : Number(l) % Number(r);
+        case '-': {
+          // P1-21: 'abc'-1 → NaN，应返回 null
+          const ln = Number(l), rn = Number(r);
+          if (isNaN(ln) || isNaN(rn)) return null;
+          return ln - rn;
+        }
+        case '*': {
+          const ln = Number(l), rn = Number(r);
+          if (isNaN(ln) || isNaN(rn)) return null;
+          return ln * rn;
+        }
+        case '/': {
+          const ln = Number(l), rn = Number(r);
+          if (isNaN(ln) || isNaN(rn) || rn === 0) return null;
+          return ln / rn;
+        }
+        case '%': {
+          const ln = Number(l), rn = Number(r);
+          if (isNaN(ln) || isNaN(rn) || rn === 0) return null;
+          return ln % rn;
+        }
         // MySQL 整数除法 DIV（结果向零取整）
         case 'DIV': return r === 0 ? null : Math.trunc(Number(l) / Number(r));
         // 位运算：先按整数归一，与 MySQL 的整数位运算语义一致
         case '&': return (Number(l) | 0) & (Number(r) | 0);
         case '|': return (Number(l) | 0) | (Number(r) | 0);
         case '^': return (Number(l) | 0) ^ (Number(r) | 0);
-        case '<<': return (Number(l) | 0) << (Number(r) | 0);
-        case '>>': return (Number(l) | 0) >> (Number(r) | 0);
+        // P1-22: JavaScript 位运算只使用 32 位整数，移位量对 32 取模
+        // 1 << 32 = 1 << 0 = 1，但 SQL 中 1 << 32 = 4294967296
+        case '<<': return Number(l) * Math.pow(2, Number(r));
+        case '>>': return Math.floor(Number(l) / Math.pow(2, Number(r)));
       }
       return null;
     }
     case 'bitnot':
       return ~(Number(resolveOperand(operand.expr, row, ctx)) | 0);
+    case 'negate': {
+      const v = resolveOperand(operand.operand, row, ctx);
+      if (v === null || v === undefined) return null;
+      return -Number(v);
+    }
+    // P1-19: ON DUPLICATE KEY UPDATE 表达式赋值，如 count = count + 1
+    case 'binary': {
+      return evaluateExpr({ type: 'arith', op: operand.op, left: operand.left, right: operand.right }, row, ctx);
+    }
     case 'func':
       return applyScalarFunction(operand, row, ctx);
     case 'case':
@@ -2950,9 +3143,21 @@ function applyScalarFunction(fnNode, row, ctx) {
     case 'CURDATE': case 'CURRENT_DATE': return sqlLocalDateTime().slice(0, 10);
     case 'CURTIME': return sqlLocalDateTime().slice(11, 19);
     case 'UTC_TIMESTAMP': return new Date().toISOString().slice(0, 19).replace('T', ' ') + ' UTC';
-    case 'CONCAT': return args.map(a => a === null || a === undefined ? '' : String(a)).join('');
+    case 'CONCAT': {
+      // 任一参数是 NULL 就返回 NULL —— MySQL 语义，也是本引擎其余所有标量
+      // 函数（UPPER / LENGTH / TRIM / ABS / SUBSTRING / REPLACE ...）的统一约定。
+      // 此前把 NULL 当成空串，会悄悄拼出一个「看起来正常」的错值：
+      // CONCAT(first, ' ', last) 里 last 为 NULL 时会得到 "John " 而不是 NULL，
+      // 缺失的字段就此被掩盖。
+      if (args.some(a => a == null)) return null;
+      return args.map(a => String(a)).join('');
+    }
     case 'CONCAT_WS': {
-      const sep = args[0] == null ? ',' : String(args[0]);
+      // 与 CONCAT 相反：CONCAT_WS 跳过值为 NULL 的参数（MySQL 语义）。
+      // 但分隔符本身为 NULL 时整体返回 NULL —— 此前会悄悄退回逗号，
+      // 拼出一个用户没要求的分隔符。
+      if (args[0] == null) return null;
+      const sep = String(args[0]);
       return args.slice(1).filter(a => a !== null && a !== undefined).map(a => String(a)).join(sep);
     }
     case 'UPPER': case 'UCASE': return args[0] == null ? null : String(args[0]).toUpperCase();
@@ -3247,7 +3452,13 @@ function applyScalarFunction(fnNode, row, ctx) {
     case 'POWER': case 'POW': return args[0] == null ? null : Math.pow(args[0], args[1]);
     case 'SQRT': return args[0] == null ? null : Math.sqrt(args[0]);
     case 'IFNULL': case 'NVL': return args[0] != null ? args[0] : args[1];
-    case 'COALESCE': return args.find(a => a != null);
+    case 'COALESCE': {
+      // 不能直接 return find(...)：全都取不到值时 find 返回 undefined，
+      // 而 undefined 在结果行里会整个键消失（JSON.stringify 会丢掉它），
+      // 于是这一列凭空不见了。统一成 null，与 IFNULL / CASE 的行为一致。
+      const hit = args.find(a => a != null);
+      return hit === undefined ? null : hit;
+    }
     case 'NULLIF': return args[0] === args[1] ? null : args[0];
     case 'IF': return args[0] ? args[1] : args[2];
     case 'REPLACE': return args[0] == null ? null : String(args[0]).split(args[1]).join(args[2]);
@@ -3314,8 +3525,18 @@ function applyScalarFunction(fnNode, row, ctx) {
       }
       return Math.floor(Date.now() / 1000);
     }
-    case 'GREATEST': return args.reduce((m, a) => a > m ? a : m, args[0]);
-    case 'LEAST': return args.reduce((m, a) => a < m ? a : m, args[0]);
+    case 'GREATEST': {
+      // 任一参数是 NULL 就返回 NULL（MySQL 语义）。
+      // 此前直接拿 JS 的 > 比较，而 JS 里 null 会被强转成 0 ——
+      // 于是 GREATEST(NULL, 1) 得 1 而 LEAST(NULL, 1) 得 NULL：
+      // 这一对函数自相矛盾，总有一个是错的。
+      if (!args.length || args.some(a => a == null)) return null;
+      return args.reduce((m, a) => (a > m ? a : m));
+    }
+    case 'LEAST': {
+      if (!args.length || args.some(a => a == null)) return null;
+      return args.reduce((m, a) => (a < m ? a : m));
+    }
     case 'UUID': return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
       const r = Math.random() * 16 | 0; const v = c === 'x' ? r : (r & 0x3 | 0x8);
       return v.toString(16);
@@ -3731,7 +3952,8 @@ class SQLExecutor {
         return { ok: true, type: 'truncate', table: statement.name, affectedRows: 0 };
       }
       case 'alterTable': {
-        const table = this.engine._tables ? this.engine._tables[statement.name] : null;
+        // let 而非 const：RENAME 会把表挪到新名字下，需要重新取
+        let table = this.engine._tables ? this.engine._tables[statement.name] : null;
         if (!table) throw new Error(`Table '${statement.name}' does not exist`);
         for (const op of statement.ops) {
           switch (op.op) {
@@ -3769,6 +3991,9 @@ class SQLExecutor {
             }
             case 'dropPrimary': {
               for (const def of Object.values(table._schema)) { if (def && typeof def === 'object') { def.primaryKey = false; } }
+              // P1-23: 清除主键缓存，否则后续插入仍会检查主键冲突
+              table._primaryKey = null;
+              table._pkIndex = null;
               break;
             }
             case 'addIndex': {
@@ -3776,11 +4001,79 @@ class SQLExecutor {
               for (const c of op.columns) table._schema[c].unique = true;
               break;
             }
+            case 'rename': {
+              // 真正改表名。此前落到 default 直接 break ——
+              // 返回 ok:true 但表名没变，调用方以为改成功了。
+              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);
+              table = this.engine._tables[op.newName] || table;
+              statement.name = op.newName;
+              break;
+            }
+            case 'renameColumn': {
+              const oldCol = op.column;
+              const newCol = op.newColumn;
+              if (!(oldCol in table._schema)) {
+                throw new Error(`Unknown column '${oldCol}' in '${statement.name}'`);
+              }
+              if (oldCol === newCol) break;
+              if (newCol in table._schema) {
+                throw new Error(`Duplicate column name '${newCol}'`);
+              }
+              // 按原顺序重建而不是改键：直接 delete+赋值会把这一列挪到末尾，
+              // SELECT * 的列序、以及依赖列序的代码就都变了。
+              const newSchema = {};
+              for (const [f, def] of Object.entries(table._schema)) {
+                if (f === oldCol) newSchema[newCol] = def;
+                else newSchema[f] = def;
+              }
+              table._schema = newSchema;
+              for (const row of table._rows) {
+                if (!(oldCol in row)) continue;
+                const rebuilt = {};
+                for (const [k, v] of Object.entries(row)) {
+                  if (k === oldCol) rebuilt[newCol] = v;
+                  else rebuilt[k] = v;
+                }
+                for (const k of Object.keys(row)) delete row[k];
+                Object.assign(row, rebuilt);
+              }
+              break;
+            }
+            case 'dropIndex': {
+              // ALTER TABLE t DROP INDEX idx / DROP KEY idx
+              const idxName = op.name;
+              if (!idxName) throw new Error(`ALTER TABLE ... DROP INDEX requires an index name`);
+              // 索引名 → 列：优先查登记表（复合索引登记了多列），
+              // 查不到就把名字当列名（兼容单列同名的老用法）。
+              const reg = this.engine._indexRegistry
+                && this.engine._indexRegistry.get(String(idxName).toLowerCase());
+              const fields = (reg && reg.columns && reg.columns.length) ? reg.columns.slice() : [idxName];
+              const present = fields.filter(f => table._indexes[f] || table._btrees[f]);
+              if (!present.length) {
+                throw new Error(`Index '${idxName}' does not exist on '${statement.name}'`);
+              }
+              // 复合索引是逐列建的，必须全部清掉，只删首列会留残余索引
+              for (const f of present) table.dropIndex(f);
+              if (this.engine._indexRegistry) {
+                this.engine._indexRegistry.delete(String(idxName).toLowerCase());
+              }
+              break;
+            }
             case 'addForeign':
-            case 'dropIndex':
-            case 'rename':
+            case 'dropForeign':
+              // 外键在这个引擎里没有实现（连 CREATE TABLE 的表级 FOREIGN KEY
+              // 都只是解析掉、不记录、不强制）。与其返回成功让人以为约束生效，
+              // 不如明确报错。要支持得先做引用完整性检查。
+              throw new Error(
+                `ALTER TABLE ... ${op.op === 'addForeign' ? 'ADD FOREIGN KEY' : 'DROP FOREIGN KEY'} is not supported: ` +
+                `this engine does not implement foreign key constraints.`
+              );
             default:
-              break;
+              // 绝不能静默 break —— 那会返回 ok:true 却什么都没做
+              throw new Error(`ALTER TABLE: unsupported operation '${op.op}'`);
           }
         }
         await this._rebuildTableCache(table);
@@ -3946,6 +4239,9 @@ class SQLExecutor {
                       data[col] = d[val._valuesOf] !== undefined ? d[val._valuesOf] : null;
                     } else if (val && typeof val === 'object' && val._excludedOf !== undefined) {
                       data[col] = d[val._excludedOf] !== undefined ? d[val._excludedOf] : null;
+                    } else if (val && typeof val === 'object' && val.type === 'binary') {
+                      // P1-19: ON DUPLICATE KEY UPDATE 支持表达式赋值，如 count = count + 1
+                      data[col] = evaluateExpr(val, d, this.ctx);
                     } else {
                       data[col] = val;
                     }
@@ -4009,7 +4305,21 @@ class SQLExecutor {
       case 'with': {
         // CTE：按声明顺序把已展开的 CTE 内联进引用它的 FROM（含嵌套 CTE 引用）
         const map = new Map();
+        // 递归 CTE：自身引用不能内联成子查询（会无限展开 / 找不到列），
+        // 改由 _execRecursiveCte 迭代求解，这里先把名字登记进 map 供其识别。
+        const recursiveNames = new Set();
         for (const cte of statement.ctes) {
+          const key = String(cte.name).toLowerCase();
+          // 不要求显式写 RECURSIVE：只要 CTE 引用自身就按递归求解。
+          // 否则 `WITH c(n) AS (SELECT 1 UNION ALL SELECT n+1 FROM c ...)`
+          // 这种省略 RECURSIVE 的写法会走普通内联路径 → 找不到表 c。
+          // 必须有 UNION：自引用但无 UNION 的 CTE 无法终止，不是递归 CTE。
+          const hasUnion = !!cte.select.union;
+          if (hasUnion && this._cteIsRecursive(cte, key)) {
+            recursiveNames.add(key);
+            map.set(key, cte.select);   // 占位，实际不参与内联
+            continue;
+          }
           const sel = JSON.parse(JSON.stringify(cte.select));
           // CTE 显式列名清单 `name (a, b) AS (...)`：按顺序重命名输出列
           if (cte.columns && cte.columns.length) {
@@ -4018,7 +4328,10 @@ class SQLExecutor {
             });
           }
           this._inlineCteRefs(sel, map);
-          map.set(String(cte.name).toLowerCase(), sel);
+          map.set(key, sel);
+        }
+        if (recursiveNames.size) {
+          return await this._execWithRecursiveCtes(statement, map, recursiveNames);
         }
         const stmt = JSON.parse(JSON.stringify(statement.statement));
         this._inlineCteRefs(stmt, map);
@@ -4100,6 +4413,14 @@ class SQLExecutor {
             `CREATE INDEX is not supported by this engine (no createIndex/_ensureTable on the engine object)`
           );
         }
+        // 登记 索引名 → 表 + 列，供 DROP INDEX 按索引名反查
+        // （标准 SQL 的 DROP INDEX 不带表名，而存储层 dropIndex 收的是列名）
+        if (this.engine) {
+          if (!this.engine._indexRegistry) this.engine._indexRegistry = new Map();
+          this.engine._indexRegistry.set(String(statement.name).toLowerCase(), {
+            table: tName, columns: statement.columns.slice(),
+          });
+        }
         return {
           ok: true, type: 'createIndex', table: tName, name: statement.name,
           affectedRows: 0, warnings: [],
@@ -4107,14 +4428,49 @@ class SQLExecutor {
         };
       }
       case 'dropIndex': {
-        const tName2 = statement.table;
+        // DROP INDEX 只给索引名（标准 SQL 不要求写表名），而存储层的
+        // Table.dropIndex(field) 收的是**列名**。此前这里直接把索引名当列名传，
+        // 又因 table=null 拿不到表对象 → 一律报「not supported」。
+        // 现在：CREATE INDEX 时登记 索引名 → 表 + 列，删除时据此反查。
+        let tName2 = statement.table;
+        const rawName = String(statement.name || '');
+        // 支持 `DROP INDEX t.idx_a` 形式
+        if (!tName2 && rawName.includes('.')) {
+          const parts = rawName.split('.');
+          tName2 = parts[0];
+          statement.name = parts[parts.length - 1];
+        }
+        if (!tName2 && this.engine && this.engine._indexRegistry) {
+          const hit = this.engine._indexRegistry.get(String(statement.name || '').toLowerCase());
+          if (hit) tName2 = hit.table;
+        }
         let handled = false;
+        let droppedField = null;
+        const findTable = () => (typeof this.engine._ensureTable === 'function')
+          ? (this.engine._ensureTable(tName2) || (this.engine._tables && this.engine._tables[tName2]))
+          : null;
         if (typeof this.engine.dropIndex === 'function') {
           await this.engine.dropIndex(tName2, statement.name);
           handled = true;
-        } else if (tName2 && typeof this.engine._ensureTable === 'function') {
-          const tbl = this.engine._ensureTable(tName2) || (this.engine._tables && this.engine._tables[tName2]);
-          if (tbl && typeof tbl.dropIndex === 'function') { tbl.dropIndex(statement.name); handled = true; }
+        } else {
+          const tbl = tName2 ? findTable() : null;
+          if (tbl && typeof tbl.dropIndex === 'function') {
+            // 索引名 → 列名：优先用登记信息，否则当列名直接删（兼容单列同名的老用法）
+            const reg = this.engine._indexRegistry && this.engine._indexRegistry.get(String(statement.name || '').toLowerCase());
+            // 复合索引是逐列建的（a,b 各建一个），删除时必须全部清掉，
+            // 否则只删首列会留下残余索引，白占内存还让查询走错路径。
+            const fields = (reg && reg.columns && reg.columns.length) ? reg.columns.slice() : [statement.name];
+            const present = fields.filter(f => tbl._indexes[f] || tbl._btrees[f]);
+            if (present.length === 0) {
+              if (statement.ifExists) {
+                return { ok: true, type: 'dropIndex', affectedRows: 0, skipped: true, warnings: [], message: `Index '${statement.name}' did not exist` };
+              }
+              throw new Error(`Index '${statement.name}' does not exist`);
+            }
+            for (const f of present) tbl.dropIndex(f);
+            droppedField = present.length === 1 ? present[0] : present.join(',');
+            handled = true;
+          }
         }
         if (!handled) {
           if (statement.ifExists) {
@@ -4122,30 +4478,48 @@ class SQLExecutor {
           }
           throw new Error(`DROP INDEX is not supported by this engine (no dropIndex on the engine/table object)`);
         }
-        return { ok: true, type: 'dropIndex', table: tName2, name: statement.name, affectedRows: 0, warnings: [], message: `Index '${statement.name}' dropped` };
+        if (this.engine && this.engine._indexRegistry) this.engine._indexRegistry.delete(String(statement.name || '').toLowerCase());
+        return {
+          ok: true, type: 'dropIndex', table: tName2, name: statement.name,
+          affectedRows: 0, warnings: [],
+          message: `Index '${statement.name}' dropped` + (droppedField ? ` (column '${droppedField}')` : ''),
+        };
       }
       case 'savepoint': {
-        // 引擎侧没有保存点/快照能力。这里只登记名字，绝不假装能回滚。
-        if (!this.engine._savepoints) this.engine._savepoints = new Set();
-        this.engine._savepoints.add(String(statement.name).toLowerCase());
-        return { ok: true, type: 'savepoint', message: `Savepoint '${statement.name}' noted`, affectedRows: 0, warnings: [] };
+        requireSavepointEngine(this.engine, 'SAVEPOINT');
+        this.engine.savepoint(statement.name);
+        return {
+          ok: true, type: 'savepoint', name: statement.name,
+          message: `Savepoint '${statement.name}' created`,
+          affectedRows: 0, warnings: []
+        };
       }
       case 'releaseSavepoint': {
-        if (this.engine._savepoints) this.engine._savepoints.delete(String(statement.name).toLowerCase());
-        return { ok: true, type: 'releaseSavepoint', message: `Savepoint '${statement.name}' released`, affectedRows: 0, warnings: [] };
+        requireSavepointEngine(this.engine, 'RELEASE SAVEPOINT');
+        this.engine.releaseSavepoint(statement.name);
+        return {
+          ok: true, type: 'releaseSavepoint', name: statement.name,
+          message: `Savepoint '${statement.name}' released`,
+          affectedRows: 0, warnings: []
+        };
       }
       case 'rollbackTo': {
-        // 明确报错而不是静默无效：静默的"回滚成功"会让调用方以为数据已还原。
-        throw new Error(
-          `ROLLBACK TO SAVEPOINT '${statement.name}' is not supported: the engine has no savepoint/snapshot support. ` +
-          `Use ROLLBACK to abort the whole transaction.`
-        );
+        requireSavepointEngine(this.engine, 'ROLLBACK TO SAVEPOINT');
+        this.engine.rollbackTo(statement.name);
+        return {
+          ok: true, type: 'rollbackTo', name: statement.name,
+          message: `Rolled back to savepoint '${statement.name}'`,
+          affectedRows: 0, warnings: []
+        };
       }
       case 'update': {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
         const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
+        if (pkCols.length === 0) {
+          throw createError('ER_PARSE_ERROR', `Table '${statement.table}' has no primary key, UPDATE requires a primary key`);
+        }
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         let count = 0;
         for (const row of all) {
@@ -4503,6 +4877,33 @@ class SQLExecutor {
    * 其它条件（范围、OR、函数、IN、子查询）一律不下推，交回内存过滤，
    * 避免为了快而改错结果。
    */
+  /**
+   * 将查询值转换为与列类型匹配的类型，避免隐式类型转换不一致。
+   * 例如：WHERE int_col='1' 中 '1' 应转为整数 1。
+   */
+  _coerceValue(val, colDef) {
+    if (val === null || val === undefined) return val;
+    const type = colDef && colDef.type;
+    if (!type) return val;
+    if (type === 'integer' || type === 'int' || type === 'bigint' || type === 'smallint' || type === 'tinyint') {
+      const n = Number(val);
+      return Number.isNaN(n) ? val : n;
+    }
+    if (type === 'float' || type === 'double' || type === 'decimal' || type === 'real' || type === 'number') {
+      const n = Number(val);
+      return Number.isNaN(n) ? val : n;
+    }
+    if (type === 'boolean' || type === 'bool') {
+      if (typeof val === 'string') {
+        const lower = val.toLowerCase();
+        if (lower === 'true' || lower === '1') return true;
+        if (lower === 'false' || lower === '0') return false;
+      }
+      return val;
+    }
+    return val;
+  }
+
   _pushdownEqualities(statement) {
     const out = {};
     if (!statement || !statement.where || typeof statement.where !== 'object') return out;
@@ -4516,7 +4917,9 @@ class SQLExecutor {
       if (isCol(node.left) && isVal(node.right)) { col = node.left.name; val = node.right.value; }
       else if (isCol(node.right) && isVal(node.left)) { col = node.right.name; val = node.left.value; }
       if (col === null) return;
-      const key = col.includes('.') ? col.slice(col.lastIndexOf('.') + 1) : col;
+      // 保留表限定信息：有前缀用 "table.col"，无前缀用 "col"
+      // 这样 _readTable 可以判断该条件是否属于当前表
+      const key = col;
       // 同一列出现多个等值条件（如 id=1 AND id=2）时不推，交给内存求值
       if (Object.prototype.hasOwnProperty.call(out, key)) delete out[key];
       else out[key] = val;
@@ -4525,10 +4928,27 @@ class SQLExecutor {
     return out;
   }
 
-  async _readTable(table, statement) {
+  async _readTable(table, statement, alias) {
     const schema = await this._getSchema(table);
     // 有可下推的等值条件时交给存储层走索引；没有则维持原来的全表读取
-    const filter = statement ? this._pushdownEqualities(statement) : {};
+    const allFilters = statement ? this._pushdownEqualities(statement) : {};
+    // 只保留属于当前表的条件：
+    // - 带表限定的条件（如 "o.amount"）：检查表名/别名是否匹配
+    // - 不带表限定的条件（如 "amount"）：检查当前表的 schema 是否包含该列
+    const filter = {};
+    for (const [key, val] of Object.entries(allFilters)) {
+      if (key.includes('.')) {
+        // 带表限定：检查是否匹配当前表的别名或表名
+        const tablePart = key.slice(0, key.lastIndexOf('.'));
+        if (tablePart === alias || tablePart === table) {
+          const colPart = key.slice(key.lastIndexOf('.') + 1);
+          if (schema[colPart]) filter[colPart] = this._coerceValue(val, schema[colPart]);
+        }
+      } else {
+        // 不带表限定：只下推到持有该列的表
+        if (schema[key]) filter[key] = this._coerceValue(val, schema[key]);
+      }
+    }
     const useIndex = Object.keys(filter).length > 0 &&
       (typeof this.engine.exists === 'function' || typeof this.engine.find === 'function');
     const rows = useIndex
@@ -4539,10 +4959,19 @@ class SQLExecutor {
 
   async _execFromItem(item) {
     if (item.subquery) {
+      // 递归 CTE 物化出来的派生表：直接携带行数据
+      if (item.subquery._virtualSource) {
+        return { schema: null, rows: item.subquery._virtualSource.map(r => Object.assign({}, r)) };
+      }
       const res = await this.executeSelect(item.subquery);
       return { schema: null, rows: res.rows.map(r => Object.assign({}, r)) };
     }
-    return this._readTable(item.table);
+    // 递归 CTE 迭代用：把已累积的行当作一张临时表
+    // （否则 FROM 会去找真实表，报 no such table / no such column）
+    if (item._virtualRows) {
+      return { schema: null, rows: item._virtualRows.map(r => Object.assign({}, r)) };
+    }
+    return this._readTable(item.table, item._stmt, item.alias || item.table);
   }
 
   _infoSchemaColumns(view) {
@@ -4676,6 +5105,11 @@ class SQLExecutor {
       }
     }
     table._rows.forEach((row, idx) => {
+      // 重建 _pkIndex
+      if (table._pkIndex && table._primaryKey) {
+        const pkVal = row[table._primaryKey];
+        if (pkVal !== undefined && pkVal !== null) table._pkIndex.set(pkVal, idx);
+      }
       for (const [f, tree] of Object.entries(table._btrees)) {
         const v = row[f];
         if (v !== undefined && v !== null) tree.insert(v, idx);
@@ -5123,6 +5557,242 @@ class SQLExecutor {
    * 把 AST 中引用 CTE 名称的 FROM 项替换成对应的子查询（就地改写）。
    * map: 小写 CTE 名 -> 已展开的 select AST
    */
+  /**
+   * 判断某个 CTE 是否引用自身（因而需要递归求解）。
+   * 自引用必须出现在 UNION / UNION ALL 的**递归项**（右侧）里；
+   * 左侧（锚点）出现自引用无法终止，按普通 CTE 处理即可。
+   */
+  _cteIsRecursive(cte, key) {
+    // 既接受 {select: ...}（CTE 节点），也接受裸 select 节点（UNION 链上的分支）。
+    // 分支自身没有 union（链上最内层），所以只看「本分支内有没有自引用」，
+    // 不要求存在 union —— 否则链上最后一个分支永远判不出递归。
+    const sel = cte && cte.type === 'select' ? cte : (cte && cte.select);
+    if (!sel) return false;
+    let found = false;
+    const visit = (n) => {
+      if (found || !n || typeof n !== 'object') return;
+      if (Array.isArray(n)) { for (const x of n) visit(x); return; }
+      if (n.from) {
+        for (const t of (n.from.tables || [])) {
+          if (t && t.table && String(t.table).toLowerCase() === key) { found = true; return; }
+        }
+        for (const j of (n.from.joins || [])) {
+          if (j && j.item && j.item.table && String(j.item.table).toLowerCase() === key) { found = true; return; }
+        }
+      }
+      for (const k of Object.keys(n)) { if (k !== 'from') visit(n[k]); }
+    };
+    visit(sel);
+    return found;
+  }
+
+  /**
+   * 求解带递归 CTE 的 WITH 语句。
+   *
+   * 标准语义：递归 CTE = 锚点（anchor）SELECT UNION [ALL] 递归项 SELECT。
+   * 递归项里的自身引用指向「到目前为止累积的所有行」，反复迭代直到不再产生新行。
+   * UNION ALL 允许重复行与无限递归风险，故设迭代上限兜底。
+   */
+  async _execWithRecursiveCtes(statement, map, recursiveNames) {
+    // 先把递归 CTE 逐个求值，结果作为「派生表」供后续 CTE 与主查询引用
+    const resolved = new Map();
+    for (const cte of statement.ctes) {
+      const key = String(cte.name).toLowerCase();
+      if (!recursiveNames.has(key)) {
+        resolved.set(key, map.get(key));
+        continue;
+      }
+      const rows = await this._evalRecursiveCte(cte, key, resolved);
+      // 递归结果物化成派生表，主查询与其它 CTE 都能引用。
+      // 保留输出列名（CTE 声明的列名清单或首行列名），外层才能按 alias 引用。
+      const outCols = (cte.columns && cte.columns.length)
+        ? cte.columns.slice()
+        : Object.keys(rows[0] || { c0: 1 });
+      const sub = { type: 'select', columns: outCols.map(c => ({ expr: c, alias: c })), _virtualSource: rows };
+      resolved.set(key, sub);
+    }
+    // 主查询：把递归名替换成携带行数据的子查询
+    const stmt = JSON.parse(JSON.stringify(statement.statement));
+    const inject = (node) => {
+      if (!node || typeof node !== 'object') return;
+      if (Array.isArray(node)) { for (const x of node) inject(x); return; }
+      if (node.type === 'select' && node.from) {
+        const fix = (item) => {
+          if (!item || !item.table) return;
+          const k = String(item.table).toLowerCase();
+          if (!resolved.has(k)) return;
+          if (process.env.JSQL_DBG) console.error('[dbg] fix hit:', k, 'alias=', item.alias);
+          const src = resolved.get(k);
+          if (src && src._virtualSource) {
+            // 保留别名并清掉 table 名，否则外层 `FROM c c1` 找不到物化结果
+            item.subquery = JSON.parse(JSON.stringify(src));
+            item.alias = item.alias || item.table;
+            delete item.table;
+          } else {
+            item.subquery = JSON.parse(JSON.stringify(src));
+            item.alias = item.alias || item.table;
+            delete item.table;
+          }
+        };
+        for (const t of (node.from.tables || [])) fix(t);
+        for (const j of (node.from.joins || [])) fix(j.item);
+      }
+      for (const k of Object.keys(node)) { if (k !== 'from') inject(node[k]); }
+    };
+    inject(stmt);
+    if (process.env.JSQL_DBG) console.error('[dbg] inject done, FROM=', JSON.stringify(stmt.from));
+    return await this.execute(stmt);
+  }
+
+  /** 迭代求解单个递归 CTE，返回全部累积行 */
+  async _evalRecursiveCte(cte, key, resolved) {
+    const sel = cte.select;
+    // 兜底：UNION ALL 允许重复行，条件写错（如 WHERE 子句恒真）会导致无限增长。
+    // 单看迭代次数不够 —— 每轮累积行数可能翻倍，1000 轮就是 2^1000 行，
+    // 内存会先于迭代上限被打爆（实测 OOM）。所以同时限制总行数。
+    const MAX_ITER = 1000;
+    const MAX_ROWS = 100000;
+    let accumulated = [];
+    let recSel = null;          // 声明在 if 块外：循环里要用
+
+    if (sel.union) {
+      // UNION 链里可能有多个分支（`SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT n+1 FROM c`）。
+      // 语义：含自身引用的分支是**递归项**（只能有一个，取最后一个），
+      // 前面所有分支都是**锚点**，结果并入起始集。
+      // 此前只拆一层（左侧当锚点、右侧当递归项），
+      // 多个锚点时中间分支被当成递归项喂回 → 行数暴涨。
+      const branches = [];
+      let cur = sel;
+      while (cur && cur.union) { branches.push(cur); cur = cur.union.select; }
+      if (cur) branches.push(cur);   // 最内层（无 union）
+
+      const selfRef = (n) => this._cteIsRecursive({ select: n }, key);
+      const isRec = (n) => selfRef(n);
+      // 最后一个含自引用的分支 = 递归项；其后的分支（若有）也并入锚点
+      let recIdx = -1;
+      branches.forEach((b, i) => { if (isRec(b)) recIdx = i; });
+      let anchorBranches;
+      if (recIdx === -1) { anchorBranches = branches; recSel = null; }
+      else {
+        anchorBranches = branches.slice(0, recIdx);
+        recSel = branches[recIdx];
+        // 递归项之后还挂着的分支（非标准写法）也当锚点，避免丢结果
+        for (let i = recIdx + 1; i < branches.length; i++) anchorBranches.push(branches[i]);
+      }
+
+      // 执行锚点：逐个分支求值后合并
+      const want = (cte.columns && cte.columns.length) || (sel.columns || []).length;
+      for (const b of anchorBranches) {
+        // 关键：分支是 UNION 链上的一节，可能还挂着更深的 union.select。
+        // 只清 union=null 不够 —— 残留的深层分支里若含 FROM c 就会去查真实表。
+        // 这里只取该分支自身的 SELECT（含它自己的 from/where/columns），
+        // 其 union 指向的分支已在 branches 里单独处理。
+        const anchorStmt = {
+          type: 'select',
+          columns: b.columns,
+          from: b.from,
+          where: b.where,
+          groupBy: b.groupBy,
+          having: b.having,
+          orderBy: null,
+          limit: null,
+          offset: 0,
+          union: null, intersect: null, except: null, rollup: null,
+          aggregate: b.aggregate, distinct: b.distinct,
+        };
+        if (want) {
+          anchorStmt.columns = (anchorStmt.columns || []).slice(0, want)
+            .map((c, i) => ({ ...c, alias: (cte.columns && cte.columns[i]) || c.alias || ('c' + i) }));
+        }
+        const anchorRes = await this.executeSelect(anchorStmt);
+        accumulated = accumulated.concat(anchorRes.rows.map(r => Object.assign({}, r)));
+      }
+      if (!recSel) return accumulated;
+    } else {
+      return [];
+    }
+
+    // 显式列名清单：把输出列改名，便于递归项引用
+    if (cte.columns && cte.columns.length) {
+      accumulated = accumulated.map((r) => {
+        const keys = Object.keys(r);
+        const out = {};
+        cte.columns.forEach((c, idx) => { out[c] = r[keys[idx]]; });
+        return out;
+      });
+    }
+
+    const isAll = !!sel.union.all;
+    // semi-naive 求值：每轮只对本轮「新增」的行做一次递归。
+    // 若把全部累积行都喂回递归项，每行都会再产出一行 → 行数按轮次递增，
+    // 结果里出现大量重复（1..5 会得到 1,2,2,3,2,3,3,4,…）。
+    let frontier = accumulated;
+    for (let iter = 0; iter < MAX_ITER; iter++) {
+      if (frontier.length === 0) break;
+      // 把自身引用换成「本轮新增的行」。
+      // 只取递归项分支自身的 SELECT：它可能挂着更深的 union.select，
+      // 整段丢给 executeSelect 会再跑一轮 UNION，把自引用当普通表查。
+      const recBranch = JSON.parse(JSON.stringify(recSel));
+      const step = {
+        type: 'select',
+        columns: recBranch.columns,
+        from: recBranch.from,
+        where: recBranch.where,
+        groupBy: recBranch.groupBy,
+        having: recBranch.having,
+        orderBy: null, limit: null, offset: 0,
+        union: null, intersect: null, except: null, rollup: null,
+        aggregate: recBranch.aggregate, distinct: recBranch.distinct,
+      };
+      const bind = (node) => {
+        if (!node || typeof node !== 'object') return;
+        if (Array.isArray(node)) { for (const x of node) bind(x); return; }
+        if (node.type === 'select' && node.from) {
+          const fix = (item) => {
+            if (item && item.table && String(item.table).toLowerCase() === key) {
+              item._virtualRows = frontier;
+              item.alias = item.alias || item.table;
+              delete item.table;
+            }
+          };
+          for (const t of (node.from.tables || [])) fix(t);
+          for (const j of (node.from.joins || [])) fix(j.item);
+        }
+        for (const k of Object.keys(node)) { if (k !== 'from') bind(node[k]); }
+      };
+      bind(step);
+      // 递归项的输出列强制用 CTE 声明的列名 —— 表达式文本（'n + 1'）不能当列名，
+      // 否则下一轮迭代取不到列。
+      if (cte.columns && cte.columns.length) {
+        step.columns = (step.columns || []).slice(0, cte.columns.length)
+          .map((c, i) => ({ ...c, alias: cte.columns[i] }));
+      }
+      const res = await this.executeSelect(step);
+      let next = res.rows.map(r => Object.assign({}, r));
+      if (cte.columns && cte.columns.length) {
+        next = next.map(r => {
+          const keys = Object.keys(r);
+          const out = {};
+          cte.columns.forEach((c, idx) => { out[c] = r[keys[idx]]; });
+          return out;
+        });
+      }
+      if (!isAll) {
+        const seen = new Set(accumulated.map(r => JSON.stringify(r)));
+        next = next.filter(r => !seen.has(JSON.stringify(r)));
+      }
+      if (next.length === 0) break;
+      // 超过行数上限说明递归条件写错（恒真），提前收手而不是撑爆内存
+      if (accumulated.length + next.length > MAX_ROWS) {
+        accumulated = accumulated.concat(next.slice(0, MAX_ROWS - accumulated.length));
+        break;
+      }
+      accumulated = accumulated.concat(next);
+      frontier = next;      // 下一轮只喂本轮新增的行
+    }
+    return accumulated;
+  }
+
   _inlineCteRefs(node, map) {
     if (!node || typeof node !== 'object' || map.size === 0) return;
     if (Array.isArray(node)) {
@@ -5413,21 +6083,59 @@ class SQLExecutor {
         return { ok: true, type: 'select', table: firstItem.table, columns: outCols, rows, raw: filtered };
       }
       if (firstItem.subquery) {
-        const res = await this.executeSelect(firstItem.subquery);
-        rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
+        // 递归 CTE 物化出来的派生表：直接携带行数据
+        if (firstItem.subquery._virtualSource) {
+          rowsAll = { rows: firstItem.subquery._virtualSource.map(r => Object.assign({}, r)), schema: null, columns: null };
+        } else {
+          const res = await this.executeSelect(firstItem.subquery);
+          rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
+        }
+      } else if (firstItem._virtualRows) {
+        // 递归 CTE 迭代中：自身引用绑定到已累积的行
+        rowsAll = { rows: firstItem._virtualRows.map(r => Object.assign({}, r)), schema: null, columns: null };
       } else {
-        rowsAll = await this._readTable(firstItem.table, statement);
+        rowsAll = await this._readTable(firstItem.table, statement, firstItem.alias || firstItem.table);
       }
       schema = rowsAll.schema;
       const firstPrefix = firstItem.alias || firstItem.table;
-      let rows = rowsAll.rows.map(r => this._prefixRow(r, firstPrefix));
+      // 虚拟行分两种，语义不同：
+      //  - _virtualRows：递归 CTE **迭代过程内部**，FROM 是自身引用，列名不带前缀
+      //    （否则递归项里的 `n+1` 取不到值）
+      //  - subquery._virtualSource：递归 CTE **求值完成后**物化成的派生表，
+      //    与普通子查询一样按别名加前缀，外层才能写 c.n / x.n
+      const isVirtualSource = !!(firstItem.subquery && firstItem.subquery._virtualSource);
+      // 物化派生表：行键需要同时有 'c.n'（限定引用）与 'n'（非限定引用）。
+      // _prefixRow 正是这么做的 —— 但 SELECT * 会把两者都投影，同一列输出两次。
+      // 所以额外记下真实列名，SELECT * 时按它们去重。
+      this._curStarCols = isVirtualSource
+        ? (firstItem.subquery.columns || []).map(c => {
+            const a = c.alias || c.expr;
+            return (a && String(a).includes('.') ? String(a) : `${firstPrefix}.${a}`);
+          }).filter(Boolean)
+        : null;
+      let rows = isVirtualSource
+        ? rowsAll.rows.map(r => this._prefixRow(r, firstPrefix))
+        : (firstItem._virtualRows ? rowsAll.rows : rowsAll.rows.map(r => this._prefixRow(r, firstPrefix)));
 
       for (const j of statement.from.joins) {
-        const rightRes = j.item.subquery
-          ? await this.executeSelect(j.item.subquery)
-          : await this._readTable(j.item.table, statement);
+        // 虚拟行（递归 CTE 物化的派生表）要直接取行，不能当普通子查询执行
+        const jVirtual = j.item._virtualRows ||
+          (j.item.subquery && j.item.subquery._virtualSource);
+        const rightRes = jVirtual
+          ? { rows: (j.item._virtualRows || j.item.subquery._virtualSource).map(r => Object.assign({}, r)) }
+          : j.item.subquery
+            ? await this.executeSelect(j.item.subquery)
+            : await this._readTable(j.item.table, statement, j.item.alias || j.item.table);
         const rightPrefix = j.item.alias || j.item.table;
-        const rightRows = (j.item.subquery ? this._subQueryRows(rightRes) : rightRes.rows).map(r => this._prefixRow(r, rightPrefix));
+        // 迭代内部的虚拟行不加前缀；物化后的派生表要加（与普通子查询一致）
+        const jRaw = j.item._virtualRows
+          ? j.item._virtualRows
+          : (j.item.subquery && j.item.subquery._virtualSource
+            ? j.item.subquery._virtualSource
+            : (j.item.subquery ? this._subQueryRows(rightRes) : rightRes.rows));
+        const rightRows = (j.item._virtualRows && !j.item.subquery)
+          ? jRaw
+          : jRaw.map(r => this._prefixRow(r, rightPrefix));
 
         // 匹配（INNER/LEFT/RIGHT）
         if (j.type === 'cross' || (!j.on)) {
@@ -5537,7 +6245,21 @@ class SQLExecutor {
         const key = JSON.stringify(statement.columns.map(c => {
           // SELECT DISTINCT *：按整行去重（此前把 '*' 当列名解析成 null，导致所有行同 key 只剩 1 行）
           if (c.expr === '*') {
-            return Object.keys(r).filter(k => !String(k).startsWith('_')).sort().map(k => r[k]);
+            const allKeys = Object.keys(r).filter(k => !String(k).startsWith('_'));
+            // 物化派生表（递归 CTE 结果）的行同时带 'c.n' 与 'n' 两个键 ——
+            // 前者供限定引用、后者供非限定引用。SELECT * 时两者都会被投影，
+            // 同一列会输出两次，所以按 FROM 里的声明列去重，保留带前缀的那个。
+            // 现算而不是读实例字段：投影发生在另一次调用里，字段已被覆盖。
+            const fi = statement.from && statement.from.tables && statement.from.tables[0];
+            const vs = fi && fi.subquery && fi.subquery._virtualSource && fi.subquery.columns;
+            if (vs && vs.length) {
+              return vs.map(c => {
+                const a = c.alias || c.expr;
+                const key = (a && String(a).includes('.')) ? String(a) : `${fi.alias || fi.table}.${a}`;
+                return r[key] !== undefined ? r[key] : r[a];
+              });
+            }
+            return allKeys.map(k => r[k]);
           }
           if (c.scalar) return resolveOperand(c.scalar, r, this.ctx);
           if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
@@ -5669,7 +6391,8 @@ class SQLExecutor {
           if (av === bv || (av === undefined && bv === undefined)) continue;
           if (av === undefined || av === null) return o.dir === 'asc' ? -1 : 1;
           if (bv === undefined || bv === null) return o.dir === 'asc' ? 1 : -1;
-          const r = typeof av === 'number' && typeof bv === 'number' ? av - bv : String(av).localeCompare(String(bv));
+          // P2-1: localeCompare 对字符串排序受 locale 影响，应使用简单字符串比较
+          const r = typeof av === 'number' && typeof bv === 'number' ? av - bv : (String(av) < String(bv) ? -1 : String(av) > String(bv) ? 1 : 0);
           if (r !== 0) return o.dir === 'asc' ? r : -r;
         }
         return 0;
@@ -5689,21 +6412,56 @@ class SQLExecutor {
       const pkCols = schemaKeys.filter(k => schema && schema[k] && schema[k].primaryKey);
       const pk = pkCols.length > 0 ? pkCols[0] : (schemaKeys[0] || 'id');
       let cols;
-      if (schema) {
+      // 有 JOIN 时，SELECT * 应展开所有表的列（合并后的行包含所有前缀列）
+      const hasJoins = statement.from && statement.from.joins && statement.from.joins.length > 0;
+      if (schema && !hasJoins) {
         cols = [pk, ...schemaKeys.filter(k => k !== pk)];
       } else if (rowsAll && rowsAll.columns) {
         cols = rowsAll.columns;
       } else {
-        cols = Object.keys(all[0] || {}).filter((v, i, a) => a.indexOf(v) === i);
+        // JOIN 时：只使用带前缀的键，避免同一列重复
+        if (hasJoins) {
+          const seen = new Set();
+          cols = [];
+          for (const r of rows) {
+            for (const k of Object.keys(r)) {
+              const bare = k.includes('.') ? k.slice(k.indexOf('.') + 1) : k;
+              if (!seen.has(bare)) { seen.add(bare); cols.push(k); }
+            }
+          }
+        } else {
+          const allKeys = [];
+          for (const r of rows) {
+            for (const k of Object.keys(r)) {
+              if (!allKeys.includes(k)) allKeys.push(k);
+            }
+          }
+          cols = allKeys;
+        }
+      }
+      // 物化派生表（递归 CTE 结果）的行同时带 'c.n' 与 'n'：前者供限定引用、
+      // 后者供非限定引用。SELECT * 会把两者都输出，同一列重复。
+      // 按声明的列去重，优先取带前缀的那个键。
+      const fi = statement.from && statement.from.tables && statement.from.tables[0];
+      const vs = fi && fi.subquery && fi.subquery._virtualSource && fi.subquery.columns;
+      if (vs && vs.length) {
+        cols = vs.map(c => {
+          const a = c.alias || c.expr;
+          return (a && String(a).includes('.')) ? String(a) : `${fi.alias || fi.table}.${a}`;
+        });
       }
-      return { ok: true, type: 'select', table: tableName, columns: cols, rows: rows.map(r => cols.map(c => r[c])), raw: rows };
+      return { ok: true, type: 'select', table: tableName, columns: cols, rows: rows.map(r => cols.map(c => (r[c] !== undefined ? r[c] : r[String(c).slice(String(c).indexOf('.') + 1)]))), raw: rows };
     }
 
     const cols = statement.columns.map(c => scalarColumnName(c));
     const mapped = await this._projectRows(statement, rows, (r) => statement.columns.map(c => {
       if (c.over || (c.scalar && c.scalar.over)) return windowColumnValue(c, r);
       if (c.scalar) return projectScalar(resolveOperand(c.scalar, r, this.ctx));
-      if (c.expr === '*') return null;
+      // P1-18: SELECT *, col 星号列输出 null——应展开为所有列
+      if (c.expr === '*') {
+        // 展开星号：返回行的所有值
+        return Object.keys(r).map(k => r[k]);
+      }
       if (c.literal !== undefined) return c.literal;
       if (c.caseExpr) return projectScalar(evaluateCaseVal(c.caseExpr, r));
       return projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, this.ctx));
@@ -5846,7 +6604,7 @@ function escapeValue(value) {
     }
     return value.map(escapeValue).join(', ');
   }
-  if (typeof value === 'object') return "'" + JSON.stringify(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'";
+  if (typeof value === 'object') return "'" + JSON.stringify(value).replace(/'/g, "\\'") + "'";
   const str = String(value)
     .replace(/\\/g, '\\\\')
     .replace(/\0/g, '\\0')
@@ -6075,6 +6833,23 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
 // AST 访问与改写能力（纯新增，不改变既有导出项）
 const AST = require('./ast.js');
 
+/**
+ * 保存点需要引擎侧真的能做行级快照，否则「回滚成功」是假的。
+ *
+ * 内置的 Database 引擎有完整实现；wasm / native 引擎的事务在 Rust 侧，
+ * 目前还没有保存点 —— 那种情况必须明确报错，不能静默假装成功。
+ */
+function requireSavepointEngine(engine, op) {
+  if (engine && typeof engine.savepoint === 'function') return;
+  const who = (engine && engine.constructor && engine.constructor.name) || 'this engine';
+  throw new Error(
+    `${op} is not supported by ${who}: it has no savepoint support. ` +
+    `The built-in Database engine (require('jsql-neo').Database) supports it; ` +
+    `the wasm/native engines do not yet. ` +
+    `Use ROLLBACK to abort the whole transaction instead.`
+  );
+}
+
 module.exports = {
   tokenize, parseSQL, executeSQL, SQLExecutor, Parser,
   splitStatements, applyParams, escapeValue, escapeId,