jsql-neo 4.2.0 → 4.3.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'
 ]);
 
 function tokenize(sql) {
@@ -191,6 +192,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 +213,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 +294,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 +354,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':
@@ -423,6 +441,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 +467,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 +486,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 +701,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 +841,46 @@ 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 === '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 +897,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')) {
@@ -875,17 +1025,101 @@ const OPERATORS = {
 };
 
 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;
+  if (operand === null || operand === undefined) return null;
+  if (typeof operand === 'string') return resolveOperand({ type: 'column', name: operand }, row);
+  switch (operand.type) {
+    case 'value':
+    case 'literal':
+      return operand.value;
+    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);
+      const r = resolveOperand(operand.right, row);
+      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);
+    case 'case':
+      return evaluateCaseVal(operand, row);
+    case 'aggregate':
+    case 'subquery':
+      return undefined;
+    default:
+      return undefined;
+  }
+}
+
+function applyScalarFunction(fnNode, row) {
+  const name = (fnNode.name || '').toUpperCase();
+  const args = (fnNode.args || []).map(a => resolveOperand(a, row));
+  switch (name) {
+    case 'VERSION': return '8.0.0-jsql-neo';
+    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) {
@@ -976,8 +1210,68 @@ function evaluateCaseVal(caseExpr, row) {
   return caseExpr.elseVal ? resolveOperand(caseExpr.elseVal, row) : null;
 }
 
-function normalizeRow(row, schema) {
-  if (row && typeof row === 'object' && row.fields && typeof row.fields === 'object') {
+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';
+  }
+}
+
+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);
+  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);
+  if (c.expr === '*') return r[Object.keys(r).find(k => !k.startsWith('_'))];
+  return resolveOperand({ type: 'column', name: c.expr }, r);
+}
+
+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);
@@ -1014,9 +1308,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 +1338,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 +1349,7 @@ class SQLExecutor {
             });
             return row;
           });
+          dataRows = dataRows.map(stripDefault);
         }
         if (!schema) {
           schema = this.engine.getTableSchema
@@ -1169,7 +1481,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 +1494,72 @@ 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':
+        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 +1661,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)).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 +1734,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);
@@ -1443,8 +1831,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);
+          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);
         }));
         if (seen.has(key)) return false;
         seen.add(key);
@@ -1463,23 +1853,10 @@ class SQLExecutor {
 
     // 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 };
     }
@@ -1515,14 +1892,9 @@ 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);
       if (c.expr === '*') return null;
       if (c.literal !== undefined) return c.literal;
       if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);