jsql-neo 4.0.1 → 4.1.0

package/lib/sql.js

@@ -1,6 +1,8 @@
 const DANGEROUS_SQL = [
   { re: /^INTO$/, next: /^(OUTFILE|DUMPFILE)$/, name: 'INTO OUTFILE/DUMPFILE' },
   { re: /^LOAD$/, next: /^(FILE|DATA)$/, name: 'LOAD_FILE/LOAD DATA' },
+  { re: /^LOAD_FILE$/, name: 'LOAD_FILE' },
+  { re: /^LOAD_DATA$/, next: /^(INFILE)$/, name: 'LOAD DATA INFILE' },
   { re: /^SLEEP$/, name: 'SLEEP' },
   { re: /^BENCHMARK$/, name: 'BENCHMARK' },
   { re: /^GET_LOCK$/, name: 'GET_LOCK' },
@@ -18,7 +20,7 @@ function findDangerousSQL(tokens) {
       if (d.re.test(upper)) {
         if (d.next) {
           const nxt = tokens[i + 1];
-          if (nxt && nxt.type === 'keyword' && d.next.test(String(nxt.value).toUpperCase())) {
+          if (nxt && d.next.test(String(nxt.value).toUpperCase())) {
             return d.name;
           }
         } else {
@@ -42,12 +44,15 @@ const KEYWORDS = new Set([
   'CREATE', 'TABLE', 'DROP', 'INSERT', 'INTO', 'VALUES', 'SELECT', 'FROM',
   'WHERE', 'UPDATE', 'SET', 'DELETE', 'AND', 'OR', 'NOT', 'NULL', 'IS',
   'LIKE', 'IN', 'LIMIT', 'OFFSET', 'ORDER', 'BY', 'ASC', 'DESC', 'PRIMARY',
-  'KEY', 'AUTO_INCREMENT', 'INTEGER', 'INT', 'BIGINT', 'STRING', 'TEXT',
-  'FLOAT', 'DOUBLE', 'REAL', 'BOOLEAN', 'BOOL', 'DATE', 'DATETIME',
-  'TIMESTAMP', 'ANY', 'OBJECT', 'ARRAY', 'BEGIN', 'COMMIT', 'ROLLBACK',
+  'KEY', 'AUTO_INCREMENT', 'AUTOINCREMENT', 'INTEGER', 'INT', 'BIGINT', 'STRING', 'TEXT',
+  'VARCHAR', 'CHAR', 'FLOAT', 'DOUBLE', 'REAL', 'NUMERIC', 'DECIMAL', 'BOOLEAN', 'BOOL', 'DATE', 'DATETIME',
+  'TIMESTAMP', 'ANY', 'OBJECT', 'ARRAY', 'JSON', 'SMALLINT', 'TINYINT', 'BEGIN', 'COMMIT', 'ROLLBACK',
   'TRANSACTION', 'WORK', 'COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'AS', 'UNIQUE',
   'NOTNULL', 'DEFAULT', 'IF', 'EXISTS', 'DISTINCT', 'SHOW', 'USE', 'TABLES',
-  'DATABASES', 'DESCRIBE', 'DESC', 'ON', 'DUPLICATE'
+  'DATABASES', 'DATABASE', 'DESCRIBE', 'DESC', 'ON', 'DUPLICATE',
+  'JOIN', 'LEFT', 'RIGHT', 'INNER', 'OUTER', 'CROSS',
+  'GROUP', 'HAVING', 'UNION', 'ALL', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END',
+  'BETWEEN', 'USING', 'FULL'
 ]);
 
 function tokenize(sql) {
@@ -192,8 +197,14 @@ class Parser {
     if (t.type !== 'keyword') throw new Error(`Expected SQL statement, got '${t.value}'`);
 
     switch (t.value) {
-      case 'CREATE': return this.parseCreateTable();
-      case 'DROP': return this.parseDropTable();
+      case 'CREATE':
+        if (this.isKeyword('TABLE', 1)) return this.parseCreateTable();
+        if (this.isKeyword('DATABASE', 1)) return this.parseCreateDatabase();
+        throw new Error('Unsupported CREATE statement');
+      case 'DROP':
+        if (this.isKeyword('TABLE', 1)) return this.parseDropTable();
+        if (this.isKeyword('DATABASE', 1)) return this.parseDropDatabase();
+        throw new Error('Unsupported DROP statement');
       case 'INSERT': return this.parseInsert();
       case 'SELECT': return this.parseSelect();
       case 'UPDATE': return this.parseUpdate();
@@ -292,6 +303,25 @@ class Parser {
     if (!mapped) throw new Error(`Unsupported column type: ${typeTok.value}`);
     def.type = mapped;
 
+    // 长度限制: TEXT(255) / VARCHAR(100) / INTEGER(11) ...
+    if (this.peek().type === 'op' && this.peek().value === '(') {
+      this.next();
+      const lenTok = this.next();
+      if (lenTok.type !== 'number') throw new Error(`Expected length after type '(', got '${lenTok.value}'`);
+      const len = lenTok.value;
+      if (this.peek().type === 'op' && this.peek().value === ',') {
+        this.next();
+        const decTok = this.next();
+        if (decTok.type !== 'number') throw new Error(`Expected precision after ',', got '${decTok.value}'`);
+        def.precision = decTok.value;
+      }
+      this.expect('op', ')');
+      if (len > 0) {
+        def.length = len;
+        if (mapped === 'string') def.maxLength = len;
+      }
+    }
+
     while (true) {
       const t = this.peek();
       if (t.type === 'keyword') {
@@ -301,6 +331,7 @@ class Parser {
           case 'KEY':
             this.next(); def.primaryKey = true; def.unique = true; break;
           case 'AUTO_INCREMENT':
+          case 'AUTOINCREMENT':
             this.next(); def.autoIncrement = true; break;
           case 'UNIQUE':
             this.next(); def.unique = true; break;
@@ -415,12 +446,12 @@ class Parser {
         this.expect('op', ')');
         aggregate = { type: 'COUNT' };
         if (this.isKeyword('AS')) { this.next(); aggregate.alias = this.parseAlias(); }
-        columns.push({ expr: null, aggregate: true });
+        columns.push({ expr: null, aggregate: 'COUNT' });
       } else if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX'].includes(t.value)) {
         this.next();
         const fn = t.value;
         this.expect('op', '(');
-        const col = this.parseTableName();
+        const col = this.parseColumnRef();
         this.expect('op', ')');
         aggregate = { type: fn, column: col };
         if (this.isKeyword('AS')) { this.next(); aggregate.alias = this.parseAlias(); }
@@ -433,6 +464,11 @@ class Parser {
         let alias = null;
         if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
         columns.push({ expr: null, literal: t.value, alias });
+      } else if (t.type === 'keyword' && t.value === 'CASE') {
+        const caseExpr = this.parseOperand();
+        let alias = null;
+        if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
+        columns.push({ expr: null, caseExpr, alias });
       } else {
         const col = this.parseColumnRef();
         let alias = null;
@@ -443,13 +479,25 @@ class Parser {
       break;
     }
 
-    let table = null;
+    let from = null;
     if (this.isKeyword('FROM')) {
       this.next();
-      table = this.parseTableName();
+      from = this.parseFrom();
     }
     let where = null;
     if (this.isKeyword('WHERE')) { this.next(); where = this.parseExpr(); }
+    let groupBy = null;
+    if (this.isKeyword('GROUP')) {
+      this.expectKeyword('GROUP'); this.expectKeyword('BY');
+      groupBy = [];
+      while (true) {
+        groupBy.push(this.parseColumnRef());
+        if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+        break;
+      }
+    }
+    let having = null;
+    if (this.isKeyword('HAVING')) { this.next(); having = this.parseExpr(); }
     let orderBy = null;
     if (this.isKeyword('ORDER')) {
       this.expectKeyword('ORDER'); this.expectKeyword('BY');
@@ -471,9 +519,68 @@ class Parser {
       if (this.isKeyword('OFFSET')) { this.next(); offset = this.parseValue(); }
       else if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); offset = limit; limit = this.parseValue(); }
     }
+    let union = null;
+    if (this.isKeyword('UNION')) {
+      this.next();
+      const all = this.isKeyword('ALL');
+      if (all) this.next();
+      union = { all, select: this.parseSelect() };
+    }
     this.optionalTailSemicolon();
 
-    return { type: 'select', columns, aggregate, distinct, table, where, orderBy, limit, offset };
+    return { type: 'select', columns, aggregate, distinct, from, where, groupBy, having, orderBy, limit, offset, union };
+  }
+
+  parseFrom() {
+    const tables = [this.parseFromItem()];
+    const joins = [];
+    while (true) {
+      let type = null;
+      if (this.isKeyword('LEFT') || this.isKeyword('RIGHT')) {
+        type = this.peek().value.toLowerCase();
+        this.next();
+        if (this.isKeyword('OUTER')) this.next();
+        this.expectKeyword('JOIN');
+      } else if (this.isKeyword('INNER') || this.isKeyword('CROSS')) {
+        this.next();
+        this.expectKeyword('JOIN');
+        type = 'inner';
+      } else if (this.isKeyword('JOIN')) {
+        this.next();
+        type = 'inner';
+      } else if (this.peek().type === 'op' && this.peek().value === ',') {
+        this.next();
+        type = 'cross';
+      } else {
+        break;
+      }
+      const item = this.parseFromItem();
+      let on = null;
+      if (this.isKeyword('ON')) { this.next(); on = this.parseExpr(); }
+      joins.push({ type, item, on });
+    }
+    return { tables, joins };
+  }
+
+  parseFromItem() {
+    // 子查询: (SELECT ...) [AS] alias
+    if (this.peek().type === 'op' && this.peek().value === '(' && this.isKeyword('SELECT', 1)) {
+      this.next();
+      const sub = this.parseSelect();
+      this.expect('op', ')');
+      let alias = null;
+      if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
+      else if (this.peek().type === 'ident') { alias = this.next().value; }
+      if (!alias) throw new Error('Subquery in FROM requires an alias');
+      return { subquery: sub, alias };
+    }
+    const table = this.parseTableName();
+    let alias = null;
+    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')) {
+      alias = this.next().value;
+    }
+    return { table, alias };
   }
 
   parseAlias() {
@@ -485,6 +592,12 @@ class Parser {
   parseColumnRef() {
     const t = this.next();
     if (t.type !== 'ident') 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;
+    }
     return t.value;
   }
 
@@ -528,6 +641,31 @@ class Parser {
     return { type: 'dropTable', table, ifExists };
   }
 
+  parseCreateDatabase() {
+    this.expectKeyword('CREATE');
+    this.expectKeyword('DATABASE');
+    let ifNotExists = false;
+    if (this.isKeyword('IF')) {
+      this.expectKeyword('IF'); this.expectKeyword('NOT'); this.expectKeyword('EXISTS');
+      ifNotExists = true;
+    }
+    const name = this.parseTableName();
+    this.optionalTailSemicolon();
+    return { type: 'createDatabase', database: name, ifNotExists };
+  }
+
+  parseDropDatabase() {
+    this.expectKeyword('DROP');
+    this.expectKeyword('DATABASE');
+    let ifExists = false;
+    if (this.isKeyword('IF')) {
+      this.expectKeyword('IF'); this.expectKeyword('EXISTS'); ifExists = true;
+    }
+    const name = this.parseTableName();
+    this.optionalTailSemicolon();
+    return { type: 'dropDatabase', database: name, ifExists };
+  }
+
   parseShow() {
     this.expectKeyword('SHOW');
     if (this.isKeyword('TABLES')) { this.next(); this.optionalTailSemicolon(); return { type: 'showTables' }; }
@@ -593,9 +731,33 @@ class Parser {
 
   parseOperand() {
     const t = this.next();
-    if (t.type === 'ident') return { type: 'column', name: t.value };
+    if (t.type === 'ident') {
+      // 支持 alias.column 引用
+      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 { type: 'column', name: t.value + '.' + col.value };
+      }
+      return { type: 'column', name: t.value };
+    }
     if (t.type === 'number' || t.type === 'string') return { type: 'value', value: t.value };
     if (t.type === 'keyword' && t.value === 'NULL') return { type: 'value', value: null };
+    if (t.type === 'keyword' && t.value === 'CASE') return this.parseCase();
+    if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX', 'COUNT'].includes(t.value)) {
+      const fn = t.value;
+      this.expect('op', '(');
+      let column = null;
+      if (this.peek().type === 'op' && this.peek().value === '*') { this.next(); }
+      else column = this.parseColumnRef();
+      this.expect('op', ')');
+      return { type: 'aggregate', fn, column };
+    }
+    if (t.type === 'op' && t.value === '(' && this.peek().type === 'keyword' && this.peek().value === 'SELECT') {
+      const sub = this.parseSelect();
+      this.expect('op', ')');
+      return { type: 'subquery', select: sub };
+    }
     if (t.type === 'op' && (t.value === '-' || t.value === '+')) {
       const num = this.next();
       if (num.type !== 'number') throw new Error('Expected number after sign');
@@ -604,6 +766,32 @@ class Parser {
     throw new Error(`Expected value or column, got '${t.value}'`);
   }
 
+  parseCase() {
+    let base = null;
+    if (!this.isKeyword('WHEN')) {
+      base = this.parseOperand();
+    }
+    const branches = [];
+    while (this.isKeyword('WHEN')) {
+      this.next();
+      // 简单 CASE: CASE x WHEN v THEN ... ; 搜索 CASE: CASE WHEN cond THEN ...
+      let cond;
+      if (base) {
+        const v = this.parseOperand();
+        cond = { type: 'compare', op: '=', left: base, right: v };
+      } else {
+        cond = this.parseComparison();
+      }
+      this.expectKeyword('THEN');
+      const val = this.parseOperand();
+      branches.push({ cond, val });
+    }
+    let elseVal = null;
+    if (this.isKeyword('ELSE')) { this.next(); elseVal = this.parseOperand(); }
+    this.expectKeyword('END');
+    return { type: 'case', branches, elseVal };
+  }
+
   parseComparison() {
     const left = this.parseOperand();
     const t = this.peek();
@@ -619,6 +807,12 @@ class Parser {
     if (t.type === 'keyword' && t.value === 'IN') {
       this.next();
       this.expect('op', '(');
+      // IN (SELECT ...) 子查询
+      if (this.isKeyword('SELECT')) {
+        const sub = this.parseSelect();
+        this.expect('op', ')');
+        return { type: 'in', operand: left, subquery: sub };
+      }
       const list = [];
       while (true) {
         list.push(this.parseValue());
@@ -629,6 +823,19 @@ class Parser {
       return { type: 'in', operand: left, list };
     }
 
+    if (t.type === 'keyword' && t.value === 'BETWEEN') {
+      this.next();
+      const low = this.parseOperand();
+      const not = false;
+      let andTok = this.peek();
+      if (andTok.type === 'keyword' && andTok.value === 'AND') {
+        this.next();
+        const high = this.parseOperand();
+        return { type: 'between', operand: left, low, high, not };
+      }
+      throw new Error(`Expected AND in BETWEEN, got '${andTok.value}'`);
+    }
+
     if (t.type === 'keyword' && t.value === 'LIKE') {
       this.next();
       const pattern = this.parseValue();
@@ -657,7 +864,16 @@ const OPERATORS = {
 
 function resolveOperand(operand, row) {
   if (operand.type === 'value') return operand.value;
-  return row[operand.name];
+  const n = operand.name;
+  if (n === undefined) return undefined;
+  if (row[n] !== undefined) return row[n];
+  if (n.includes('.')) {
+    const k = n;
+    if (row[k] !== undefined) return row[k];
+    const col = n.slice(n.lastIndexOf('.') + 1);
+    return row[col];
+  }
+  return undefined;
 }
 
 function likeMatch(value, pattern) {
@@ -678,7 +894,7 @@ function extractEqualPushdown(expr, schema) {
     if (node.type === 'and') { walk(node.left); walk(node.right); return; }
     if (node.type === 'compare' && node.op === '=') {
       const col = node.left && node.left.type === 'column' ? node.left.name : null;
-      const val = node.right && node.right.type === 'literal' ? node.right.value : undefined;
+      const val = node.right && (node.right.type === 'literal' || node.right.type === 'value') ? node.right.value : undefined;
       if (col && val !== undefined && val !== null && schema[col] && !(schema[col].primaryKey && schema[col].autoIncrement === false)) {
         filter[col] = val;
         return;
@@ -715,13 +931,39 @@ function evaluateExpr(expr, row) {
     }
     case 'in': {
       const v = resolveOperand(expr.operand, row);
+      if (expr.subquery && expr.subquery._values !== undefined) expr.list = expr.subquery._values;
+      if (!expr.list) return false;
       return expr.list.some(x => x === v || String(x) === String(v));
     }
     case 'like': return likeMatch(resolveOperand(expr.operand, row), expr.pattern);
+    case 'between': {
+      const v = resolveOperand(expr.operand, row);
+      const lo = resolveOperand(expr.low, row);
+      const hi = resolveOperand(expr.high, row);
+      if (v === null || lo === null || hi === null) return false;
+      const inRange = typeof v === 'number' && typeof lo === 'number' && typeof hi === 'number'
+        ? v >= lo && v <= hi
+        : String(v) >= String(lo) && String(v) <= String(hi);
+      return expr.not ? !inRange : inRange;
+    }
+    case 'case': {
+      for (const b of expr.branches) {
+        if (evaluateExpr(b.cond, row)) return resolveOperand(b.val, row);
+      }
+      return expr.elseVal ? resolveOperand(expr.elseVal, row) : null;
+    }
     default: return false;
   }
 }
 
+function evaluateCaseVal(caseExpr, row) {
+  if (!caseExpr || caseExpr.type !== 'case') return undefined;
+  for (const b of caseExpr.branches) {
+    if (evaluateExpr(b.cond, row)) return resolveOperand(b.val, row);
+  }
+  return caseExpr.elseVal ? resolveOperand(caseExpr.elseVal, row) : null;
+}
+
 function normalizeRow(row, schema) {
   if (row && typeof row === 'object' && row.fields && typeof row.fields === 'object') {
     const flat = { ...row.fields };
@@ -747,10 +989,16 @@ class SQLExecutor {
   async execute(statement) {
     switch (statement.type) {
       case 'createTable': {
+        if (statement.ifNotExists && this.engine.hasTable && this.engine.hasTable(statement.name)) {
+          return { ok: true, type: 'createTable', table: statement.name, affectedRows: 0, skipped: true };
+        }
         const r = await this.engine.createTable(statement.name, statement.schema);
         return { ok: true, type: 'createTable', table: statement.name, affectedRows: 0, result: r };
       }
       case 'dropTable': {
+        if (statement.ifExists && !this.engine.hasTable(statement.table)) {
+          return { ok: true, type: 'dropTable', table: statement.table, affectedRows: 0 };
+        }
         await this.engine.dropTable(statement.table);
         return { ok: true, type: 'dropTable', table: statement.table, affectedRows: 0 };
       }
@@ -850,92 +1098,7 @@ class SQLExecutor {
         };
       }
       case 'select': {
-        let schema = null;
-        let all;
-        if (statement.table === null) {
-          all = [{ _virtual: true }];
-        } else {
-          if (this.engine.hasTable && !this.engine.hasTable(statement.table)) {
-            throw new Error(`Table '${statement.table}' does not exist`);
-          }
-          schema = this.engine.getTableSchema
-            ? await this.engine.getTableSchema(statement.table)
-            : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
-          if (!schema) {
-            throw new Error(`Table '${statement.table}' does not exist`);
-          }
-          const pushdown = extractEqualPushdown(statement.where, schema);
-          const engineFilter = pushdown ? pushdown.filter : {};
-          all = (await this.engine.find(statement.table, engineFilter, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
-          if (pushdown && pushdown.rest) {
-            all = all.filter(r => evaluateExpr(pushdown.rest, r));
-          }
-        }
-
-        let rows = all;
-        if (statement.where) {
-          rows = rows.filter(r => evaluateExpr(statement.where, r));
-        }
-        if (statement.distinct) {
-          const seen = new Set();
-          rows = rows.filter(r => {
-            const key = JSON.stringify(statement.columns.map(c => r[c.expr]));
-            if (seen.has(key)) return false;
-            seen.add(key);
-            return true;
-          });
-        }
-        if (statement.orderBy) {
-          const cmp = (a, b) => {
-            for (const o of statement.orderBy) {
-              const av = a[o.column], bv = b[o.column];
-              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));
-              if (r !== 0) return o.dir === 'asc' ? r : -r;
-            }
-            return 0;
-          };
-          rows = rows.slice().sort(cmp);
-        }
-
-        if (statement.aggregate) {
-          const agg = statement.aggregate;
-          const rowsOnly = rows;
-          const aggName = agg.alias || (agg.type === 'COUNT' ? 'COUNT(*)' : agg.type + '(' + agg.column + ')');
-          if (agg.type === 'COUNT') {
-            return { ok: true, type: 'select', table: statement.table, columns: [aggName], rows: [[rowsOnly.length]], aggregate: agg };
-          }
-          const values = rowsOnly.map(r => r[agg.column]).filter(v => v !== null && v !== undefined);
-          let value;
-          if (agg.type === 'SUM') value = values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0);
-          else if (agg.type === 'AVG') value = values.length ? values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0) / values.length : null;
-          else if (agg.type === 'MIN') value = values.length ? Math.min(...values.map(v => Number(v))) : null;
-          else if (agg.type === 'MAX') value = values.length ? Math.max(...values.map(v => Number(v))) : null;
-          return { ok: true, type: 'select', table: statement.table, columns: [aggName], rows: [[value]], aggregate: agg };
-        }
-
-        if (statement.limit !== null) {
-          const start = statement.offset || 0;
-          rows = rows.slice(start, start + statement.limit);
-        }
-
-        if (statement.columns.length === 1 && statement.columns[0].expr === '*') {
-          const schemaKeys = schema ? Object.keys(schema) : [];
-          const pkCols = schemaKeys.filter(k => schema[k].primaryKey);
-          const pk = pkCols.length > 0 ? pkCols[0] : (schemaKeys[0] || 'id');
-          const cols = schema ? [pk, ...schemaKeys.filter(k => k !== pk)] : Object.keys(all[0] || {});
-          return { ok: true, type: 'select', table: statement.table, columns: cols, rows: rows.map(r => cols.map(c => r[c])), raw: rows };
-        }
-
-        const cols = statement.columns.map(c => c.alias || (c.literal !== undefined ? (c.expr === null ? String(c.literal) : c.expr) : c.expr));
-        const mapped = rows.map(r => statement.columns.map(c => {
-          if (c.expr === '*') return null;
-          if (c.literal !== undefined) return c.literal;
-          return r[c.expr];
-        }));
-        return { ok: true, type: 'select', table: statement.table, columns: cols, rows: mapped, raw: rows };
+        return await this.executeSelect(statement);
       }
       case 'update': {
         const schema = this.engine.getTableSchema
@@ -976,27 +1139,385 @@ class SQLExecutor {
         await this.engine.flush();
         return { ok: true, type: 'delete', table: statement.table, affectedRows: ids.length };
       }
-      case 'begin': return { ok: true, type: 'begin' };
-      case 'commit': return { ok: true, type: 'commit' };
-      case 'rollback': return { ok: true, type: 'rollback' };
+      case 'begin':
+        if (this.engine.beginTx) this.engine._txId = await this.engine.beginTx();
+        else if (this.engine.begin) await this.engine.begin();
+        return { ok: true, type: 'begin' };
+      case 'commit':
+        if (this.engine._txId !== undefined && this.engine.commitTx) {
+          await this.engine.commitTx(this.engine._txId);
+          this.engine._txId = undefined;
+        } else if (this.engine.commit) await this.engine.commit();
+        return { ok: true, type: 'commit' };
+      case 'rollback':
+        if (this.engine._txId !== undefined && this.engine.rollbackTx) {
+          await this.engine.rollbackTx(this.engine._txId);
+          this.engine._txId = undefined;
+        } else if (this.engine.rollback) await this.engine.rollback();
+        return { ok: true, type: 'rollback' };
       case 'showTables': {
         const tables = this.engine.getTables ? this.engine.getTables() : (this.engine.tables ? this.engine.tables() : []);
         return { ok: true, type: 'showTables', columns: ['Tables'], rows: tables.map(t => [t]) };
       }
-      case 'showDatabases':
-        return { ok: true, type: 'showDatabases', columns: ['Database'], rows: [['jsql']] };
+      case 'showDatabases': {
+        const list = this.engine.listDatabases
+          ? await this.engine.listDatabases()
+          : ['jsql'];
+        return { ok: true, type: 'showDatabases', columns: ['Database'], rows: list.map(d => [d]) };
+      }
+      case 'createDatabase': {
+        if (!this.engine.createDatabase) throw new Error('CREATE DATABASE is not supported by this engine');
+        await this.engine.createDatabase(statement.database, { ifNotExists: statement.ifNotExists });
+        return { ok: true, type: 'createDatabase', database: statement.database };
+      }
+      case 'dropDatabase': {
+        if (!this.engine.dropDatabase) throw new Error('DROP DATABASE is not supported by this engine');
+        await this.engine.dropDatabase(statement.database, { ifExists: statement.ifExists });
+        return { ok: true, type: 'dropDatabase', database: statement.database };
+      }
+      case 'use':
+        if (this.engine.useDatabase) {
+          await this.engine.useDatabase(statement.database);
+        }
+        return { ok: true, type: 'use', database: statement.database };
       case 'describe': {
         const schema = this.engine.getTableSchema ? await this.engine.getTableSchema(statement.table) : null;
         if (!schema) throw new Error(`Table '${statement.table}' does not exist`);
         const rows = Object.entries(schema).map(([col, def]) => [col, def.type, def.primaryKey ? 'PRI' : '', def.autoIncrement ? 'auto_increment' : null, def.default !== undefined ? def.default : null]);
         return { ok: true, type: 'describe', table: statement.table, columns: ['Field', 'Type', 'Key', 'Extra', 'Default'], rows };
       }
-      case 'use':
-        return { ok: true, type: 'use', database: statement.database };
       default:
         throw new Error(`Unsupported statement type: ${statement.type}`);
     }
   }
+
+  async _getSchema(name) {
+    if (this.engine.hasTable && !this.engine.hasTable(name)) {
+      throw new Error(`Table '${name}' does not exist`);
+    }
+    const schema = this.engine.getTableSchema
+      ? await this.engine.getTableSchema(name)
+      : (this.engine._schemas ? this.engine._schemas[name] : null);
+    if (!schema) throw new Error(`Table '${name}' does not exist`);
+    return schema;
+  }
+
+  async _readTable(table) {
+    const schema = await this._getSchema(table);
+    const rows = (await this.engine.find(table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
+    return { schema, rows };
+  }
+
+  async _execFromItem(item) {
+    if (item.subquery) {
+      const res = await this.executeSelect(item.subquery);
+      return { schema: null, rows: res.rows.map(r => Object.assign({}, r)) };
+    }
+    return this._readTable(item.table);
+  }
+
+  // 物化表达式树中的子查询：IN (SELECT ...) -> expr.list
+  async _materialize(expr) {
+    if (!expr || typeof expr !== 'object') return;
+    if (expr.type === 'in' && expr.subquery) {
+      const res = await this.executeSelect(expr.subquery);
+      expr.list = res.rows.map(r => r[0]);
+      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;
+      return;
+    }
+    for (const k of Object.keys(expr)) {
+      if (expr[k] && typeof expr[k] === 'object') await this._materialize(expr[k]);
+    }
+  }
+
+  // 物化 FROM 子查询（把子查询替换为行数组），返回 { rows, alias }
+  async _materializeFrom(item) {
+    if (item.subquery) {
+      const res = await this.executeSelect(item.subquery);
+      const rows = res.rows.map(r => {
+        if (Array.isArray(r)) {
+          const obj = {};
+          res.columns.forEach((c, i) => { obj[c] = r[i]; });
+          return obj;
+        }
+        return Object.assign({}, r);
+      });
+      return { rows, alias: item.alias };
+    }
+    return null;
+  }
+
+  _prefixRow(row, prefix) {
+    const out = {};
+    for (const k of Object.keys(row)) {
+      out[prefix + '.' + k] = row[k];
+      if (out[k] === undefined) out[k] = row[k];
+    }
+    return out;
+  }
+
+  _aggValue(rows, fn, column) {
+    if (fn === 'COUNT') return rows.length;
+    const values = rows.map(r => resolveOperand({ type: 'column', name: column }, r)).filter(v => v !== null && v !== undefined);
+    if (fn === 'SUM') return values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0);
+    if (fn === 'AVG') return values.length ? values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0) / values.length : null;
+    if (fn === 'MIN') return values.length ? Math.min(...values.map(v => Number(v))) : null;
+    if (fn === 'MAX') return values.length ? Math.max(...values.map(v => Number(v))) : null;
+    return null;
+  }
+
+  _replaceAggregates(node, group) {
+    if (!node || typeof node !== 'object') return;
+    if (node.type === 'aggregate') {
+      node.type = 'value';
+      node.value = this._aggValue(group, node.fn, node.column);
+      delete node.fn;
+      delete node.column;
+      return;
+    }
+    for (const k of Object.keys(node)) {
+      if (node[k] && typeof node[k] === 'object') this._replaceAggregates(node[k], group);
+    }
+  }
+
+  _subQueryRows(res) {
+    return res.rows.map(r => {
+      if (Array.isArray(r)) {
+        const obj = {};
+        res.columns.forEach((c, i) => { obj[c] = r[i]; });
+        return obj;
+      }
+      return Object.assign({}, r);
+    });
+  }
+
+  async executeSelect(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;
+        });
+      }
+      return { ok: true, type: 'select', columns: left.columns, rows, raw: rows };
+    }
+
+    // 物化 WHERE / HAVING / JOIN ON 中的子查询
+    await this._materialize(statement.where);
+    await this._materialize(statement.having);
+    if (statement.from) {
+      for (const j of statement.from.joins) await this._materialize(j.on);
+    }
+    for (const c of statement.columns) {
+      if (c.caseExpr) await this._materialize(c.caseExpr);
+    }
+
+    let schema = null;
+    let all;
+    if (!statement.from) {
+      // 无 FROM：虚拟行（SELECT 1, 'a'）
+      all = [{ _virtual: true }];
+    } else {
+      const items = statement.from.tables.concat(statement.from.joins.map(j => j.item));
+      const prefix = item => item.alias || (item.subquery ? item.alias : item.table);
+
+      // 读第一表
+      const firstItem = statement.from.tables[0];
+      let rowsAll;
+      if (firstItem.subquery) {
+        const res = await this.executeSelect(firstItem.subquery);
+        rowsAll = { rows: this._subQueryRows(res), schema: null };
+      } else {
+        rowsAll = await this._readTable(firstItem.table);
+      }
+      schema = rowsAll.schema;
+      const firstPrefix = firstItem.alias || firstItem.table;
+      let 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);
+        const rightPrefix = j.item.alias || j.item.table;
+        const rightRows = (j.item.subquery ? this._subQueryRows(rightRes) : rightRes.rows).map(r => this._prefixRow(r, rightPrefix));
+
+        // 匹配（INNER/LEFT/RIGHT）
+        if (j.type === 'cross' || (!j.on)) {
+          // CROSS JOIN / 逗号：笛卡尔积
+          rows = rows.flatMap(l => rightRows.map(r => ({ ...l, ...r })));
+          continue;
+        }
+        const matched = [];
+        const unmatchedRight = new Set(rightRows.map((r, i) => i));
+        rows.forEach(l => {
+          let m = null;
+          for (let ri = 0; ri < rightRows.length; ri++) {
+            if (evaluateExpr(j.on, { ...l, ...rightRows[ri] })) {
+              m = ri;
+              break;
+            }
+          }
+          if (m !== null) {
+            matched.push({ ...l, ...rightRows[m] });
+            unmatchedRight.delete(m);
+          } else if (j.type === 'left') {
+            matched.push({ ...l });
+          }
+        });
+        if (j.type === 'right') {
+          for (const ri of unmatchedRight) matched.push({ ...rightRows[ri] });
+        }
+        rows = matched;
+      }
+      all = rows;
+    }
+
+    let rows = all;
+    if (statement.where) {
+      rows = rows.filter(r => evaluateExpr(statement.where, r));
+    }
+
+    // 分组聚合
+    if (statement.groupBy) {
+      const groups = new Map();
+      for (const row of rows) {
+        const key = JSON.stringify(statement.groupBy.map(g => resolveOperand({ type: 'column', name: g }, row)));
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(row);
+      }
+      const groupList = [...groups.values()];
+      rows = groupList.map(g => {
+        const rep = g[0];
+        const out = { ...rep, _group: g };
+        return out;
+      });
+    }
+
+    if (statement.having) {
+      const havingAst = JSON.parse(JSON.stringify(statement.having));
+      rows = rows.filter(r => {
+        const ctx = { ...r };
+        const h = JSON.parse(JSON.stringify(havingAst));
+        this._replaceAggregates(h, r._group || [r]);
+        for (const c of statement.columns) {
+          if (c.aggregate) {
+            const group = r._group || [r];
+            const v = this._aggValue(group, c.aggregate || 'COUNT', c.column);
+            ctx['__agg_' + (c.alias || c.column || 'COUNT(*)')] = v;
+            if (c.column) ctx[c.column] = v;
+            if (c.alias) ctx[c.alias] = v;
+          }
+        }
+        return evaluateExpr(h, ctx);
+      });
+    }
+
+    if (statement.distinct) {
+      const seen = new Set();
+      rows = rows.filter(r => {
+        const key = JSON.stringify(statement.columns.map(c => {
+          if (c.aggregate) return this._aggValue(r._group || [r], c.aggregate || 'COUNT', c.column);
+          return resolveOperand(c.caseExpr || { type: 'column', name: c.expr }, r);
+        }));
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+    }
+
+    // 聚合输出（无 GROUP BY 时）
+    if (statement.aggregate && !statement.groupBy) {
+      const agg = statement.aggregate;
+      const rowsOnly = rows;
+      const aggName = agg.alias || (agg.type === 'COUNT' ? 'COUNT(*)' : agg.type + '(' + agg.column + ')');
+      const value = this._aggValue(rowsOnly, agg.type, agg.column);
+      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: [aggName], rows: [[value]], aggregate: agg };
+    }
+
+    // GROUP BY 输出：每组的列（含聚合列）
+    if (statement.groupBy) {
+      const aggName = (c) => c.alias || (c.aggregate === 'COUNT' ? 'COUNT(*)' : c.aggregate + '(' + c.column + ')');
+      const cols = statement.columns.map(c => {
+        if (c.alias) return c.alias;
+        if (c.aggregate) return aggName(c);
+        if (c.literal !== undefined) return String(c.literal);
+        if (c.caseExpr) return 'CASE';
+        const dot = c.expr.indexOf('.');
+        return dot !== -1 ? c.expr.slice(dot + 1) : c.expr;
+      });
+      const mapped = rows.map(r => {
+        const group = r._group || [r];
+        return statement.columns.map(c => {
+          if (c.aggregate) return this._aggValue(group, c.aggregate || 'COUNT', c.column);
+          if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
+          if (c.expr === '*') return r[Object.keys(r).find(k => !k.startsWith('_'))];
+          return resolveOperand({ type: 'column', name: c.expr }, r);
+        });
+      });
+      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: mapped, raw: rows };
+    }
+
+    if (statement.orderBy) {
+      const cmp = (a, b) => {
+        for (const o of statement.orderBy) {
+          const av = resolveOperand({ type: 'column', name: o.column }, a);
+          const bv = resolveOperand({ type: 'column', name: o.column }, b);
+          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));
+          if (r !== 0) return o.dir === 'asc' ? r : -r;
+        }
+        return 0;
+      };
+      rows = rows.slice().sort(cmp);
+    }
+
+    if (statement.limit !== null) {
+      const start = statement.offset || 0;
+      rows = rows.slice(start, start + statement.limit);
+    }
+
+    // 无分组、无聚合的正常输出
+    const tableName = statement.from ? (statement.from.tables[0].table || null) : null;
+    if (statement.columns.length === 1 && statement.columns[0].expr === '*') {
+      const schemaKeys = schema ? Object.keys(schema) : [];
+      const pkCols = schemaKeys.filter(k => schema && schema[k] && schema[k].primaryKey);
+      const pk = pkCols.length > 0 ? pkCols[0] : (schemaKeys[0] || 'id');
+      const cols = schema ? [pk, ...schemaKeys.filter(k => k !== pk)] : Object.keys(all[0] || {}).filter((v, i, a) => a.indexOf(v) === i);
+      return { ok: true, type: 'select', table: tableName, columns: cols, rows: rows.map(r => cols.map(c => r[c])), raw: rows };
+    }
+
+    const cols = statement.columns.map(c => {
+      if (c.alias) return c.alias;
+      if (c.literal !== undefined) return String(c.literal);
+      if (c.caseExpr) return 'CASE';
+      const dot = c.expr.indexOf('.');
+      return dot !== -1 ? c.expr.slice(dot + 1) : c.expr;
+    });
+    const mapped = rows.map(r => statement.columns.map(c => {
+      if (c.expr === '*') return null;
+      if (c.literal !== undefined) return c.literal;
+      if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
+      return resolveOperand({ type: 'column', name: c.expr }, r);
+    }));
+    return { ok: true, type: 'select', table: tableName, columns: cols, rows: mapped, raw: rows };
+  }
 }
 
 function splitStatements(sql) {
@@ -1014,6 +1535,21 @@ function splitStatements(sql) {
       continue;
     }
     if (c === "'" || c === '"') { inStr = c; current += c; i++; continue; }
+    if (c === '-' && sql[i + 1] === '-') {
+      while (i < sql.length && sql[i] !== '\n') { current += sql[i]; i++; }
+      continue;
+    }
+    if (c === '#') {
+      while (i < sql.length && sql[i] !== '\n') { current += sql[i]; i++; }
+      continue;
+    }
+    if (c === '/' && sql[i + 1] === '*') {
+      current += '/*';
+      i += 2;
+      while (i + 1 < sql.length && !(sql[i] === '*' && sql[i + 1] === '/')) { current += sql[i]; i++; }
+      if (i + 1 < sql.length) { current += '*/'; i += 2; }
+      continue;
+    }
     if (c === ';') {
       if (current.trim()) statements.push(current.trim());
       current = '';