jsql-neo 6.5.26 → 6.5.29

package/lib/sql.js

@@ -1533,7 +1533,25 @@ class Parser {
       this.expectKeyword('GROUP'); this.expectKeyword('BY');
       groupBy = [];
       while (true) {
-        groupBy.push(this.parseColumnRef());
+        // 支持表达式分组：GROUP BY a%2、GROUP BY UPPER(name)（#51）。
+        // 裸列名仍保留字符串形态，避免破坏既有别名解析与下游处理。
+        let g;
+        const save = this.pos;
+        const GROUP_END = ['HAVING', 'ORDER', 'LIMIT', 'OFFSET', 'UNION', 'INTERSECT',
+          'EXCEPT', 'RETURNING', 'WITH'];
+        const endsGroupItem = (tk) => {
+          if (tk.type === 'eof') return true;
+          if (tk.type === 'op' && (tk.value === ',' || tk.value === ';' || tk.value === ')')) return true;
+          return GROUP_END.some(w => this.isWord(w));
+        };
+        try {
+          g = this.parseColumnRef();
+          if (!endsGroupItem(this.peek())) { this.pos = save; g = this.parseScalar(); }
+        } catch (e) {
+          this.pos = save;
+          g = this.parseScalar();
+        }
+        groupBy.push(g);
         if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
         break;
       }
@@ -1631,6 +1649,17 @@ class Parser {
       else if (this.isKeyword('DISTINCT')) this.next();
       except = { all, select: this.parseSelect() };
     }
+    // 标准 SQL：组合查询尾部的 ORDER BY / LIMIT / OFFSET 作用于整个结果。
+    // 语法上它们会被解析进最右侧的 SELECT（#57），这里逐层提升到外层，
+    // 否则执行层在 concat 后直接返回，尾部子句被静默丢弃。
+    {
+      const rhsSel = (union || intersect || except || {}).select;
+      if (rhsSel) {
+        if (rhsSel.orderBy) { orderBy = rhsSel.orderBy; rhsSel.orderBy = null; }
+        if (rhsSel.limit !== null && rhsSel.limit !== undefined) { limit = rhsSel.limit; rhsSel.limit = null; }
+        if (rhsSel.offset) { offset = rhsSel.offset; rhsSel.offset = 0; }
+      }
+    }
     // FETCH FIRST n ROWS ONLY（SQL 标准的 LIMIT 写法）
     if (this.isWord('FETCH')) {
       this.next();
@@ -4964,6 +4993,24 @@ function evaluateCaseVal(caseExpr, row, ctx) {
   return caseExpr.elseVal ? resolveOperand(caseExpr.elseVal, row, ctx) : null;
 }
 
+/**
+ * 聚合参数的可读列名（#54）：c.column 通常是 AST 节点（{type:'column',name:'b'}），
+ * 直接字符串拼理会得到 "SUM([object Object])"。
+ */
+function columnLabel(col) {
+  if (col === undefined || col === null) return '*';
+  if (typeof col === 'string') return col;
+  if (typeof col === 'number' || typeof col === 'bigint') return String(col);
+  if (typeof col === 'object') {
+    if (col.type === 'column' && col.name !== undefined) return String(col.name);
+    if (col.type === 'star' || col.type === '*') return '*';
+    if (col.type === 'value' || col.type === 'literal') return String(col.value);
+    if (col.type === 'tuple' && Array.isArray(col.items)) return col.items.map(columnLabel).join(', ');
+    try { return scalarName(col); } catch (e) { return 'expr'; }
+  }
+  return String(col);
+}
+
 function scalarName(node) {
   if (!node) return 'expr';
   switch (node.type) {
@@ -4976,7 +5023,7 @@ function scalarName(node) {
     case 'literal': return String(node.value);
     case 'arith': return scalarName(node.left) + ' ' + node.op + ' ' + scalarName(node.right);
     case 'case': return 'CASE';
-    case 'aggregate': return node.fn + '(' + (node.column || '*') + ')';
+    case 'aggregate': return node.fn + '(' + columnLabel(node.column) + ')';
     default: return 'expr';
   }
 }
@@ -4989,7 +5036,7 @@ function scalarColumnName(c) {
   }
   if (c.alias) return c.alias;
   if (c.scalar) return scalarName(c.scalar);
-  if (c.aggregate) return c.alias || (c.aggregate === 'COUNT' ? 'COUNT(*)' : c.aggregate + '(' + c.column + ')');
+  if (c.aggregate) return c.alias || c.aggregate + '(' + columnLabel(c.column) + ')';
   if (c.literal !== undefined) return String(c.literal);
   if (c.caseExpr) return 'CASE';
   if (c.expr === '*') return '*';
@@ -5050,7 +5097,16 @@ function scalarColumnValue(c, r, ctx) {
   }
   
   if (c.literal !== undefined) return c.literal;
-  if (c.caseExpr) return projectScalar(evaluateCaseVal(c.caseExpr, r, ctx));
+  if (c.caseExpr) {
+    // CASE WHEN 内嵌聚合（#52）：先把聚合按当前分组替换成字面值，
+    // 否则 resolveOperand 不认识 aggregate 节点，条件恒为假 → 恒走 ELSE。
+    if (ctx && ctx._replaceAggregates && containsAggregateNode(c.caseExpr)) {
+      const copy = JSON.parse(JSON.stringify(c.caseExpr));
+      ctx._replaceAggregates(copy, ctx.group || [r]);
+      return projectScalar(evaluateCaseVal(copy, r, ctx));
+    }
+    return projectScalar(evaluateCaseVal(c.caseExpr, r, ctx));
+  }
   if (c.expr === '*') return r[Object.keys(r).find(k => !k.startsWith('_'))];
   return projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, ctx));
 }
@@ -6524,13 +6580,42 @@ class SQLExecutor {
         return typeof agg.result === 'function' ? agg.result(state) : state;
       }
     }
+    // 整数精确累加（#56）：SUM/AVG 若全为整数，用 BigInt 累加，
+    // 避免 >2^53 时 Number 浮点加法把 9007199254740993 + 9007199254740992
+    // 舍入成 18014398509481984。结果在安全范围内仍返回 number。
+    const exactIntSum = () => {
+      let total = 0n;
+      for (const v of values) {
+        if (typeof v === 'bigint') { total += v; continue; }
+        if (typeof v === 'number' && Number.isInteger(v)) { total += BigInt(v); continue; }
+        if (typeof v === 'string' && /^[-+]?\d+$/.test(v.trim())) {
+          try { total += BigInt(v.trim()); continue; } catch (e) { return undefined; }
+        }
+        return undefined;
+      }
+      return total;
+    };
+    const SAFE_MAX = BigInt(Number.MAX_SAFE_INTEGER);
+    const SAFE_MIN = BigInt(Number.MIN_SAFE_INTEGER);
     if (fn === 'SUM') {
       // MySQL 语义：空集（或无任何非 NULL 值）的 SUM 为 NULL，而非 0。
       // AVG/MIN/MAX 已按此处理，此前只有 SUM 漏了。
       if (!values.length) return null;
+      const exact = exactIntSum();
+      if (exact !== undefined) {
+        return (exact >= SAFE_MIN && exact <= SAFE_MAX) ? Number(exact) : exact;
+      }
       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 === 'AVG') {
+      if (!values.length) return null;
+      const exact = exactIntSum();
+      if (exact !== undefined) {
+        // 先精确求和，再除以行数；Number(total) 只在最后一步转换
+        return Number(exact) / values.length;
+      }
+      return values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0) / values.length;
+    }
     if (fn === 'MIN' || fn === 'MAX') {
       const vs = values.filter(v => v !== null && v !== undefined);
       if (!vs.length) return null;
@@ -7327,36 +7412,108 @@ class SQLExecutor {
     return statement;
   }
 
+  /**
+   * 组合查询（UNION/INTERSECT/EXCEPT）尾部的 ORDER BY / LIMIT / OFFSET（#57）。
+   * 此时 rows 已是投影后的数组，排序键按左分支列名或 1-based 列序号解析。
+   */
+  _finalizeSetOp(rows, columns, statement) {
+    let out = rows;
+    const orderBy = statement.orderBy;
+    if (Array.isArray(orderBy) && orderBy.length) {
+      const idxOf = (name) => {
+        const n = String(name).toLowerCase();
+        for (let i = 0; i < columns.length; i++) {
+          if (String(columns[i]).toLowerCase() === n) return i;
+        }
+        return -1;
+      };
+      const objOf = (r) => {
+        if (r && !Array.isArray(r) && typeof r === 'object') return r;
+        const o = {};
+        for (let i = 0; i < columns.length; i++) o[columns[i]] = r ? r[i] : undefined;
+        return o;
+      };
+      const keyed = out.map((r, i) => ({ r, i, o: objOf(r) }));
+      const keyOf = (entry, o) => {
+        const c = o.column;
+        if (typeof c === 'number') {
+          if (c >= 1 && c <= columns.length) return entry.r[c - 1];
+          throw new Error(`ORDER BY position ${c} is out of range`);
+        }
+        if (typeof c === 'string' || (c && (c.type === 'column' || (c.type === 'value' && typeof c.value === 'number')))) {
+          if (c && c.type === 'value') {
+            const n = Number(c.value);
+            if (n >= 1 && n <= columns.length) return entry.r[n - 1];
+            throw new Error(`ORDER BY position ${n} is out of range`);
+          }
+          const name = typeof c === 'string' ? c : c.name;
+          const idx = idxOf(name);
+          if (idx === -1) throw new Error(`no such column: ${name}`);
+          return entry.r[idx];
+        }
+        // 表达式排序：按列名构造对象后求值
+        return resolveOperand(c, entry.o, this.ctx);
+      };
+      keyed.sort((a, b) => {
+        for (const o of orderBy) {
+          const av = keyOf(a, o);
+          const bv = keyOf(b, o);
+          if (av === bv) continue;
+          const aNull = av === null || av === undefined;
+          const bNull = bv === null || bv === undefined;
+          if (aNull || bNull) {
+            const r = aNull && bNull ? 0 : (aNull ? -1 : 1);
+            return o.dir === 'desc' ? -r : r;
+          }
+          const d = typeof av === 'number' && typeof bv === 'number'
+            ? av - bv : String(av).localeCompare(String(bv));
+          if (d !== 0) return o.dir === 'desc' ? -d : d;
+        }
+        return a.i - b.i;
+      });
+      out = keyed.map(x => x.r);
+    }
+    if (statement.offset) out = out.slice(statement.offset);
+    if (statement.limit !== null && statement.limit !== undefined) out = out.slice(0, statement.limit);
+    return out;
+  }
+
   async executeSelect(statement) {
     // 视图：FROM 里的视图名展开成子查询
     if (this.engine && this.engine._views) this._expandViews(statement);
 
+    // 集合运算：左分支不应用尾部 ORDER BY/LIMIT/OFFSET（它们属于整个组合结果）
+    const setOpBase = { orderBy: null, limit: null, offset: 0, fetch: undefined };
+
     // UNION 处理
     if (statement.union) {
-      const left = await this.executeSelect({ ...statement, union: null });
+      const left = await this.executeSelect({ ...statement, ...setOpBase, union: null });
       const right = await this.executeSelect(statement.union.select);
       let rows = left.rows.concat(right.rows);
       if (!statement.union.all) rows = dedupeRows(rows);
+      rows = this._finalizeSetOp(rows, left.columns, statement);
       return { ok: true, type: 'select', columns: left.columns, rows, raw: rows };
     }
 
     // INTERSECT：保留同时出现在右侧结果中的行（默认 DISTINCT，与 UNION 的处理保持一致）
     if (statement.intersect) {
-      const left = await this.executeSelect({ ...statement, intersect: null, except: null });
+      const left = await this.executeSelect({ ...statement, ...setOpBase, intersect: null, except: null });
       const right = await this.executeSelect(statement.intersect.select);
       const seen = new Set(right.rows.map(r => JSON.stringify(r)));
       let out = left.rows.filter(r => seen.has(JSON.stringify(r)));
       if (!statement.intersect.all) out = dedupeRows(out);
+      out = this._finalizeSetOp(out, left.columns, statement);
       return { ok: true, type: 'select', columns: left.columns, rows: out, raw: out };
     }
 
     // EXCEPT：去掉出现在右侧结果中的行（默认 DISTINCT）
     if (statement.except) {
-      const left = await this.executeSelect({ ...statement, intersect: null, except: null });
+      const left = await this.executeSelect({ ...statement, ...setOpBase, intersect: null, except: null });
       const right = await this.executeSelect(statement.except.select);
       const seen = new Set(right.rows.map(r => JSON.stringify(r)));
       let out = left.rows.filter(r => !seen.has(JSON.stringify(r)));
       if (!statement.except.all) out = dedupeRows(out);
+      out = this._finalizeSetOp(out, left.columns, statement);
       return { ok: true, type: 'select', columns: left.columns, rows: out, raw: out };
     }
 
@@ -7555,7 +7712,8 @@ class SQLExecutor {
       // 此前全用 resolveOperand({type:'column', name:g}) 按列名取，导致 GROUP BY b
       // 取 row['b']，而原始行里没有 b 列（b 是别名），全返回 undefined 并成一组。
       const aliases = {};        // alias名字 → true（存在性检查用）
-      const aliasToCol = {};     // alias名字 → 对应的表达式（用于从原始行取值）
+      const aliasToCol = {};     // alias名字 → 对应的列名（用于从原始行取值）
+      const aliasExpr = {};      // alias名字 → 对应的表达式 AST（GROUP BY 表达式别名，#51）
       if (statement.columns) {
         for (const c of statement.columns) {
           if (c.alias) {
@@ -7565,18 +7723,28 @@ class SQLExecutor {
             // expr 可能是字符串 'a'（列名）或对象 {type:'column', name:'a'}
             if (typeof src === 'string') aliasToCol[c.alias.toLowerCase()] = src;
             else if (src && src.type === 'column') aliasToCol[c.alias.toLowerCase()] = src.name;
+            else if (src && typeof src === 'object') aliasExpr[c.alias.toLowerCase()] = src;
           }
         }
       }
       const groups = new Map();
       for (const row of rows) {
         const key = JSON.stringify(statement.groupBy.map(g => {
+          // 表达式分组（#51）：直接对原始行求值表达式
+          if (g && typeof g === 'object') {
+            const v = resolveOperand(g, row, this.ctx);
+            return typeof v === 'bigint' ? v.toString() + 'n' : v;
+          }
           const key = String(g).toLowerCase();
           if (aliases[key]) {
             // 优先用行中已有的 alias 值（投影后才有），没有则尝试从原始列取值
             if (row[key] !== undefined) return row[key];
             // alias → 原始列名 的映射（如 b → a），从原始行取该列的值
             if (aliasToCol[key]) return resolveOperand({ type: 'column', name: aliasToCol[key] }, row, this.ctx);
+            if (aliasExpr[key]) {
+              const v = resolveOperand(aliasExpr[key], row, this.ctx);
+              return typeof v === 'bigint' ? v.toString() + 'n' : v;
+            }
             return row[key];   // row[key] 为 undefined，但保持一致
           }
           return resolveOperand({ type: 'column', name: g }, row, this.ctx);
@@ -7647,7 +7815,14 @@ class SQLExecutor {
             return allKeys.map(k => r[k]);
           }
           if (c.scalar) return resolveOperand(c.scalar, r, this.ctx);
-          if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
+          if (c.caseExpr) {
+            if (containsAggregateNode(c.caseExpr)) {
+              const cc = JSON.parse(JSON.stringify(c.caseExpr));
+              this._replaceAggregates(cc, r._group || [r]);
+              return evaluateCaseVal(cc, r, this.ctx);
+            }
+            return evaluateCaseVal(c.caseExpr, r, this.ctx);
+          }
           if (c.aggregate) return this._aggValue(r._group || [r], c.aggregate || 'COUNT', c.column, c.distinct, c.separator, c.orderBy);
           return resolveOperand({ type: 'column', name: c.expr }, r, this.ctx);
         }));
@@ -7663,7 +7838,8 @@ class SQLExecutor {
     // 无 GROUP BY 的整表聚合：顶层是聚合（AVG(x)）、自定义聚合（total(x)），
     // 以及嵌套聚合（ROUND(AVG(x),1) —— 聚合藏在 scalar 的参数里，顶层 c.aggregate 为空）
     const hasNestedAgg = !statement.groupBy &&
-      statement.columns.some(c => c.scalar && containsAggregateNode(c.scalar));
+      statement.columns.some(c => (c.scalar && containsAggregateNode(c.scalar)) ||
+        (c.caseExpr && containsAggregateNode(c.caseExpr)));
     if (!statement.groupBy && (statement.columns.some(c => c.aggregate && !c.window) || hasCustomAgg || hasNestedAgg)) {
       const cols = statement.columns.map(c => scalarColumnName(c));
       const tableName2 = statement.from ? (statement.from.tables[0].table || null) : null;
@@ -7688,7 +7864,15 @@ class SQLExecutor {
           }
           return projectScalar(resolveOperand(c.scalar, rows[0] || {}, this.ctx));
         }
-        if (c.caseExpr) return projectScalar(resolveOperand(c.caseExpr, rows[0] || {}, this.ctx));
+        if (c.caseExpr) {
+          // CASE 内嵌聚合按整表求值替换（#52）
+          if (containsAggregateNode(c.caseExpr)) {
+            const nestedCase = JSON.parse(JSON.stringify(c.caseExpr));
+            this._replaceAggregates(nestedCase, rows);
+            return projectScalar(evaluateCaseVal(nestedCase, rows[0] || {}, this.ctx));
+          }
+          return projectScalar(evaluateCaseVal(c.caseExpr, rows[0] || {}, this.ctx));
+        }
         if (c.expr !== null && c.expr !== '*') return rows[0] ? projectScalar(resolveOperand({ type: 'column', name: c.expr }, rows[0])) : null;
         return null;
       };
@@ -8337,6 +8521,57 @@ function finalizeBigInts(value, seen) {
   return value;
 }
 
+/**
+ * SQLResult 专用的 BigInt 收尾 —— 保留语义，去掉 20 万次递归和 Set.add。
+ *
+ * 通用 finalizeBigInts 会对 rows（10 万个数组）+ raw（10 万个对象）逐个
+ * 深递归，每进一个对象就 seen.add 一次。node --prof 显示光
+ * SetPrototypeAdd 就占 18 ticks（约 14% JS），加上 finalizeBigInts 自身
+ * 共 ~23% JS ticks，整体 33% 时间花在 GC 上。
+ *
+ * 而结果的形状是规则的：rows 是二维数组，raw 是对象数组，元素绝大多数是
+ * number / string / null —— 根本不可能是 BigInt。用紧凑循环只做 typeof
+ * 检查，遇到嵌套对象才退回通用实现。语义与深递归等价，但不再给每个
+ * 标量行建 Set 条目。
+ */
+function finalizeResultBigInts(r) {
+  if (!r || typeof r !== 'object' || Array.isArray(r)) return finalizeBigInts(r);
+
+  if (Array.isArray(r.rows)) {
+    const rows = r.rows;
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      if (!Array.isArray(row)) { rows[i] = finalizeBigInts(row); continue; }
+      for (let j = 0; j < row.length; j++) {
+        const v = row[j];
+        if (typeof v === 'bigint') row[j] = v.toString();
+        else if (v && typeof v === 'object') row[j] = finalizeBigInts(v);
+      }
+    }
+  }
+
+  if (Array.isArray(r.raw)) {
+    const raw = r.raw;
+    for (let i = 0; i < raw.length; i++) {
+      const obj = raw[i];
+      if (!obj || typeof obj !== 'object' || Array.isArray(obj)) continue;
+      for (const k of Object.keys(obj)) {
+        const v = obj[k];
+        if (typeof v === 'bigint') obj[k] = v.toString();
+        else if (v && typeof v === 'object') obj[k] = finalizeBigInts(v);
+      }
+    }
+  }
+
+  // 其余字段（columns / insertId / ids / columnTypes / 元数据）都很小，
+  // 走通用实现，保证不漏掉任何可能含 BigInt 的位置。
+  for (const k of Object.keys(r)) {
+    if (k === 'rows' || k === 'raw') continue;
+    r[k] = finalizeBigInts(r[k]);
+  }
+  return r;
+}
+
 async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
   // 参数守卫：engine 必须是引擎对象，sql 必须是字符串。误用时报清晰错误，
   // 而不是在后续像 `reading 'length'` 那样抛出令人费解的 TypeError。
@@ -8410,7 +8645,7 @@ async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
     let r = await executor.execute(stmt);
     const durationMs = Number(process.hrtime.bigint() - t0) / 1e6;
     r = buildResultEnvelope(stmt, r, Math.round(durationMs * 1000) / 1000);
-    r = finalizeBigInts(r);
+    r = finalizeResultBigInts(r);
     if (r && r.columns && r.columnTypes === undefined) {
       r.columnTypes = await inferColumnTypes(engine, stmt, r);
     }

package/lib/table.js

@@ -456,24 +456,25 @@ class Table {
 
     findById(id) {
         if (!this._primaryKey) throw createError('ER_PARSE_ERROR', 'Table has no primary key');
+        // Issue #44：字符串主键查询值先按列类型归一，否则索引静默未命中
+        const key = this._coerceQueryValue(this._primaryKey, id);
         // Hash 索引 O(1)
         if (this._pkIndex) {
-            const rowIndex = this._pkIndex.get(id);
+            const rowIndex = this._pkIndex.get(key);
             if (rowIndex !== undefined) {
                 const row = this._rows[rowIndex];
                 if (row && !row._deleted) return { ...row };
             }
-            return null;
-        }
-        if (this._btrees[this._primaryKey]) {
-            const indices = this._btrees[this._primaryKey].search(id);
+        } else if (this._btrees[this._primaryKey]) {
+            const indices = this._btrees[this._primaryKey].search(key);
             if (indices.length > 0) {
                 const row = this._rows[indices[0]];
                 if (row && !row._deleted) return { ...row };
             }
-            return null;
         }
-        return this.findOne({ [this._primaryKey]: id });
+        // 索引未命中不等于不存在：回落主键列全表匹配（类型差异 / 索引未覆盖的行）
+        const row = this._rows.find(r => r && !r._deleted && r[this._primaryKey] === key);
+        return row ? { ...row } : null;
     }
 
     findAll() {
@@ -533,24 +534,25 @@ class Table {
             updates = hook({ [this._primaryKey]: id }, { ...updates }) || updates;
         }
         updates = this._validateDataTypes(updates, true);
+        const pkKey = this._coerceQueryValue(this._primaryKey, id);
         let rowIndex;
         if (this._pkIndex) {
-            rowIndex = this._pkIndex.get(id);
-        } else {
-            if (this._btrees[this._primaryKey]) {
-                const indices = this._btrees[this._primaryKey].search(id);
-                rowIndex = indices.length > 0 ? indices[0] : undefined;
-            } else {
-                rowIndex = this._rows.findIndex(r => r[this._primaryKey] === id);
-                if (rowIndex === -1) rowIndex = undefined;
-            }
+            rowIndex = this._pkIndex.get(pkKey);
+        } else if (this._btrees[this._primaryKey]) {
+            const indices = this._btrees[this._primaryKey].search(pkKey);
+            rowIndex = indices.length > 0 ? indices[0] : undefined;
+        }
+        if (rowIndex === undefined) {
+            // Issue #44：索引未命中时回落全表匹配
+            const found = this._rows.findIndex(r => r && !r._deleted && r[this._primaryKey] === pkKey);
+            if (found !== -1) rowIndex = found;
         }
         if (rowIndex === undefined) return 0;
         const row = this._rows[rowIndex];
         if (row && row._deleted) return 0;
         // P1-3：主键被更新时传播到外键引用（CASCADE / SET NULL / RESTRICT）
-        if (updates[this._primaryKey] !== undefined && updates[this._primaryKey] !== id) {
-            this._propagatePKUpdate(id, updates[this._primaryKey]);
+        if (updates[this._primaryKey] !== undefined && updates[this._primaryKey] !== pkKey) {
+            this._propagatePKUpdate(pkKey, updates[this._primaryKey]);
         }
         const oldData = { ...row };
         const merged = { ...row, ...updates };
@@ -633,17 +635,19 @@ class Table {
 
     removeById(id) {
         if (!this._primaryKey) throw createError('ER_PARSE_ERROR', 'Table has no primary key');
+        // Issue #44：同 findById，先按列类型归一查询值
+        const pkKey = this._coerceQueryValue(this._primaryKey, id);
         let rowIndex;
         if (this._pkIndex) {
-            rowIndex = this._pkIndex.get(id);
-        } else {
-            if (this._btrees[this._primaryKey]) {
-                const indices = this._btrees[this._primaryKey].search(id);
-                rowIndex = indices.length > 0 ? indices[0] : undefined;
-            } else {
-                rowIndex = this._rows.findIndex(r => r[this._primaryKey] === id);
-                if (rowIndex === -1) rowIndex = undefined;
-            }
+            rowIndex = this._pkIndex.get(pkKey);
+        } else if (this._btrees[this._primaryKey]) {
+            const indices = this._btrees[this._primaryKey].search(pkKey);
+            rowIndex = indices.length > 0 ? indices[0] : undefined;
+        }
+        if (rowIndex === undefined) {
+            // Issue #44：索引未命中时回落全表匹配
+            const found = this._rows.findIndex(r => r && !r._deleted && r[this._primaryKey] === pkKey);
+            if (found !== -1) rowIndex = found;
         }
         if (rowIndex === undefined) return 0;
         const row = this._rows[rowIndex];
@@ -1037,32 +1041,129 @@ class Table {
         return end > 0 ? pattern.slice(0, end) : null;
     }
 
-    _applyFilterOptimized(rows, query) {
+    /**
+     * Issue #44：按列声明类型归一查询值。
+     *
+     * 索引（B-Tree / hash）命中用的是严格 ===，所以字符串 '5' 永远搜不到
+     * INT 列里的数字 5，表现为「静默返回空」；SQL 的 WHERE 路径早就在
+     * 解析阶段强转过了，文档 API 这条路径没有。
+     *
+     * 归一结果与 insert 时 _validateDataTypes 的产物一致（整数 → number/BigInt、
+     * 浮点 → number、布尔 → boolean、字符串列 → string）。无法归一的值原样返回。
+     */
+    _coerceQueryValue(field, value) {
+        const def = this._schema && this._schema[field];
+        if (!def || typeof def === 'string' || value === null || value === undefined) return value;
+        const t = String(def.type || '').toLowerCase();
+        if (t === 'integer' || t === 'int' || t === 'bigint') {
+            if (typeof value === 'bigint') {
+                return (value >= SAFE_INT_MIN && value <= SAFE_INT_MAX) ? Number(value) : value;
+            }
+            if (typeof value === 'number') return value;
+            if (typeof value === 'string' && DECIMAL_INT_RE.test(value.trim())) {
+                try { return normalizeInteger(value.trim(), t); } catch (_) { return value; }
+            }
+            return value;
+        }
+        if (t === 'float' || t === 'double' || t === 'number' || t === 'real') {
+            if (typeof value === 'number') return value;
+            if (typeof value === 'string' && value.trim() !== '' && !Number.isNaN(Number(value))) return Number(value);
+            return value;
+        }
+        if (t === 'boolean' || t === 'bool') {
+            if (typeof value === 'boolean') return value;
+            if (value === 0 || value === 1) return !!value;
+            if (typeof value === 'string' && ['true', 'false', '1', '0'].includes(value.toLowerCase())) {
+                return value.toLowerCase() === 'true' || value === '1';
+            }
+            return value;
+        }
+        if (t === 'string' || t === 'text' || t === 'varchar' || t === 'char') {
+            if (typeof value === 'string') return value;
+            if (typeof value === 'number' || typeof value === 'boolean' || value instanceof Date) return String(value);
+            return value;
+        }
+        return value;
+    }
+
+    /** 按 schema 归一 query 中的等值 / $eq / $in / 范围值（Issue #44）。 */
+    _coerceQuery(query) {
+        let out = null;
+        const set = (field, value) => {
+            if (!out) out = { ...query };
+            out[field] = value;
+        };
         for (const [field, condition] of Object.entries(query)) {
+            if (field === '$or' || field === '$and') {
+                if (Array.isArray(condition)) {
+                    const subs = condition.map(c => (c && typeof c === 'object' && !Array.isArray(c)) ? this._coerceQuery(c) : c);
+                    if (subs.some((s, i) => s !== condition[i])) set(field, subs);
+                }
+                continue;
+            }
+            if (field === '$not' || field[0] === '$' || !this._schema[field]) continue;
+            const next = this._coerceCondition(field, condition);
+            if (next !== condition) set(field, next);
+        }
+        return out || query;
+    }
+
+    _coerceCondition(field, condition) {
+        if (condition === null || typeof condition !== 'object' || condition instanceof RegExp) {
+            return this._coerceQueryValue(field, condition);
+        }
+        if (Array.isArray(condition)) {
+            const next = condition.map(v => this._coerceQueryValue(field, v));
+            return next.some((v, i) => v !== condition[i]) ? next : condition;
+        }
+        const keys = Object.keys(condition);
+        if (keys.length === 0 || !keys.every(k => k[0] === '$')) return condition;
+        let copy = null;
+        for (const [op, val] of Object.entries(condition)) {
+            let next = val;
+            if (op === '$eq' || op === '$ne' || op === '$gt' || op === '$gte' || op === '$lt' || op === '$lte') {
+                next = this._coerceQueryValue(field, val);
+            } else if ((op === '$in' || op === '$nin' || op === '$between') && Array.isArray(val)) {
+                next = val.map(v => this._coerceQueryValue(field, v));
+            }
+            if (next !== val) {
+                if (!copy) copy = { ...condition };
+                copy[op] = next;
+            }
+        }
+        return copy || condition;
+    }
+
+    _applyFilterOptimized(rows, query) {
+        // Issue #44：索引查找前先把查询值归一成列声明类型，避免 '5' 查不到 5
+        const q = this._coerceQuery(query);
+        for (const [field, condition] of Object.entries(q)) {
             if (field === '$or' || field === '$and' || field === '$not') continue;
             if (typeof condition !== 'object' || condition === null || Array.isArray(condition) || condition instanceof RegExp) {
                 if (this._btrees[field]) {
                     const indices = this._btrees[field].search(condition);
-                    if (indices.length === 0) return [];
-                    return this._applyFilter(this._rowsFromIndices(indices), query);
+                    // #44：索引未命中时回落全表过滤——索引键是严格相等的，
+                    // 类型/形态不一致的行会被漏掉，不能直接断言「没有数据」。
+                    if (indices.length === 0) return this._applyFilter(rows, q);
+                    return this._applyFilter(this._rowsFromIndices(indices), q);
                 }
                 if (this._indexes[field] && this._indexes[field].has(condition)) {
-                    return this._applyFilter(this._rowsFromIndices(this._indexes[field].get(condition)), query);
+                    return this._applyFilter(this._rowsFromIndices(this._indexes[field].get(condition)), q);
                 }
-                if (this._indexes[field]) return [];
+                if (this._indexes[field]) return this._applyFilter(rows, q);
             }
             if (condition && typeof condition === 'object') {
                 if (this._btrees[field] && Array.isArray(condition.$in) && condition.$in.length > 0) {
                     const indices = this._btrees[field].searchMany(condition.$in);
-                    if (indices.length === 0) return [];
-                    return this._applyFilter(this._rowsFromIndices(indices), query);
+                    if (indices.length === 0) return this._applyFilter(rows, q);
+                    return this._applyFilter(this._rowsFromIndices(indices), q);
                 }
                 if (this._btrees[field] && typeof condition.$like === 'string') {
                     const prefix = this._likePrefix(condition.$like);
                     if (prefix) {
                         const indices = this._btrees[field].prefix(prefix);
-                        if (indices.length === 0) return [];
-                        return this._applyFilter(this._rowsFromIndices(indices), query);
+                        if (indices.length === 0) return this._applyFilter(rows, q);
+                        return this._applyFilter(this._rowsFromIndices(indices), q);
                     }
                 }
                 if (this._btrees[field] && (condition.$gt !== undefined || condition.$gte !== undefined ||
@@ -1086,11 +1187,11 @@ class Table {
                     } else {
                         indices = exclusiveMax ? this._btrees[field].lessThan(max) : this._btrees[field].lessThanEqual(max);
                     }
-                    return this._applyFilter(this._rowsFromIndices(indices), query);
+                    return this._applyFilter(this._rowsFromIndices(indices), q);
                 }
             }
         }
-        return this._applyFilter(rows, query);
+        return this._applyFilter(rows, q);
     }
 
     /**

package/native/.installed.json

@@ -0,0 +1,8 @@
+{
+  "tag": "v6.5.29",
+  "sha256": "e39295e4bd4f2b705a8b686454c5f2bbe519261bc839810185775146acbadcde",
+  "packageVersion": "6.5.29",
+  "installedAt": "2026-11-09T04:35:25.960Z",
+  "platform": "linux",
+  "arch": "x64"
+}