jsql-neo 5.4.2 → 6.0.0-beta2

package/lib/sql.js

@@ -56,7 +56,13 @@ const KEYWORDS = new Set([
   'BETWEEN', 'USING', 'FULL', 'UNSIGNED', 'ZEROFILL', 'TRUNCATE', 'COLLATE', 'CHARACTER',
   'ALTER', 'ADD', 'COLUMN', 'MODIFY', 'CHANGE', 'INDEX', 'FOREIGN', 'REFERENCES',
   'CONSTRAINT', 'RENAME', 'TO', 'AFTER', 'FIRST', 'ENGINE', 'AUTO_INCREMENT', 'SPATIAL',
-  'REGEXP', 'TRUE', 'FALSE', 'RLIKE', 'PRAGMA', 'REPLACE', 'BLOB', 'RAISE', 'IGNORE'
+  'REGEXP', 'TRUE', 'FALSE', 'RLIKE', 'PRAGMA', 'REPLACE', 'BLOB', 'RAISE', 'IGNORE',
+  // 5.5.0 新增：CTE 与集合运算符
+  'WITH', 'RECURSIVE', 'INTERSECT', 'EXCEPT'
+  // 注意：OVER / PARTITION / UNBOUNDED / PRECEDING / FOLLOWING 等刻意不加入此表。
+  // 它们同时是常见标识符（列名 rank、current、row…），若被词法层标记为 keyword
+  // 会让 `SELECT rank FROM t` 之类的既有语句解析失败。这些词改由 Parser.isWord()
+  // 在语法层按上下文大小写不敏感地匹配，从而不破坏既有解析行为。
 ]);
 
 function tokenize(sql) {
@@ -160,6 +166,17 @@ function tokenize(sql) {
       continue;
     }
 
+    // 参数占位符：? （顺序）、?N （编号）、?? （标识符占位）
+    if (c === '?') {
+      if (sql[i + 1] === '?') { tokens.push(new SQLToken('param', '??', i)); i += 2; continue; }
+      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));
+      i = j;
+      continue;
+    }
+
     const two = sql.slice(i, i + 2);
     if (two === '<=' || two === '>=' || two === '!=' || two === '<>' || two === '==') {
       tokens.push(new SQLToken('op', two, i));
@@ -184,6 +201,7 @@ class Parser {
   constructor(tokens) {
     this.tokens = tokens;
     this.pos = 0;
+    this.paramCount = 0;   // 顺序占位符 ? 的序号（从 0 开始）
   }
 
   peek(offset = 0) { return this.tokens[this.pos + offset]; }
@@ -220,27 +238,70 @@ class Parser {
   parseStatement() {
     const t = this.peek();
     if (t.type === 'eof') return null;
-    if (t.type !== 'keyword') throw new Error(`Expected SQL statement, got '${t.value}'`);
+    if (t.type !== 'keyword') {
+      // 少数语句起始词刻意不进关键字表（它们同时是常见标识符），按上下文识别
+      const w = String(t.value).toUpperCase();
+      if (w === 'EXPLAIN') {
+        this.next();
+        if (this.isWord('ANALYZE')) this.next();
+        const stmt = this.parseStatement();
+        if (!stmt) throw new Error('EXPLAIN requires a following statement');
+        return { type: 'explain', statement: stmt };
+      }
+      if (w === 'SAVEPOINT') {
+        this.next();
+        const nm = this.next();
+        if (nm.type !== 'ident') throw new Error(`Expected savepoint name, got '${nm.value}'`);
+        this.optionalTailSemicolon();
+        return { type: 'savepoint', name: nm.value };
+      }
+      if (w === 'RELEASE') {
+        this.next();
+        if (this.isWord('SAVEPOINT')) this.next();
+        const nm = this.next();
+        if (nm.type !== 'ident') throw new Error(`Expected savepoint name, got '${nm.value}'`);
+        this.optionalTailSemicolon();
+        return { type: 'releaseSavepoint', name: nm.value };
+      }
+      throw new Error(`Expected SQL statement, got '${t.value}'`);
+    }
 
     switch (t.value) {
       case 'CREATE':
         if (this.isKeyword('TABLE', 1)) return this.parseCreateTable();
         if (this.isKeyword('DATABASE', 1)) return this.parseCreateDatabase();
+        if (this.isWord('VIEW', 1) || this.isWord('OR', 1)) return this.parseCreateView();
         throw new Error('Unsupported CREATE statement');
       case 'DROP':
         if (this.isKeyword('TABLE', 1)) return this.parseDropTable();
         if (this.isKeyword('DATABASE', 1)) return this.parseDropDatabase();
+        if (this.isWord('VIEW', 1)) return this.parseDropView();
         throw new Error('Unsupported DROP statement');
       case 'INSERT': return this.parseInsert();
+      case 'REPLACE': return this.parseReplace();
       case 'ALTER': return this.parseAlter();
       case 'TRUNCATE': this.expectKeyword('TRUNCATE'); if (this.isKeyword('TABLE')) this.next(); return { type: 'truncate', name: this.parseTableName() };
       case 'SELECT': return this.parseSelect();
+      case 'WITH': return this.parseWith();
       case 'UPDATE': return this.parseUpdate();
       case 'DELETE': return this.parseDelete();
       case 'BEGIN': this.expectKeyword('BEGIN'); this.optionalTransaction(); return { type: 'begin' };
       case 'START': this.expectKeyword('START'); if (this.isKeyword('TRANSACTION')) this.next(); return { type: 'begin' };
       case 'COMMIT': this.expectKeyword('COMMIT'); this.optionalTransaction(); return { type: 'commit' };
-      case 'ROLLBACK': this.expectKeyword('ROLLBACK'); this.optionalTransaction(); return { type: 'rollback' };
+      case 'ROLLBACK': {
+        this.expectKeyword('ROLLBACK');
+        // ROLLBACK TO [SAVEPOINT] name —— 回滚到保存点而非回滚整个事务
+        if (this.isKeyword('TO')) {
+          this.next();
+          if (this.isWord('SAVEPOINT')) this.next();
+          const nm = this.next();
+          if (nm.type !== 'ident') throw new Error(`Expected savepoint name, got '${nm.value}'`);
+          this.optionalTailSemicolon();
+          return { type: 'rollbackTo', name: nm.value };
+        }
+        this.optionalTransaction();
+        return { type: 'rollback' };
+      }
       case 'SHOW': return this.parseShow();
       case 'SET': return this.parseSet();
       case 'DESCRIBE': case 'DESC': return this.parseDescribe();
@@ -255,6 +316,54 @@ class Parser {
     if (this.isKeyword('WORK')) this.next();
   }
 
+  /**
+   * CREATE [OR REPLACE] VIEW name [(cols)] AS SELECT ...
+   * 视图在语法层解析成 { type:'createView', name, columns, select }；
+   * 执行层由引擎侧决定如何注册（不存在视图存储时退化为"可用即查询"）。
+   */
+  parseCreateView() {
+    this.expectKeyword('CREATE');
+    let orReplace = false;
+    if (this.isWord('OR')) {
+      this.next();
+      if (!this.isWord('REPLACE')) throw new Error(`Expected REPLACE after OR, got '${this.peek().value}'`);
+      this.next();
+      orReplace = true;
+    }
+    if (!this.isWord('VIEW')) throw new Error(`Expected VIEW, got '${this.peek().value}'`);
+    this.next();
+    const name = this.parseTableName();
+    let columns = null;
+    if (this.peek().type === 'op' && this.peek().value === '(') {
+      this.next();
+      columns = [];
+      for (;;) {
+        columns.push(this.parseColumnRef());
+        if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+        break;
+      }
+      this.expect('op', ')');
+    }
+    if (!this.isKeyword('AS')) throw new Error(`Expected AS in CREATE VIEW, got '${this.peek().value}'`);
+    this.next();
+    const select = this.parseSelect();
+    this.optionalTailSemicolon();
+    return { type: 'createView', name, columns, select, orReplace };
+  }
+
+  parseDropView() {
+    this.expectKeyword('DROP');
+    if (!this.isWord('VIEW')) throw new Error(`Expected VIEW, got '${this.peek().value}'`);
+    this.next();
+    let ifExists = false;
+    if (this.isKeyword('IF')) {
+      this.expectKeyword('IF'); this.expectKeyword('EXISTS'); ifExists = true;
+    }
+    const name = this.parseTableName();
+    this.optionalTailSemicolon();
+    return { type: 'dropView', name, ifExists };
+  }
+
   parseTableName() {
     const t = this.next();
     if (t.type !== 'ident') throw new Error(`Expected table name, got '${t.value}'`);
@@ -425,9 +534,26 @@ class Parser {
     }
   }
 
+  // REPLACE INTO t ... —— 等价于"存在则替换"，解析结构与 INSERT 一致
+  parseReplace() {
+    this.expectKeyword('REPLACE');
+    if (this.isKeyword('INTO')) this.next();
+    const stmt = this.parseInsertBody();
+    stmt.replace = true;
+    return stmt;
+  }
+
   parseInsert() {
     this.expectKeyword('INSERT');
+    let ignore = false;
+    if (this.isKeyword('IGNORE')) { this.next(); ignore = true; }
     this.expectKeyword('INTO');
+    const stmt = this.parseInsertBody();
+    stmt.ignore = ignore;
+    return stmt;
+  }
+
+  parseInsertBody() {
     const name = this.parseTableName();
     let columns = null;
     if (this.peek().type === 'op' && this.peek().value === '(') {
@@ -440,6 +566,12 @@ class Parser {
       }
       this.expect('op', ')');
     }
+    // INSERT INTO t [(cols)] SELECT ... —— 与 VALUES 互斥的另一条插入来源
+    if (this.isKeyword('SELECT')) {
+      const select = this.parseSelect();
+      this.optionalTailSemicolon();
+      return { type: 'insert', name, columns, select, dataRows: null, values: null, onDuplicate: null };
+    }
     this.expectKeyword('VALUES');
     const rows = [];
     while (true) {
@@ -468,31 +600,94 @@ class Parser {
     });
 
     let onDuplicate = null;
+    let onConflict = null;
     if (this.isKeyword('ON')) {
       this.expectKeyword('ON');
-      this.expectKeyword('DUPLICATE');
-      this.expectKeyword('KEY');
-      this.expectKeyword('UPDATE');
-      onDuplicate = [];
-      while (true) {
-        const col = this.parseTableName();
-        this.expect('op', '=');
-        const val = this.parseValue();
-        onDuplicate.push([col, val]);
-        if (this.peek().value === ',') { this.next(); continue; }
-        break;
+      // PostgreSQL: ON CONFLICT [(cols)] DO NOTHING | DO UPDATE SET ...
+      if (this.isWord('CONFLICT')) {
+        this.next();
+        let target = null;
+        if (this.peek().type === 'op' && this.peek().value === '(') {
+          this.next();
+          target = [];
+          for (;;) {
+            target.push(this.parseColumnRef());
+            if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+            break;
+          }
+          this.expect('op', ')');
+        }
+        if (!this.isWord('DO')) throw new Error(`Expected DO after ON CONFLICT, got '${this.peek().value}'`);
+        this.next();
+        if (this.isWord('NOTHING')) { this.next(); onConflict = { target, action: 'nothing' }; }
+        else if (this.isWord('UPDATE')) {
+          this.next();
+          if (!this.isKeyword('SET')) throw new Error(`Expected SET after DO UPDATE, got '${this.peek().value}'`);
+          this.next();
+          const sets = [];
+          for (;;) {
+            const col = this.parseColumnRef();
+            this.expect('op', '=');
+            const val = this.parseValue();
+            sets.push([col, val]);
+            if (this.peek().value === ',') { this.next(); continue; }
+            break;
+          }
+          onConflict = { target, action: 'update', sets };
+        } else {
+          throw new Error(`Expected NOTHING or UPDATE after DO, got '${this.peek().value}'`);
+        }
+      } else {
+        this.expectKeyword('DUPLICATE');
+        this.expectKeyword('KEY');
+        this.expectKeyword('UPDATE');
+        onDuplicate = [];
+        while (true) {
+          const col = this.parseTableName();
+          this.expect('op', '=');
+          const val = this.parseValue();
+          onDuplicate.push([col, val]);
+          if (this.peek().value === ',') { this.next(); continue; }
+          break;
+        }
       }
     }
     this.optionalTailSemicolon();
 
-    return { type: 'insert', name, columns, dataRows: columns ? dataRows : null, values: columns ? null : rows, onDuplicate };
+    // RETURNING * | RETURNING col [, col]...
+    const returning = this.parseOptionalReturning();
+    return { type: 'insert', name, columns, dataRows: columns ? dataRows : null, values: columns ? null : rows, onDuplicate, onConflict, returning };
+  }
+
+  /**
+   * 冲突处理策略 —— 把四种写法归一成一个动作：
+   *   REPLACE INTO                      → 'replace'
+   *   INSERT IGNORE / ON CONFLICT DO NOTHING → 'ignore'
+   *   ON DUPLICATE KEY UPDATE / ON CONFLICT DO UPDATE → 'update'
+   *   默认                               → 'throw'（ER_DUP_ENTRY）
+   */
+  /** 解析可选的 RETURNING 子句（INSERT / UPDATE / DELETE 通用） */
+  parseOptionalReturning() {
+    if (!this.isWord('RETURNING')) return null;
+    this.next();
+    if (this.peek().type === 'op' && this.peek().value === '*') { this.next(); return ['*']; }
+    const cols = [];
+    for (;;) {
+      cols.push(this.parseColumnRef());
+      if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+      break;
+    }
+    return cols;
   }
 
   parseValue() {
     const t = this.next();
     if (t.type === 'number' || t.type === 'string') return t.value;
     if (t.type === 'keyword' && t.value === 'NULL') return null;
+    if (t.type === 'keyword' && t.value === 'TRUE') return true;
+    if (t.type === 'keyword' && t.value === 'FALSE') return false;
     if (t.type === 'keyword' && t.value === 'DEFAULT') return { _default: true };
+    if (t.type === 'param') return { type: 'param', index: t.value, position: this.paramCount++ };
     if (t.type === 'op' && t.value === '-') {
       const num = this.next();
       if (num.type !== 'number') throw new Error('Expected number after -');
@@ -506,6 +701,126 @@ class Parser {
     throw new Error(`Expected value, got '${t.value}'`);
   }
 
+  /**
+   * WITH [RECURSIVE] name [(col, ...)] AS (SELECT ...), ... <statement>
+   * CTE 在语法层解析为 { type:'with', ctes:[{name, columns, select}], statement }。
+   * 执行层会把 CTE 内联为 FROM 子查询，因此不需要引擎侧临时表。
+   */
+  parseWith() {
+    this.expectKeyword('WITH');
+    let recursive = false;
+    if (this.isKeyword('RECURSIVE')) { this.next(); recursive = true; }
+    const ctes = [];
+    for (;;) {
+      const nameTok = this.next();
+      if (nameTok.type !== 'ident') throw new Error(`Expected CTE name, got '${nameTok.value}'`);
+      let columns = null;
+      if (this.peek().type === 'op' && this.peek().value === '(') {
+        this.next();
+        columns = [];
+        for (;;) {
+          columns.push(this.parseColumnRef());
+          if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+          break;
+        }
+        this.expect('op', ')');
+      }
+      this.expectKeyword('AS');
+      this.expect('op', '(');
+      const select = this.parseSelect();
+      this.expect('op', ')');
+      ctes.push({ name: nameTok.value, columns, select, recursive });
+      if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+      break;
+    }
+    const statement = this.parseStatement();
+    if (!statement) throw new Error('WITH requires a following SELECT/INSERT/UPDATE/DELETE statement');
+    return { type: 'with', recursive, ctes, statement };
+  }
+
+  /**
+   * 可选的窗口定义：OVER ( [PARTITION BY ...] [ORDER BY ...] [frame] ) 或 OVER win_name
+   * 只在真的出现 OVER 时才改写节点，因此不影响既有 func / aggregate 节点形状。
+   */
+  parseOptionalOver(node) {
+    if (!this.isWord('OVER')) return node;
+    this.next();
+    // 命名窗口：OVER w（后面必须不是 '(' ）
+    if (!(this.peek().type === 'op' && this.peek().value === '(')) {
+      const nameTok = this.next();
+      if (nameTok.type === 'eof') throw new Error('Expected window name or "(" after OVER');
+      node.over = { windowName: nameTok.value };
+      return node;
+    }
+    this.expect('op', '(');
+    const spec = {};
+    if (this.isWord('PARTITION')) {
+      this.next();
+      if (!this.isWord('BY')) throw new Error(`Expected BY after PARTITION, got '${this.peek().value}'`);
+      this.next();
+      spec.partitionBy = [];
+      for (;;) {
+        spec.partitionBy.push(this.parseOperand());
+        if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+        break;
+      }
+    }
+    if (this.isWord('ORDER')) {
+      this.next();
+      if (!this.isWord('BY')) throw new Error(`Expected BY after ORDER, got '${this.peek().value}'`);
+      this.next();
+      spec.orderBy = [];
+      for (;;) {
+        const col = this.parseOperand();
+        let dir = 'asc';
+        if (this.isWord('ASC')) { this.next(); }
+        else if (this.isWord('DESC')) { this.next(); dir = 'desc'; }
+        spec.orderBy.push({ column: col, dir });
+        if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+        break;
+      }
+    }
+    if (this.isWord('ROWS') || this.isWord('RANGE')) spec.frame = this.parseFrameSpec();
+    this.expect('op', ')');
+    node.over = spec;
+    return node;
+  }
+
+  // ROWS/RANGE BETWEEN <bound> AND <bound> | ROWS <bound>
+  parseFrameSpec() {
+    const unit = String(this.next().value).toUpperCase() === 'RANGE' ? 'RANGE' : 'ROWS';
+    const bound = () => {
+      if (this.isWord('UNBOUNDED')) {
+        this.next();
+        const d = String(this.next().value).toUpperCase();
+        if (d !== 'PRECEDING' && d !== 'FOLLOWING') throw new Error(`Expected PRECEDING or FOLLOWING after UNBOUNDED, got '${d}'`);
+        return { type: 'unbounded', direction: d === 'FOLLOWING' ? 'following' : 'preceding' };
+      }
+      if (this.isWord('CURRENT')) {
+        this.next();
+        this.next();   // ROW
+        return { type: 'currentRow' };
+      }
+      const nTok = this.next();
+      const num = nTok.type === 'number' ? nTok.value : parseInt(String(nTok.value), 10);
+      if (!Number.isFinite(num)) throw new Error(`Expected number in window frame bound, got '${nTok.value}'`);
+      const d = String(this.next().value).toUpperCase();
+      if (d !== 'PRECEDING' && d !== 'FOLLOWING') throw new Error(`Expected PRECEDING or FOLLOWING, got '${d}'`);
+      return { type: 'offset', value: num, direction: d === 'FOLLOWING' ? 'following' : 'preceding' };
+    };
+    let start = null, end = null;
+    if (this.isWord('BETWEEN')) {
+      this.next();
+      start = bound();
+      if (!this.isWord('AND')) throw new Error(`Expected AND in window frame, got '${this.peek().value}'`);
+      this.next();
+      end = bound();
+    } else {
+      start = bound();
+    }
+    return { unit, start, end };
+  }
+
   parseSelect() {
     this.expectKeyword('SELECT');
     let distinct = false;
@@ -523,8 +838,9 @@ class Parser {
         else if (!(this.peek().type === 'op' && this.peek().value === ')')) col = this.parseScalar();
         this.expect('op', ')');
         aggregate = { type: 'COUNT', column: col };
+        aggregate = this.parseOptionalOver(aggregate);
         aggregate.alias = this.parseOptionalAlias();
-        columns.push({ expr: col, aggregate: 'COUNT', column: col, alias: aggregate.alias });
+        columns.push({ expr: col, aggregate: 'COUNT', column: col, alias: aggregate.alias, over: aggregate.over || null, window: !!aggregate.over });
       } else if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX'].includes(t.value)) {
         this.next();
         const fn = t.value;
@@ -532,8 +848,9 @@ class Parser {
         const col = this.parseScalar();
         this.expect('op', ')');
         aggregate = { type: fn, column: col };
+        aggregate = this.parseOptionalOver(aggregate);
         aggregate.alias = this.parseOptionalAlias();
-        columns.push({ expr: col, aggregate: fn, column: col, alias: aggregate.alias });
+        columns.push({ expr: col, aggregate: fn, column: col, alias: aggregate.alias, over: aggregate.over || null, window: !!aggregate.over });
       } else if (t.type === 'op' && t.value === '*') {
         this.next();
         columns.push({ expr: '*' });
@@ -585,7 +902,28 @@ class Parser {
       this.expectKeyword('ORDER'); this.expectKeyword('BY');
       orderBy = [];
       while (true) {
-        const col = this.parseColumnRef();
+        // 支持表达式排序：ORDER BY a + b DESC、ORDER BY UPPER(name)
+        // 纯列名仍走 parseColumnRef，保持既有字符串形态不破坏下游
+        let col;
+        const save = this.pos;
+        // ORDER BY 项的合法结束符；不是这些就说明是表达式（如 a+b、UPPER(name)）
+        const ORDER_END = ['ASC', 'DESC', 'LIMIT', 'OFFSET', 'FETCH', 'UNION', 'INTERSECT',
+          'EXCEPT', 'RETURNING', 'FOR', 'WITH'];
+        const endsClause = (tk) => {
+          if (tk.type === 'eof') return true;
+          if (tk.type === 'op' && (tk.value === ',' || tk.value === ';' || tk.value === ')')) return true;
+          return ORDER_END.some(w => this.isWord(w));
+        };
+        try {
+          col = this.parseColumnRef();
+          if (!endsClause(this.peek())) {
+            this.pos = save;
+            col = this.parseScalar();
+          }
+        } catch (e) {
+          this.pos = save;
+          col = this.parseScalar();
+        }
         let dir = 'asc';
         if (this.isKeyword('ASC')) { this.next(); }
         else if (this.isKeyword('DESC')) { this.next(); dir = 'desc'; }
@@ -602,16 +940,49 @@ class Parser {
       if (this.isKeyword('OFFSET')) { this.next(); offset = this.parseValue(); if (typeof offset === 'number' && offset < 0) throw new Error(`OFFSET must be a non-negative integer, got ${offset}`); }
       else if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); offset = limit; limit = this.parseValue(); if (typeof limit === 'number' && limit < 0) throw new Error(`LIMIT must be a non-negative integer, got ${limit}`); }
     }
-    let union = null;
+    // 集合运算：UNION [ALL|DISTINCT] / INTERSECT [ALL|DISTINCT] / EXCEPT [ALL|DISTINCT]
+    let union = null, intersect = null, except = null;
     if (this.isKeyword('UNION')) {
       this.next();
       const all = this.isKeyword('ALL');
       if (all) this.next();
+      else if (this.isKeyword('DISTINCT')) this.next();
       union = { all, select: this.parseSelect() };
+    } else if (this.isKeyword('INTERSECT')) {
+      this.next();
+      const all = this.isKeyword('ALL');
+      if (all) this.next();
+      else if (this.isKeyword('DISTINCT')) this.next();
+      intersect = { all, select: this.parseSelect() };
+    } else if (this.isKeyword('EXCEPT')) {
+      this.next();
+      const all = this.isKeyword('ALL');
+      if (all) this.next();
+      else if (this.isKeyword('DISTINCT')) this.next();
+      except = { all, select: this.parseSelect() };
+    }
+    // GROUP BY ... WITH ROLLUP
+    let rollup = false;
+    if (groupBy && this.isKeyword('WITH')) {
+      this.next();
+      if (this.isWord('ROLLUP')) { this.next(); rollup = true; }
+      else throw new Error(`Expected ROLLUP after WITH, got '${this.peek().value}'`);
+    }
+    // FETCH FIRST n ROWS ONLY（SQL 标准的 LIMIT 写法）
+    if (this.isWord('FETCH')) {
+      this.next();
+      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);
+      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();
+      if (this.isWord('ONLY')) this.next();
     }
     this.optionalTailSemicolon();
 
-    return { type: 'select', columns, aggregate, distinct, from, where, groupBy, having, orderBy, limit, offset, union };
+    return { type: 'select', columns, aggregate, distinct, from, where, groupBy, having, orderBy, limit, offset, union, intersect, except, rollup };
   }
 
   parseFrom() {
@@ -619,7 +990,12 @@ class Parser {
     const joins = [];
     while (true) {
       let type = null;
-      if (this.isKeyword('LEFT') || this.isKeyword('RIGHT')) {
+      if (this.isKeyword('FULL')) {
+        this.next();
+        if (this.isKeyword('OUTER')) this.next();
+        this.expectKeyword('JOIN');
+        type = 'full';
+      } else if (this.isKeyword('LEFT') || this.isKeyword('RIGHT')) {
         type = this.peek().value.toLowerCase();
         this.next();
         if (this.isKeyword('OUTER')) this.next();
@@ -659,8 +1035,13 @@ class Parser {
     }
     const table = this.parseTableName();
     let alias = null;
+    // 这里排除的是"未进关键字表、但会跟在表名之后"的子句起始词，
+    // 否则 `FROM t FETCH FIRST 10 ROWS ONLY` 会把 FETCH 当成表别名吃掉。
+    const NOT_ALIAS = ['JOIN', 'LEFT', 'RIGHT', 'FULL', 'WHERE', 'GROUP', 'ORDER', 'LIMIT',
+      'ON', 'HAVING', 'UNION', 'INNER', 'CROSS', 'OUTER', 'INTERSECT', 'EXCEPT',
+      'FETCH', 'RETURNING', 'WINDOW'];
     if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
-    else if (this.peek().type === 'ident' && !this.isKeyword('JOIN') && !this.isKeyword('LEFT') && !this.isKeyword('RIGHT') && !this.isKeyword('WHERE') && !this.isKeyword('GROUP') && !this.isKeyword('ORDER') && !this.isKeyword('LIMIT') && !this.isKeyword('ON') && !this.isKeyword('HAVING') && !this.isKeyword('UNION') && !this.isKeyword('INNER') && !this.isKeyword('CROSS')) {
+    else if (this.peek().type === 'ident' && !NOT_ALIAS.some(w => this.isWord(w))) {
       alias = this.next().value;
     }
     return { table, alias };
@@ -704,8 +1085,9 @@ class Parser {
     }
     let where = null;
     if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
+    const returning = this.parseOptionalReturning();
     this.optionalTailSemicolon();
-    return { type: 'update', table, assignments, where };
+    return { type: 'update', table, assignments, where, returning };
   }
 
   parseDelete() {
@@ -714,8 +1096,9 @@ class Parser {
     const table = this.parseTableName();
     let where = null;
     if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
+    const returning = this.parseOptionalReturning();
     this.optionalTailSemicolon();
-    return { type: 'delete', table, where };
+    return { type: 'delete', table, where, returning };
   }
 
   parseDropTable() {
@@ -1026,14 +1409,28 @@ class Parser {
   parseNot() {
     if (this.isKeyword('NOT')) {
       this.next();
-      return { type: 'not', expr: this.parseNot() };
-    }
-    if (this.peek().type === 'op' && this.peek().value === '(') {
+      const inner = this.parseNot();
+      // NOT EXISTS (...) 折叠成 exists.not，而不是包一层 not —— 语义等价且便于执行层物化
+      if (inner && inner.type === 'exists') { inner.not = !inner.not; return inner; }
+      return { type: 'not', expr: inner };
+    }
+    // 括号分组 —— 但 `(SELECT ...)` 是标量子查询，不能当分组吃掉
+    const isSubqueryParen = this.peek().type === 'op' && this.peek().value === '(' &&
+      this.peek(1) && this.peek(1).type === 'keyword' && this.peek(1).value === 'SELECT';
+    if (!isSubqueryParen && this.peek().type === 'op' && this.peek().value === '(') {
       this.next();
       const e = this.parseExpr();
       this.expect('op', ')');
       return e;
     }
+    // EXISTS (SELECT ...)：子查询是否存在至少一行
+    if (this.isKeyword('EXISTS')) {
+      this.next();
+      this.expect('op', '(');
+      const select = this.parseSelect();
+      this.expect('op', ')');
+      return { type: 'exists', select, not: false };
+    }
     return this.parseComparison();
   }
 
@@ -1048,6 +1445,30 @@ class Parser {
         if (col.type !== 'ident') throw new Error(`Expected column name after '.', got '${col.value}'`);
         return { type: 'column', name: t.value + '.' + col.value };
       }
+      // CAST(expr AS type)
+      if (String(t.value).toUpperCase() === 'CAST' && this.peek().type === 'op' && this.peek().value === '(') {
+        this.next();
+        const expr = this.parseScalar();
+        if (!this.isWord('AS')) throw new Error(`Expected AS in CAST, got '${this.peek().value}'`);
+        this.next();
+        const typeTok = this.next();
+        let dataType = String(typeTok.value).toUpperCase();
+        // VARCHAR(10) / DECIMAL(10,2) 这类带长度的类型
+        if (this.peek().type === 'op' && this.peek().value === '(') {
+          this.next();
+          let depth = 1;
+          let spec = '';
+          while (depth > 0 && this.peek().type !== 'eof') {
+            const tk = this.next();
+            if (tk.type === 'op' && tk.value === '(') depth++;
+            else if (tk.type === 'op' && tk.value === ')') { depth--; if (depth === 0) break; }
+            spec += tk.value;
+          }
+          dataType += '(' + spec + ')';
+        }
+        this.expect('op', ')');
+        return { type: 'cast', expr, dataType };
+      }
       // 函数调用: VERSION() / CONCAT(a, b) / NOW() ...
       if (this.peek().type === 'op' && this.peek().value === '(') {
         const name = t.value;
@@ -1062,13 +1483,17 @@ class Parser {
           }
         }
         this.expect('op', ')');
-        return { type: 'func', name, args };
+        return this.parseOptionalOver({ type: 'func', name, args });
       }
       return { type: 'column', name: t.value };
     }
     if (t.type === 'number' || t.type === 'string') return { type: 'value', value: t.value };
     if (t.type === 'sysvar') return { type: 'sysvar', name: t.value };
+    if (t.type === 'param') return { type: 'param', index: t.value, position: this.paramCount++ };
     if (t.type === 'keyword' && t.value === 'NULL') return { type: 'value', value: null };
+    // MySQL: TRUE/FALSE 是 1/0 的别名，可作为值字面量出现在任意表达式位置
+    if (t.type === 'keyword' && t.value === 'TRUE') return { type: 'value', value: true };
+    if (t.type === 'keyword' && t.value === 'FALSE') return { type: 'value', value: false };
     if (t.type === 'keyword' && t.value === 'CASE') return this.parseCase();
     if (t.type === 'keyword' && !['SUM', 'AVG', 'MIN', 'MAX', 'COUNT'].includes(t.value) && this.peek().type === 'op' && this.peek().value === '(') {
       const name = t.value;
@@ -1083,7 +1508,7 @@ class Parser {
         }
       }
       this.expect('op', ')');
-      return { type: 'func', name, args };
+      return this.parseOptionalOver({ type: 'func', name, args });
     }
     if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX', 'COUNT'].includes(t.value)) {
       const fn = t.value;
@@ -1092,7 +1517,7 @@ class Parser {
       if (this.peek().type === 'op' && this.peek().value === '*') { this.next(); }
       else if (!(this.peek().type === 'op' && this.peek().value === ')')) column = this.parseScalar();
       this.expect('op', ')');
-      return { type: 'aggregate', fn, column };
+      return this.parseOptionalOver({ type: 'aggregate', fn, column });
     }
     if (t.type === 'op' && t.value === '(' && this.peek().type === 'keyword' && this.peek().value === 'SELECT') {
       const sub = this.parseSelect();
@@ -1206,8 +1631,8 @@ class Parser {
       not = true;
       // NOT 后必须紧跟比较关键字
       const n = this.peek();
-      if (!['IN', 'BETWEEN', 'LIKE', 'REGEXP'].includes(n.value)) {
-        throw new Error(`Expected IN, BETWEEN, LIKE or REGEXP after NOT, got '${n.value}'`);
+      if (!['IN', 'BETWEEN', 'LIKE', 'REGEXP', 'RLIKE', 'ILIKE'].includes(n.value)) {
+        throw new Error(`Expected IN, BETWEEN, LIKE, ILIKE, REGEXP or RLIKE after NOT, got '${n.value}'`);
       }
     }
     const t2 = this.peek();
@@ -1256,13 +1681,16 @@ class Parser {
       throw new Error(`Expected AND in BETWEEN, got '${andTok.value}'`);
     }
 
-    if (t2.type === 'keyword' && t2.value === 'LIKE') {
+    // ILIKE 刻意不加进 KEYWORDS（避免影响同名标识符），用 isWord 按上下文匹配
+    if ((t2.type === 'keyword' && t2.value === 'LIKE') || this.isWord('ILIKE')) {
+      const isILike = !(t2.type === 'keyword' && t2.value === 'LIKE');
       this.next();
       const pattern = this.parseValue();
-      return { type: 'like', operand: left, pattern, not };
+      return { type: 'like', operand: left, pattern, not, ci: isILike };
     }
 
-    if (t2.type === 'keyword' && t2.value === 'REGEXP') {
+    // MySQL 中 RLIKE 是 REGEXP 的同义词
+    if (t2.type === 'keyword' && (t2.value === 'REGEXP' || t2.value === 'RLIKE')) {
       this.next();
       const pattern = this.parseValue();
       return { type: 'regexp', operand: left, pattern, not };
@@ -1270,6 +1698,15 @@ class Parser {
 
     if (t2.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>='].includes(t2.value)) {
       this.next();
+      // = ANY (SELECT ...) / > ALL (SELECT ...)
+      const anyAll = this.isWord('ANY') || this.isWord('ALL') || this.isWord('SOME');
+      if (anyAll) {
+        const quantifier = String(this.next().value).toUpperCase() === 'ALL' ? 'ALL' : 'ANY';
+        this.expect('op', '(');
+        const sub = this.parseSelect();
+        this.expect('op', ')');
+        return { type: 'quantified', op: t2.value === '<>' ? '!=' : t2.value, operand: left, select: sub, quantifier, not };
+      }
       const right = this.parseOperand();
       return { type: 'compare', op: t2.value === '<>' ? '!=' : t2.value, left, right };
     }
@@ -1288,6 +1725,34 @@ const OPERATORS = {
   '>=': (a, b) => a >= b
 };
 
+/** CAST(expr AS type) 的类型转换 */
+function applyCast(value, dataType) {
+  const t = String(dataType || '').toUpperCase().replace(/\(.*\)$/, '').trim();
+  if (value === null || value === undefined) return null;
+  if (t === 'INTEGER' || t === 'INT' || t === 'BIGINT' || t === 'SMALLINT' || t === 'TINYINT') {
+    const n = Number(value);
+    return Number.isFinite(n) ? Math.trunc(n) : null;
+  }
+  if (t === 'FLOAT' || t === 'DOUBLE' || t === 'REAL' || t === 'NUMERIC' || t === 'DECIMAL') {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  if (t === 'BOOLEAN' || t === 'BOOL') {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number') return value !== 0;
+    const s = String(value).toLowerCase();
+    return s === 'true' || s === '1' || s === 't' || s === 'yes';
+  }
+  if (t === 'TEXT' || t === 'VARCHAR' || t === 'CHAR' || t === 'STRING') return String(value);
+  return value;
+}
+
+// 行对象里是否存在 `alias.col` 形式的键（即该行是否已被加过表前缀）
+function rowHasPrefixedKeys(row) {
+  for (const k in row) if (k.indexOf('.') !== -1) return true;
+  return false;
+}
+
 function resolveOperand(operand, row, ctx) {
   if (operand === null || operand === undefined) return null;
   if (typeof operand === 'string') return resolveOperand({ type: 'column', name: operand }, row, ctx);
@@ -1321,11 +1786,15 @@ function resolveOperand(operand, row, ctx) {
       const n = operand.name;
       if (n === undefined) return undefined;
       if (row[n] !== undefined) return row[n];
-      if (n.includes('.')) {
-        if (row[n] !== undefined) return row[n];
+      if (n.indexOf('.') !== -1) {
         const col = n.slice(n.lastIndexOf('.') + 1);
-        return row[col];
+        // 只有当行完全没有带前缀的键（即行未被 _prefixRow 处理过）时才回退到裸列名。
+        // 否则 `e.dept` 这种未知限定符会静默取到当前行自己的 dept，
+        // 让相关子查询变成“自匹配”，EXISTS 恒为真。
+        if (!rowHasPrefixedKeys(row) && row[col] !== undefined) return row[col];
       }
+      // 相关子查询：回退到外层行（ctx.__outer 由 _evalExists 临时注入）
+      if (ctx && ctx.__outer && ctx.__outer[n] !== undefined) return ctx.__outer[n];
       return undefined;
     }
     case 'arith': {
@@ -1352,8 +1821,35 @@ function resolveOperand(operand, row, ctx) {
     case 'like':
     case 'between':
       return evaluateExpr(operand, row, ctx);
-    case 'aggregate':
+    case 'param': {
+      // 原生 ? 占位符。executeSQL 默认会先用 applyParams 内联替换，
+      // 只有在显式传入 ctx.params 时才走这条路径。
+      const params = ctx && ctx.params;
+      if (params == null) return undefined;
+      if (operand.index === '??') {
+        return typeof params === 'object' && !Array.isArray(params) ? params['@@'] : undefined;
+      }
+      const i = operand.index != null && operand.index !== '??' ? operand.index - 1 : (operand.position || 0);
+      return Array.isArray(params) ? params[i] : params[i];
+    }
+    case 'cast': {
+      const v = resolveOperand(operand.expr, row, ctx);
+      return applyCast(v, operand.dataType);
+    }
+    case 'quantified': {
+      // = ANY / > ALL (SELECT ...) —— 需先由执行层物化成 operand._list
+      const v = resolveOperand(operand.operand, row, ctx);
+      const list = operand._list || [];
+      if (list.length === 0) return operand.quantifier === 'ALL';
+      const fn = OPERATORS[operand.op];
+      if (!fn) return false;
+      const results = list.map(x => (v === null || x === null) ? false : fn(v, x));
+      return operand.quantifier === 'ALL' ? results.every(Boolean) : results.some(Boolean);
+    }
     case 'subquery':
+      // 相关子查询：值由 _evalCorrelated 按外层行算好写回 _value
+      return operand._value !== undefined ? operand._value : null;
+    case 'aggregate':
       return undefined;
     default:
       return undefined;
@@ -1478,13 +1974,14 @@ function seedRand(seed) {
   };
 }
 
-function likeMatch(value, pattern) {
+// ci 默认 true：保持 LIKE 既有的大小写不敏感行为不变；ILIKE 同为不敏感。
+function likeMatch(value, pattern, ci = true) {
   if (typeof value !== 'string') return false;
   const regex = pattern
     .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
     .replace(/%/g, '.*')
     .replace(/_/g, '.');
-  return new RegExp('^' + regex + '$', 'i').test(value);
+  return new RegExp('^' + regex + '$', ci ? 'i' : '').test(value);
 }
 
 function extractEqualPushdown(expr, schema) {
@@ -1512,6 +2009,25 @@ function extractEqualPushdown(expr, schema) {
   return { filter, rest };
 }
 
+// 行去重（保持首次出现顺序），供 UNION / INTERSECT / EXCEPT 的 DISTINCT 语义使用
+function dedupeRows(rows) {
+  const seen = new Set();
+  return rows.filter(r => {
+    const k = JSON.stringify(r);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+
+// 比较前把布尔归一化为 1/0，但只在“另一侧是数值/布尔”时做，
+// 避免把 true 与字符串 'true' 的比较悄悄改成 1 与 'true' 的比较。
+function normalizeCmpValue(a, other) {
+  if (typeof a !== 'boolean') return a;
+  const otherIsNumeric = typeof other === 'number' || typeof other === 'boolean';
+  return otherIsNumeric ? (a ? 1 : 0) : a;
+}
+
 function evaluateExpr(expr, row, ctx) {
   if (expr === null || expr === undefined) return false;
   switch (expr.type) {
@@ -1523,9 +2039,12 @@ function evaluateExpr(expr, row, ctx) {
       const r = resolveOperand(expr.right, row, ctx);
       // SQL 标准：任何与 NULL 的比较结果为 UNKNOWN（在 WHERE/ON/HAVING 中视为 false）
       if (l === null || r === null) return false;
-      if (expr.op === '=') return l === r || (l !== null && r !== null && String(l) === String(r));
+      // 布尔与数值互通（MySQL: 1 = TRUE、0 = FALSE）
+      const nl = normalizeCmpValue(l, r);
+      const nr = normalizeCmpValue(r, l);
+      if (expr.op === '=') return nl === nr || String(nl) === String(nr);
       const fn = OPERATORS[expr.op];
-      return typeof l === 'number' && typeof r === 'number' ? fn(l, r) : fn(String(l), String(r));
+      return typeof nl === 'number' && typeof nr === 'number' ? fn(nl, nr) : fn(String(nl), String(nr));
     }
     case 'isNull': {
       const v = resolveOperand(expr.operand, row, ctx);
@@ -1539,9 +2058,12 @@ function evaluateExpr(expr, row, ctx) {
       return expr.list.some(x => x === v || String(x) === String(v));
     }
     case 'like': {
-      const r = likeMatch(resolveOperand(expr.operand, row, ctx), expr.pattern);
+      const v = resolveOperand(expr.operand, row, ctx);
+      const r = likeMatch(v, expr.pattern, !!expr.ci);
       return expr.not ? !r : r;
     }
+    case 'quantified':
+      return !!resolveOperand(expr, row, ctx);
     case 'regexp': {
       const v = resolveOperand(expr.operand, row, ctx);
       if (v === null || v === undefined) return false;
@@ -1566,6 +2088,12 @@ function evaluateExpr(expr, row, ctx) {
         : String(v) >= String(lo) && String(v) <= String(hi);
       return expr.not ? !inRange : inRange;
     }
+    case 'exists': {
+      // 执行层会把子查询物化成 expr._rowCount，这里只做布尔判定
+      const n = typeof expr._rowCount === 'number' ? expr._rowCount : (expr._rows ? expr._rows.length : 0);
+      const has = n > 0;
+      return expr.not ? !has : has;
+    }
     case 'case': {
       for (const b of expr.branches) {
         if (evaluateExpr(b.cond, row, ctx)) return resolveOperand(b.val, row, ctx);
@@ -1602,6 +2130,11 @@ function scalarName(node) {
 }
 
 function scalarColumnName(c) {
+  // 未起别名的窗口函数列给一个可读的名字（仅影响新增语法，不动既有命名规则）
+  if ((c.over || (c.scalar && c.scalar.over)) && !c.alias) {
+    const fn = String(c.aggregate || (c.scalar && c.scalar.name) || 'WINDOW').toUpperCase();
+    return fn + '() OVER ()';
+  }
   if (c.alias) return c.alias;
   if (c.scalar) return scalarName(c.scalar);
   if (c.aggregate) return c.alias || (c.aggregate === 'COUNT' ? 'COUNT(*)' : c.aggregate + '(' + c.column + ')');
@@ -1612,7 +2145,15 @@ function scalarColumnName(c) {
   return dot !== -1 ? c.expr.slice(dot + 1) : c.expr;
 }
 
+// 窗口函数列：值由 _computeWindows 预先写回行对象，投影时直接取用
+function windowColumnValue(c, r) {
+  const key = c._windowKey || c.alias || scalarColumnName(c);
+  const v = r ? r[key] : undefined;
+  return v === undefined ? null : v;
+}
+
 function scalarColumnValue(c, r, ctx) {
+  if (c.over || (c.scalar && c.scalar.over)) return windowColumnValue(c, r);
   if (c.scalar) {
     const s = c.scalar;
     if (s && s.type === 'func' && ctx && ctx.ctxAggregates && Object.prototype.hasOwnProperty.call(ctx.ctxAggregates, String(s.name).toUpperCase())) {
@@ -1775,6 +2316,16 @@ class SQLExecutor {
           });
           dataRows = statement.dataRows;
         }
+        // INSERT ... SELECT：先跑 SELECT，再把结果行映射成待插入行
+        if (statement.select) {
+          const res = await this.executeSelect(statement.select);
+          const cols = statement.columns && statement.columns.length ? statement.columns : res.columns;
+          dataRows = res.rows.map(arr => {
+            const row = {};
+            cols.forEach((c, i) => { row[c] = arr[i]; });
+            return row;
+          });
+        }
         if (dataRows === null && statement.values) {
           const colNames = Object.keys(schema);
           const skipAuto = statement.values[0].length < colNames.length;
@@ -1798,6 +2349,7 @@ class SQLExecutor {
         const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         let toInsert = dataRows;
         let updated = 0;
+        let skipped = 0;
         if (pkCols.length > 0) {
           const keyOf = (row) => pkCols.map(c => (row[c] !== undefined && row[c] !== null ? String(row[c]) : '')).join('|');
           const hasExplicitPk = (row) => pkCols.some(c => row[c] !== undefined && row[c] !== null);
@@ -1819,25 +2371,49 @@ class SQLExecutor {
                 fresh.push(d);
               }
             }
-            if (conflicts.length > 0 && !statement.onDuplicate) {
+            const conflictAction = this._conflictAction(statement);
+            const conflictSets = this._conflictSets(statement);
+            if (conflicts.length > 0 && conflictAction === 'throw') {
               throw new Error('ER_DUP_ENTRY: Duplicate entry for primary key');
             }
-            if (statement.onDuplicate && conflicts.length > 0) {
+            if (conflicts.length > 0 && conflictAction === 'ignore') {
+              // INSERT IGNORE / ON CONFLICT DO NOTHING：静默跳过冲突行
+              skipped = conflicts.length;
+            }
+            if (conflicts.length > 0 && conflictAction === 'replace') {
+              // REPLACE INTO：删除旧行后按新行插入
+              const oldIds = [];
+              for (const { existingId } of conflicts) {
+                if (existingId.length === 1) oldIds.push(existingId[0]);
+              }
+              if (oldIds.length > 0) {
+                if (this.engine.removeByIds) await this.engine.removeByIds(statement.name, oldIds);
+                else for (const id of oldIds) await this.engine.removeById(statement.name, id);
+              }
+              toInsert = dataRows;
+              await this.engine.flush();
+            } else if (conflicts.length > 0 && conflictAction === 'update') {
               for (const { d, existingId } of conflicts) {
                 const data = {};
-                for (const [col, val] of statement.onDuplicate) data[col] = val;
+                if (conflictSets) {
+                  for (const [col, val] of conflictSets) data[col] = val;
+                } else {
+                  for (const k of Object.keys(d)) if (!pkCols.includes(k)) data[k] = d[k];
+                }
                 if (this.engine.updateById && existingId.length === 1) {
-                  this.engine.updateById(statement.name, existingId[0], data);
+                  await this.engine.updateById(statement.name, existingId[0], data);
                 } else if (this.engine.update) {
                   const filter = {};
                   pkCols.forEach((c, i) => { filter[c] = existingId[i]; });
-                  this.engine.update(statement.name, filter, data);
+                  await this.engine.update(statement.name, filter, data);
                 }
                 updated++;
               }
               await this.engine.flush();
+              toInsert = fresh;
+            } else if (conflictAction !== 'replace') {
+              toInsert = fresh;
             }
-            toInsert = fresh;
           }
           const seen = new Map();
           let kept = [];
@@ -1845,10 +2421,12 @@ class SQLExecutor {
             if (!hasExplicitPk(d)) { kept.push(d); continue; }
             const key = keyOf(d);
             if (seen.has(key)) {
-              if (!statement.onDuplicate) {
+              const act = this._conflictAction(statement);
+              if (act === 'throw') {
                 throw new Error('ER_DUP_ENTRY: Duplicate entry for primary key');
               }
-              seen.get(key).row = d;
+              if (act === 'ignore') { skipped++; continue; }
+              seen.get(key).row = d;   // update / replace：后出现的行覆盖先出现的行
             } else {
               seen.set(key, { row: d });
             }
@@ -1861,17 +2439,109 @@ class SQLExecutor {
           ids = await this.engine.insert(statement.name, toInsert);
           await this.engine.flush();
         }
-        return {
+        const out = {
           ok: true, type: 'insert', table: statement.name,
           affectedRows: toInsert.length + updated,
           insertId: Array.isArray(ids) && ids.length > 0 ? ids[0] : null,
           ids,
           duplicateUpdated: updated,
         };
+        if (skipped > 0) out.duplicateSkipped = skipped;
+        if (statement.returning) this._attachReturning(out, statement, toInsert, schema);
+        return out;
       }
       case 'select': {
         return await this.executeSelect(statement);
       }
+      case 'with': {
+        // CTE：按声明顺序把已展开的 CTE 内联进引用它的 FROM（含嵌套 CTE 引用）
+        const map = new Map();
+        for (const cte of statement.ctes) {
+          const sel = JSON.parse(JSON.stringify(cte.select));
+          // CTE 显式列名清单 `name (a, b) AS (...)`：按顺序重命名输出列
+          if (cte.columns && cte.columns.length) {
+            sel.columns.forEach((c, i) => {
+              if (cte.columns[i] && !c.alias) c.alias = cte.columns[i];
+            });
+          }
+          this._inlineCteRefs(sel, map);
+          map.set(String(cte.name).toLowerCase(), sel);
+        }
+        const stmt = JSON.parse(JSON.stringify(statement.statement));
+        this._inlineCteRefs(stmt, map);
+        return await this.execute(stmt);
+      }
+      case 'explain': {
+        const lines = [];
+        const describe = (s, indent) => {
+          if (!s) return;
+          const pad = indent || '';
+          if (s.type === 'select') {
+            lines.push([pad + 'SELECT', s.from ? '' : '(no FROM)']);
+            if (s.from) {
+              for (const t of (s.from.tables || [])) lines.push([pad + '  SCAN', t.table || '(subquery)']);
+              for (const j of (s.from.joins || [])) lines.push([pad + '  ' + String(j.type).toUpperCase() + ' JOIN', (j.item && (j.item.table || '(subquery)')) || '']);
+            }
+            if (s.where) lines.push([pad + '  FILTER', 'WHERE']);
+            if (s.groupBy) lines.push([pad + '  AGGREGATE', 'GROUP BY ' + s.groupBy.join(', ') + (s.rollup ? ' WITH ROLLUP' : '')]);
+            if (s.having) lines.push([pad + '  FILTER', 'HAVING']);
+            if (s.orderBy) lines.push([pad + '  SORT', 'ORDER BY ' + s.orderBy.map(o => (typeof o.column === 'string' ? o.column : 'expr') + ' ' + o.dir).join(', ')]);
+            if (s.limit !== null && s.limit !== undefined) lines.push([pad + '  LIMIT', String(s.limit)]);
+            if (s.union) describe(s.union.select, pad + '  ');
+          } else if (s.type === 'with') {
+            for (const c of s.ctes) { lines.push([pad + 'CTE ' + c.name, '']); describe(c.select, pad + '  '); }
+            describe(s.statement, indent);
+          } else {
+            lines.push([String(s.type).toUpperCase(), s.table || s.name || '']);
+          }
+        };
+        describe(statement.statement, '');
+        return {
+          ok: true, type: 'explain', columns: ['step', 'detail'], rows: lines,
+          rowCount: lines.length, affectedRows: 0, message: `${lines.length} step(s) — 无代价模型，仅展示计划结构`,
+          command: 'EXPLAIN', warnings: [],
+        };
+      }
+      case 'createView': {
+        if (!this.engine._views) this.engine._views = Object.create(null);
+        const key = String(statement.name).toLowerCase();
+        if (this.engine._views[key] && !statement.orReplace) {
+          throw new Error(`View '${statement.name}' already exists (use CREATE OR REPLACE VIEW)`);
+        }
+        this.engine._views[key] = {
+          name: statement.name,
+          columns: statement.columns || null,
+          select: statement.select,
+        };
+        return { ok: true, type: 'createView', message: `View '${statement.name}' created`, affectedRows: 0, warnings: [] };
+      }
+      case 'dropView': {
+        if (!this.engine._views) this.engine._views = Object.create(null);
+        const key = String(statement.name).toLowerCase();
+        if (!this.engine._views[key]) {
+          if (statement.ifExists) return { ok: true, type: 'dropView', message: `View '${statement.name}' did not exist`, affectedRows: 0, skipped: true, warnings: [] };
+          throw new Error(`View '${statement.name}' does not exist`);
+        }
+        delete this.engine._views[key];
+        return { ok: true, type: 'dropView', message: `View '${statement.name}' dropped`, affectedRows: 0, warnings: [] };
+      }
+      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: [] };
+      }
+      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: [] };
+      }
+      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.`
+        );
+      }
       case 'update': {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
@@ -1893,7 +2563,16 @@ class SQLExecutor {
           }
         }
         await this.engine.flush();
-        return { ok: true, type: 'update', table: statement.table, affectedRows: count };
+        const updOut = { ok: true, type: 'update', table: statement.table, affectedRows: count };
+        if (statement.returning) {
+          const after = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
+          const changed = [];
+          for (const row of after) {
+            if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) changed.push(row);
+          }
+          this._attachReturning(updOut, statement, changed, schema);
+        }
+        return updOut;
       }
       case 'delete': {
         const schema = this.engine.getTableSchema
@@ -1902,18 +2581,22 @@ class SQLExecutor {
         const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         const ids = [];
+        const removedRows = [];
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
             const id = this._rowPkId(row, pkCols);
-            if (id !== undefined) ids.push(id);
+            if (id !== undefined) { ids.push(id); removedRows.push(row); }
           }
         }
         if (ids.length > 0) {
-          if (this.engine.removeByIds) this.engine.removeByIds(statement.table, ids);
-          else for (const id of ids) this.engine.removeById(statement.table, id);
+          if (this.engine.removeByIds) await this.engine.removeByIds(statement.table, ids);
+          else for (const id of ids) await this.engine.removeById(statement.table, id);
         }
         await this.engine.flush();
-        return { ok: true, type: 'delete', table: statement.table, affectedRows: ids.length };
+        const delOut = { ok: true, type: 'delete', table: statement.table, affectedRows: ids.length };
+        // DELETE ... RETURNING 返回被删除的行
+        if (statement.returning) this._attachReturning(delOut, statement, removedRows, schema);
+        return delOut;
       }
       case 'begin':
         if (this.engine.beginTx) this.engine._txId = await this.engine.beginTx();
@@ -2345,15 +3028,23 @@ class SQLExecutor {
     if (expr.type === 'in' && expr.subquery) {
       const res = await this.executeSelect(expr.subquery);
       expr.list = res.rows.map(r => r[0]);
-      delete expr.subquery;
+      // 不 delete expr.subquery：相关子查询需要在逐行求值时重跑
       return;
     }
     if (expr.type === 'subquery') {
       const res = await this.executeSelect(expr.select);
-      const v = res.rows.length > 0 ? res.rows[0][0] : null;
-      expr.type = 'value';
-      expr.value = v;
-      delete expr.select;
+      expr._value = res.rows.length > 0 ? res.rows[0][0] : null;
+      // 不改写类型、不 delete select：保留节点以便相关场景逐行重算
+      return;
+    }
+    if (expr.type === 'exists' && expr.select) {
+      // 非相关场景（HAVING / JOIN ON）只求值一次；保留 select 以便 WHERE 里逐行关联求值
+      await this._evalCorrelated(expr, null);
+      return;
+    }
+    if (expr.type === 'quantified' && expr.select) {
+      const res = await this.executeSelect(expr.select);
+      expr._list = res.rows.map(r => (Array.isArray(r) ? r[0] : r));
       return;
     }
     for (const k of Object.keys(expr)) {
@@ -2400,6 +3091,29 @@ class SQLExecutor {
     return out;
   }
 
+  /**
+   * 构造 WITH ROLLUP 的汇总行：把各组的原始行合并成一个"超级组"，
+   * 分组列不设值（投影时会取 null），聚合列则覆盖全部行。
+   */
+  _rollupRow(groupReps) {
+    const all = [];
+    for (const rep of groupReps) {
+      if (rep._group) all.push(...rep._group);
+      else all.push(rep);
+    }
+    const out = {};
+    if (all.length > 0) {
+      // 分组列显式置为 null，避免取到某一组的代表值
+      for (const k of Object.keys(all[0])) {
+        if (k === '_group' || k === '_rid') continue;
+        out[k] = null;
+      }
+    }
+    out._group = all;
+    out._rollup = true;
+    return out;
+  }
+
   _aggValue(rows, fn, column) {
     if (fn === 'COUNT') return rows.length;
     const op = typeof column === 'string' ? { type: 'column', name: column } : column;
@@ -2438,6 +3152,331 @@ class SQLExecutor {
     }
   }
 
+  /**
+   * 收集表达式树里所有「带子查询」的节点：
+   * exists(select) / subquery(select) / in(subquery)。
+   * 这些节点都可能需要按外层行逐行重新求值（相关子查询）。
+   */
+  _collectSubqueries(node, out = []) {
+    if (!node || typeof node !== 'object') return out;
+    if (Array.isArray(node)) { for (const n of node) this._collectSubqueries(n, out); return out; }
+    if ((node.select || node.subquery) &&
+        (node.type === 'exists' || node.type === 'subquery' || node.type === 'in')) out.push(node);
+    for (const k of Object.keys(node)) {
+      const v = node[k];
+      if (v && typeof v === 'object') this._collectSubqueries(v, out);
+    }
+    return out;
+  }
+
+  /**
+   * 冲突处理策略 —— 把四种写法归一成一个动作：
+   *   REPLACE INTO                                   → 'replace'
+   *   INSERT IGNORE / ON CONFLICT DO NOTHING         → 'ignore'
+   *   ON DUPLICATE KEY UPDATE / ON CONFLICT DO UPDATE→ 'update'
+   *   默认                                            → 'throw'（ER_DUP_ENTRY）
+   */
+  _conflictAction(statement) {
+    if (statement.replace) return 'replace';
+    if (statement.ignore) return 'ignore';
+    const oc = statement.onConflict;
+    if (oc) return oc.action === 'nothing' ? 'ignore' : 'update';
+    if (statement.onDuplicate) return 'update';
+    return 'throw';
+  }
+
+  /** 冲突时要写入的列值（ON DUPLICATE KEY UPDATE / ON CONFLICT DO UPDATE SET） */
+  _conflictSets(statement) {
+    if (statement.onDuplicate) return statement.onDuplicate;
+    if (statement.onConflict && statement.onConflict.action === 'update') return statement.onConflict.sets;
+    return null;
+  }
+
+  /**
+   * 把 RETURNING 结果挂到返回对象上。
+   * RETURNING * → 返回完整行；RETURNING a, b → 只取指定列。
+   */
+  _attachReturning(out, statement, rows, schema) {
+    const cols = Array.isArray(statement.returning) ? statement.returning : [];
+    const isStar = cols.length === 1 && cols[0] === '*';
+    const outCols = isStar
+      ? (schema ? Object.keys(schema).filter(k => k !== '_softDelete') : Object.keys((rows && rows[0]) || {}))
+      : cols;
+    out.returning = {
+      columns: outCols,
+      rows: (rows || []).map(r => outCols.map(c => (r && r[c] !== undefined ? r[c] : null))),
+    };
+    out.columns = outCols;
+    out.rows = out.returning.rows;
+    return out;
+  }
+
+  /** 收集子树里所有列名（含限定形式 alias.col） */
+  _collectColumnNames(node, out = []) {
+    if (!node || typeof node !== 'object') return out;
+    if (Array.isArray(node)) { for (const n of node) this._collectColumnNames(n, out); return out; }
+    if (node.type === 'column' && typeof node.name === 'string') out.push(node.name);
+    for (const k of Object.keys(node)) {
+      const v = node[k];
+      if (v && typeof v === 'object') this._collectColumnNames(v, out);
+    }
+    return out;
+  }
+
+  /** 外层 FROM 的表名 / 别名集合 */
+  _outerAliases(statement) {
+    const set = new Set();
+    if (!statement || !statement.from) return set;
+    const add = (it) => { if (it && (it.alias || it.table)) set.add(String(it.alias || it.table).toLowerCase()); };
+    for (const t of (statement.from.tables || [])) add(t);
+    for (const j of (statement.from.joins || [])) add(j.item);
+    return set;
+  }
+
+  /**
+   * 子查询是否引用了外层别名（即相关子查询）。
+   * 非相关子查询只求值一次，避免无谓的 O(n) 逐行重跑。
+   */
+  _isCorrelated(node, outerAliases) {
+    if (!outerAliases || outerAliases.size === 0) return false;
+    for (const n of this._collectColumnNames(node, [])) {
+      const dot = n.indexOf('.');
+      if (dot === -1) continue;
+      if (outerAliases.has(n.slice(0, dot).toLowerCase())) return true;
+    }
+    return false;
+  }
+
+  /**
+   * 投影行数组。若 SELECT 列表里有相关子查询（如
+   * `(SELECT COUNT(*) FROM o WHERE o.uid = u.id)`），必须"求值一行、投影一行"交错进行，
+   * 因为子查询节点是共享对象，先全算再投影只会留下最后一行的结果。
+   */
+  async _projectRows(statement, rows, projectRow) {
+    const outerAliases = this._outerAliases(statement);
+    const found = [];
+    for (const c of statement.columns) {
+      if (c.scalar) this._collectSubqueries(c.scalar, found);
+      if (c.caseExpr) this._collectSubqueries(c.caseExpr, found);
+    }
+    const subs = found.filter(n => this._isCorrelated(n, outerAliases));
+    if (subs.length === 0) return rows.map(projectRow);
+    const out = [];
+    for (const r of rows) {
+      for (const n of subs) await this._evalCorrelated(n, r);
+      out.push(projectRow(r));
+    }
+    return out;
+  }
+
+  /**
+   * 按外层行求值一个子查询节点。
+   * 临时把外层行挂到 ctx.__outer，让 `u.id` 这类外层引用能解析到。
+   * 结果写回节点：exists→_rowCount，subquery→_value，in→list。
+   */
+  async _evalCorrelated(node, outerRow) {
+    const prevCtx = this.ctx;
+    this.ctx = outerRow ? Object.assign({}, prevCtx || {}, { __outer: outerRow }) : prevCtx;
+    try {
+      if (node.type === 'exists') {
+        const res = await this.executeSelect(node.select);
+        node._rowCount = res.rows.length;
+      } else if (node.type === 'subquery') {
+        const res = await this.executeSelect(node.select);
+        node._value = res.rows.length > 0 ? res.rows[0][0] : null;
+      } else if (node.type === 'in') {
+        const res = await this.executeSelect(node.subquery);
+        node.list = res.rows.map(r => (Array.isArray(r) ? r[0] : r));
+      }
+    } finally {
+      this.ctx = prevCtx;
+    }
+  }
+
+  /**
+   * 把 AST 中引用 CTE 名称的 FROM 项替换成对应的子查询（就地改写）。
+   * map: 小写 CTE 名 -> 已展开的 select AST
+   */
+  _inlineCteRefs(node, map) {
+    if (!node || typeof node !== 'object' || map.size === 0) return;
+    if (Array.isArray(node)) {
+      for (const n of node) this._inlineCteRefs(n, map);
+      return;
+    }
+    if (node.type === 'select' && node.from) {
+      const rewrite = (item) => {
+        if (!item || !item.table) return;
+        const key = String(item.table).toLowerCase();
+        if (!map.has(key)) return;
+        const sub = JSON.parse(JSON.stringify(map.get(key)));
+        item.subquery = sub;
+        item.alias = item.alias || item.table;
+        delete item.table;
+      };
+      for (const t of (node.from.tables || [])) rewrite(t);
+      for (const j of (node.from.joins || [])) rewrite(j.item);
+    }
+    for (const k of Object.keys(node)) {
+      if (k === 'from') continue;                    // 已单独处理，避免重复改写
+      const v = node[k];
+      if (v && typeof v === 'object') this._inlineCteRefs(v, map);
+    }
+  }
+
+  /**
+   * 计算 SELECT 列表中的窗口函数列，把结果直接写回每一行（键名为输出列名）。
+   * 放在 WHERE / GROUP BY / HAVING 之后、ORDER BY / LIMIT 之前，符合 SQL 求值顺序。
+   */
+  _computeWindows(statement, rows) {
+    if (!rows || rows.length === 0) return rows;
+    const specs = [];
+    for (const c of statement.columns) {
+      const sc = c.scalar;
+      const over = (sc && sc.over) || c.over;
+      if (!over) continue;
+      const fn = sc && sc.type === 'aggregate' ? String(sc.fn)
+        : (sc && sc.type === 'func' ? String(sc.name).toUpperCase()
+          : String(c.aggregate || '').toUpperCase());
+      specs.push({ col: c, spec: sc, over, fn, name: scalarColumnName(c) });
+    }
+    if (specs.length === 0) return rows;
+    const toNode = (x) => !x ? null : (typeof x === 'string' ? { type: 'column', name: x } : x);
+    specs.forEach((w, i) => { w.col._windowKey = w.col.alias || ('__win_' + i); });
+
+    for (const w of specs) {
+      const partBy = w.over.partitionBy || [];
+      const orderBy = w.over.orderBy || [];
+      // 分区
+      const buckets = new Map();
+      rows.forEach((r, idx) => {
+        const key = partBy.length
+          ? partBy.map(p => JSON.stringify(resolveOperand(p, r, this.ctx))).join('
')
+          : '';
+        if (!buckets.has(key)) buckets.set(key, []);
+        buckets.get(key).push(idx);
+      });
+
+      for (const idxs of buckets.values()) {
+        let ordered = idxs.slice();
+        if (orderBy.length) {
+          ordered = ordered.slice().sort((ia, ib) => {
+            const ra = rows[ia], rb = rows[ib];
+            for (const o of orderBy) {
+              const av = resolveOperand(o.column, ra, this.ctx);
+              const bv = resolveOperand(o.column, rb, this.ctx);
+              if (av === bv) continue;
+              if (av === undefined || av === null) return -1;
+              if (bv === undefined || bv === null) return 1;
+              const d = typeof av === 'number' && typeof bv === 'number' ? av - bv : String(av).localeCompare(String(bv));
+              if (d !== 0) return o.dir === 'asc' ? d : -d;
+            }
+            return ia - ib;
+          });
+        }
+        // 帧范围（ROWS 帧；RANGE 在当前实现下退化为整个分区，保守处理）
+        const frameIdx = (i) => {
+          const f = w.over.frame;
+          if (!f) return { start: 0, end: ordered.length - 1 };
+          let start = 0, end = ordered.length - 1;
+          const apply = (b, isStart) => {
+            if (!b) return isStart ? 0 : ordered.length - 1;
+            if (b.type === 'unbounded') return b.direction === 'preceding' ? 0 : ordered.length - 1;
+            if (b.type === 'currentRow') return i;
+            return b.direction === 'preceding' ? i - b.value : i + b.value;
+          };
+          start = apply(f.start, true);
+          end = apply(f.end, false);
+          return { start: Math.max(0, start), end: Math.min(ordered.length - 1, end) };
+        };
+
+        const argNode = toNode((w.spec && (w.spec.column || (w.spec.args && w.spec.args[0]))) || w.col.column || w.col.expr);
+        const valAt = (rowIdx, node) => resolveOperand(node || { type: 'value', value: 1 }, rows[rowIdx], this.ctx);
+
+        ordered.forEach((rowIdx, pos) => {
+          let v = null;
+          switch (w.fn) {
+            case 'ROW_NUMBER': v = pos + 1; break;
+            case 'RANK': {
+              // RANK = 1 + 分区内排在本行之前、且不是同值(peer)的行数
+              v = 1;
+              for (let k = 0; k < pos; k++) {
+                if (this._windowPeerCmp(rows[ordered[k]], rows[rowIdx], orderBy, this.ctx) !== 0) v++;
+              }
+              break;
+            }
+            case 'DENSE_RANK': {
+              // 1 + 排在本行之前的不同取值个数（同值并列，不跳号）
+              const curKey = this._windowPeerKey(rows[rowIdx], orderBy, this.ctx);
+              const seen = new Set();
+              for (let k = 0; k < pos; k++) {
+                const kk = this._windowPeerKey(rows[ordered[k]], orderBy, this.ctx);
+                if (kk !== curKey) seen.add(kk);
+              }
+              v = seen.size + 1;
+              break;
+            }
+            case 'NTILE': {
+              const n = w.spec && w.spec.args && w.spec.args[0] ? Number(resolveOperand(w.spec.args[0], rows[rowIdx], this.ctx)) : 1;
+              const bucketsN = Math.max(1, Math.floor(n) || 1);
+              v = Math.min(bucketsN, Math.floor((pos * bucketsN) / ordered.length) + 1);
+              break;
+            }
+            case 'LAG':
+            case 'LEAD': {
+              const off = w.spec && w.spec.args && w.spec.args[1] ? Number(resolveOperand(w.spec.args[1], rows[rowIdx], this.ctx)) : 1;
+              const target = w.fn === 'LAG' ? pos - off : pos + off;
+              if (target < 0 || target >= ordered.length) {
+                v = w.spec && w.spec.args && w.spec.args[2] ? resolveOperand(w.spec.args[2], rows[rowIdx], this.ctx) : null;
+              } else {
+                v = valAt(ordered[target], argNode);
+              }
+              break;
+            }
+            case 'FIRST_VALUE':
+            case 'LAST_VALUE': {
+              const f = frameIdx(pos);
+              const t = w.fn === 'FIRST_VALUE' ? f.start : f.end;
+              v = valAt(ordered[t], argNode);
+              break;
+            }
+            case 'COUNT':
+            case 'SUM':
+            case 'AVG':
+            case 'MIN':
+            case 'MAX': {
+              const f = frameIdx(pos);
+              const slice = ordered.slice(f.start, f.end + 1).map(i => rows[i]);
+              v = this._aggValue(slice, w.fn, argNode);
+              break;
+            }
+            default: v = null;
+          }
+          rows[rowIdx][w.col._windowKey] = v;
+        });
+      }
+    }
+    return rows;
+  }
+
+  _windowPeerKey(row, orderBy, ctx) {
+    if (!orderBy.length) return '';
+    return orderBy.map(o => JSON.stringify(resolveOperand(o.column, row, ctx))).join('
');
+  }
+
+  _windowPeerCmp(rowA, rowB, orderBy, ctx) {
+    if (!orderBy.length) return 0;
+    for (const o of orderBy) {
+      const av = resolveOperand(o.column, rowA, ctx);
+      const bv = resolveOperand(o.column, rowB, ctx);
+      if (av === bv) continue;
+      if (av === undefined || av === null) return -1;
+      if (bv === undefined || bv === null) return 1;
+      const d = typeof av === 'number' && typeof bv === 'number' ? av - bv : String(av).localeCompare(String(bv));
+      if (d !== 0) return d;
+    }
+    return 0;
+  }
+
   _subQueryRows(res) {
     return res.rows.map(r => {
       if (Array.isArray(r)) {
@@ -2449,24 +3488,65 @@ class SQLExecutor {
     });
   }
 
+  /**
+   * 把 FROM 中引用视图的表名展开为视图定义里的子查询（就地改写）。
+   * 与 CTE 一样走子查询内联，不需要引擎侧物化视图。
+   */
+  _expandViews(statement, depth = 0) {
+    const views = this.engine && this.engine._views;
+    if (!views || !statement || !statement.from) return statement;
+    if (depth > 16) throw new Error('View nesting too deep — possible circular view definition');
+    const rewrite = (item) => {
+      if (!item || !item.table) return;
+      const v = views[String(item.table).toLowerCase()];
+      if (!v) return;
+      const sub = JSON.parse(JSON.stringify(v.select));
+      if (v.columns && v.columns.length) {
+        sub.columns.forEach((c, i) => { if (v.columns[i] && !c.alias) c.alias = v.columns[i]; });
+      }
+      this._expandViews(sub, depth + 1);       // 视图里再引用视图
+      item.subquery = sub;
+      item.alias = item.alias || item.table;
+      delete item.table;
+    };
+    for (const t of (statement.from.tables || [])) rewrite(t);
+    for (const j of (statement.from.joins || [])) rewrite(j.item);
+    return statement;
+  }
+
   async executeSelect(statement) {
+    // 视图：FROM 里的视图名展开成子查询
+    if (this.engine && this.engine._views) this._expandViews(statement);
+
     // UNION 处理
     if (statement.union) {
       const left = await this.executeSelect({ ...statement, union: null });
       const right = await this.executeSelect(statement.union.select);
       let rows = left.rows.concat(right.rows);
-      if (!statement.union.all) {
-        const seen = new Set();
-        rows = rows.filter(r => {
-          const k = JSON.stringify(r);
-          if (seen.has(k)) return false;
-          seen.add(k);
-          return true;
-        });
-      }
+      if (!statement.union.all) rows = dedupeRows(rows);
       return { ok: true, type: 'select', columns: left.columns, rows, raw: rows };
     }
 
+    // INTERSECT：保留同时出现在右侧结果中的行（默认 DISTINCT，与 UNION 的处理保持一致）
+    if (statement.intersect) {
+      const left = await this.executeSelect({ ...statement, intersect: null, except: null });
+      const right = await this.executeSelect(statement.intersect.select);
+      const seen = new Set(right.rows.map(r => JSON.stringify(r)));
+      let out = left.rows.filter(r => seen.has(JSON.stringify(r)));
+      if (!statement.intersect.all) out = dedupeRows(out);
+      return { ok: true, type: 'select', columns: left.columns, rows: out, raw: out };
+    }
+
+    // EXCEPT：去掉出现在右侧结果中的行（默认 DISTINCT）
+    if (statement.except) {
+      const left = await this.executeSelect({ ...statement, intersect: null, except: null });
+      const right = await this.executeSelect(statement.except.select);
+      const seen = new Set(right.rows.map(r => JSON.stringify(r)));
+      let out = left.rows.filter(r => !seen.has(JSON.stringify(r)));
+      if (!statement.except.all) out = dedupeRows(out);
+      return { ok: true, type: 'select', columns: left.columns, rows: out, raw: out };
+    }
+
     // 物化 WHERE / HAVING / JOIN ON 中的子查询
     await this._materialize(statement.where);
     await this._materialize(statement.having);
@@ -2475,6 +3555,8 @@ class SQLExecutor {
     }
     for (const c of statement.columns) {
       if (c.caseExpr) await this._materialize(c.caseExpr);
+      // 非相关标量子查询先求值一次；相关子查询稍后由 _projectRows 逐行覆盖
+      if (c.scalar) await this._materialize(c.scalar);
     }
 
     let schema = null;
@@ -2544,11 +3626,11 @@ class SQLExecutor {
           if (m !== null) {
             matched.push({ ...l, ...rightRows[m] });
             unmatchedRight.delete(m);
-          } else if (j.type === 'left') {
+          } else if (j.type === 'left' || j.type === 'full') {
             matched.push(rightNulls ? { ...rightNulls, ...l } : { ...l });
           }
         });
-        if (j.type === 'right') {
+        if (j.type === 'right' || j.type === 'full') {
           for (const ri of unmatchedRight) matched.push(leftNulls ? { ...leftNulls, ...rightRows[ri] } : { ...rightRows[ri] });
         }
         rows = matched;
@@ -2558,7 +3640,20 @@ class SQLExecutor {
 
     let rows = all;
     if (statement.where) {
-      rows = rows.filter(r => evaluateExpr(statement.where, r, this.ctx));
+      // 相关子查询：必须逐行重新求值，否则外层引用拿不到当前行的值
+      const outerAliases = this._outerAliases(statement);
+      const subNodes = this._collectSubqueries(statement.where)
+        .filter(n => this._isCorrelated(n, outerAliases));
+      if (subNodes.length > 0) {
+        const kept = [];
+        for (const r of rows) {
+          for (const node of subNodes) await this._evalCorrelated(node, r);
+          if (evaluateExpr(statement.where, r, this.ctx)) kept.push(r);
+        }
+        rows = kept;
+      } else {
+        rows = rows.filter(r => evaluateExpr(statement.where, r, this.ctx));
+      }
     }
 
     // 分组聚合
@@ -2596,6 +3691,11 @@ class SQLExecutor {
       });
     }
 
+    // 窗口函数：在 WHERE/GROUP BY/HAVING 之后、DISTINCT/ORDER BY/LIMIT 之前求值
+    if (statement.columns.some(c => (c.scalar && c.scalar.over) || c.over)) {
+      this._computeWindows(statement, rows);
+    }
+
     if (statement.distinct) {
       const seen = new Set();
       rows = rows.filter(r => {
@@ -2613,7 +3713,8 @@ class SQLExecutor {
 
     // 聚合输出（无 GROUP BY 时）
     const hasCustomAgg = this.ctx && this.ctx.aggregates && statement.columns.some(c => c.scalar && c.scalar.type === 'func' && Object.prototype.hasOwnProperty.call(this.ctx.aggregates, String(c.scalar.name).toUpperCase()));
-    if (!statement.groupBy && (statement.columns.some(c => c.aggregate) || hasCustomAgg)) {
+    // 注意：带 OVER 的聚合是窗口函数，不是“整表塌缩成一行”的聚合，必须排除
+    if (!statement.groupBy && (statement.columns.some(c => c.aggregate && !c.window) || hasCustomAgg)) {
       const cols = statement.columns.map(c => scalarColumnName(c));
       const valueOf = (c) => {
         if (c.aggregate) return this._aggValue(rows, c.aggregate || 'COUNT', c.column);
@@ -2634,18 +3735,26 @@ class SQLExecutor {
     // GROUP BY 输出：每组的列（含聚合列）
     if (statement.groupBy) {
       const cols = statement.columns.map(c => scalarColumnName(c));
-      const mapped = rows.map(r => {
+      const rowsForGroups = (statement.rollup && rows.length > 0)
+        // WITH ROLLUP：追加一个"全表汇总"分组（分组列取 NULL，聚合列覆盖全部行）
+        ? rows.concat([this._rollupRow(rows)])
+        : rows;
+      const mapped = await this._projectRows(statement, rowsForGroups, (r) => {
         const group = r._group || [r];
         return statement.columns.map(c => scalarColumnValue(c, r, { _aggValue: this._aggValue.bind(this), group, ctxAggregates: this.ctx ? this.ctx.aggregates : null }));
       });
-      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: mapped, raw: rows };
+      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: mapped, raw: rowsForGroups };
     }
 
     if (statement.orderBy) {
+      // ORDER BY 项可能是列名字符串，也可能是表达式节点
+      const ordVal = (row, o) => (typeof o.column === 'string'
+        ? resolveOperand({ type: 'column', name: o.column }, row, this.ctx)
+        : resolveOperand(o.column, row, this.ctx));
       const cmp = (a, b) => {
         for (const o of statement.orderBy) {
-          const av = resolveOperand({ type: 'column', name: o.column }, a, this.ctx);
-          const bv = resolveOperand({ type: 'column', name: o.column }, b, this.ctx);
+          const av = ordVal(a, o);
+          const bv = ordVal(b, o);
           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;
@@ -2680,7 +3789,8 @@ class SQLExecutor {
     }
 
     const cols = statement.columns.map(c => scalarColumnName(c));
-    const mapped = rows.map(r => statement.columns.map(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 resolveOperand(c.scalar, r, this.ctx);
       if (c.expr === '*') return null;
       if (c.literal !== undefined) return c.literal;
@@ -2694,18 +3804,25 @@ class SQLExecutor {
 function splitStatements(sql) {
   const statements = [];
   let current = '';
-  let inStr = null;
+  let inStr = null;   // "'" | '"' | '`'
   let i = 0;
   while (i < sql.length) {
     const c = sql[i];
     if (inStr) {
       current += c;
+      if (inStr === '`') {
+        // 反引号标识符内部反斜杠不是转义符；两个连续反引号才表示一个字面反引号。
+        if (c === '`' && sql[i + 1] === '`') { current += sql[i + 1]; i += 2; continue; }
+        if (c === '`') inStr = null;
+        i++;
+        continue;
+      }
       if (c === '\\' && i + 1 < sql.length) { current += sql[i + 1]; i += 2; continue; }
       if (c === inStr) inStr = null;
       i++;
       continue;
     }
-    if (c === "'" || c === '"') { inStr = c; current += c; i++; continue; }
+    if (c === "'" || c === '"' || c === '`') { inStr = c; current += c; i++; continue; }
     if (c === '-' && sql[i + 1] === '-') {
       while (i < sql.length && sql[i] !== '\n') i++;
       continue;
@@ -2911,6 +4028,7 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
   }
   const ctx = {};
   if (opts.session) ctx.session = opts.session;
+  if (opts.params) ctx.params = opts.params;   // 原生 ? 占位符（applyParams 之外的另一种用法）
   if (opts.functions && typeof opts.functions === 'object') ctx.functions = opts.functions;
   if (opts.aggregates && typeof opts.aggregates === 'object') ctx.aggregates = opts.aggregates;
   const executor = new SQLExecutor(engine, Object.keys(ctx).length > 0 ? ctx : null);
@@ -2922,4 +4040,14 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
   return results.length === 1 ? results[0] : results;
 }
 
-module.exports = { tokenize, parseSQL, executeSQL, SQLExecutor, splitStatements, applyParams, escapeValue, escapeId };
+// AST 访问与改写能力（纯新增，不改变既有导出项）
+const AST = require('./ast.js');
+
+module.exports = {
+  tokenize, parseSQL, executeSQL, SQLExecutor, Parser,
+  splitStatements, applyParams, escapeValue, escapeId,
+  AST,
+  walk: AST.walk,
+  transform: AST.transform,
+  visit: AST.StatementVisitor
+};