jsql-neo 6.5.10 → 6.5.11

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL, PostgreSQL, MongoDB, Redis, SQL, TypeScript, **and the browser**.
 
-> **v6.5.10** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.5.11** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.5.10 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.5.11 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/sql.js

@@ -708,6 +708,11 @@ class Parser {
         break;
       } else {
         const col = this.parseTableName();
+        // 重复列名必须报错：对象键覆盖会静默丢列（schema[col] = def 直接覆盖），
+        // 用户 CREATE TABLE d(a INT, a INT) 会悄悄变成单列 a。
+        if (schema[col] !== undefined) {
+          throw new Error(`Duplicate column name '${col}' in table '${name}'`);
+        }
         const def = this.parseColumnDef();
         schema[col] = def;
         if (def.primaryKey) hasPk = true;
@@ -755,6 +760,8 @@ class Parser {
     const mapped = typeMap[type];
     if (!mapped) throw new Error(`Unsupported column type: ${typeTok.value}`);
     def.type = mapped;
+    // JSON / JSONB 列保留原始标记，供数据层校验非法 JSON（{bad json 这类字符串会被 JSON.parse 拒绝）
+    if (type === 'json' || type === 'jsonb') def.jsonType = true;
     if (/^(BIG)?SERIAL$/i.test(typeRaw)) { def.autoIncrement = true; def.required = true; }
 
     // 长度限制: TEXT(255) / VARCHAR(100) / INTEGER(11) ...
@@ -3110,10 +3117,6 @@ function resolveOperand(operand, row, ctx) {
     // 布尔类节点出现在"取值"位置时（如 IF(status = 'paid', ...)、SUM(IF(a > b,1,0))），
     // 求值成 true/false 供上层按真值判断
     case 'compare':
-    case 'and':
-    case 'or':
-    case 'xor':
-    case 'not':
     case 'in':
     case 'isNull':
     case 'isTruth':
@@ -3122,6 +3125,25 @@ function resolveOperand(operand, row, ctx) {
     case 'like':
     case 'between':
       return evaluateExpr(operand, row, ctx);
+    case 'and': {
+      const a = sqlTruthy(resolveOperand(operand.left, row, ctx));
+      const b = sqlTruthy(resolveOperand(operand.right, row, ctx));
+      return sqlAnd(a, b);
+    }
+    case 'or': {
+      const a = sqlTruthy(resolveOperand(operand.left, row, ctx));
+      const b = sqlTruthy(resolveOperand(operand.right, row, ctx));
+      return sqlOr(a, b);
+    }
+    case 'xor': {
+      const a = sqlTruthy(resolveOperand(operand.left, row, ctx));
+      const b = sqlTruthy(resolveOperand(operand.right, row, ctx));
+      return sqlXor(a, b);
+    }
+    case 'not': {
+      const v = sqlTruthy(resolveOperand(operand.expr, row, ctx));
+      return v === null ? null : (v ? 0 : 1);
+    }
     case 'unit': {
       // 裸时间单位（MONTH / DAY …）：优先当列取，取不到就返回单位名本身
       const lower = String(operand.name).toLowerCase();
@@ -4422,6 +4444,33 @@ function ciCompare(a, b, cs) {
   return as === bs ? 0 : (as < bs ? -1 : 1);
 }
 
+// ── 三值逻辑（SQL 标准：TRUE / FALSE / UNKNOWN）──────────────────────
+// NULL 参与布尔运算时结果不是 0/1，而是 UNKNOWN（用 null 表示）。
+// 此前 resolveOperand 没有 and/or/xor/not 分支，SELECT TRUE AND TRUE 落到
+// default 返回 undefined → 数值化成 0，所有布尔表达式全部失效。
+function sqlTruthy(v) {
+  if (v === null || v === undefined) return null;
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') return v !== '' && !(Number(v) === 0 && String(v).trim() !== '');
+  return Boolean(v);
+}
+// 三值真值表，入参已归一化为 true / false / null，返回 1 / 0 / null
+function sqlAnd(a, b) {
+  if (a === false || b === false) return 0;
+  if (a === null || b === null) return null;
+  return 1;
+}
+function sqlOr(a, b) {
+  if (a === true || b === true) return 1;
+  if (a === null || b === null) return null;
+  return 0;
+}
+function sqlXor(a, b) {
+  if (a === null || b === null) return null;
+  return a !== b ? 1 : 0;
+}
+
 function evaluateExpr(expr, row, ctx) {
   if (expr === null || expr === undefined) return false;
   switch (expr.type) {
@@ -6347,6 +6396,18 @@ class SQLExecutor {
     walk(statement.where);
     walk(statement.having);
     walk(statement.orderBy);
+    // ORDER BY 的列在解析器里是裸字符串（非 {type:'column'} 对象），walk 检不到。
+    // 字符串可能是输出别名/位置序号（已在 known 里豁免），也可能是真实列；
+    // 两者都不是 → 必须报错（此前静默忽略，用户 ORDER BY nonexistent_col 拿到原序）。
+    if (Array.isArray(statement.orderBy)) {
+      for (const o of statement.orderBy) {
+        const c = o && o.column;
+        if (typeof c !== 'string') continue; // 位置序号（数字）跳过
+        const n = c.toLowerCase();
+        const base = n.indexOf('.') >= 0 ? n.slice(n.indexOf('.') + 1) : n;
+        if (!known.has(n) && !known.has(base)) throw new Error(`no such column: ${c}`);
+      }
+    }
     if (Array.isArray(statement.groupBy)) {
       // groupBy 是列名字符串数组
       for (const g of statement.groupBy) {
@@ -7876,6 +7937,30 @@ async function inferColumnTypes(engine, stmt, r) {
   });
 }
 
+// 结果里的大整数（> MAX_SAFE_INTEGER 的 BigInt）在 JSON.stringify / wasm 绑定下
+// 无法序列化（"Do not know how to serialize a BigInt"）。输出前递归转成字符串，
+// 保留精度且可序列化；内部运算仍走 BigInt，精度不丢。
+function finalizeBigInts(value, seen) {
+  if (typeof value === 'bigint') return value.toString();
+  if (Array.isArray(value)) {
+    if (!seen) seen = new Set();
+    if (seen.has(value)) return value;
+    seen.add(value);
+    for (let i = 0; i < value.length; i++) value[i] = finalizeBigInts(value[i], seen);
+    return value;
+  }
+  if (value && typeof value === 'object') {
+    // Buffer / Date / RegExp 等特殊对象不深入（Buffer 是 Uint8Array，逐字节递归会爆栈）
+    if (value instanceof Buffer || value instanceof Date || value instanceof RegExp) return value;
+    if (!seen) seen = new Set();
+    if (seen.has(value)) return value;
+    seen.add(value);
+    for (const k of Object.keys(value)) value[k] = finalizeBigInts(value[k], seen);
+    return value;
+  }
+  return value;
+}
+
 async function executeSQL(engine, sql, paramsOrOpts, opts = {}) {
   // 参数守卫：engine 必须是引擎对象，sql 必须是字符串。误用时报清晰错误，
   // 而不是在后续像 `reading 'length'` 那样抛出令人费解的 TypeError。
@@ -7934,6 +8019,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);
     if (r && r.columns && r.columnTypes === undefined) {
       r.columnTypes = await inferColumnTypes(engine, stmt, r);
     }

package/lib/table.js

@@ -1543,6 +1543,11 @@ class Table {
                 else if (typeof v === 'number' || typeof v === 'boolean' || v instanceof Date) result[field] = String(v);
                 else if (Buffer.isBuffer(v)) result[field] = v.toString('utf8');
                 else throw createError('ER_TRUNCATED_WRONG_VALUE', t, v);
+            } else if ((t === 'object' || t === 'array' || t === 'json') && (def.jsonType || t === 'json')) {
+                // JSON / JSONB 列：字符串形式必须是合法 JSON（{bad json 这类会被 JSON.parse 拒绝）
+                if (typeof v === 'string') {
+                    try { JSON.parse(v); } catch (e) { throw createError('ER_TRUNCATED_WRONG_VALUE', t, v); }
+                }
             }
         }
         return result;

package/lib/wasm_client.js

@@ -561,6 +561,18 @@ class JSQL {
     // 难以定位的 "Cannot convert undefined or null to object"，这里直接给明确 TypeError
     const arr = Array.isArray(data) ? data : [data];
     arr.forEach((row, i) => assertRowObject(row, i, arr.length > 1 || Array.isArray(data)));
+    // JSON / JSONB 列：字符串形式必须是合法 JSON（{bad json 这类会被 JSON.parse 拒绝）
+    const schema = this._schemas[table];
+    if (schema) {
+      for (const row of arr) {
+        for (const [f, def] of Object.entries(schema)) {
+          if (def && def.jsonType && typeof row[f] === 'string') {
+            try { JSON.parse(row[f]); }
+            catch (e) { throw new Error(`Truncated incorrect object value: '${row[f]}'`); }
+          }
+        }
+      }
+    }
     if (!(await this._runHooks('beforeInsert', [table, arr]))) return [];
     if (arr.length > 1) {
       await this._flush();

package/package.json

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

package/test/bug-regression.test.js

@@ -0,0 +1,87 @@
+/*
+ * Bug 回归测试：此前发现的 5 个缺陷，逐一固化，防止回退。
+ *
+ *   1. 布尔求值器整体失效：TRUE AND TRUE → 0、NULL AND TRUE → 0、NULL OR FALSE → 0。
+ *      正确三值逻辑：1 / NULL / NULL。根因是 resolveOperand 没有 and/or/xor/not 分支，
+ *      落到 default 返回 undefined → 数值化成 0。
+ *   2. CREATE TABLE d(a INT, a INT) 不拒绝重复列名（对象键覆盖静默丢列）。
+ *   3. JSONB 列能塞进 {bad json 这种非法 JSON（两引擎：Database _validateDataTypes + wasm insert）。
+ *   4. ORDER BY 不存在的列静默忽略（解析产物是裸字符串，_validateColumnRefs 的 walk 检不到）。
+ *   5. SELECT 超大整数抛 "Do not know how to serialize a BigInt"（输出前应转字符串）。
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const { JSQL } = require(path.join(ROOT, 'index.js'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
+
+const OPTS = { safety: false };
+let pass = 0, fail = 0;
+
+function ok(name, cond, extra) {
+  if (cond) { pass++; console.log('[OK]  ', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra).slice(0, 150) : ''); }
+}
+const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+(async () => {
+  const db = new JSQL(':memory:');
+  await db.start();
+  const q = (sql) => executeSQL(db, sql, OPTS);
+  const rows = async (sql) => (await q(sql)).rows;
+  const one = async (sql) => (await q(sql)).rows[0][0];
+  const fails = async (sql) => { try { await q(sql); return null; } catch (e) { return e.message; } };
+
+  // ── 1. 三值布尔逻辑 ────────────────────────────────────────────
+  console.log('--- 1. 布尔三值逻辑 ---');
+  ok('TRUE AND TRUE = 1', (await one('SELECT TRUE AND TRUE')) === 1);
+  ok('TRUE AND FALSE = 0', (await one('SELECT TRUE AND FALSE')) === 0);
+  ok('NULL AND TRUE = NULL', (await one('SELECT NULL AND TRUE')) === null);
+  ok('NULL AND FALSE = 0', (await one('SELECT NULL AND FALSE')) === 0);
+  ok('NULL OR FALSE = NULL', (await one('SELECT NULL OR FALSE')) === null);
+  ok('NULL OR TRUE = 1', (await one('SELECT NULL OR TRUE')) === 1);
+  ok('FALSE OR FALSE = 0', (await one('SELECT FALSE OR FALSE')) === 0);
+  ok('NOT TRUE = 0', (await one('SELECT NOT TRUE')) === 0);
+  ok('NOT NULL = NULL', (await one('SELECT NOT NULL')) === null);
+  ok('1 AND 0 = 0', (await one('SELECT 1 AND 0')) === 0);
+  ok('1 XOR 0 = 1', (await one('SELECT 1 XOR 0')) === 1);
+  ok('TRUE OR NULL = 1', (await one('SELECT TRUE OR NULL')) === 1);
+
+  // ── 2. CREATE TABLE 重复列名 ───────────────────────────────────
+  console.log('--- 2. 重复列名 ---');
+  ok('d(a INT, a INT) 报错', /Duplicate column/i.test(await fails('CREATE TABLE r1(a INT, a INT)')));
+  ok('d(x,y,x) 报错', /Duplicate column/i.test(await fails('CREATE TABLE r2(x INT, y INT, x INT)')));
+  ok('正常列不报错', (await fails('CREATE TABLE r3(a INT, b TEXT)')) === null);
+  ok('id PRIMARY KEY + id 重复报错', /Duplicate column/i.test(await fails('CREATE TABLE r4(id INT PRIMARY KEY, id INT)')));
+
+  // ── 3. JSONB 非法 JSON ─────────────────────────────────────────
+  console.log('--- 3. JSONB 校验 ---');
+  await q('CREATE TABLE rj(c JSONB)');
+  ok('{bad json 拒绝', /Truncated incorrect object value/.test(await fails(`INSERT INTO rj VALUES ('{bad json')`)));
+  ok('[1,2 拒绝', /Truncated incorrect object value/.test(await fails(`INSERT INTO rj VALUES ('[1,2')`)));
+  ok('合法 {"a":1} 通过', (await fails(`INSERT INTO rj VALUES ('{"a":1}')`)) === null);
+  await q('CREATE TABLE rj2(c JSON)');
+  ok('JSON 列 nope 拒绝', /Truncated incorrect object value/.test(await fails(`INSERT INTO rj2 VALUES ('nope')`)));
+
+  // ── 4. ORDER BY 不存在列 ───────────────────────────────────────
+  console.log('--- 4. ORDER BY 校验 ---');
+  await q('CREATE TABLE ro (id INT PRIMARY KEY, v INT, s TEXT)');
+  await q('INSERT INTO ro VALUES (1,2,\'x\'),(2,1,\'y\')');
+  ok('ORDER BY nonexistent_col 报错', /no such column: nonexistent_col/.test(await fails('SELECT id FROM ro ORDER BY nonexistent_col')));
+  ok('WHERE 不存在列报错', /no such column: nosuch/.test(await fails('SELECT id FROM ro WHERE nosuch > 1')));
+  ok('ORDER BY 真列 v 正常', eq(await rows('SELECT id FROM ro ORDER BY v'), [[2], [1]]));
+  ok('ORDER BY 位置序号 1 正常', eq(await rows('SELECT id FROM ro ORDER BY 1'), [[1], [2]]));
+  ok('ORDER BY 输出别名 vv 正常', eq(await rows('SELECT v AS vv FROM ro ORDER BY vv'), [[1], [2]]));
+
+  // ── 5. 超大整数序列化 ──────────────────────────────────────────
+  console.log('--- 5. 超大整数 ---');
+  const big = await one('SELECT 1000000000000000000000');
+  ok('超大整数可序列化（字符串）', typeof big === 'string' && big === '1000000000000000000000');
+  ok('超界精确值 9007199254740993', (await one('SELECT 9007199254740993')) === '9007199254740993');
+  const bigRows = await rows('SELECT 1000000000000000000000');
+  ok('JSON.stringify 不炸', (() => { try { JSON.stringify(bigRows); return true; } catch (e) { return false; } })());
+
+  await db.stop();
+  console.log(`\nRESULT: ${pass} passed, ${fail} failed`);
+  process.exit(fail ? 1 : 0);
+})().catch((e) => { console.error('FATAL', e); process.exit(1); });