jsql-neo 4.2.0 → 4.4.0

package/lib/sql.js

@@ -47,12 +47,13 @@ const KEYWORDS = new Set([
   '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',
+  'START',
   'TRANSACTION', 'WORK', 'COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'AS', 'UNIQUE',
   'NOTNULL', 'DEFAULT', 'IF', 'EXISTS', 'DISTINCT', 'SHOW', 'USE', 'TABLES',
   'DATABASES', 'DATABASE', 'DESCRIBE', 'DESC', 'ON', 'DUPLICATE',
   'JOIN', 'LEFT', 'RIGHT', 'INNER', 'OUTER', 'CROSS',
   'GROUP', 'HAVING', 'UNION', 'ALL', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END',
-  'BETWEEN', 'USING', 'FULL'
+  'BETWEEN', 'USING', 'FULL', 'UNSIGNED', 'ZEROFILL', 'TRUNCATE', 'COLLATE', 'CHARACTER'
 ]);
 
 function tokenize(sql) {
@@ -84,7 +85,7 @@ function tokenize(sql) {
       while (j < n) {
         if (sql[j] === '\\' && j + 1 < n) {
           const esc = sql[j + 1];
-          const map = { n: '\n', t: '\t', r: '\r', '0': '\0', "'": "'", '"': '"', '\\': '\\' };
+          const map = { n: '\n', t: '\t', r: '\r', '0': '\0', "'": "'", '"': '"', '\\': '\\', b: '\b', Z: '\x1a', a: '\a' };
           str += map[esc] !== undefined ? map[esc] : esc;
           j += 2;
         } else if (sql[j] === quote) {
@@ -140,6 +141,22 @@ function tokenize(sql) {
       continue;
     }
 
+    if (c === '@') {
+      let j = i;
+      while (j < n && sql[j] === '@') j++;
+      const ats = j - i;
+      let k = j;
+      while (k < n && /[A-Za-z0-9_$]/.test(sql[k])) k++;
+      if (k > j) {
+        tokens.push(new SQLToken('sysvar', sql.slice(j, k), i));
+        if (ats > 1) i = k;
+        else i = k;
+        continue;
+      }
+      i = j;
+      continue;
+    }
+
     const two = sql.slice(i, i + 2);
     if (two === '<=' || two === '>=' || two === '!=' || two === '<>' || two === '==') {
       tokens.push(new SQLToken('op', two, i));
@@ -191,6 +208,12 @@ class Parser {
     return t.type === 'keyword' && t.value === kw;
   }
 
+  // 匹配大小写不敏感的词（无论被 tokenize 成 ident 还是 keyword）
+  isWord(kw, offset = 0) {
+    const t = this.peek(offset);
+    return t.value !== undefined && String(t.value).toUpperCase() === kw;
+  }
+
   parseStatement() {
     const t = this.peek();
     if (t.type === 'eof') return null;
@@ -206,13 +229,16 @@ class Parser {
         if (this.isKeyword('DATABASE', 1)) return this.parseDropDatabase();
         throw new Error('Unsupported DROP statement');
       case 'INSERT': return this.parseInsert();
+      case 'TRUNCATE': this.expectKeyword('TRUNCATE'); if (this.isKeyword('TABLE')) this.next(); return { type: 'truncate', name: this.parseTableName() };
       case 'SELECT': return this.parseSelect();
       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 'SHOW': return this.parseShow();
+      case 'SET': return this.parseSet();
       case 'DESCRIBE': case 'DESC': return this.parseDescribe();
       case 'USE': return this.parseUse();
       default: throw new Error(`Unsupported statement: ${t.value}`);
@@ -284,6 +310,11 @@ class Parser {
       throw new Error(`Expected ',' or ')' in CREATE TABLE, got '${sep.value}'`);
     }
     this.expect('op', ')');
+
+    // 跳过表选项: ENGINE=InnoDB, DEFAULT CHARSET=..., AUTO_INCREMENT=1, COLLATE=...（直到 ; 或语句结束）
+    while (!(this.peek().type === 'eof' || (this.peek().type === 'op' && this.peek().value === ';'))) {
+      this.next();
+    }
     this.optionalTailSemicolon();
 
     if (!hasPk && schema.id === undefined) {
@@ -339,6 +370,9 @@ class Parser {
           case 'AUTO_INCREMENT':
           case 'AUTOINCREMENT':
             this.next(); def.autoIncrement = true; break;
+          case 'UNSIGNED':
+          case 'ZEROFILL':
+            this.next(); def.unsigned = true; break;
           case 'UNIQUE':
             this.next(); def.unique = true; break;
           case 'NOT':
@@ -347,6 +381,13 @@ class Parser {
             this.next(); break;
           case 'DEFAULT':
             this.next(); def.default = this.parseValue(); break;
+          case 'COLLATE':
+            this.next(); if (this.peek().type !== 'op' && this.peek().type !== 'eof') this.next(); break;
+          case 'CHARACTER':
+            this.next();
+            if (this.isKeyword('SET')) this.next();
+            if (this.peek().type !== 'op' && this.peek().type !== 'eof') this.next();
+            break;
           default:
             return def;
         }
@@ -423,6 +464,7 @@ class Parser {
     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 === 'DEFAULT') return { _default: true };
     if (t.type === 'op' && t.value === '-') {
       const num = this.next();
       if (num.type !== 'number') throw new Error('Expected number after -');
@@ -448,16 +490,18 @@ class Parser {
       if (t.type === 'keyword' && t.value === 'COUNT') {
         this.next();
         this.expect('op', '(');
-        this.expect('op', '*');
+        let col = null;
+        if (this.peek().type === 'op' && this.peek().value === '*') { this.next(); }
+        else if (!(this.peek().type === 'op' && this.peek().value === ')')) col = this.parseScalar();
         this.expect('op', ')');
-        aggregate = { type: 'COUNT' };
+        aggregate = { type: 'COUNT', column: col };
         if (this.isKeyword('AS')) { this.next(); aggregate.alias = this.parseAlias(); }
-        columns.push({ expr: null, aggregate: 'COUNT' });
+        columns.push({ expr: col, aggregate: 'COUNT', column: col, alias: aggregate.alias });
       } else if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX'].includes(t.value)) {
         this.next();
         const fn = t.value;
         this.expect('op', '(');
-        const col = this.parseColumnRef();
+        const col = this.parseScalar();
         this.expect('op', ')');
         aggregate = { type: fn, column: col };
         if (this.isKeyword('AS')) { this.next(); aggregate.alias = this.parseAlias(); }
@@ -465,21 +509,23 @@ class Parser {
       } else if (t.type === 'op' && t.value === '*') {
         this.next();
         columns.push({ expr: '*' });
-      } else if (t.type === 'number' || t.type === 'string') {
-        this.next();
-        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();
+        // 列 / 常量 / 函数 / 算术表达式
+        const expr = this.parseScalar();
         let alias = null;
         if (this.isKeyword('AS')) { this.next(); alias = this.parseAlias(); }
-        columns.push({ expr: col, alias });
+        if (expr.type === 'aggregate') {
+          columns.push({ expr: expr.column, aggregate: expr.fn, column: expr.column, alias, scalar: expr });
+        } else if (expr.type === 'column') {
+          columns.push({ expr: expr.name, scalar: expr, alias });
+        } else {
+          columns.push({ expr: null, scalar: expr, alias });
+        }
       }
       if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
       break;
@@ -678,13 +724,80 @@ class Parser {
       this.next();
       let database = null;
       if (this.isKeyword('FROM')) { this.next(); database = this.parseTableName(); }
+      let like = null;
+      if (this.isKeyword('LIKE')) { this.next(); like = this.parseValue(); }
       this.optionalTailSemicolon();
-      return { type: 'showTables', database };
+      return { type: 'showTables', database, like };
     }
     if (this.isKeyword('DATABASES')) { this.next(); this.optionalTailSemicolon(); return { type: 'showDatabases' }; }
+    if (this.isWord('FULL')) this.next();
+    if (this.isWord('COLUMNS')) {
+      this.next();
+      if (!(this.isKeyword('FROM') || this.isWord('IN'))) throw new Error("Expected FROM after SHOW COLUMNS");
+      this.next();
+      let table = this.parseTableName();
+      if (table.includes('.')) table = table.slice(table.lastIndexOf('.') + 1);
+      let like = null;
+      if (this.isKeyword('LIKE')) { this.next(); like = this.parseValue(); }
+      this.optionalTailSemicolon();
+      return { type: 'showColumns', table, like };
+    }
+    if (this.isWord('INDEX') || this.isWord('INDEXES') || this.isWord('KEYS')) {
+      this.next();
+      if (!(this.isKeyword('FROM') || this.isWord('IN'))) throw new Error("Expected FROM after SHOW INDEX");
+      this.next();
+      let table = this.parseTableName();
+      if (table.includes('.')) table = table.slice(table.lastIndexOf('.') + 1);
+      this.optionalTailSemicolon();
+      return { type: 'showIndex', table };
+    }
+    if (this.isKeyword('CREATE')) {
+      this.next();
+      this.expectKeyword('TABLE');
+      let table = this.parseTableName();
+      if (table.includes('.')) table = table.slice(table.lastIndexOf('.') + 1);
+      this.optionalTailSemicolon();
+      return { type: 'showCreateTable', table };
+    }
+    if (this.isWord('SESSION') || this.isWord('GLOBAL')) {
+      this.next();
+    }
+    if (this.isWord('VARIABLES')) {
+      this.next();
+      let like = null;
+      if (this.isKeyword('LIKE')) { this.next(); like = this.parseValue(); }
+      this.optionalTailSemicolon();
+      return { type: 'showVariables', like };
+    }
+    if (this.isWord('STATUS')) {
+      this.next();
+      this.optionalTailSemicolon();
+      return { type: 'showStatus' };
+    }
+    if (this.isWord('GRANTS')) {
+      this.next();
+      if (this.isKeyword('FOR')) { this.next(); this.parseTableName(); }
+      this.optionalTailSemicolon();
+      return { type: 'showGrants' };
+    }
+    if (this.isWord('WARNINGS') || this.isWord('ERRORS')) {
+      this.next();
+      this.optionalTailSemicolon();
+      return { type: 'showWarnings' };
+    }
     throw new Error('Unsupported SHOW statement');
   }
 
+  parseSet() {
+    this.expectKeyword('SET');
+    const parts = [];
+    while (!(this.peek().type === 'eof' || (this.peek().type === 'op' && this.peek().value === ';'))) {
+      parts.push(this.next().value);
+    }
+    this.optionalTailSemicolon();
+    return { type: 'set', raw: parts.join(' ') };
+  }
+
   parseDescribe() {
     this.next();
     const table = this.parseTableName();
@@ -751,17 +864,47 @@ class Parser {
         if (col.type !== 'ident') throw new Error(`Expected column name after '.', got '${col.value}'`);
         return { type: 'column', name: t.value + '.' + col.value };
       }
+      // 函数调用: VERSION() / CONCAT(a, b) / NOW() ...
+      if (this.peek().type === 'op' && this.peek().value === '(') {
+        const name = t.value;
+        this.next();
+        const args = [];
+        if (!(this.peek().type === 'op' && this.peek().value === ')')) {
+          for (;;) {
+            args.push(this.parseOperand());
+            if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+            break;
+          }
+        }
+        this.expect('op', ')');
+        return { 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 === 'keyword' && t.value === 'NULL') return { type: 'value', value: null };
     if (t.type === 'keyword' && t.value === 'CASE') return this.parseCase();
+    if (t.type === 'keyword' && this.peek().type === 'op' && this.peek().value === '(') {
+      const name = t.value;
+      this.next();
+      const args = [];
+      if (!(this.peek().type === 'op' && this.peek().value === ')')) {
+        for (;;) {
+          args.push(this.parseOperand());
+          if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+          break;
+        }
+      }
+      this.expect('op', ')');
+      return { type: 'func', name, args };
+    }
     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();
+      else if (!(this.peek().type === 'op' && this.peek().value === ')')) column = this.parseScalar();
       this.expect('op', ')');
       return { type: 'aggregate', fn, column };
     }
@@ -778,6 +921,37 @@ class Parser {
     throw new Error(`Expected value or column, got '${t.value}'`);
   }
 
+  // 算术表达式: + - * / % (左结合, * / 优先)
+  parseScalar() {
+    let node = this.parseTerm();
+    for (;;) {
+      const t = this.peek();
+      if (t.type === 'op' && (t.value === '+' || t.value === '-')) {
+        this.next();
+        const right = this.parseTerm();
+        node = { type: 'arith', op: t.value, left: node, right };
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+
+  parseTerm() {
+    let node = this.parseOperand();
+    for (;;) {
+      const t = this.peek();
+      if (t.type === 'op' && (t.value === '*' || t.value === '/' || t.value === '%')) {
+        this.next();
+        const right = this.parseOperand();
+        node = { type: 'arith', op: t.value, left: node, right };
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+
   parseCase() {
     let base = null;
     if (!this.isKeyword('WHEN')) {
@@ -874,18 +1048,136 @@ const OPERATORS = {
   '>=': (a, b) => a >= b
 };
 
-function resolveOperand(operand, row) {
-  if (operand.type === 'value') return operand.value;
-  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 resolveOperand(operand, row, ctx) {
+  if (operand === null || operand === undefined) return null;
+  if (typeof operand === 'string') return resolveOperand({ type: 'column', name: operand }, row, ctx);
+  switch (operand.type) {
+    case 'value':
+    case 'literal':
+      return operand.value;
+    case 'sysvar': {
+      const s = (ctx && ctx.session && ctx.session.sysvars) || {};
+      const name = String(operand.name).toLowerCase();
+      if (s[name] !== undefined) return s[name];
+      const DEFAULTS = {
+        'version': '8.0.0-jsql-neo',
+        'version_comment': 'jsql-neo',
+        'version_compile_os': 'linux',
+        'sql_mode': '',
+        'autocommit': 1,
+        'character_set_client': 'utf8mb4',
+        'character_set_connection': 'utf8mb4',
+        'character_set_results': 'utf8mb4',
+        'collation_connection': 'utf8mb4_general_ci',
+        'transaction_isolation': 'REPEATABLE-READ',
+        'max_allowed_packet': 67108864,
+        'wait_timeout': 28800,
+        'lower_case_table_names': 0,
+        'sql_auto_is_null': 0,
+      };
+      return DEFAULTS[name] !== undefined ? DEFAULTS[name] : '';
+    }
+    case 'column': {
+      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];
+        const col = n.slice(n.lastIndexOf('.') + 1);
+        return row[col];
+      }
+      return undefined;
+    }
+    case 'arith': {
+      const l = resolveOperand(operand.left, row, ctx);
+      const r = resolveOperand(operand.right, row, ctx);
+      if (l === null || r === null || l === undefined || r === undefined) return null;
+      switch (operand.op) {
+        case '+': return l + r;
+        case '-': return l - r;
+        case '*': return l * r;
+        case '/': return r === 0 ? null : l / r;
+        case '%': return r === 0 ? null : l % r;
+      }
+      return null;
+    }
+    case 'func':
+      return applyScalarFunction(operand, row, ctx);
+    case 'case':
+      return evaluateCaseVal(operand, row, ctx);
+    case 'aggregate':
+    case 'subquery':
+      return undefined;
+    default:
+      return undefined;
+  }
+}
+
+function applyScalarFunction(fnNode, row, ctx) {
+  const name = (fnNode.name || '').toUpperCase();
+  const args = (fnNode.args || []).map(a => resolveOperand(a, row, ctx));
+  const session = ctx && ctx.session;
+  switch (name) {
+    case 'VERSION': return '8.0.0-jsql-neo';
+    case 'LAST_INSERT_ID': {
+      if (args.length > 0) {
+        if (session) session.lastInsertId = args[0];
+        return args[0];
+      }
+      return session && session.lastInsertId !== undefined ? session.lastInsertId : 0;
+    }
+    case 'ROW_COUNT': return session && session.rowCount !== undefined ? session.rowCount : 0;
+    case 'FOUND_ROWS': return session && session.foundRows !== undefined ? session.foundRows : 0;
+    case 'CONNECTION_ID': return session && session.connectionId !== undefined ? session.connectionId : 0;
+    case 'DATABASE': case 'SCHEMA': return session && session.currentDb ? session.currentDb : 'default';
+    case 'NOW': case 'CURRENT_TIMESTAMP': return new Date().toISOString().slice(0, 19).replace('T', ' ');
+    case 'CURDATE': case 'CURRENT_DATE': return new Date().toISOString().slice(0, 10);
+    case 'CURTIME': return new Date().toISOString().slice(11, 19);
+    case 'UTC_TIMESTAMP': return new Date().toISOString().slice(0, 19).replace('T', ' ') + ' UTC';
+    case 'CONCAT': return args.map(a => a === null || a === undefined ? '' : String(a)).join('');
+    case 'CONCAT_WS': return (args.slice(1).map(a => a === null || a === undefined ? '' : String(a))).join(args[0] == null ? ',' : String(args[0]));
+    case 'UPPER': case 'UCASE': return args[0] == null ? null : String(args[0]).toUpperCase();
+    case 'LOWER': case 'LCASE': return args[0] == null ? null : String(args[0]).toLowerCase();
+    case 'LENGTH': case 'CHAR_LENGTH': case 'CHARACTER_LENGTH': return args[0] == null ? null : String(args[0]).length;
+    case 'TRIM': return args[0] == null ? null : String(args[0]).trim();
+    case 'LTRIM': return args[0] == null ? null : String(args[0]).replace(/^\s+/, '');
+    case 'RTRIM': return args[0] == null ? null : String(args[0]).replace(/\s+$/, '');
+    case 'ABS': return args[0] == null ? null : Math.abs(args[0]);
+    case 'ROUND': return args[0] == null ? null : (args[1] !== undefined ? Number(args[0].toFixed(args[1])) : Math.round(args[0]));
+    case 'FLOOR': return args[0] == null ? null : Math.floor(args[0]);
+    case 'CEIL': case 'CEILING': return args[0] == null ? null : Math.ceil(args[0]);
+    case 'MOD': return (args[0] == null || args[1] === 0) ? null : args[0] % args[1];
+    case 'POWER': case 'POW': return args[0] == null ? null : Math.pow(args[0], args[1]);
+    case 'SQRT': return args[0] == null ? null : Math.sqrt(args[0]);
+    case 'IFNULL': case 'NVL': return args[0] != null ? args[0] : args[1];
+    case 'COALESCE': return args.find(a => a != null);
+    case 'NULLIF': return args[0] === args[1] ? null : args[0];
+    case 'IF': return args[0] ? args[1] : args[2];
+    case 'REPLACE': return args[0] == null ? null : String(args[0]).split(args[1]).join(args[2]);
+    case 'SUBSTRING': case 'SUBSTR': {
+      if (args[0] == null) return null;
+      const s = String(args[0]);
+      const start = Number(args[1]);
+      if (args[2] !== undefined) return s.substr(start - 1, Number(args[2]));
+      return s.substr(start - 1);
+    }
+    case 'LEFT': return args[0] == null ? null : String(args[0]).slice(0, Number(args[1]));
+    case 'RIGHT': return args[0] == null ? null : String(args[0]).slice(-Number(args[1]));
+    case 'LOCATE': case 'INSTR': {
+      if (args[0] == null || args[1] == null) return null;
+      const idx = String(args[1]).indexOf(String(args[0]));
+      return idx + 1;
+    }
+    case 'GREATEST': return args.reduce((m, a) => a > m ? a : m, args[0]);
+    case 'LEAST': return args.reduce((m, a) => a < m ? a : m, args[0]);
+    case 'UUID': return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+      const r = Math.random() * 16 | 0; const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+    case 'DATABASE': case 'SCHEMA': return row && row.__db !== undefined ? row.__db : 'default';
+    default:
+      return null;
+  }
 }
 
 function likeMatch(value, pattern) {
@@ -922,36 +1214,36 @@ function extractEqualPushdown(expr, schema) {
   return { filter, rest };
 }
 
-function evaluateExpr(expr, row) {
+function evaluateExpr(expr, row, ctx) {
   if (expr === null || expr === undefined) return false;
   switch (expr.type) {
-    case 'and': return evaluateExpr(expr.left, row) && evaluateExpr(expr.right, row);
-    case 'or': return evaluateExpr(expr.left, row) || evaluateExpr(expr.right, row);
-    case 'not': return !evaluateExpr(expr.expr, row);
+    case 'and': return evaluateExpr(expr.left, row, ctx) && evaluateExpr(expr.right, row, ctx);
+    case 'or': return evaluateExpr(expr.left, row, ctx) || evaluateExpr(expr.right, row, ctx);
+    case 'not': return !evaluateExpr(expr.expr, row, ctx);
     case 'compare': {
-      const l = resolveOperand(expr.left, row);
-      const r = resolveOperand(expr.right, row);
+      const l = resolveOperand(expr.left, row, ctx);
+      const r = resolveOperand(expr.right, row, ctx);
       if (expr.op === '=') return l === r || (l === null && r === null) || (l !== null && r !== null && String(l) === String(r));
       if (l === null || r === null) return false;
       const fn = OPERATORS[expr.op];
       return typeof l === 'number' && typeof r === 'number' ? fn(l, r) : fn(String(l), String(r));
     }
     case 'isNull': {
-      const v = resolveOperand(expr.operand, row);
+      const v = resolveOperand(expr.operand, row, ctx);
       const isNull = v === null || v === undefined;
       return expr.not ? !isNull : isNull;
     }
     case 'in': {
-      const v = resolveOperand(expr.operand, row);
+      const v = resolveOperand(expr.operand, row, ctx);
       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 'like': return likeMatch(resolveOperand(expr.operand, row, ctx), expr.pattern);
     case 'between': {
-      const v = resolveOperand(expr.operand, row);
-      const lo = resolveOperand(expr.low, row);
-      const hi = resolveOperand(expr.high, row);
+      const v = resolveOperand(expr.operand, row, ctx);
+      const lo = resolveOperand(expr.low, row, ctx);
+      const hi = resolveOperand(expr.high, row, ctx);
       if (v === null || lo === null || hi === null) return false;
       const inRange = typeof v === 'number' && typeof lo === 'number' && typeof hi === 'number'
         ? v >= lo && v <= hi
@@ -960,24 +1252,84 @@ function evaluateExpr(expr, row) {
     }
     case 'case': {
       for (const b of expr.branches) {
-        if (evaluateExpr(b.cond, row)) return resolveOperand(b.val, row);
+        if (evaluateExpr(b.cond, row, ctx)) return resolveOperand(b.val, row, ctx);
       }
-      return expr.elseVal ? resolveOperand(expr.elseVal, row) : null;
+      return expr.elseVal ? resolveOperand(expr.elseVal, row, ctx) : null;
     }
     default: return false;
   }
 }
 
-function evaluateCaseVal(caseExpr, row) {
+function evaluateCaseVal(caseExpr, row, ctx) {
   if (!caseExpr || caseExpr.type !== 'case') return undefined;
   for (const b of caseExpr.branches) {
-    if (evaluateExpr(b.cond, row)) return resolveOperand(b.val, row);
+    if (evaluateExpr(b.cond, row, ctx)) return resolveOperand(b.val, row, ctx);
+  }
+  return caseExpr.elseVal ? resolveOperand(caseExpr.elseVal, row, ctx) : null;
+}
+
+function scalarName(node) {
+  if (!node) return 'expr';
+  switch (node.type) {
+    case 'column': {
+      const dot = node.name.indexOf('.');
+      return dot !== -1 ? node.name.slice(dot + 1) : node.name;
+    }
+    case 'func': return node.name + '()';
+    case 'value':
+    case 'literal': return String(node.value);
+    case 'arith': return scalarName(node.left) + ' ' + node.op + ' ' + scalarName(node.right);
+    case 'case': return 'CASE';
+    case 'aggregate': return node.fn + '(' + (node.column || '*') + ')';
+    default: return 'expr';
   }
-  return caseExpr.elseVal ? resolveOperand(caseExpr.elseVal, row) : null;
 }
 
-function normalizeRow(row, schema) {
-  if (row && typeof row === 'object' && row.fields && typeof row.fields === 'object') {
+function scalarColumnName(c) {
+  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 + ')');
+  if (c.literal !== undefined) return String(c.literal);
+  if (c.caseExpr) return 'CASE';
+  if (c.expr === '*') return '*';
+  const dot = (c.expr || '').indexOf('.');
+  return dot !== -1 ? c.expr.slice(dot + 1) : c.expr;
+}
+
+function scalarColumnValue(c, r, ctx) {
+  if (c.scalar) return resolveOperand(c.scalar, r, ctx);
+  if (c.aggregate) return ctx._aggValue(ctx.group, c.aggregate || 'COUNT', c.column);
+  if (c.literal !== undefined) return c.literal;
+  if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r, ctx);
+  if (c.expr === '*') return r[Object.keys(r).find(k => !k.startsWith('_'))];
+  return resolveOperand({ type: 'column', name: c.expr }, r, ctx);
+}
+
+function sqlTypeName(type) {
+  const t = String(type || 'string').toLowerCase();
+  if (t === 'string' || t === 'text') return 'varchar(255)';
+  if (t === 'integer') return 'int';
+  if (t === 'float' || t === 'double') return 'float';
+  if (t === 'boolean') return 'tinyint(1)';
+  if (t === 'date' || t === 'datetime' || t === 'timestamp') return 'datetime';
+  if (t === 'object' || t === 'array') return 'json';
+  return t;
+}
+
+function buildCreateTableSql(name, schema) {
+  const parts = Object.entries(schema).map(([col, def]) => {
+    const seg = ['`' + col + '`', sqlTypeName(def.type)];
+    if (def.autoIncrement) seg.push('AUTO_INCREMENT');
+    if (def.nullable === false) seg.push('NOT NULL');
+    if (def.default !== undefined) seg.push('DEFAULT ' + (typeof def.default === 'string' ? "'" + def.default + "'" : def.default));
+    return seg.join(' ');
+  });
+  const pks = Object.keys(schema).filter(k => schema[k].primaryKey);
+  if (pks.length > 0) parts.push('PRIMARY KEY (' + pks.map(k => '`' + k + '`').join(', ') + ')');
+  return 'CREATE TABLE `' + name + '` (\n  ' + parts.join(',\n  ') + '\n) ENGINE=JSQL DEFAULT CHARSET=utf8mb4';
+}
+
+function normalizeRow(row, schema) {  if (row && typeof row === 'object' && row.fields && typeof row.fields === 'object') {
     const flat = { ...row.fields };
     if (schema) {
       const pkCols = Object.keys(schema).filter(k => schema[k].primaryKey);
@@ -994,8 +1346,9 @@ function normalizeRow(row, schema) {
 }
 
 class SQLExecutor {
-  constructor(engine) {
+  constructor(engine, ctx) {
     this.engine = engine;
+    this.ctx = ctx || null;
   }
 
   async execute(statement) {
@@ -1014,9 +1367,25 @@ class SQLExecutor {
         await this.engine.dropTable(statement.table);
         return { ok: true, type: 'dropTable', table: statement.table, affectedRows: 0 };
       }
+      case 'truncate': {
+        if (this.engine.hasTable(statement.name)) await this.engine.truncate(statement.name);
+        return { ok: true, type: 'truncate', table: statement.name, affectedRows: 0 };
+      }
       case 'insert': {
         let dataRows = statement.dataRows;
         let schema = null;
+        const stripDefault = (row) => {
+          const out = {};
+          for (const [k, v] of Object.entries(row)) {
+            if (v && typeof v === 'object' && v._default) continue;
+            out[k] = v;
+          }
+          return out;
+        };
+        if (statement.dataRows) {
+          statement.dataRows = statement.dataRows.map(stripDefault);
+          dataRows = statement.dataRows;
+        }
         if (dataRows === null && statement.values) {
           schema = this.engine.getTableSchema
             ? await this.engine.getTableSchema(statement.name)
@@ -1028,7 +1397,8 @@ class SQLExecutor {
             const row = {};
             let vi = 0;
             colNames.forEach(c => {
-              if (schema[c].autoIncrement && (skipAuto || vals[vi] === undefined || vals[vi] === null)) {
+              const isDefault = vals[vi] && typeof vals[vi] === 'object' && vals[vi]._default;
+              if (schema[c].autoIncrement && (skipAuto || vals[vi] === undefined || vals[vi] === null || isDefault)) {
                 if (!skipAuto && vi < vals.length) vi++;
                 return;
               }
@@ -1038,6 +1408,7 @@ class SQLExecutor {
             });
             return row;
           });
+          dataRows = dataRows.map(stripDefault);
         }
         if (!schema) {
           schema = this.engine.getTableSchema
@@ -1119,7 +1490,7 @@ class SQLExecutor {
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         let count = 0;
         for (const row of all) {
-          if (!statement.where || evaluateExpr(statement.where, row)) {
+          if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
             const id = row._rid !== undefined ? row._rid : row.id;
             if (id !== undefined) {
               const data = {};
@@ -1139,7 +1510,7 @@ class SQLExecutor {
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         const ids = [];
         for (const row of all) {
-          if (!statement.where || evaluateExpr(statement.where, row)) {
+          if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
             const id = row._rid !== undefined ? row._rid : row.id;
             if (id !== undefined) ids.push(id);
           }
@@ -1169,7 +1540,12 @@ class SQLExecutor {
         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]) };
+        let list = tables.map(t => [t]);
+        if (statement.like) {
+          const re = new RegExp('^' + statement.like.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.') + '$', 'i');
+          list = list.filter(r => re.test(r[0]));
+        }
+        return { ok: true, type: 'showTables', columns: ['Tables_in_' + (statement.database || 'default')], rows: list };
       }
       case 'showDatabases': {
         const list = this.engine.listDatabases
@@ -1177,6 +1553,83 @@ class SQLExecutor {
           : ['jsql'];
         return { ok: true, type: 'showDatabases', columns: ['Database'], rows: list.map(d => [d]) };
       }
+      case 'showColumns': {
+        const schema = this.engine.getTableSchema ? await this.engine.getTableSchema(statement.table) : null;
+        if (!schema) throw new Error(`Table '${statement.table}' does not exist`);
+        let rows = Object.entries(schema).map(([col, def]) => [
+          col,
+          sqlTypeName(def.type),
+          def.nullable === false ? 'NO' : 'YES',
+          def.primaryKey ? 'PRI' : (def.unique ? 'UNI' : ''),
+          def.default !== undefined && def.default !== null ? String(def.default) : null,
+          def.autoIncrement ? 'auto_increment' : '',
+        ]);
+        if (statement.like) {
+          const re = new RegExp('^' + statement.like.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.') + '$', 'i');
+          rows = rows.filter(r => re.test(r[0]));
+        }
+        return { ok: true, type: 'showColumns', table: statement.table, columns: ['Field', 'Type', 'Null', 'Key', 'Default', 'Extra'], rows };
+      }
+      case 'showIndex': {
+        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 = [];
+        let seq = 0;
+        for (const col of Object.keys(schema).filter(k => schema[k].primaryKey)) {
+          rows.push([statement.table, 0, 'PRIMARY', ++seq, col, 'A', 0, null, null, schema[col].nullable === false ? '' : 'YES', 'BTREE', '']);
+        }
+        for (const col of Object.keys(schema).filter(k => schema[k].unique && !schema[k].primaryKey)) {
+          rows.push([statement.table, 0, col, ++seq, col, 'A', 0, null, null, schema[col].nullable === false ? '' : 'YES', 'BTREE', '']);
+        }
+        return { ok: true, type: 'showIndex', table: statement.table, columns: ['Table', 'Non_unique', 'Key_name', 'Seq_in_index', 'Column_name', 'Collation', 'Cardinality', 'Sub_part', 'Packed', 'Null', 'Index_type', 'Comment'], rows };
+      }
+      case 'showCreateTable': {
+        const schema = this.engine.getTableSchema ? await this.engine.getTableSchema(statement.table) : null;
+        if (!schema) throw new Error(`Table '${statement.table}' does not exist`);
+        const ddl = buildCreateTableSql(statement.table, schema);
+        return { ok: true, type: 'showCreateTable', table: statement.table, columns: ['Table', 'Create Table'], rows: [[statement.table, ddl]] };
+      }
+      case 'showVariables': {
+        const vars = {
+          'version': '8.0.0-jsql-neo',
+          'version_comment': 'JSQL-NEO',
+          'version_compile_os': 'any',
+          'sql_mode': '',
+          'character_set_client': 'utf8mb4',
+          'character_set_connection': 'utf8mb4',
+          'character_set_server': 'utf8mb4',
+          'collation_server': 'utf8mb4_general_ci',
+          'lower_case_table_names': '1',
+          'max_allowed_packet': '1048576',
+          'autocommit': 'ON',
+          'transaction_isolation': 'REPEATABLE-READ',
+        };
+        let entries = Object.entries(vars);
+        if (statement.like) {
+          const re = new RegExp('^' + statement.like.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.') + '$', 'i');
+          entries = entries.filter(([k]) => re.test(k));
+        }
+        return { ok: true, type: 'showVariables', columns: ['Variable_name', 'Value'], rows: entries };
+      }
+      case 'showStatus':
+        return { ok: true, type: 'showStatus', columns: ['Variable_name', 'Value'], rows: [] };
+      case 'showGrants':
+        return { ok: true, type: 'showGrants', columns: ['Grants for root@localhost'], rows: ['GRANT ALL PRIVILEGES ON *.* TO `root`@`localhost`'].map(g => [g]) };
+      case 'showWarnings':
+        return { ok: true, type: 'showWarnings', columns: ['Level', 'Code', 'Message'], rows: [] };
+      case 'set': {
+        const session = this.ctx && this.ctx.session;
+        if (session) {
+          const raw = String(statement.raw || '');
+          const m = raw.match(/^\s*([A-Za-z0-9_]+)(?:\.[A-Za-z0-9_]+)?\s*=\s*(.+)$/);
+          if (m) {
+            let val = m[2].trim().replace(/^'|'$/g, '').replace(/^"|"$/g, '');
+            if (/^-?\d+(\.\d+)?$/.test(val)) val = Number(val);
+            session.sysvars[m[1].toLowerCase()] = val;
+          }
+        }
+        return { ok: true, type: 'set', raw: statement.raw };
+      }
       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 });
@@ -1278,7 +1731,8 @@ class SQLExecutor {
 
   _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);
+    const op = typeof column === 'string' ? { type: 'column', name: column } : column;
+    const values = rows.map(r => resolveOperand(op, r, this.ctx)).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;
@@ -1350,6 +1804,10 @@ class SQLExecutor {
 
       // 读第一表
       const firstItem = statement.from.tables[0];
+      if (firstItem && firstItem.table && String(firstItem.table).toLowerCase().startsWith('information_schema.')) {
+        const cols = statement.columns.map(c => scalarColumnName(c));
+        return { ok: true, type: 'select', table: null, columns: cols, rows: [], raw: [] };
+      }
       let rowsAll;
       if (firstItem.subquery) {
         const res = await this.executeSelect(firstItem.subquery);
@@ -1401,14 +1859,14 @@ class SQLExecutor {
 
     let rows = all;
     if (statement.where) {
-      rows = rows.filter(r => evaluateExpr(statement.where, r));
+      rows = rows.filter(r => evaluateExpr(statement.where, r, this.ctx));
     }
 
     // 分组聚合
     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)));
+        const key = JSON.stringify(statement.groupBy.map(g => resolveOperand({ type: 'column', name: g }, row, this.ctx)));
         if (!groups.has(key)) groups.set(key, []);
         groups.get(key).push(row);
       }
@@ -1443,8 +1901,10 @@ class SQLExecutor {
       const seen = new Set();
       rows = rows.filter(r => {
         const key = JSON.stringify(statement.columns.map(c => {
+          if (c.scalar) return resolveOperand(c.scalar, r, this.ctx);
+          if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
           if (c.aggregate) return this._aggValue(r._group || [r], c.aggregate || 'COUNT', c.column);
-          return resolveOperand(c.caseExpr || { type: 'column', name: c.expr }, r);
+          return resolveOperand({ type: 'column', name: c.expr }, r, this.ctx);
         }));
         if (seen.has(key)) return false;
         seen.add(key);
@@ -1453,33 +1913,24 @@ class SQLExecutor {
     }
 
     // 聚合输出（无 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 };
+    if (!statement.groupBy && statement.columns.some(c => c.aggregate)) {
+      const cols = statement.columns.map(c => scalarColumnName(c));
+      const valueOf = (c) => {
+        if (c.aggregate) return this._aggValue(rows, c.aggregate || 'COUNT', c.column);
+        if (c.scalar) return resolveOperand(c.scalar, rows[0] || {}, this.ctx);
+        if (c.caseExpr) return resolveOperand(c.caseExpr, rows[0] || {}, this.ctx);
+        if (c.expr !== null && c.expr !== '*') return rows[0] ? resolveOperand({ type: 'column', name: c.expr }, rows[0]) : null;
+        return null;
+      };
+      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: [[...statement.columns.map(valueOf)]], aggregate: statement.aggregate };
     }
 
     // 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 cols = statement.columns.map(c => scalarColumnName(c));
       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 statement.columns.map(c => scalarColumnValue(c, r, { _aggValue: this._aggValue.bind(this), group }));
       });
       return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: mapped, raw: rows };
     }
@@ -1487,8 +1938,8 @@ class SQLExecutor {
     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);
+          const av = resolveOperand({ type: 'column', name: o.column }, a, this.ctx);
+          const bv = resolveOperand({ type: 'column', name: o.column }, b, this.ctx);
           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;
@@ -1515,18 +1966,13 @@ class SQLExecutor {
       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 cols = statement.columns.map(c => scalarColumnName(c));
     const mapped = rows.map(r => statement.columns.map(c => {
+      if (c.scalar) return resolveOperand(c.scalar, r, this.ctx);
       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 resolveOperand({ type: 'column', name: c.expr }, r, this.ctx);
     }));
     return { ok: true, type: 'select', table: tableName, columns: cols, rows: mapped, raw: rows };
   }
@@ -1696,7 +2142,7 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
       if (dangerous) throw new Error(`SQL statement blocked by security policy: ${dangerous}`);
     }
   }
-  const executor = new SQLExecutor(engine);
+  const executor = new SQLExecutor(engine, opts.session ? { session: opts.session } : null);
   const results = [];
   for (const stmtSql of statements) {
     const stmt = parseSQL(stmtSql);