jsql-neo 6.1.0 → 6.3.0

package/lib/sql.js

@@ -11,6 +11,10 @@ const DANGEROUS_SQL = [
   { re: /^SYSEXEC$|^SYS_EXEC$/, name: 'sys_exec' },
 ];
 
+// SQL 文本体积上限（默认 64 MiB）：防止超大、无分号的输入造成无界内存消耗
+// （CWE-770）。可在 executeSQL 通过 opts.maxSqlLength 放宽/关闭（传 Infinity）。
+const DEFAULT_MAX_SQL_LENGTH = 64 * 1024 * 1024;
+
 function findDangerousSQL(tokens) {
   for (let i = 0; i < tokens.length; i++) {
     const t = tokens[i];
@@ -79,10 +83,12 @@ function tokenize(sql) {
       while (i < n && sql[i] !== '\n') i++;
       continue;
     }
-    // PG 的 JSON 路径操作符 #> / #>> 尚未实现。
-    // 若不在这里拦截，'#' 会被当成行注释吃掉，导致 SQL 后半段被静默丢弃。
+    // PG 的 JSON 路径操作符 #> / #>>（必须在 '#' 行注释之前识别）
     if (c === '#' && sql[i + 1] === '>') {
-      throw new Error("JSON 路径操作符 '#>' / '#>>' 暂不支持，请改用 '->' / '->>'");
+      const op = sql[i + 2] === '>' ? '#>>' : '#>';
+      tokens.push(new SQLToken('op', op, i));
+      i += op.length;
+      continue;
     }
     if (c === '#' || (c === '/' && sql[i + 1] === '*')) {
       if (c === '#') { while (i < n && sql[i] !== '\n') i++; continue; }
@@ -106,12 +112,15 @@ function tokenize(sql) {
           else str += esc;
           j += 2;
         } else if (sql[j] === quote) {
+          // SQL 标准转义：字符串内两个连续引号表示一个字面量引号（'O''Brien' → O'Brien）
+          if (sql[j + 1] === quote) { str += quote; j += 2; continue; }
           break;
         } else {
           str += sql[j];
           j++;
         }
       }
+      if (j >= n) throw new Error(`Unterminated ${quote === '"' ? 'double' : 'single'}-quoted string at position ${i}`);
       tokens.push(new SQLToken('string', str, i));
       i = j + 1;
       continue;
@@ -153,15 +162,17 @@ function tokenize(sql) {
     if (c === '`') {
       let j = i + 1;
       while (j < n && sql[j] !== '`') j++;
+      if (j >= n) throw new Error(`Unterminated backtick-quoted identifier at position ${i}`);
       tokens.push(new SQLToken('ident', sql.slice(i + 1, j), i));
       i = j + 1;
       continue;
     }
 
-    // PG 的 JSON 包含操作符 @> 尚未实现。
-    // 若不拦截，'@' 会被 sysvar 分支静默吞掉、'>' 退化成普通大于号，产生错误结果。
+    // PG 的 JSON 包含操作符 @>
     if (c === '@' && sql[i + 1] === '>') {
-      throw new Error("JSON 包含操作符 '@>' 暂不支持");
+      tokens.push(new SQLToken('op', '@>', i));
+      i += 2;
+      continue;
     }
 
     if (c === '@') {
@@ -181,6 +192,12 @@ function tokenize(sql) {
     }
 
     // 参数占位符：? （顺序）、?N （编号）、?? （标识符占位）
+    // 注意：?| / ?& 是 PG 的 JSON 键存在操作符，必须优先识别
+    if (c === '?' && (sql[i + 1] === '|' || sql[i + 1] === '&')) {
+      tokens.push(new SQLToken('op', '?' + sql[i + 1], i));
+      i += 2;
+      continue;
+    }
     if (c === '?') {
       if (sql[i + 1] === '?') { tokens.push(new SQLToken('param', '??', i)); i += 2; continue; }
       let j = i + 1;
@@ -193,9 +210,11 @@ function tokenize(sql) {
 
     const three = sql.slice(i, i + 3);
     if (sql.slice(i, i + 2) === '<@') {
-      throw new Error("JSON 包含操作符 '<@' 暂不支持");
+      tokens.push(new SQLToken('op', '<@', i));
+      i += 2;
+      continue;
     }
-    if (three === '->>' || three === '<=>') {
+    if (three === '->>' || three === '<=>' || three === '!~*') {
       tokens.push(new SQLToken('op', three, i));
       i += 3;
       continue;
@@ -204,7 +223,7 @@ function tokenize(sql) {
     const two = sql.slice(i, i + 2);
     if (two === '<=' || two === '>=' || two === '!=' || two === '<>' || two === '==' ||
         two === '<<' || two === '>>' || two === '->' || two === '::' ||
-        two === '&&' || two === '||') {
+        two === '&&' || two === '||' || two === '~*' || two === '!~') {
       tokens.push(new SQLToken('op', two, i));
       i += 2;
       continue;
@@ -1838,6 +1857,13 @@ class Parser {
         this.expect('op', ')');
         return { type: 'cast', expr, dataType };
       }
+      // 零参时间函数：CURRENT_DATE / CURRENT_TIME / CURRENT_TIMESTAMP（可省略括号）。
+      // 此前不在 KEYWORDS 里，被当成列名解析 → "no such column: CURRENT_DATE"
+      if (['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP'].includes(String(t.value).toUpperCase())) {
+        const name = String(t.value).toUpperCase();
+        if (this.peek().type === 'op' && this.peek().value === '(') { this.next(); this.expect('op', ')'); }
+        return { type: 'func', name, args: [] };
+      }
       // EXTRACT(YEAR FROM expr) —— 标准 SQL 的 FROM 形式
       if (String(t.value).toUpperCase() === 'EXTRACT' && this.peek().type === 'op' && this.peek().value === '(') {
         this.next();
@@ -1943,6 +1969,13 @@ class Parser {
         this.expect('op', ')');
         return this.parseOptionalOver({ type: 'func', name, args });
       }
+      // 时间单位裸关键字（TIMESTAMPDIFF(MONTH, a, b) 里的 MONTH）：
+      // 解析成 unit 节点，取值时优先当列、取不到才当单位名，
+      // 这样既支持裸写法，也不影响真正名为 month/year 的列。
+      if (TIME_UNITS.has(String(t.value).toUpperCase()) &&
+          !(this.peek().type === 'op' && (this.peek().value === '(' || this.peek().value === '.'))) {
+        return { type: 'unit', name: String(t.value).toUpperCase() };
+      }
       return { type: 'column', name: t.value };
     }
     if (t.type === 'number' || t.type === 'string') return { type: 'value', value: t.value };
@@ -2101,6 +2134,13 @@ class Parser {
         node = { type: 'jsonAccess', operand: node, key, asText: t.value === '->>' };
         continue;
       }
+      // PG 路径取值：meta#>'{a,b}' / meta#>>'{a,b}'
+      if (t.type === 'op' && (t.value === '#>' || t.value === '#>>')) {
+        this.next();
+        const key = this.parseValue();
+        node = { type: 'jsonAccess', operand: node, key, asText: t.value === '#>>', isPath: true };
+        continue;
+      }
       break;
     }
     return node;
@@ -2193,13 +2233,38 @@ class Parser {
 
     // ILIKE 刻意不加进 KEYWORDS（避免影响同名标识符），用 isWord 按上下文匹配
     if ((t2.type === 'keyword' && t2.value === 'LIKE') || this.isWord('ILIKE')) {
-      const isILike = !(t2.type === 'keyword' && t2.value === 'LIKE');
       this.next();
+      // 可选 BINARY 关键字：LIKE BINARY '...' 才区分大小写
+      let binary = false;
+      if (this.isWord('BINARY')) { this.next(); binary = true; }
       const pattern = this.parseValue();
       // 可选 ESCAPE 子句：LIKE '...' ESCAPE '!'
       let escape = null;
       if (this.isWord('ESCAPE')) { this.next(); escape = this.parseValue(); }
-      return { type: 'like', operand: left, pattern, not, ci: isILike, escape };
+      // MySQL 的 LIKE 默认不区分大小写（默认 collation 为 CI），
+      // 此前写成 ci: isILike，导致 LIKE 恒为大小写敏感。
+      return { type: 'like', operand: left, pattern, not, ci: !binary, escape };
+    }
+
+    // PG 正则操作符（双目位置）：~（大小写敏感）/ ~*（不敏感）/ !~ / !~*
+    if (t2.type === 'op' && (t2.value === '~' || t2.value === '~*' || t2.value === '!~' || t2.value === '!~*')) {
+      this.next();
+      const pattern = this.parseValue();
+      return {
+        type: 'regexp', operand: left, pattern,
+        not: t2.value.startsWith('!') || not,
+        ci: t2.value.endsWith('*'),
+      };
+    }
+
+    // PG JSON 键存在：? / ?| / ?&
+    // 裸 `?` 在此处处于"运算符位置"，与值位置上的 `?` 参数占位符不冲突。
+    if ((t2.type === 'op' && (t2.value === '?|' || t2.value === '?&')) ||
+        (t2.type === 'param' && t2.value === null)) {
+      const mode = t2.type === 'param' ? '?' : t2.value;
+      this.next();
+      const keys = this.parseValue();
+      return { type: 'jsonKeyExists', operand: left, keys, mode, not };
     }
 
     // MySQL 中 RLIKE 是 REGEXP 的同义词
@@ -2209,6 +2274,13 @@ class Parser {
       return { type: 'regexp', operand: left, pattern, not };
     }
 
+    // PG JSON 包含操作符
+    if (t2.type === 'op' && (t2.value === '@>' || t2.value === '<@')) {
+      this.next();
+      const right = this.parseBitwise();
+      return { type: 'jsonContains', op: t2.value, left, right, not };
+    }
+
     if (t2.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>=', '<=>'].includes(t2.value)) {
       this.next();
       // = ANY (SELECT ...) / > ALL (SELECT ...)
@@ -2355,6 +2427,12 @@ function resolveOperand(operand, row, ctx) {
     case 'like':
     case 'between':
       return evaluateExpr(operand, row, ctx);
+    case 'unit': {
+      // 裸时间单位（MONTH / DAY …）：优先当列取，取不到就返回单位名本身
+      const lower = String(operand.name).toLowerCase();
+      const v = row ? row[lower] : undefined;
+      return v !== undefined ? v : String(operand.name).toUpperCase();
+    }
     case 'param': {
       // 原生 ? 占位符。executeSQL 默认会先用 applyParams 内联替换，
       // 只有在显式传入 ctx.params 时才走这条路径。
@@ -2377,15 +2455,18 @@ function resolveOperand(operand, row, ctx) {
       if (typeof base === 'string') {
         try { base = JSON.parse(base); } catch (e) { return null; }
       }
-      const key = operand.key;
-      let v;
-      if (Array.isArray(base)) {
-        const idx = Number(key);
-        v = Number.isInteger(idx) ? (idx < 0 ? base[base.length + idx] : base[idx]) : undefined;
-      } else if (base && typeof base === 'object') {
-        v = base[key];
-      } else {
-        return null;
+      const keys = operand.isPath ? parsePgPath(operand.key) : [operand.key];
+      let v = base;
+      for (const key of keys) {
+        if (v === null || v === undefined) return null;
+        if (Array.isArray(v)) {
+          const idx = Number(key);
+          v = Number.isInteger(idx) ? (idx < 0 ? v[v.length + idx] : v[idx]) : undefined;
+        } else if (typeof v === 'object') {
+          v = v[key];
+        } else {
+          return null;
+        }
       }
       if (v === undefined) return null;
       if (operand.asText) {
@@ -2394,6 +2475,17 @@ function resolveOperand(operand, row, ctx) {
       }
       return v;
     }
+    case 'jsonContains': {
+      const l = resolveOperand(operand.left, row, ctx);
+      const r = resolveOperand(operand.right, row, ctx);
+      const res = jsonContains(l, r, operand.op === '<@');
+      return operand.not ? !res : res;
+    }
+    case 'jsonKeyExists': {
+      const base = resolveOperand(operand.operand, row, ctx);
+      const res = jsonKeyExists(base, operand.keys, operand.mode);
+      return operand.not ? !res : res;
+    }
     case 'quantified': {
       // = ANY / > ALL (SELECT ...) —— 需先由执行层物化成 operand._list
       const v = resolveOperand(operand.operand, row, ctx);
@@ -2425,12 +2517,161 @@ function parseSqlDate(v) {
 
 function pad2(n) { return String(n).padStart(2, '0'); }
 
+/** 本地时区的 'YYYY-MM-DD HH:mm:ss'（MySQL 的 NOW() 语义；区别于 UTC_TIMESTAMP） */
+function sqlLocalDateTime(d = new Date()) {
+  return d.getFullYear() + '-' + pad2(d.getMonth() + 1) + '-' + pad2(d.getDate()) + ' ' +
+    pad2(d.getHours()) + ':' + pad2(d.getMinutes()) + ':' + pad2(d.getSeconds());
+}
+
 /** 按输入形态回写日期：纯日期返回 YYYY-MM-DD，带时间返回 YYYY-MM-DD HH:MM:SS */
 function fmtSqlDate(dateOnly, d) {
   const ymd = d.getFullYear() + '-' + pad2(d.getMonth() + 1) + '-' + pad2(d.getDate());
   return dateOnly ? ymd : ymd + ' ' + pad2(d.getHours()) + ':' + pad2(d.getMinutes()) + ':' + pad2(d.getSeconds());
 }
 
+const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTH_NAMES = ['January', 'February', 'March', 'April', 'May', 'June',
+  'July', 'August', 'September', 'October', 'November', 'December'];
+
+/** 可作为裸关键字出现的时间单位（TIMESTAMPDIFF(MONTH, a, b) / DATE_ADD 的 INTERVAL n unit） */
+const TIME_UNITS = new Set([
+  'MICROSECOND', 'SECOND', 'MINUTE', 'HOUR', 'DAY', 'WEEK', 'MONTH', 'QUARTER', 'YEAR',
+  'SECONDS', 'MINUTES', 'HOURS', 'DAYS', 'WEEKS', 'MONTHS', 'YEARS',
+]);
+
+/** MySQL DATE_FORMAT 的 % 说明符 */
+function strftime(d, fmt) {
+  const h12 = ((d.getHours() % 12) || 12);
+  const map = {
+    '%Y': String(d.getFullYear()), '%y': pad2(d.getFullYear() % 100),
+    '%m': pad2(d.getMonth() + 1), '%c': String(d.getMonth() + 1),
+    '%d': pad2(d.getDate()), '%e': String(d.getDate()),
+    '%H': pad2(d.getHours()), '%k': String(d.getHours()),
+    '%h': pad2(h12), '%I': pad2(h12), '%l': String(h12),
+    '%i': pad2(d.getMinutes()), '%S': pad2(d.getSeconds()), '%s': pad2(d.getSeconds()),
+    '%p': d.getHours() < 12 ? 'AM' : 'PM',
+    '%M': MONTH_NAMES[d.getMonth()], '%b': MONTH_NAMES[d.getMonth()].slice(0, 3),
+    '%W': DAY_NAMES[d.getDay()], '%a': DAY_NAMES[d.getDay()].slice(0, 3),
+    '%w': String(d.getDay()),
+    '%j': String(Math.round((d - new Date(d.getFullYear(), 0, 0)) / 86400000)),
+    '%%': '%',
+  };
+  return String(fmt).replace(/%[A-Za-z%]/g, (m) => (m in map ? map[m] : m));
+}
+
+/** PG 日期格式串（YYYY-MM-DD / HH24:MI:SS）→ MySQL 的 % 说明符 */
+function pgFmtToMysql(fmt) {
+  const s = String(fmt);
+  if (s.indexOf('%') !== -1) return s;
+  // 长模式先替换成占位符，避免被短模式（MM 吃掉 MMMM）误匹配
+  const rules = [
+    [/YYYY/g, '\u0001'], [/YY/g, '\u0002'],
+    [/MMMM/g, '\u0003'], [/MMM/g, '\u0004'], [/MM/g, '\u0005'],
+    [/DDDD/g, '\u0006'], [/DDD/g, '\u0007'], [/DD/g, '\u0008'],
+    [/HH24/g, '\u0009'], [/HH12/g, '\u0010'], [/HH/g, '\u0011'],
+    [/MI/g, '\u0012'], [/SS/g, '\u0013'],
+    [/AM/g, '\u0014'], [/PM/g, '\u0014'],
+  ];
+  let out = s;
+  for (const [re, ch] of rules) out = out.replace(re, ch);
+  const back = { '\u0001': '%Y', '\u0002': '%y', '\u0003': '%M', '\u0004': '%b', '\u0005': '%m',
+    '\u0006': '%W', '\u0007': '%a', '\u0008': '%d', '\u0009': '%H', '\u0010': '%h', '\u0011': '%H',
+    '\u0012': '%i', '\u0013': '%S', '\u0014': '%p' };
+  return out.replace(/[\u0001-\u0014]/g, (c) => back[c] || c);
+}
+
+/** STR_TO_DATE / TO_DATE：按格式串反解出 Date */
+function strToDate(s, fmt) {
+  const spec = {
+    Y: '(\\d{4})', y: '(\\d{2})', m: '(\\d{1,2})', c: '(\\d{1,2})',
+    d: '(\\d{1,2})', e: '(\\d{1,2})',
+    H: '(\\d{1,2})', k: '(\\d{1,2})', h: '(\\d{1,2})', I: '(\\d{1,2})', l: '(\\d{1,2})',
+    i: '(\\d{1,2})', S: '(\\d{1,2})', s: '(\\d{1,2})',
+    M: '([A-Za-z]+)', b: '([A-Za-z]+)', p: '(?:AM|PM|am|pm)?',
+  };
+  let pattern = '';
+  const order = [];
+  for (let i = 0; i < String(fmt).length;) {
+    if (String(fmt)[i] === '%' && i + 1 < String(fmt).length) {
+      const c = String(fmt)[i + 1];
+      if (c === '%') { pattern += '%'; i += 2; continue; }
+      if (spec[c]) { pattern += spec[c]; order.push(c); i += 2; continue; }
+      pattern += c; i += 2; continue;
+    }
+    pattern += String(fmt)[i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    i++;
+  }
+  const m = new RegExp('^' + pattern + '$').exec(String(s));
+  if (!m) return null;
+  let year = 1970, month = 0, day = 1, hour = 0, min = 0, sec = 0;
+  order.forEach((c, idx) => {
+    const v = m[idx + 1];
+    if (v === undefined) return;
+    switch (c) {
+      case 'Y': year = Number(v); break;
+      case 'y': year = Number(v) < 70 ? 2000 + Number(v) : 1900 + Number(v); break;
+      case 'm': case 'c': month = Number(v) - 1; break;
+      case 'M': case 'b': {
+        const mi = MONTH_NAMES.findIndex((x) => x.toLowerCase().startsWith(String(v).toLowerCase().slice(0, 3)));
+        if (mi >= 0) month = mi;
+        break;
+      }
+      case 'd': case 'e': day = Number(v); break;
+      case 'H': case 'k': hour = Number(v); break;
+      case 'h': case 'I': case 'l': {
+        const hh = Number(v) % 12;
+        hour = /pm/i.test(String(s)) ? hh + 12 : hh;
+        break;
+      }
+      case 'i': min = Number(v); break;
+      case 'S': case 's': sec = Number(v); break;
+      default: break;
+    }
+  });
+  const d = new Date(year, month, day, hour, min, sec);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+/** PG DATE_PART / EXTRACT 的部件取值 */
+function pgDatePart(part, d) {
+  switch (String(part).toLowerCase()) {
+    case 'year': case 'y': return d.getFullYear();
+    case 'month': case 'mon': case 'mm': return d.getMonth() + 1;
+    case 'day': case 'dd': case 'd': return d.getDate();
+    case 'hour': case 'hh': return d.getHours();
+    case 'minute': case 'mi': return d.getMinutes();
+    case 'second': case 'ss': return d.getSeconds();
+    case 'dow': return d.getDay();
+    case 'doy': return Math.round((d - new Date(d.getFullYear(), 0, 0)) / 86400000);
+    case 'quarter': return Math.floor(d.getMonth() / 3) + 1;
+    case 'epoch': return Math.floor(d.getTime() / 1000);
+    case 'week': {
+      // ISO 8601 周序号
+      const t = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+      const dayNr = (t.getDay() + 6) % 7;
+      t.setDate(t.getDate() - dayNr + 3);
+      const firstThursday = new Date(t.getFullYear(), 0, 4);
+      const fdayNr = (firstThursday.getDay() + 6) % 7;
+      firstThursday.setDate(firstThursday.getDate() - fdayNr + 3);
+      return 1 + Math.round((t - firstThursday) / (7 * 86400000));
+    }
+    default: return null;
+  }
+}
+
+/** PG AGE(from, to) 的间隔文本：'6 years 7 mons 11 days' */
+function pgAge(from, to) {
+  let years = to.getFullYear() - from.getFullYear();
+  let months = to.getMonth() - from.getMonth();
+  let days = to.getDate() - from.getDate();
+  if (days < 0) {
+    months -= 1;
+    days += new Date(to.getFullYear(), to.getMonth(), 0).getDate();
+  }
+  if (months < 0) { years -= 1; months += 12; }
+  return `${years} years ${months} mons ${days} days`;
+}
+
 function applyScalarFunction(fnNode, row, ctx) {
   const name = (fnNode.name || '').toUpperCase();
   const rawArgs = fnNode.args || [];
@@ -2456,9 +2697,11 @@ function applyScalarFunction(fnNode, row, ctx) {
     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);
+    // NOW() / CURDATE() / CURTIME() 返回会话时区（本地）时间，不能用 toISOString()（UTC）——
+    // 否则东八区凌晨会整整差一天（2024-02-29 被存成 2024-02-28）。
+    case 'NOW': case 'CURRENT_TIMESTAMP': return sqlLocalDateTime();
+    case 'CURDATE': case 'CURRENT_DATE': return sqlLocalDateTime().slice(0, 10);
+    case 'CURTIME': return sqlLocalDateTime().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': {
@@ -2527,6 +2770,178 @@ function applyScalarFunction(fnNode, row, ctx) {
       }
       return fmtSqlDate(isDateOnly, d);
     }
+    // ===== 日期/时间（补齐 README 契约：此前这些全部缺失，静默返回 null）=====
+    case 'YEAR': {
+      const d = parseSqlDate(args[0]);
+      return d ? d.getFullYear() : null;
+    }
+    case 'MONTH': {
+      const d = parseSqlDate(args[0]);
+      return d ? d.getMonth() + 1 : null;
+    }
+    case 'DAY': case 'DAYOFMONTH': {
+      const d = parseSqlDate(args[0]);
+      return d ? d.getDate() : null;
+    }
+    case 'HOUR': {
+      const d = parseSqlDate(args[0]);
+      return d ? d.getHours() : null;
+    }
+    case 'MINUTE': {
+      const d = parseSqlDate(args[0]);
+      return d ? d.getMinutes() : null;
+    }
+    case 'SECOND': {
+      const d = parseSqlDate(args[0]);
+      return d ? d.getSeconds() : null;
+    }
+    case 'QUARTER': {
+      const d = parseSqlDate(args[0]);
+      return d ? Math.floor(d.getMonth() / 3) + 1 : null;
+    }
+    case 'WEEK': {
+      const d = parseSqlDate(args[0]);
+      if (!d) return null;
+      const mode = args[1] != null ? Number(args[1]) : 0;
+      // mode 1/3（周一为一周之始且首周需 ≥4 天）走 ISO 周序；其余按 MySQL 默认 mode 0
+      if (mode === 1 || mode === 3) return pgDatePart('week', d);
+      // mode 0：周日为一周之始，第 1 周是本年第一个含周日的周（之前为第 0 周）
+      const jan1Dow = new Date(d.getFullYear(), 0, 1).getDay();   // 0=周日
+      const firstSunday = jan1Dow === 0 ? 1 : 8 - jan1Dow;
+      const doy = Math.round((d - new Date(d.getFullYear(), 0, 0)) / 86400000);
+      if (doy < firstSunday) return 0;
+      return Math.floor((doy - firstSunday) / 7) + 1;
+    }
+    case 'DAYOFWEEK': {   // MySQL：1=周日 … 7=周六
+      const d = parseSqlDate(args[0]);
+      return d ? d.getDay() + 1 : null;
+    }
+    case 'DATE': {
+      const d = parseSqlDate(args[0]);
+      return d ? fmtSqlDate(true, d) : null;
+    }
+    case 'TIME': {
+      const d = parseSqlDate(args[0]);
+      return d ? pad2(d.getHours()) + ':' + pad2(d.getMinutes()) + ':' + pad2(d.getSeconds()) : null;
+    }
+    case 'DATEDIFF': {
+      const a = parseSqlDate(args[0]);
+      const b = parseSqlDate(args[1]);
+      if (!a || !b) return null;
+      // MySQL 语义：按日期相减（忽略时间部分）
+      const ua = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
+      const ub = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());
+      return Math.round((ua - ub) / 86400000);
+    }
+    case 'TIMESTAMPDIFF': {
+      // unit 允许写成裸关键字（TIMESTAMPDIFF(MONTH, a, b)），此时会被解析成列名而取不到值，
+      // 回退用列名文本；不影响真正名为 month/year 的列。
+      const raw0 = rawArgs[0];
+      const unit = String(args[0] != null ? args[0]
+        : (raw0 && raw0.type === 'column' ? raw0.name : '') || '').toUpperCase();
+      // MySQL 语义：TIMESTAMPDIFF(unit, start, end) = end - start
+      const a = parseSqlDate(args[2]);
+      const b = parseSqlDate(args[1]);
+      if (!a || !b) return null;
+      const ms = a.getTime() - b.getTime();
+      const months = (a.getFullYear() - b.getFullYear()) * 12 + (a.getMonth() - b.getMonth());
+      switch (unit) {
+        case 'MICROSECOND': return Math.floor(ms * 1000);
+        case 'SECOND': return Math.floor(ms / 1000);
+        case 'MINUTE': return Math.floor(ms / 60000);
+        case 'HOUR': return Math.floor(ms / 3600000);
+        case 'DAY': return Math.floor(ms / 86400000);
+        case 'WEEK': return Math.floor(ms / (86400000 * 7));
+        case 'MONTH': return months;
+        case 'QUARTER': return Math.floor(months / 3);
+        case 'YEAR': return a.getFullYear() - b.getFullYear();
+        default: return null;
+      }
+    }
+    case 'DATE_FORMAT': {
+      const d = parseSqlDate(args[0]);
+      return d ? strftime(d, String(args[1] || '%Y-%m-%d')) : null;
+    }
+    case 'STR_TO_DATE': {
+      const d = strToDate(String(args[0] == null ? '' : args[0]), String(args[1] || ''));
+      return d ? fmtSqlDate(!/%[HhIiklsS]/.test(String(args[1] || '')), d) : null;
+    }
+    case 'TO_CHAR': {   // PG：TO_CHAR(d, fmt) —— 格式串用 PG 风格（YYYY-MM-DD）
+      const d = parseSqlDate(args[0]);
+      return d ? strftime(d, pgFmtToMysql(args[1] || '%Y-%m-%d')) : null;
+    }
+    case 'TO_DATE': {   // PG：TO_DATE(s, fmt)
+      const d = strToDate(String(args[0] == null ? '' : args[0]), pgFmtToMysql(String(args[1] || '')));
+      return d ? fmtSqlDate(true, d) : null;
+    }
+    case 'DATE_PART': { // PG：DATE_PART('year', d)
+      const d = parseSqlDate(args[1]);
+      return d ? pgDatePart(args[0], d) : null;
+    }
+    case 'AGE': {       // PG：AGE(a, b) —— a 相对 b 的间隔
+      const a = parseSqlDate(args[0]);
+      const b = args[1] !== undefined && args[1] !== null ? parseSqlDate(args[1]) : new Date();
+      return (a && b) ? pgAge(b, a) : null;
+    }
+    case 'FROM_UNIXTIME': {
+      const ts = Number(args[0]);
+      if (!Number.isFinite(ts)) return null;
+      const d = new Date(ts * 1000);
+      return args[1] !== undefined && args[1] !== null ? strftime(d, String(args[1])) : fmtSqlDate(false, d);
+    }
+    case 'LAST_DAY': {
+      const d = parseSqlDate(args[0]);
+      return d ? fmtSqlDate(true, new Date(d.getFullYear(), d.getMonth() + 1, 0)) : null;
+    }
+    case 'WEEKDAY': {   // MySQL：0=周一 … 6=周日
+      const d = parseSqlDate(args[0]);
+      return d ? (d.getDay() + 6) % 7 : null;
+    }
+    case 'DAYOFYEAR': {
+      const d = parseSqlDate(args[0]);
+      return d ? Math.round((d - new Date(d.getFullYear(), 0, 0)) / 86400000) : null;
+    }
+    case 'DAYNAME': {
+      const d = parseSqlDate(args[0]);
+      return d ? DAY_NAMES[d.getDay()] : null;
+    }
+    case 'MONTHNAME': {
+      const d = parseSqlDate(args[0]);
+      return d ? MONTH_NAMES[d.getMonth()] : null;
+    }
+    case 'MAKEDATE': {
+      const y = Number(args[0]);
+      const doy = Number(args[1]);
+      if (!Number.isFinite(y) || !Number.isFinite(doy)) return null;
+      const d = new Date(y, 0, 1);
+      d.setDate(doy);
+      return fmtSqlDate(true, d);
+    }
+    case 'PERIOD_DIFF': {
+      const p1 = String(args[0] == null ? '' : args[0]);
+      const p2 = String(args[1] == null ? '' : args[1]);
+      if (!/^\d{6}$/.test(p1) || !/^\d{6}$/.test(p2)) return null;
+      return (Number(p1.slice(0, 4)) * 12 + Number(p1.slice(4))) -
+             (Number(p2.slice(0, 4)) * 12 + Number(p2.slice(4)));
+    }
+    case 'DATE_TRUNC': { // PG：DATE_TRUNC('month', d)
+      const part = String(args[0] || '').toLowerCase();
+      const d = parseSqlDate(args[1]);
+      if (!d) return null;
+      let nd;
+      switch (part) {
+        case 'year': nd = new Date(d.getFullYear(), 0, 1); break;
+        case 'quarter': nd = new Date(d.getFullYear(), Math.floor(d.getMonth() / 3) * 3, 1); break;
+        case 'month': nd = new Date(d.getFullYear(), d.getMonth(), 1); break;
+        case 'week': { const wd = (d.getDay() + 6) % 7; nd = new Date(d.getFullYear(), d.getMonth(), d.getDate() - wd); break; }
+        case 'day': nd = new Date(d.getFullYear(), d.getMonth(), d.getDate()); break;
+        case 'hour': nd = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours()); break;
+        case 'minute': nd = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes()); break;
+        case 'second': nd = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds()); break;
+        default: return null;
+      }
+      return fmtSqlDate(false, nd);
+    }
     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]);
@@ -2633,6 +3048,57 @@ function likeMatch(value, pattern, ci = true, escape = '\\') {
   return new RegExp('^' + out + '$', ci ? 'i' : '').test(value);
 }
 
+/** 解析 PG 的路径字面量：'{a,b}' 或数组 → ['a','b'] */
+function parsePgPath(key) {
+  if (Array.isArray(key)) return key.map(String);
+  if (typeof key === 'string') {
+    const s = key.trim();
+    if (s.startsWith('{') && s.endsWith('}')) {
+      return s.slice(1, -1).split(',').map(x => x.trim().replace(/^"(.*)"$/, '$1')).filter(x => x !== '');
+    }
+    return [s];
+  }
+  return [String(key)];
+}
+
+/** 把可能是 JSON 字符串的值归一为 JS 值 */
+function toJsonValue(v) {
+  if (typeof v === 'string') { try { return JSON.parse(v); } catch (e) { return v; } }
+  return v;
+}
+
+/** JSON 包含语义（PG 的 @> / <@）。swap=true 时判断 target 是否包含 container。 */
+function jsonContains(a, b, swap) {
+  const container = toJsonValue(swap ? b : a);
+  const target = toJsonValue(swap ? a : b);
+  return jsonContainsValue(container, target);
+}
+
+function jsonContainsValue(container, target) {
+  if (target === null || target === undefined) return true;
+  if (Array.isArray(target)) {
+    if (!Array.isArray(container)) return false;
+    return target.every(t => container.some(c => jsonContainsValue(c, t)));
+  }
+  if (typeof target === 'object') {
+    if (container === null || typeof container !== 'object' || Array.isArray(container)) return false;
+    return Object.keys(target).every(k => Object.prototype.hasOwnProperty.call(container, k) && jsonContainsValue(container[k], target[k]));
+  }
+  if (Array.isArray(container)) return container.some(c => c === target || String(c) === String(target));
+  if (container !== null && typeof container === 'object') return false;
+  return container === target || String(container) === String(target);
+}
+
+/** JSON 键存在（PG 的 ? / ?| / ?&）。keys 为单个键名或 '{a,b}' 形式的键列表。 */
+function jsonKeyExists(base, keys, mode) {
+  const v = toJsonValue(base);
+  if (v === null || typeof v !== 'object' || Array.isArray(v)) return false;
+  const has = (k) => Object.prototype.hasOwnProperty.call(v, k);
+  if (mode === '?|') return parsePgPath(keys).some(has);
+  if (mode === '?&') return parsePgPath(keys).every(has);
+  return has(String(keys));
+}
+
 function extractEqualPushdown(expr, schema) {
   if (!expr || !schema) return null;
   const filter = {};
@@ -2683,7 +3149,11 @@ function evaluateExpr(expr, row, ctx) {
     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 'xor': return Boolean(evaluateExpr(expr.left, row, ctx)) !== Boolean(evaluateExpr(expr.right, row, ctx));
-    case 'not': return !evaluateExpr(expr.expr, row, ctx);
+    case 'not': {
+      // 三值逻辑：NOT UNKNOWN = UNKNOWN（返回 null，在 WHERE/ON/HAVING 中视为不选中）
+      const v = evaluateExpr(expr.expr, row, ctx);
+      return v === null ? null : !v;
+    }
     case 'compare': {
       const l = resolveOperand(expr.left, row, ctx);
       const r = resolveOperand(expr.right, row, ctx);
@@ -2694,13 +3164,23 @@ function evaluateExpr(expr, row, ctx) {
         if (ln || rn) return ln && rn;
         return l === r || String(l) === String(r);
       }
-      // SQL 标准：任何与 NULL 的比较结果为 UNKNOWN（在 WHERE/ON/HAVING 中视为 false）
-      if (l === null || r === null) return false;
+      // SQL 标准：与 NULL 的比较结果是 UNKNOWN，这里用 null 表示。
+      // 不能返回 false —— 否则 NOT (a > 1) 会把 a 为 NULL 的行错误纳入结果。
+      if (l === null || l === undefined || r === null || r === undefined) return null;
       // 布尔与数值互通（MySQL: 1 = TRUE、0 = FALSE）
       const nl = normalizeCmpValue(l, r);
       const nr = normalizeCmpValue(r, l);
-      if (expr.op === '=') return nl === nr || String(nl) === String(nr);
+      const isNum = (v) => typeof v === 'number';
+      const isNumStr = (v) => typeof v === 'string' && String(v).trim() !== '' && Number.isFinite(Number(v));
+      // 数值 vs 数值字符串（age < '10'、age = '09'）必须按数值比，
+      // 否则退化成字典序：'9' < '10' 为 false、'9' = '09' 为 false
+      const mixedNum = (isNum(nl) && isNumStr(nr)) || (isNumStr(nl) && isNum(nr));
+      if (expr.op === '=') {
+        if (mixedNum) return Number(nl) === Number(nr);
+        return nl === nr || String(nl) === String(nr);
+      }
       const fn = OPERATORS[expr.op];
+      if (mixedNum) return fn(Number(nl), Number(nr));
       return typeof nl === 'number' && typeof nr === 'number' ? fn(nl, nr) : fn(String(nl), String(nr));
     }
     case 'isNull': {
@@ -2712,22 +3192,30 @@ function evaluateExpr(expr, row, ctx) {
       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));
+      const r = expr.list.some(x => x === v || String(x) === String(v));
+      return expr.not ? !r : r;   // NOT IN：此前漏了取反，导致 NOT IN 与 IN 结果相同
     }
     case 'like': {
       const v = resolveOperand(expr.operand, row, ctx);
-      const r = likeMatch(v, expr.pattern, !!expr.ci, expr.escape);
+      // MySQL 的 LIKE 默认不区分大小写；只有显式 BINARY / ci=false 才敏感。
+      // 此前写成 !!expr.ci，把 likeMatch 的 ci 默认值 true 覆盖成了 false。
+      const r = likeMatch(v, expr.pattern, expr.ci !== false, expr.escape);
       return expr.not ? !r : r;
     }
     case 'quantified':
       return !!resolveOperand(expr, row, ctx);
+    case 'jsonContains':
+      return !!resolveOperand(expr, row, ctx);
     case 'regexp': {
       const v = resolveOperand(expr.operand, row, ctx);
       if (v === null || v === undefined) return false;
-      const re = new RegExp(String(expr.pattern), 'i');
+      // REGEXP / RLIKE 历史上就是大小写不敏感的；`~` 敏感、`~*` 不敏感
+      const re = new RegExp(String(expr.pattern), expr.ci === false ? '' : 'i');
       const r = re.test(String(v));
       return expr.not ? !r : r;
     }
+    case 'jsonKeyExists':
+      return !!resolveOperand(expr, row, ctx);
     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);
@@ -3013,9 +3501,30 @@ class SQLExecutor {
           dataRows = dataRows.map(stripDefault);
         }
         const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
+        const uniqueCols = schema ? Object.keys(schema).filter(k => schema[k].unique && !schema[k].primaryKey) : [];
         let toInsert = dataRows;
         let updated = 0;
         let skipped = 0;
+        // 非主键 UNIQUE 约束：默认动作（无 ON CONFLICT / IGNORE / REPLACE）下违反即 ER_DUP_ENTRY。
+        // 主键冲突由下面的冲突逻辑处理；这里补唯一列（含批内重复）。
+        if (uniqueCols.length > 0 && this._conflictAction(statement) === 'throw') {
+          const existing = (await this.engine.find(statement.name, {}, { limit: 1e9, offset: 0 }))
+            .map(r => normalizeRow(r, schema));
+          for (const col of uniqueCols) {
+            const used = new Set();
+            for (const r of existing) {
+              const v = r[col];
+              if (v !== undefined && v !== null) used.add(String(v));
+            }
+            for (const d of dataRows) {
+              const v = d[col];
+              if (v === undefined || v === null) continue;   // UNIQUE 允许多个 NULL
+              const s = String(v);
+              if (used.has(s)) throw new Error(`ER_DUP_ENTRY: Duplicate entry '${s}' for unique column '${col}'`);
+              used.add(s);
+            }
+          }
+        }
         if (pkCols.length > 0) {
           const keyOf = (row) => pkCols.map(c => (row[c] !== undefined && row[c] !== null ? String(row[c]) : '')).join('|');
           const hasExplicitPk = (row) => pkCols.some(c => row[c] !== undefined && row[c] !== null);
@@ -3028,11 +3537,8 @@ class SQLExecutor {
             : null;
           const extraIdx = [];
           if (ocTarget && ocTarget.length) extraIdx.push(ocTarget);
-          else if (statement.onDuplicate && schema) {
-            for (const [c, def] of Object.entries(schema)) {
-              if (def && def.unique && !def.primaryKey) extraIdx.push([c]);
-            }
-          }
+          // 唯一列始终参与冲突判定（PG 的 ON CONFLICT 与 MySQL 的 ON DUPLICATE 都包含唯一键）
+          for (const c of uniqueCols) extraIdx.push([c]);
           const hasAllOf = (cols) => (row) => cols.every(c => row[c] !== undefined && row[c] !== null);
 
           const explicit = dataRows.filter((row) => hasExplicitPk(row) || extraIdx.some((cols) => hasAllOf(cols)(row)));
@@ -3918,8 +4424,25 @@ class SQLExecutor {
     }
     if (fn === 'SUM') return values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0);
     if (fn === 'AVG') return values.length ? values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0) / values.length : null;
-    if (fn === 'MIN') return values.length ? Math.min(...values.map(v => Number(v))) : null;
-    if (fn === 'MAX') return values.length ? Math.max(...values.map(v => Number(v))) : null;
+    if (fn === 'MIN' || fn === 'MAX') {
+      const vs = values.filter(v => v !== null && v !== undefined);
+      if (!vs.length) return null;
+      // 数值按数值比；字符串/日期按字典序/时间序。
+      // 此前一律 Number(v) —— 字符串列会得到 NaN，MIN(name) 直接变 null。
+      const numeric = (v) => typeof v === 'number' ||
+        (typeof v === 'string' && String(v).trim() !== '' && Number.isFinite(Number(v)));
+      if (vs.every(numeric)) {
+        const nums = vs.map(v => Number(v));
+        return fn === 'MIN' ? Math.min(...nums) : Math.max(...nums);
+      }
+      let best = vs[0];
+      for (const v of vs.slice(1)) {
+        const a = String(v);
+        const b = String(best);
+        if (fn === 'MIN' ? a < b : a > b) best = v;
+      }
+      return best;
+    }
     if (fn === 'FIRST') return values.length ? values[0] : null;
     if (fn === 'LAST') return values.length ? values[values.length - 1] : null;
     if (fn === 'GROUP_CONCAT') {
@@ -4058,6 +4581,15 @@ class SQLExecutor {
     if (!sample || typeof sample !== 'object') return;
     const known = new Set();
     for (const k of Object.keys(sample)) known.add(String(k).toLowerCase());
+    // 相关子查询：外层行的列也算已知。
+    // _evalCorrelated 会把外层行挂到 ctx.__outer，子查询（`WHERE EXISTS (SELECT ... WHERE b.av = a.v)`）
+    // 里的 `a.v` 属于外层作用域，不在本层 rows 里，不纳入就会误报 no such column。
+    const outer = this.ctx && this.ctx.__outer;
+    if (outer && typeof outer === 'object') {
+      for (const k of Object.keys(outer)) known.add(String(k).toLowerCase());
+    }
+    // 本层 FROM 的表名/别名，用于判断限定引用是否指向外层
+    const localAliases = this._outerAliases(statement);
     // HAVING / ORDER BY 允许引用 SELECT 的输出别名（如 HAVING cnt >= 1），
     // 这些名字不在表里，必须一并视为已知，否则会误报 no such column
     if (Array.isArray(statement.columns)) {
@@ -4073,7 +4605,11 @@ class SQLExecutor {
       if (node.type === 'select' || node.type === 'subquery') return;
       if (node.type === 'column' && typeof node.name === 'string') {
         const n = node.name.toLowerCase();
-        const base = n.indexOf('.') >= 0 ? n.slice(n.indexOf('.') + 1) : n;
+        const dot = n.indexOf('.');
+        const base = dot >= 0 ? n.slice(dot + 1) : n;
+        // 限定列引用了本层 FROM 之外的表/别名 → 属于外层作用域（相关子查询），放行。
+        // 否则 `WHERE EXISTS (SELECT 1 FROM b WHERE b.av = a.v)` 里的 a.v 会被误杀。
+        if (dot >= 0 && !localAliases.has(n.slice(0, dot))) return;
         if (!known.has(n) && !known.has(base)) {
           throw new Error(`no such column: ${node.name}`);
         }
@@ -4504,16 +5040,16 @@ class SQLExecutor {
         const rightNulls = (rightRes.schema) ? this._nullPrefixedRow(rightRes.schema, rightPrefix) : null;
         const leftNulls = (rowsAll && rowsAll.schema) ? this._nullPrefixedRow(rowsAll.schema, firstPrefix) : null;
         rows.forEach(l => {
-          let m = null;
+          // 一对多：一个左行可能匹配多个右行，必须全部收进来（此前只取第一个）
+          const hits = [];
           for (let ri = 0; ri < rightRows.length; ri++) {
-            if (evaluateExpr(j.on, { ...l, ...rightRows[ri] })) {
-              m = ri;
-              break;
-            }
+            if (evaluateExpr(j.on, { ...l, ...rightRows[ri] })) hits.push(ri);
           }
-          if (m !== null) {
-            matched.push({ ...l, ...rightRows[m] });
-            unmatchedRight.delete(m);
+          if (hits.length > 0) {
+            for (const ri of hits) {
+              matched.push({ ...l, ...rightRows[ri] });
+              unmatchedRight.delete(ri);
+            }
           } else if (j.type === 'left' || j.type === 'full') {
             matched.push(rightNulls ? { ...rightNulls, ...l } : { ...l });
           }
@@ -4561,6 +5097,14 @@ class SQLExecutor {
       });
     }
 
+    // 无 GROUP BY 时整张表就是一个分组。必须先给每行挂上 _group=全表，
+    // 否则 HAVING 里的 COUNT(*) 会被逐行算成 1（r._group || [r]），
+    // 于是 HAVING COUNT(*) > 2 会把所有行滤掉、最终输出 0 而不是真实计数。
+    if (statement.having && !statement.groupBy) {
+      const wholeTable = rows.slice();
+      rows = rows.map((r) => ({ ...r, _group: wholeTable }));
+    }
+
     if (statement.having) {
       const havingAst = JSON.parse(JSON.stringify(statement.having));
       rows = rows.filter(r => {
@@ -4589,6 +5133,10 @@ class SQLExecutor {
       const seen = new Set();
       rows = rows.filter(r => {
         const key = JSON.stringify(statement.columns.map(c => {
+          // SELECT DISTINCT *：按整行去重（此前把 '*' 当列名解析成 null，导致所有行同 key 只剩 1 行）
+          if (c.expr === '*') {
+            return Object.keys(r).filter(k => !String(k).startsWith('_')).sort().map(k => r[k]);
+          }
           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, c.distinct, c.separator, c.orderBy);
@@ -4605,6 +5153,11 @@ class SQLExecutor {
     // 注意：带 OVER 的聚合是窗口函数，不是“整表塌缩成一行”的聚合，必须排除
     if (!statement.groupBy && (statement.columns.some(c => c.aggregate && !c.window) || hasCustomAgg)) {
       const cols = statement.columns.map(c => scalarColumnName(c));
+      const tableName2 = statement.from ? (statement.from.tables[0].table || null) : null;
+      // HAVING 判定不通过时 rows 已为空，此时整表聚合也应为空，不能无条件补一行
+      if (statement.having && rows.length === 0) {
+        return { ok: true, type: 'select', table: tableName2, columns: cols, rows: [], aggregate: statement.aggregate };
+      }
       const valueOf = (c) => {
         if (c.aggregate) return this._aggValue(rows, c.aggregate || 'COUNT', c.column, c.distinct, c.separator, c.orderBy);
         if (c.scalar && c.scalar.type === 'func' && hasCustomAgg) {
@@ -4618,7 +5171,7 @@ class SQLExecutor {
         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 };
+      return { ok: true, type: 'select', table: tableName2, columns: cols, rows: [[...statement.columns.map(valueOf)]], aggregate: statement.aggregate };
     }
 
     // GROUP BY 输出：每组的列（含聚合列）
@@ -4636,10 +5189,20 @@ class SQLExecutor {
     }
 
     if (statement.orderBy) {
-      // ORDER BY 项可能是列名字符串，也可能是表达式节点
-      const ordVal = (row, o) => (typeof o.column === 'string'
-        ? resolveOperand({ type: 'column', name: o.column }, row, this.ctx)
-        : resolveOperand(o.column, row, this.ctx));
+      // ORDER BY 项可能是列名字符串、表达式节点，或列的位置序号（ORDER BY 1，1-based）
+      const ordNames = statement.columns.map(c => scalarColumnName(c));
+      const ordVal = (row, o) => {
+        const pos = (o.column && typeof o.column === 'object' && o.column.type === 'value' && typeof o.column.value === 'number')
+          ? o.column.value
+          : (typeof o.column === 'number' ? o.column : null);
+        if (pos !== null && pos !== undefined) {
+          const name = ordNames[pos - 1];
+          if (name !== undefined && name !== null) return resolveOperand({ type: 'column', name }, row, this.ctx);
+        }
+        return typeof o.column === 'string'
+          ? resolveOperand({ type: 'column', name: o.column }, row, this.ctx)
+          : resolveOperand(o.column, row, this.ctx);
+      };
       const cmp = (a, b) => {
         for (const o of statement.orderBy) {
           const av = ordVal(a, o);
@@ -4690,53 +5253,88 @@ class SQLExecutor {
   }
 }
 
-function splitStatements(sql) {
-  const statements = [];
-  let current = '';
-  let inStr = null;   // "'" | '"' | '`'
-  let i = 0;
-  while (i < sql.length) {
+/** 跳过一个引号串（含转义/反引号成对），返回闭合引号之后的下标 */
+function skipQuoted(sql, i, q) {
+  const n = sql.length;
+  i++;   // 跳过起始引号
+  while (i < n) {
     const c = sql[i];
-    if (inStr) {
-      current += c;
-      if (inStr === '`') {
-        // 反引号标识符内部反斜杠不是转义符；两个连续反引号才表示一个字面反引号。
-        if (c === '`' && sql[i + 1] === '`') { current += sql[i + 1]; i += 2; continue; }
-        if (c === '`') inStr = null;
-        i++;
-        continue;
+    if (q === '`') {
+      // 反引号标识符内部反斜杠不是转义符；两个连续反引号表示一个字面反引号。
+      if (c === '`') {
+        if (sql[i + 1] === '`') { i += 2; continue; }
+        return i + 1;
       }
-      if (c === '\\' && i + 1 < sql.length) { current += sql[i + 1]; i += 2; continue; }
-      if (c === inStr) inStr = null;
       i++;
       continue;
     }
-    if (c === "'" || c === '"' || c === '`') { inStr = c; current += c; i++; continue; }
+    if (c === '\\') { i += 2; continue; }
+    if (c === q) return i + 1;
+    i++;
+  }
+  return n;   // 未闭合：到结尾
+}
+
+function splitStatements(sql, opts = {}) {
+  if (typeof sql !== 'string') {
+    throw new Error('splitStatements: sql must be a string');
+  }
+  const maxLength = opts.maxLength == null ? DEFAULT_MAX_SQL_LENGTH : opts.maxLength;
+  if (typeof maxLength === 'number' && Number.isFinite(maxLength) && sql.length > maxLength) {
+    throw new Error(
+      `SQL text too large: ${sql.length} chars exceeds limit of ${maxLength} ` +
+      `(raise opts.maxSqlLength to allow larger input)`
+    );
+  }
+  const statements = [];
+  // 用「区间切片」收集，而不是逐字符拼接：既避免 `current += c` 的 O(n²) 拷贝放大，
+  // 也避免为每个字符建一个小字符串对象（20MB 无分号输入下两者都会打爆默认堆）。
+  let parts = [];
+  const take = end => { parts.push(sql.slice(segStart, end)); };
+  const flush = () => {
+    if (parts.length === 0) return;
+    const stmt = parts.join('').trim();
+    parts = [];
+    if (stmt) statements.push(stmt);
+  };
+
+  let segStart = 0;
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const c = sql[i];
+    if (c === "'" || c === '"' || c === '`') { i = skipQuoted(sql, i, c); continue; }
     if (c === '-' && sql[i + 1] === '-') {
-      while (i < sql.length && sql[i] !== '\n') i++;
+      // 行注释：丢弃注释文本本身（与原实现一致），保留其后的换行
+      take(i);
+      while (i < n && sql[i] !== '\n') i++;
+      segStart = i;
       continue;
     }
-    if (c === '#') {
-      while (i < sql.length && sql[i] !== '\n') i++;
+    if (c === '#' && sql[i + 1] !== '>') {
+      take(i);
+      while (i < n && sql[i] !== '\n') i++;
+      segStart = i;
       continue;
     }
     if (c === '/' && sql[i + 1] === '*') {
-      current += '/*';
+      // 块注释：原实现会保留 `/* */` 原文，这里通过切片一并保留
       i += 2;
-      while (i + 1 < sql.length && !(sql[i] === '*' && sql[i + 1] === '/')) { current += sql[i]; i++; }
-      if (i + 1 < sql.length) { current += '*/'; i += 2; }
+      while (i + 1 < n && !(sql[i] === '*' && sql[i + 1] === '/')) i++;
+      i = i + 1 < n ? i + 2 : n;
       continue;
     }
     if (c === ';') {
-      if (current.trim()) statements.push(current.trim());
-      current = '';
+      take(i);
+      flush();
       i++;
+      segStart = i;
       continue;
     }
-    current += c;
     i++;
   }
-  if (current.trim()) statements.push(current.trim());
+  take(n);
+  flush();
   return statements;
 }
 
@@ -4763,7 +5361,7 @@ function hasComments(sql) {
     if (c === "'" || c === '"') { inStr = c; i++; continue; }
     if (c === '`') { i++; while (i < sql.length && sql[i] !== '`') i++; i++; continue; }
     if (c === '-' && sql[i + 1] === '-') return true;
-    if (c === '#') return true;
+    if (c === '#' && sql[i + 1] !== '>') return true;   // '#>' / '#>>' 是 JSON 操作符，不是注释
     if (c === '/' && sql[i + 1] === '*') return true;
     i++;
   }
@@ -4812,16 +5410,34 @@ function applyParams(sql, values) {
   if (args && typeof args === 'object' && !Array.isArray(args)) {
     hasNamed = true;
   }
-  while (i < sql.length) {
+  const n = sql.length;
+  while (i < n) {
     const c = sql[i];
     if (inStr) {
       out += c;
-      if (c === '\\' && i + 1 < sql.length) { out += sql[i + 1]; i += 2; continue; }
+      if (c === '\\' && i + 1 < n) { out += sql[i + 1]; i += 2; continue; }
       if (c === inStr) inStr = null;
       i++;
       continue;
     }
     if (c === "'" || c === '"' || c === '`') { inStr = c; out += c; i++; continue; }
+    // 跳过注释：`--` 和 `#`（但 `#>` / `#>>` 是 JSON 操作符，不是注释）
+    if (c === '-' && sql[i + 1] === '-') {
+      // 行注释：整段跳过，保留换行（不在注释里的字符不进入 out）
+      while (i < n && sql[i] !== '\n') i++;
+      continue;
+    }
+    if (c === '#' && sql[i + 1] !== '>') {
+      while (i < n && sql[i] !== '\n') i++;
+      continue;
+    }
+    if (c === '/' && sql[i + 1] === '*') {
+      // 块注释：整段跳过
+      i += 2;
+      while (i + 1 < n && !(sql[i] === '*' && sql[i + 1] === '/')) i++;
+      if (i + 1 < n) i += 2; else i = n;
+      continue;
+    }
     if (c === '?' && sql[i + 1] === '?') {
       if (!hasNamed && idx >= args.length) throw new Error('Not enough parameters for SQL: expected ' + (count + 1));
       out += escapeId(hasNamed ? args['@@'] : args[idx++]);
@@ -4854,6 +5470,24 @@ function applyParams(sql, values) {
       i++;
       continue;
     }
+    // $N 编号占位符（PG 风格）：$1 / $2 ...
+    if (c === '$' && i + 1 < sql.length && sql[i + 1] >= '0' && sql[i + 1] <= '9') {
+      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 ((c === ':' || c === '@' || c === '$') && i + 1 < sql.length && /[A-Za-z_]/.test(sql[i + 1])) {
       // 命名占位符 :name @name $name
       let name = '';
@@ -4936,14 +5570,19 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
   if (Array.isArray(paramsOrOpts)) {
     sql = applyParams(sql, paramsOrOpts);
   } else if (paramsOrOpts && typeof paramsOrOpts === 'object') {
-    opts = paramsOrOpts;
+    // 第三参为对象时：含已知 opts 键 → 视为 opts；否则视为命名参数（{id: 1} → :id / $id）
+    const OPTS_KEYS = ['safety', 'session', 'params', 'functions', 'aggregates',
+      'allowComments', 'maxStatements', 'maxSqlLength', 'context', 'timeout', 'dialect'];
+    const looksLikeOpts = Object.keys(paramsOrOpts).some(k => OPTS_KEYS.includes(k));
+    if (looksLikeOpts) opts = paramsOrOpts;
+    else sql = applyParams(sql, paramsOrOpts);
   }
   if (opts.safety !== false) {
     if (!opts.allowComments && hasComments(sql)) {
       throw new Error('SQL comments are disabled for security (--, #, /* */)');
     }
   }
-  let statements = splitStatements(sql);
+  let statements = splitStatements(sql, { maxLength: opts.maxSqlLength });
   if (opts.maxStatements != null && statements.length > opts.maxStatements) {
     throw new Error(`too many statements (${statements.length} > ${opts.maxStatements})`);
   }