jsql-neo 6.2.0 → 6.3.0

package/README.md

@@ -1056,10 +1056,15 @@ Coercion rules: numeric strings compare as numbers (`'5' = 5`), `NULL = NULL`
 `DAYOFWEEK`, `DAYNAME`, `MONTHNAME`, `UNIX_TIMESTAMP`, `FROM_UNIXTIME`.
 
 ```sql
-SELECT DATE_ADD('2026-08-12', INTERVAL 1 DAY);      -- '2026-08-13 00:00:00'
+SELECT DATE_ADD('2026-08-12', INTERVAL 1 DAY);         -- '2026-08-13'（纯日期进 → 纯日期出）
+SELECT DATE_ADD('2026-08-12 10:00:00', INTERVAL 1 DAY); -- '2026-08-13 10:00:00'
 SELECT DATE_FORMAT(NOW(), '%Y-%m-%d %H:%i');        -- '2026-08-12 10:30'
 SELECT EXTRACT(YEAR FROM '2026-08-12');             -- 2026
 SELECT AGE('2026-08-12', '2020-01-01');             -- '6 years 7 mons 11 days'
+SELECT DATEDIFF('2026-08-12', '2026-08-01');        -- 11
+SELECT TIMESTAMPDIFF(MONTH, '2026-01-01', '2026-08-01'); -- 7（end - start）
+SELECT TO_DATE('2026-08-12', 'YYYY-MM-DD');         -- '2026-08-12'（PG 格式串）
+SELECT DATE_TRUNC('month', '2026-08-12 10:30:00');  -- '2026-08-01 00:00:00'
 ```
 
 **Conditional / null** — `IF(cond, a, b)`, `IIF`, `IFNULL(a, b)`, `COALESCE(...)`, `NULLIF`,

package/lib/date-types.js

@@ -33,17 +33,37 @@ function validateDateType(value, type, fieldName) {
 // DATE: YYYY-MM-DD
 // ============================================================
 
+function pad2(n) { return String(n).padStart(2, '0'); }
+
+/**
+ * 本地时区的 'YYYY-MM-DD'。
+ * 不能用 toISOString().slice(0,10) —— 那是 UTC：东八区 2023-01-01 00:00 本地
+ * 会是 2022-12-31T16:00Z，切出来整整差一天（2024-02-29 → 2024-02-28）。
+ */
+function toLocalDateString(d) {
+    return d.getFullYear() + '-' + pad2(d.getMonth() + 1) + '-' + pad2(d.getDate());
+}
+
+/** 本地时区的 'YYYY-MM-DD HH:MM:SS'（同理不能用 toISOString） */
+function toLocalDateTimeString(d) {
+    return toLocalDateString(d) + ' ' +
+        pad2(d.getHours()) + ':' + pad2(d.getMinutes()) + ':' + pad2(d.getSeconds());
+}
+
 function validateDate(value, fieldName) {
     if (value instanceof Date) {
-        return value.toISOString().slice(0, 10);
+        return toLocalDateString(value);
     }
     if (typeof value === 'number') {
         // Unix timestamp → date
-        return new Date(value * 1000).toISOString().slice(0, 10);
+        return toLocalDateString(new Date(value * 1000));
     }
     if (typeof value === 'string') {
-        const d = parseDateString(value);
-        if (d) return d.toISOString().slice(0, 10);
+        const s = value.trim();
+        // 已是 YYYY-MM-DD：直接返回，避免本地→UTC 往返导致差一天
+        if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return s;
+        const d = parseDateString(s);
+        if (d) return toLocalDateString(d);
     }
     throw createError('ER_INVALID_DATE', fieldName, String(value));
 }
@@ -79,26 +99,23 @@ function parseDateString(str) {
 
 function validateDateTime(value, fieldName) {
     if (value instanceof Date) {
-        return value.toISOString().replace('T', ' ').slice(0, 19);
+        return toLocalDateTimeString(value);
     }
     if (typeof value === 'number') {
-        return new Date(value * 1000).toISOString().replace('T', ' ').slice(0, 19);
+        return toLocalDateTimeString(new Date(value * 1000));
     }
     if (typeof value === 'string') {
-        // ISO format: 2024-01-15T10:30:00.000Z
+        // ISO format: 2024-01-15T10:30:00.000Z（带时区标记，按字面取日期+时间）
         const isoMatch = value.match(/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})/);
         if (isoMatch) {
             return isoMatch[1] + ' ' + isoMatch[2];
         }
-        // MySQL format: YYYY-MM-DD HH:MM:SS
+        // MySQL format: YYYY-MM-DD HH:MM:SS —— 已是目标格式，原样返回
         const myMatch = value.match(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})$/);
-        if (myMatch) {
-            const d = new Date(value.replace(' ', 'T') + 'Z');
-            if (!isNaN(d.getTime())) return value;
-        }
+        if (myMatch) return value;
         const d = new Date(value);
         if (!isNaN(d.getTime())) {
-            return d.toISOString().replace('T', ' ').slice(0, 19);
+            return toLocalDateTimeString(d);
         }
     }
     throw createError('ER_INVALID_DATE', fieldName, String(value));

package/lib/sql.js

@@ -1969,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 };
@@ -2226,13 +2233,17 @@ 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 正则操作符（双目位置）：~（大小写敏感）/ ~*（不敏感）/ !~ / !~*
@@ -2416,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 时才走这条路径。
@@ -2512,6 +2529,149 @@ function fmtSqlDate(dateOnly, d) {
   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 || [];
@@ -2610,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]);
@@ -2817,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);
@@ -2828,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': {
@@ -2851,7 +3197,9 @@ function evaluateExpr(expr, row, ctx) {
     }
     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':
@@ -4076,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') {
@@ -4216,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)) {
@@ -4231,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}`);
         }
@@ -4719,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 => {
@@ -4767,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) {
@@ -4780,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 输出：每组的列（含聚合列）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",

package/postinstall.js

@@ -15,25 +15,36 @@ const BP = path.join(ROOT, 'bin', BIN_NAME);
 const NATIVE_PATH = path.join(ROOT, 'native', 'jsql-neo-native.node');
 
 // GitHub 加速代理前缀；加速站的用法是把原始 URL 直接拼在后面：
-//   https://<host>/https://github.com/owner/repo/releases/download/vX.Y.Z/asset?token=<TOKEN>
-// 可用环境变量覆盖 / 叠加（逗号分隔多个，按序尝试）；空字符串 '' 表示直连兜底。
+//   https://<host>/https://github.com/owner/repo/releases/download/vX.Y.Z/asset
+// 鉴权走 `Authorization: Bearer <token>` 请求头（Worker 从该头读取，不读 ?token=）。
+// 前缀可用 JSQL_GHPROXY 覆盖（逗号分隔多个，按序回退；'' 表示直连兜底）；
+// token 可用 JSQL_GHPROXY_TOKEN 覆盖。
 // 加速站候选（按优先级）：自建站优先，公共站回退，最后直连兜底。
 const DEFAULT_PROXIES = [
   'https://gh-proxyjsql-neoworkerapi.vexify.de5.net/',
   'https://gh-proxy.com/',
 ];
+// 内置 token：让所有安装者都自动走自建加速站，无需配置环境变量。
+// 加速站自身已限制只能代理 /releases/download/ 等文件下载路径，故该值公开无风险。
+const DEFAULT_GHPROXY_TOKEN =
+  'NkUbD165V_1iPvEeGRcAfNEv4cqv5WRLn1NfjgBzIMpo9gq5CBH10Rl5ZPmt7RGCh3kyaZU4Nc6pLhHHbvzc9w';
 const GHPROXY = process.env.JSQL_GHPROXY !== undefined
   ? process.env.JSQL_GHPROXY
   : DEFAULT_PROXIES[0];
-const GHPROXY_TOKEN = process.env.JSQL_GHPROXY_TOKEN || '';
+const GHPROXY_TOKEN = process.env.JSQL_GHPROXY_TOKEN || DEFAULT_GHPROXY_TOKEN;
 const TAG = `v${pkg.version}`;
 
+/** 加速站鉴权头 */
+function proxyHeaders() {
+  return GHPROXY_TOKEN ? { Authorization: 'Bearer ' + GHPROXY_TOKEN } : undefined;
+}
+
 /**
  * 生成候选下载地址列表（按优先级）：
- *   环境变量 JSQL_GHPROXY 指定的代理 → 内置加速站 → 直连
+ *   JSQL_GHPROXY 指定的代理 → 内置加速站 → 直连
  */
 function proxyCandidates(raw) {
-  const bases = String(process.env.JSQL_GHPROXY || '')
+  const bases = String(GHPROXY || '')
     .split(',')
     .map((s) => s.trim())
     .filter(Boolean)
@@ -41,12 +52,9 @@ function proxyCandidates(raw) {
     .concat('');
   const list = [];
   for (const base of bases) {
-    let url = raw;
-    if (base) url = (base.endsWith('/') ? base : base + '/') + raw;
-    if (base && GHPROXY_TOKEN) {
-      url += (url.indexOf('?') === -1 ? '?' : '&') + 'token=' + encodeURIComponent(GHPROXY_TOKEN);
-    }
-    if (list.indexOf(url) === -1) list.push(url);
+    const url = base ? (base.endsWith('/') ? base : base + '/') + raw : raw;
+    if (list.some((x) => x.url === url)) continue;
+    list.push({ url, viaProxy: !!base });
   }
   return list;
 }
@@ -65,13 +73,13 @@ function nativeTargetSuffix(platform = process.platform, arch = process.arch) {
   return `${p}-${a}-msvc`;
 }
 
-function download(url, dest) {
+function download(url, dest, headers) {
   return new Promise((resolve, reject) => {
     const mod = url.startsWith('https:') ? https : http;
-    const req = mod.get(url, (res) => {
+    const req = mod.get(url, { headers: headers || {} }, (res) => {
       if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
         res.resume();
-        download(res.headers.location, dest).then(resolve, reject);
+        download(res.headers.location, dest, headers).then(resolve, reject);
         return;
       }
       if (res.statusCode !== 200) {
@@ -130,10 +138,11 @@ async function downloadAndVerify() {
   const asset = `jsql-neo-native.${nativeTargetSuffix()}.node`;
   const raw = `https://github.com/${REPO}/releases/download/${TAG}/${asset}`;
   // 依次尝试：环境变量指定的代理 → 内置加速站 → 直连
-  for (const url of proxyCandidates(raw)) {
-    console.log(`[jsql-neo] downloading native module: ${url}`);
+  for (const cand of proxyCandidates(raw)) {
+    console.log(`[jsql-neo] downloading native module: ${cand.url}`);
     try {
-      await download(url, NATIVE_PATH);
+      // 加速站鉴权走 Authorization 头，直连时不带
+      await download(cand.url, NATIVE_PATH, cand.viaProxy ? proxyHeaders() : undefined);
       if (tryLoadNative()) {
         console.log('[jsql-neo] native module downloaded: native/jsql-neo-native.node');
         return true;

package/test/readme-audit.test.js

@@ -202,6 +202,48 @@ async function main() {
     ok("nm ~* '^a' 不敏感", JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE nm ~* '^a'")) === '[[1]]');
     ok("nm !~ '^A' 取反", JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE nm !~ '^A'")) === '[[2],[3]]');
     ok('REGEXP 仍可用', JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE nm REGEXP '^A'")) === '[[1]]');
+    // —— 日期/时间函数（README 承诺但此前大量缺失、静默返回 null）——
+    ok('YEAR()', JSON.stringify(await rowsOf("SELECT YEAR('2024-03-15')")) === '[[2024]]');
+    ok('MONTH()', JSON.stringify(await rowsOf("SELECT MONTH('2024-03-15')")) === '[[3]]');
+    ok('DAY()', JSON.stringify(await rowsOf("SELECT DAY('2024-03-15')")) === '[[15]]');
+    ok('HOUR()', JSON.stringify(await rowsOf("SELECT HOUR('2024-03-15 10:20:30')")) === '[[10]]');
+    ok('MINUTE()', JSON.stringify(await rowsOf("SELECT MINUTE('2024-03-15 10:20:30')")) === '[[20]]');
+    ok('SECOND()', JSON.stringify(await rowsOf("SELECT SECOND('2024-03-15 10:20:30')")) === '[[30]]');
+    ok('QUARTER()', JSON.stringify(await rowsOf("SELECT QUARTER('2024-08-15')")) === '[[3]]');
+    ok('DAYOFWEEK()', JSON.stringify(await rowsOf("SELECT DAYOFWEEK('2024-03-15')")) === '[[6]]');
+    ok('DATE()', JSON.stringify(await rowsOf("SELECT DATE('2024-03-15 10:20:30')")) === '[["2024-03-15"]]');
+    ok('TIME()', JSON.stringify(await rowsOf("SELECT TIME('2024-03-15 10:20:30')")) === '[["10:20:30"]]');
+    ok('DATEDIFF', JSON.stringify(await rowsOf("SELECT DATEDIFF('2026-08-12','2026-08-01')")) === '[[11]]');
+    ok('TIMESTAMPDIFF 裸 unit',
+      JSON.stringify(await rowsOf("SELECT TIMESTAMPDIFF(MONTH,'2024-01-01','2024-03-01')")) === '[[2]]');
+    ok('DATE_FORMAT',
+      JSON.stringify(await rowsOf("SELECT DATE_FORMAT('2026-08-12 10:30:00','%Y-%m-%d %H:%i')")) === '[["2026-08-12 10:30"]]');
+    ok('STR_TO_DATE',
+      JSON.stringify(await rowsOf("SELECT STR_TO_DATE('2024-03-15','%Y-%m-%d')")) === '[["2024-03-15"]]');
+    ok('TO_DATE(PG 格式)',
+      JSON.stringify(await rowsOf("SELECT TO_DATE('2024-03-15','YYYY-MM-DD')")) === '[["2024-03-15"]]');
+    ok('TO_CHAR(PG 格式)',
+      JSON.stringify(await rowsOf("SELECT TO_CHAR('2024-03-15','YYYY-MM-DD')")) === '[["2024-03-15"]]');
+    ok('DATE_PART', JSON.stringify(await rowsOf("SELECT DATE_PART('year','2024-03-15')")) === '[[2024]]');
+    ok('AGE', JSON.stringify(await rowsOf("SELECT AGE('2026-08-12','2020-01-01')")) === '[["6 years 7 mons 11 days"]]');
+    ok('LAST_DAY 闰年', JSON.stringify(await rowsOf("SELECT LAST_DAY('2024-02-05')")) === '[["2024-02-29"]]');
+    ok('DAYNAME', JSON.stringify(await rowsOf("SELECT DAYNAME('2024-03-15')")) === '[["Friday"]]');
+    ok('MONTHNAME', JSON.stringify(await rowsOf("SELECT MONTHNAME('2024-03-15')")) === '[["March"]]');
+    ok('PERIOD_DIFF', JSON.stringify(await rowsOf('SELECT PERIOD_DIFF(202403,202401)')) === '[[2]]');
+    ok('DATE_TRUNC',
+      JSON.stringify(await rowsOf("SELECT DATE_TRUNC('month','2024-03-15 10:20:30')")) === '[["2024-03-01 00:00:00"]]');
+    ok('WEEK()', JSON.stringify(await rowsOf("SELECT WEEK('2024-01-14')")) === '[[2]]');
+
+    // —— 数值比较 / 聚合 / LIKE：曾"不报错但结果错"——
+    ok('数值列 vs 数值字符串 <', JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE n < '9'")) === '[]');
+    ok('数值列 vs 数值字符串 =', JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE n = '10'")) === '[[1]]');
+    ok('HAVING 无 GROUP BY', JSON.stringify(await rowsOf('SELECT COUNT(*) AS c FROM tbl HAVING COUNT(*) > 2')) === '[[3]]');
+    ok('HAVING 不成立应为空', JSON.stringify(await rowsOf('SELECT COUNT(*) AS c FROM tbl HAVING COUNT(*) > 100')) === '[]');
+    ok('MIN 字符串列', JSON.stringify(await rowsOf('SELECT MIN(nm) FROM tbl')) === '[["Alice"]]');
+    ok('MAX 字符串列', JSON.stringify(await rowsOf('SELECT MAX(nm) FROM tbl')) === '[["Cara"]]');
+    ok('LIKE 默认不区分大小写', JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE nm LIKE 'alice'")) === '[[1]]');
+    ok('LIKE BINARY 区分大小写', JSON.stringify(await rowsOf("SELECT id FROM tbl WHERE nm LIKE BINARY 'alice'")) === '[]');
+
     // —— 6.2.0 回归项（这些曾不报错但结果错）——
     ok('NOT IN 取反', JSON.stringify(await rowsOf('SELECT id FROM tbl WHERE id NOT IN (1,2)')) === '[[3]]');
     const dStar = await rowsOf('SELECT DISTINCT * FROM tbl');
@@ -427,6 +469,44 @@ async function main() {
     }
   }
 
+  console.log('\n--- NULL 三值逻辑 / 相关子查询 / DATE 列时区 ---');
+  {
+    let JSQL, db;
+    try {
+      ({ JSQL } = require('../lib/native_client.js'));
+      db = new JSQL();
+      await db.start();
+    } catch (e) {
+      console.log('[SKIP] native 不可用：' + e.message.slice(0, 60));
+    }
+    if (db) {
+      const run = (sql) => executeSQL(db, sql, OPTS);
+      // NOT 作用于含 NULL 的比较：UNKNOWN 取反仍是 UNKNOWN，该行不应入选
+      await run('CREATE TABLE nl (id INT PRIMARY KEY, a INT)');
+      await run('INSERT INTO nl (id,a) VALUES (1,1),(2,2),(3,NULL)');
+      ok('NOT (a > 1) 排除 NULL 行', JSON.stringify((await run('SELECT id FROM nl WHERE NOT (a > 1)')).rows) === '[[1]]');
+
+      // 相关子查询引用外层别名
+      await run('CREATE TABLE ta (id INT PRIMARY KEY, v INT)');
+      await run('CREATE TABLE tb (id INT PRIMARY KEY, av INT)');
+      await run('INSERT INTO ta (id,v) VALUES (1,10),(2,20)');
+      await run('INSERT INTO tb (id,av) VALUES (1,10)');
+      ok('EXISTS 相关子查询',
+        JSON.stringify((await run('SELECT id FROM ta WHERE EXISTS (SELECT 1 FROM tb WHERE tb.av = ta.v)')).rows) === '[[1]]');
+      ok('NOT EXISTS 相关子查询',
+        JSON.stringify((await run('SELECT id FROM ta WHERE NOT EXISTS (SELECT 1 FROM tb WHERE tb.av = ta.v)')).rows) === '[[2]]');
+
+      // DATE 列序列化：不能用 toISOString（UTC），否则东八区差一天
+      const { validateDateType } = require('../lib/date-types.js');
+      ok('DATE 字符串不回退一天', validateDateType('2023-01-01', 'date', 'f') === '2023-01-01');
+      ok('DATE 闰年边界（2024-02-29）', validateDateType('2024-02-29', 'date', 'f') === '2024-02-29');
+      ok('DATE 对象按本地时区', validateDateType(new Date(2023, 0, 1), 'date', 'f') === '2023-01-01');
+      ok('DATETIME 对象按本地时区',
+        validateDateType(new Date(2023, 0, 1, 8, 30), 'datetime', 'f') === '2023-01-01 08:30:00');
+      await db.stop();
+    }
+  }
+
   console.log('\n--- Redis：RESP2 帧解析（曾 inline 命令恒为 unknown command）---');
   {
     const { RedisServer } = require('../lib/redis_server.js');