jsql-neo 4.5.1 → 5.0.0

package/lib/sql.js

@@ -55,7 +55,8 @@ const KEYWORDS = new Set([
   'GROUP', 'HAVING', 'UNION', 'ALL', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END',
   'BETWEEN', 'USING', 'FULL', 'UNSIGNED', 'ZEROFILL', 'TRUNCATE', 'COLLATE', 'CHARACTER',
   'ALTER', 'ADD', 'COLUMN', 'MODIFY', 'CHANGE', 'INDEX', 'FOREIGN', 'REFERENCES',
-  'CONSTRAINT', 'RENAME', 'TO', 'AFTER', 'FIRST', 'ENGINE', 'AUTO_INCREMENT', 'SPATIAL'
+  'CONSTRAINT', 'RENAME', 'TO', 'AFTER', 'FIRST', 'ENGINE', 'AUTO_INCREMENT', 'SPATIAL',
+  'REGEXP', 'TRUE', 'FALSE', 'RLIKE', 'PRAGMA', 'REPLACE', 'BLOB', 'RAISE', 'IGNORE'
 ]);
 
 function tokenize(sql) {
@@ -244,6 +245,7 @@ class Parser {
       case 'SET': return this.parseSet();
       case 'DESCRIBE': case 'DESC': return this.parseDescribe();
       case 'USE': return this.parseUse();
+      case 'PRAGMA': return this.parsePragma();
       default: throw new Error(`Unsupported statement: ${t.value}`);
     }
   }
@@ -379,9 +381,14 @@ class Parser {
       if (t.type === 'keyword') {
         switch (t.value) {
           case 'PRIMARY':
-            this.next(); this.expectKeyword('KEY'); def.primaryKey = true; def.unique = true; break;
+            this.next(); this.expectKeyword('KEY'); def.primaryKey = true; def.unique = true;
+            // SQLite 语义: INTEGER PRIMARY KEY 是 rowid 别名, 自动生成
+            if (mapped === 'integer') def.autoIncrement = true;
+            break;
           case 'KEY':
-            this.next(); def.primaryKey = true; def.unique = true; break;
+            this.next(); def.primaryKey = true; def.unique = true;
+            if (mapped === 'integer') def.autoIncrement = true;
+            break;
           case 'AUTO_INCREMENT':
           case 'AUTOINCREMENT':
             this.next(); def.autoIncrement = true; break;
@@ -585,8 +592,9 @@ class Parser {
     if (this.isKeyword('LIMIT')) {
       this.next();
       limit = this.parseValue();
-      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(); }
+      if (typeof limit === 'number' && limit < 0) throw new Error(`LIMIT must be a non-negative integer, got ${limit}`);
+      if (this.isKeyword('OFFSET')) { this.next(); offset = this.parseValue(); if (typeof offset === 'number' && offset < 0) throw new Error(`OFFSET must be a non-negative integer, got ${offset}`); }
+      else if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); offset = limit; limit = this.parseValue(); if (typeof limit === 'number' && limit < 0) throw new Error(`LIMIT must be a non-negative integer, got ${limit}`); }
     }
     let union = null;
     if (this.isKeyword('UNION')) {
@@ -684,7 +692,7 @@ class Parser {
     while (true) {
       const col = this.parseColumnRef();
       this.expect('op', '=');
-      assignments.push([col, this.parseValue()]);
+      assignments.push([col, this.parseScalar()]);
       if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
       break;
     }
@@ -950,6 +958,37 @@ class Parser {
     return { type: 'use', database: db };
   }
 
+  parsePragma() {
+    this.expectKeyword('PRAGMA');
+    let name = '';
+    const first = this.next();
+    if (first.type !== 'ident' && first.type !== 'keyword') throw new Error(`Expected pragma name, got '${first.value}'`);
+    name = first.value;
+    // pragma 名可能带 db. 前缀: PRAGMA main.table_info(users)
+    if (this.peek().type === 'op' && this.peek().value === '.') {
+      this.next();
+      const second = this.next();
+      if (second.type !== 'ident' && second.type !== 'keyword') throw new Error(`Expected pragma name after '.', got '${second.value}'`);
+      name = first.value + '.' + second.value;
+    }
+    let arg = null;
+    if (this.peek().type === 'op' && this.peek().value === '(') {
+      this.next();
+      const a = this.next();
+      if (a.type !== 'op' && a.type !== 'eof') arg = a.value;
+      if (this.peek().type === 'op' && this.peek().value === ')') this.next();
+    } else if (this.peek().type === 'op' && this.peek().value === '=') {
+      this.next();
+      const v = this.next();
+      if (v.type === 'number' || v.type === 'ident' || v.type === 'keyword' || v.type === 'string') arg = v.value;
+    } else if (this.peek().type !== 'eof' && !(this.peek().type === 'op' && this.peek().value === ';')) {
+      const v = this.next();
+      if (v.type === 'number' || v.type === 'ident' || v.type === 'keyword') arg = v.value;
+    }
+    this.optionalTailSemicolon();
+    return { type: 'pragma', name, arg };
+  }
+
   optionalTailSemicolon() {
     if (this.peek().type === 'op' && this.peek().value === ';') this.next();
   }
@@ -1010,7 +1049,8 @@ class Parser {
         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(); args.push({ type: 'star' }); }
+            else args.push(this.parseOperand());
             if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
             break;
           }
@@ -1030,7 +1070,8 @@ class Parser {
       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(); args.push({ type: 'star' }); }
+          else args.push(this.parseOperand());
           if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
           break;
         }
@@ -1073,6 +1114,39 @@ class Parser {
       }
       break;
     }
+    // 后缀：expr IN (...)、expr IS [NOT] TRUE/FALSE/NULL（标量上下文，如 SELECT 1 IN (...))
+    for (;;) {
+      const t = this.peek();
+      if (t.type === 'keyword' && t.value === 'IN') {
+        this.next();
+        this.expect('op', '(');
+        if (this.isKeyword('SELECT')) {
+          const sub = this.parseSelect();
+          this.expect('op', ')');
+          node = { type: 'in', operand: node, subquery: sub };
+        } else {
+          const list = [];
+          while (true) {
+            list.push(this.parseValue());
+            if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+            break;
+          }
+          this.expect('op', ')');
+          node = { type: 'in', operand: node, list };
+        }
+        continue;
+      }
+      if (t.type === 'keyword' && t.value === 'IS') {
+        this.next();
+        const not = this.isKeyword('NOT');
+        if (not) this.next();
+        if (this.isKeyword('NULL')) { this.next(); node = { type: 'isNull', operand: node, not: !!not }; continue; }
+        if (this.isKeyword('TRUE')) { this.next(); node = { type: 'isTruth', operand: node, not: !!not, truth: true }; continue; }
+        if (this.isKeyword('FALSE')) { this.next(); node = { type: 'isTruth', operand: node, not: !!not, truth: false }; continue; }
+        throw new Error(`Expected NULL, TRUE or FALSE after IS, got '${this.peek().value}'`);
+      }
+      break;
+    }
     return node;
   }
 
@@ -1120,23 +1194,39 @@ class Parser {
   parseComparison() {
     const left = this.parseOperand();
     const t = this.peek();
+    let not = false;
+    if (t.type === 'keyword' && t.value === 'NOT') {
+      this.next();
+      not = true;
+      // NOT 后必须紧跟比较关键字
+      const n = this.peek();
+      if (!['IN', 'BETWEEN', 'LIKE', 'REGEXP'].includes(n.value)) {
+        throw new Error(`Expected IN, BETWEEN, LIKE or REGEXP after NOT, got '${n.value}'`);
+      }
+    }
+    const t2 = this.peek();
 
-    if (t.type === 'keyword' && t.value === 'IS') {
+    if (t2.type === 'keyword' && t2.value === 'IS') {
       this.next();
-      const not = this.isKeyword('NOT');
-      if (not) this.next();
-      this.expectKeyword('NULL');
-      return { type: 'isNull', operand: left, not: !!not };
+      const n = this.isKeyword('NOT');
+      if (n) this.next();
+      if (this.isKeyword('NULL')) {
+        this.next();
+        return { type: 'isNull', operand: left, not: not || !!n };
+      }
+      if (this.isKeyword('TRUE')) { this.next(); return { type: 'isTruth', operand: left, not: not || !!n, truth: true }; }
+      if (this.isKeyword('FALSE')) { this.next(); return { type: 'isTruth', operand: left, not: not || !!n, truth: false }; }
+      throw new Error(`Expected NULL, TRUE or FALSE after IS, got '${this.peek().value}'`);
     }
 
-    if (t.type === 'keyword' && t.value === 'IN') {
+    if (t2.type === 'keyword' && t2.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 };
+        return { type: 'in', operand: left, subquery: sub, not };
       }
       const list = [];
       while (true) {
@@ -1145,13 +1235,12 @@ class Parser {
         break;
       }
       this.expect('op', ')');
-      return { type: 'in', operand: left, list };
+      return { type: 'in', operand: left, list, not };
     }
 
-    if (t.type === 'keyword' && t.value === 'BETWEEN') {
+    if (t2.type === 'keyword' && t2.value === 'BETWEEN') {
       this.next();
       const low = this.parseOperand();
-      const not = false;
       let andTok = this.peek();
       if (andTok.type === 'keyword' && andTok.value === 'AND') {
         this.next();
@@ -1161,19 +1250,25 @@ class Parser {
       throw new Error(`Expected AND in BETWEEN, got '${andTok.value}'`);
     }
 
-    if (t.type === 'keyword' && t.value === 'LIKE') {
+    if (t2.type === 'keyword' && t2.value === 'LIKE') {
+      this.next();
+      const pattern = this.parseValue();
+      return { type: 'like', operand: left, pattern, not };
+    }
+
+    if (t2.type === 'keyword' && t2.value === 'REGEXP') {
       this.next();
       const pattern = this.parseValue();
-      return { type: 'like', operand: left, pattern };
+      return { type: 'regexp', operand: left, pattern, not };
     }
 
-    if (t.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>='].includes(t.value)) {
+    if (t2.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>='].includes(t2.value)) {
       this.next();
       const right = this.parseOperand();
-      return { type: 'compare', op: t.value === '<>' ? '!=' : t.value, left, right };
+      return { type: 'compare', op: t2.value === '<>' ? '!=' : t2.value, left, right };
     }
 
-    throw new Error(`Expected comparison operator, got '${t.value}'`);
+    throw new Error(`Expected comparison operator, got '${t2.value}'`);
   }
 }
 
@@ -1244,6 +1339,13 @@ function resolveOperand(operand, row, ctx) {
       return applyScalarFunction(operand, row, ctx);
     case 'case':
       return evaluateCaseVal(operand, row, ctx);
+    case 'in':
+    case 'isNull':
+    case 'isTruth':
+    case 'regexp':
+    case 'like':
+    case 'between':
+      return evaluateExpr(operand, row, ctx);
     case 'aggregate':
     case 'subquery':
       return undefined;
@@ -1256,9 +1358,13 @@ 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;
+  if (ctx && ctx.functions && Object.prototype.hasOwnProperty.call(ctx.functions, name)) {
+    return ctx.functions[name].apply(null, args);
+  }
   switch (name) {
     case 'VERSION': return '8.0.0-jsql-neo';
-    case 'LAST_INSERT_ID': {
+    case 'LAST_INSERT_ID':
+    case 'LAST_INSERT_ROWID': {
       if (args.length > 0) {
         if (session) session.lastInsertId = args[0];
         return args[0];
@@ -1274,7 +1380,10 @@ function applyScalarFunction(fnNode, row, ctx) {
     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 'CONCAT_WS': {
+      const sep = args[0] == null ? ',' : String(args[0]);
+      return args.slice(1).filter(a => a !== null && a !== undefined).map(a => String(a)).join(sep);
+    }
     case 'UPPER': case 'UCASE': return args[0] == null ? null : String(args[0]).toUpperCase();
     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;
@@ -1296,8 +1405,16 @@ function applyScalarFunction(fnNode, row, ctx) {
     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]));
+      const len = s.length;
+      let start = Number(args[1]);
+      // MySQL 语义：1-based；负数从末尾倒数；0 视为 1（MySQL 返回空串）
+      if (start === 0) return '';
+      if (start < 0) start = len + start + 1;
+      if (args[2] !== undefined) {
+        let n = Number(args[2]);
+        if (n < 0) return '';
+        return s.substr(start - 1, n);
+      }
       return s.substr(start - 1);
     }
     case 'LEFT': return args[0] == null ? null : String(args[0]).slice(0, Number(args[1]));
@@ -1307,6 +1424,33 @@ function applyScalarFunction(fnNode, row, ctx) {
       const idx = String(args[1]).indexOf(String(args[0]));
       return idx + 1;
     }
+    case 'REVERSE': return args[0] == null ? null : String(args[0]).split('').reverse().join('');
+    case 'LPAD': {
+      if (args[0] == null) return null;
+      let s = String(args[0]);
+      const n = Number(args[1]);
+      const pad = args[2] == null ? ' ' : String(args[2]);
+      if (n <= s.length) return s.slice(0, n);
+      while (s.length < n) s = pad + s;
+      return s;
+    }
+    case 'RPAD': {
+      if (args[0] == null) return null;
+      let s = String(args[0]);
+      const n = Number(args[1]);
+      const pad = args[2] == null ? ' ' : String(args[2]);
+      if (n <= s.length) return s.slice(0, n);
+      while (s.length < n) s = s + pad;
+      return s;
+    }
+    case 'RAND': return args.length > 0 && args[0] != null ? seedRand(Number(args[0]))() : Math.random();
+    case 'UNIX_TIMESTAMP': {
+      if (args.length > 0 && args[0] != null) {
+        const d = new Date(String(args[0]).replace(' ', 'T'));
+        return isNaN(d.getTime()) ? 0 : Math.floor(d.getTime() / 1000);
+      }
+      return Math.floor(Date.now() / 1000);
+    }
     case 'GREATEST': return args.reduce((m, a) => a > m ? a : m, args[0]);
     case 'LEAST': return args.reduce((m, a) => a < m ? a : m, args[0]);
     case 'UUID': return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
@@ -1319,6 +1463,15 @@ function applyScalarFunction(fnNode, row, ctx) {
   }
 }
 
+function seedRand(seed) {
+  let s = Math.abs(seed) % 2147483647;
+  if (s <= 0) s = 1;
+  return () => {
+    s = (s * 16807) % 2147483647;
+    return (s - 1) / 2147483646;
+  };
+}
+
 function likeMatch(value, pattern) {
   if (typeof value !== 'string') return false;
   const regex = pattern
@@ -1362,8 +1515,9 @@ function evaluateExpr(expr, row, ctx) {
     case 'compare': {
       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));
+      // SQL 标准：任何与 NULL 的比较结果为 UNKNOWN（在 WHERE/ON/HAVING 中视为 false）
       if (l === null || r === null) return false;
+      if (expr.op === '=') return l === r || (l !== null && r !== null && String(l) === String(r));
       const fn = OPERATORS[expr.op];
       return typeof l === 'number' && typeof r === 'number' ? fn(l, r) : fn(String(l), String(r));
     }
@@ -1378,7 +1532,24 @@ function evaluateExpr(expr, row, ctx) {
       if (!expr.list) return false;
       return expr.list.some(x => x === v || String(x) === String(v));
     }
-    case 'like': return likeMatch(resolveOperand(expr.operand, row, ctx), expr.pattern);
+    case 'like': {
+      const r = likeMatch(resolveOperand(expr.operand, row, ctx), expr.pattern);
+      return expr.not ? !r : r;
+    }
+    case 'regexp': {
+      const v = resolveOperand(expr.operand, row, ctx);
+      if (v === null || v === undefined) return false;
+      const re = new RegExp(String(expr.pattern), 'i');
+      const r = re.test(String(v));
+      return expr.not ? !r : r;
+    }
+    case 'isTruth': {
+      const v = resolveOperand(expr.operand, row, ctx);
+      const isTrue = v === true || v === 1 || v === '1' || v === 'true' || v === 'TRUE' || v === 't' || (typeof v === 'number' && v !== 0);
+      const isFalse = !isTrue && v !== null && v !== undefined;
+      const result = expr.truth ? isTrue : isFalse;
+      return expr.not ? !result : result;
+    }
     case 'between': {
       const v = resolveOperand(expr.operand, row, ctx);
       const lo = resolveOperand(expr.low, row, ctx);
@@ -1436,7 +1607,15 @@ function scalarColumnName(c) {
 }
 
 function scalarColumnValue(c, r, ctx) {
-  if (c.scalar) return resolveOperand(c.scalar, r, ctx);
+  if (c.scalar) {
+    const s = c.scalar;
+    if (s && s.type === 'func' && ctx && ctx.ctxAggregates && Object.prototype.hasOwnProperty.call(ctx.ctxAggregates, String(s.name).toUpperCase())) {
+      const fn = String(s.name).toUpperCase();
+      const col = s.args && s.args[0];
+      return ctx._aggValue(ctx.group, fn, col);
+    }
+    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);
@@ -1698,7 +1877,9 @@ class SQLExecutor {
             const id = row._rid !== undefined ? row._rid : row.id;
             if (id !== undefined) {
               const data = {};
-              for (const [col, val] of statement.assignments) data[col] = val;
+              for (const [col, val] of statement.assignments) {
+                data[col] = typeof val === 'object' && val !== null && val.type ? resolveOperand(val, row, this.ctx) : val;
+              }
               this.engine.updateById(statement.table, id, data);
               count++;
             }
@@ -1849,6 +2030,16 @@ class SQLExecutor {
           await this.engine.useDatabase(statement.database);
         }
         return { ok: true, type: 'use', database: statement.database };
+      case 'pragma': {
+        const rows = this._runPragma(statement.name, statement.arg);
+        const isSelect = ['table_info', 'table_list', 'index_list', 'index_info', 'collation_list', 'database_list', 'module_list', 'function_list', 'pragma_list'].includes(statement.name.toLowerCase());
+        if (isSelect) {
+          const cols = rows.length > 0 ? Object.keys(rows[0]) : [];
+          return { ok: true, type: 'select', columns: cols, rows: rows.map(r => cols.map(c => r[c])), raw: rows };
+        }
+        const simple = rows.length > 0 && Object.keys(rows[0]).length === 1 ? rows[0][Object.keys(rows[0])[0]] : rows;
+        return { ok: true, type: 'pragma', name: statement.name, value: simple };
+      }
       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`);
@@ -1860,6 +2051,110 @@ class SQLExecutor {
     }
   }
 
+  _runPragma(name, arg) {
+    const engine = this.engine;
+    const lname = String(name).toLowerCase().replace(/^.*\./, '');
+    const rows = [];
+    switch (lname) {
+      case 'table_info': {
+        const schema = engine.getTableSchema ? engine.getTableSchema(arg) : (engine._schemas ? engine._schemas[arg] : null);
+        if (!schema) throw new Error(`table ${arg} may not be queried: no such table`);
+        let cid = 0;
+        for (const [col, def] of Object.entries(schema)) {
+          let typeName = String(def.type || 'text').toUpperCase();
+          if (typeName === 'NUMBER') typeName = 'REAL';
+          if (typeName === 'OBJECT' || typeName === 'ARRAY') typeName = 'TEXT';
+          rows.push({
+            cid,
+            name: col,
+            type: typeName,
+            notnull: def.required ? 1 : 0,
+            dflt_value: def.default !== undefined ? def.default : null,
+            pk: def.primaryKey ? 1 : 0,
+          });
+          cid++;
+        }
+        break;
+      }
+      case 'table_list': {
+        const tables = engine.listTables ? engine.listTables() : Array.from(engine._tableNames || []);
+        for (const t of tables) {
+          rows.push({ schema: 'main', name: t, type: 'table', ncol: 0, wr: 1, strict: 0 });
+        }
+        break;
+      }
+      case 'index_list': {
+        const schema = engine.getTableSchema ? engine.getTableSchema(arg) : (engine._schemas ? engine._schemas[arg] : null);
+        if (!schema) throw new Error(`table ${arg} may not be queried: no such table`);
+        let seq = 0;
+        for (const [col, def] of Object.entries(schema)) {
+          if (def.primaryKey || def.unique) {
+            rows.push({ seq, name: 'sqlite_autoindex_' + arg + '_' + (seq + 1), unique: def.unique ? 1 : 0, origin: def.primaryKey ? 'pk' : 'u', partial: 0 });
+            seq++;
+          }
+        }
+        break;
+      }
+      case 'index_info': {
+        const schema = engine.getTableSchema ? engine.getTableSchema(arg) : (engine._schemas ? engine._schemas[arg] : null);
+        if (!schema) throw new Error(`no such index: ${arg}`);
+        let seqno = 0;
+        for (const [col, def] of Object.entries(schema)) {
+          if (def.primaryKey || def.unique) {
+            rows.push({ seqno, cid: seqno, name: col });
+            seqno++;
+          }
+        }
+        break;
+      }
+      case 'database_list': {
+        rows.push({ seq: 0, name: 'main', file: '' });
+        break;
+      }
+      case 'user_version': {
+        const val = arg !== undefined && arg !== null ? arg : ((engine._pragmaValues && engine._pragmaValues.user_version) || 0);
+        if (arg !== undefined && arg !== null) {
+          engine._pragmaValues = engine._pragmaValues || {};
+          engine._pragmaValues.user_version = Number(arg);
+        }
+        rows.push({ user_version: val });
+        break;
+      }
+      case 'journal_mode': {
+        rows.push({ journal_mode: arg !== undefined && arg !== null ? arg : 'memory' });
+        break;
+      }
+      case 'foreign_keys': {
+        rows.push({ foreign_keys: arg !== undefined && arg !== null ? arg : 0 });
+        break;
+      }
+      case 'synchronous': {
+        rows.push({ synchronous: arg !== undefined && arg !== null ? arg : 0 });
+        break;
+      }
+      case 'cache_size': {
+        rows.push({ cache_size: arg !== undefined && arg !== null ? arg : 0 });
+        break;
+      }
+      case 'page_size':
+      case 'encoding':
+      case 'auto_vacuum':
+      case 'temp_store':
+      case 'locking_mode':
+      case 'application_id':
+      case 'integrity_check':
+      case 'quick_check': {
+        rows.push({ [lname]: lname === 'encoding' ? 'UTF-8' : (arg !== undefined && arg !== null ? arg : 0) });
+        break;
+      }
+      default: {
+        rows.push({ [lname]: arg !== undefined && arg !== null ? arg : 0 });
+        break;
+      }
+    }
+    return rows;
+  }
+
   async _getSchema(name) {
     if (this.engine.hasTable && !this.engine.hasTable(name)) {
       throw new Error(`Table '${name}' does not exist`);
@@ -2074,7 +2369,20 @@ class SQLExecutor {
   _aggValue(rows, fn, column) {
     if (fn === 'COUNT') return rows.length;
     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);
+    const values = op && op.type === 'star'
+      ? rows.map(r => 1)
+      : rows.map(r => resolveOperand(op, r, this.ctx)).filter(v => v !== null && v !== undefined);
+    if (this.ctx && this.ctx.aggregates && Object.prototype.hasOwnProperty.call(this.ctx.aggregates, fn)) {
+      const agg = this.ctx.aggregates[fn];
+      if (typeof agg === 'function') {
+        return agg(values);
+      }
+      if (agg && typeof agg.step === 'function') {
+        let state = typeof agg.start === 'function' ? agg.start() : undefined;
+        for (const v of values) state = agg.step(state, v);
+        return typeof agg.result === 'function' ? agg.result(state) : state;
+      }
+    }
     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;
@@ -2266,10 +2574,17 @@ class SQLExecutor {
     }
 
     // 聚合输出（无 GROUP BY 时）
-    if (!statement.groupBy && statement.columns.some(c => c.aggregate)) {
+    const hasCustomAgg = this.ctx && this.ctx.aggregates && statement.columns.some(c => c.scalar && c.scalar.type === 'func' && Object.prototype.hasOwnProperty.call(this.ctx.aggregates, String(c.scalar.name).toUpperCase()));
+    if (!statement.groupBy && (statement.columns.some(c => c.aggregate) || hasCustomAgg)) {
       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 && c.scalar.type === 'func' && hasCustomAgg) {
+          const fn = String(c.scalar.name).toUpperCase();
+          if (Object.prototype.hasOwnProperty.call(this.ctx.aggregates, fn)) {
+            return this._aggValue(rows, fn, c.scalar.args && c.scalar.args[0]);
+          }
+        }
         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;
@@ -2283,7 +2598,7 @@ class SQLExecutor {
       const cols = statement.columns.map(c => scalarColumnName(c));
       const mapped = rows.map(r => {
         const group = r._group || [r];
-        return statement.columns.map(c => scalarColumnValue(c, r, { _aggValue: this._aggValue.bind(this), group }));
+        return statement.columns.map(c => scalarColumnValue(c, r, { _aggValue: this._aggValue.bind(this), group, ctxAggregates: this.ctx ? this.ctx.aggregates : null }));
       });
       return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: mapped, raw: rows };
     }
@@ -2448,6 +2763,11 @@ function applyParams(sql, values) {
   let idx = 0;
   let inStr = null;
   let i = 0;
+  const named = {};
+  let hasNamed = false;
+  if (args && typeof args === 'object' && !Array.isArray(args)) {
+    hasNamed = true;
+  }
   while (i < sql.length) {
     const c = sql[i];
     if (inStr) {
@@ -2459,23 +2779,53 @@ function applyParams(sql, values) {
     }
     if (c === "'" || c === '"' || c === '`') { inStr = c; out += c; i++; continue; }
     if (c === '?' && sql[i + 1] === '?') {
-      if (idx >= args.length) throw new Error('Not enough parameters for SQL: expected ' + (count + 1));
-      out += escapeId(args[idx++]);
+      if (!hasNamed && idx >= args.length) throw new Error('Not enough parameters for SQL: expected ' + (count + 1));
+      out += escapeId(hasNamed ? args['@@'] : args[idx++]);
       count++;
       i += 2;
       continue;
     }
     if (c === '?') {
-      if (idx >= args.length) throw new Error('Not enough parameters for SQL: expected ' + (count + 1));
-      out += escapeValue(args[idx++]);
+      if (sql[i + 1] >= '0' && sql[i + 1] <= '9') {
+        // ?N 编号占位符
+        let num = '';
+        let j = i + 1;
+        while (j < sql.length && sql[j] >= '0' && sql[j] <= '9') { num += sql[j]; j++; }
+        const n = parseInt(num, 10);
+        if (hasNamed) {
+          if (!(n in args)) throw new Error(`No value for parameter ?${n}`);
+          out += escapeValue(args[n]);
+        } else {
+          if (n - 1 >= args.length) throw new Error(`Not enough parameters for SQL: expected ?${n}`);
+          out += escapeValue(args[n - 1]);
+          if (n > idx) idx = n;
+        }
+        count++;
+        i = j;
+        continue;
+      }
+      if (!hasNamed && idx >= args.length) throw new Error('Not enough parameters for SQL: expected ' + (count + 1));
+      out += escapeValue(hasNamed ? args['?'] : args[idx++]);
       count++;
       i++;
       continue;
     }
+    if ((c === ':' || c === '@' || c === '$') && i + 1 < sql.length && /[A-Za-z_]/.test(sql[i + 1])) {
+      // 命名占位符 :name @name $name
+      let name = '';
+      let j = i + 1;
+      while (j < sql.length && /[A-Za-z0-9_]/.test(sql[j])) { name += sql[j]; j++; }
+      if (!hasNamed) throw new Error(`Named parameter ${c}${name} requires an object of parameters`);
+      if (!(name in args)) throw new Error(`No value for parameter ${c}${name}`);
+      out += escapeValue(args[name]);
+      count++;
+      i = j;
+      continue;
+    }
     out += c;
     i++;
   }
-  if (idx !== args.length) {
+  if (!hasNamed && idx !== args.length) {
     throw new Error(`Too many parameters for SQL: got ${args.length}, expected ${count}`);
   }
   return out;
@@ -2502,7 +2852,11 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
       if (dangerous) throw new Error(`SQL statement blocked by security policy: ${dangerous}`);
     }
   }
-  const executor = new SQLExecutor(engine, opts.session ? { session: opts.session } : null);
+  const ctx = {};
+  if (opts.session) ctx.session = opts.session;
+  if (opts.functions && typeof opts.functions === 'object') ctx.functions = opts.functions;
+  if (opts.aggregates && typeof opts.aggregates === 'object') ctx.aggregates = opts.aggregates;
+  const executor = new SQLExecutor(engine, Object.keys(ctx).length > 0 ? ctx : null);
   const results = [];
   for (const stmtSql of statements) {
     const stmt = parseSQL(stmtSql);