jsql-neo 4.5.0 → 4.5.2

package/lib/database.js

@@ -1142,9 +1142,46 @@ class Database {
     async start() {
         this._runHooks('onStart', []);
         this._emit('start', {});
+        if (this._dirMode && !this._sigInstalled) {
+            this._sigInstalled = true;
+            Database._installSignalHandler(this);
+        }
         return this;
     }
 
+    /**
+     * 进程退出时兜底刷盘：拦截 SIGINT/SIGTERM，同步落盘脏表后再退出。
+     * 使用静态共享 handler，避免多个数据库实例重复注册/互相覆盖。
+     * @private
+     */
+    static _installSignalHandler(db) {
+        if (!Database._signalHandlerInstalled) {
+            Database._signalHandlerInstalled = true;
+            Database._signalDBs = new Set();
+            const handler = (sig) => {
+                for (const d of Database._signalDBs) {
+                    try {
+                        if (d._dirMode) {
+                            if (d._flushTimer) { clearTimeout(d._flushTimer); d._flushTimer = null; }
+                            d._flushDirty();
+                            d._saveMeta();
+                        }
+                    } catch (e) { /* 兜底失败不阻塞退出 */ }
+                }
+                process.exit(128 + (sig === 'SIGINT' ? 2 : 15));
+            };
+            process.on('SIGINT', handler);
+            process.on('SIGTERM', handler);
+            Database._signalHandler = handler;
+        }
+        Database._signalDBs.add(db);
+    }
+
+    /** 从进程退出兜底集合移除（stop 时调用） */
+    static _uninstallSignalHandler(db) {
+        if (Database._signalDBs) Database._signalDBs.delete(db);
+    }
+
     insert(tableName, data) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
@@ -1333,11 +1370,16 @@ class Database {
         this._runHooks('onStop', []);
         this._emit('stop', {});
         if (this._dirMode) {
+            if (this._flushTimer) { clearTimeout(this._flushTimer); this._flushTimer = null; }
             try {
                 this._flushDirty();
                 this._saveMeta();
             } catch (e) {}
         }
+        if (this._sigInstalled) {
+            this._sigInstalled = false;
+            Database._uninstallSignalHandler(this);
+        }
         return this;
     }
 

package/lib/mysql_server.js

@@ -104,8 +104,19 @@ function handshakePacket(connectionId, seed) {
   return b.build();
 }
 
-function okPacket(affectedRows = 0, insertId = 0, status = SERVER_STATUS_AUTOCOMMIT) {
-  const b = new PacketBuilder();
+/**
+ * 生成握手 seed：使用可打印 ASCII（33-126），避开 0x00。
+ * 老客户端按 C 字符串读取 seed，若含 \0 会提前截断导致握手失败/断连。
+ */
+function genSeed(len = 20) {
+  const out = Buffer.alloc(len);
+  for (let i = 0; i < len; i++) {
+    out[i] = 33 + Math.floor(Math.random() * 94);
+  }
+  return out;
+}
+
+function okPacket(affectedRows = 0, insertId = 0, status = SERVER_STATUS_AUTOCOMMIT) {  const b = new PacketBuilder();
   b.byte(0x00);
   b.raw(encodeLenenc(affectedRows));
   b.raw(encodeLenenc(insertId));
@@ -364,7 +375,7 @@ class MysqlConnection {
     this.socket = socket;
     this.server = server;
     this.connectionId = ++server._connectionCounter;
-    this.seed = crypto.randomBytes(20);
+    this.seed = genSeed(20);
     this.buffer = Buffer.alloc(0);
     this.sequence = 0;
     this.authenticated = false;
@@ -898,7 +909,7 @@ class MysqlServer {
     this._engine = null;
     this._ownEngine = false;
     this._databases = new Map();
-    this._dbDir = options.dataDir ? path.resolve(options.dataDir) : null;
+    this._dbDir = options.dataDir && options.dataDir !== ':memory:' ? path.resolve(options.dataDir) : null;
     this._defaultDbName = options.defaultDatabase || 'default';
     this._connectionCounter = 0;
     this._sockets = new Set();

package/lib/native_client.js

@@ -7,6 +7,69 @@ const STR_TAG = 3;
 const BOOL_TAG = 4;
 const INT32_TAG = 5;
 
+function safeParse(str, fallback) {
+  if (typeof str !== 'string') return fallback;
+  try { return JSON.parse(str); } catch (e) { return fallback; }
+}
+
+const NATIVE_TYPE_MAP = {
+  text: 'string',
+  varchar: 'string',
+  double: 'float',
+  number: 'float',
+  numeric: 'float',
+  decimal: 'float',
+  date: 'string',
+  timestamp: 'string',
+  datetime: 'string',
+  json: 'string',
+  array: 'string',
+  object: 'string',
+  bool: 'boolean',
+  bigint: 'string',
+  int: 'integer',
+};
+
+function mapNativeSchema(schema) {
+  const mapped = {};
+  for (const [field, def] of Object.entries(schema || {})) {
+    if (typeof def === 'string') {
+      mapped[field] = { type: NATIVE_TYPE_MAP[def.toLowerCase()] || def.toLowerCase() };
+    } else if (def && typeof def === 'object') {
+      const t = (def.type || 'string').toLowerCase();
+      mapped[field] = { ...def, type: NATIVE_TYPE_MAP[t] || t };
+    } else {
+      mapped[field] = { type: 'string' };
+    }
+  }
+  return mapped;
+}
+
+function restoreRow(row, schema) {
+  if (!schema || typeof row !== 'object' || row === null) return row;
+  const out = {};
+  for (const [field, def] of Object.entries(row)) {
+    if (field === 'fields' && typeof row[field] === 'object' && row[field] !== null) {
+      out[field] = restoreRow(row[field], schema);
+      continue;
+    }
+    const colDef = schema[field];
+    let t = null;
+    if (typeof colDef === 'string') t = colDef.toLowerCase();
+    else if (colDef && typeof colDef === 'object' && colDef.type) t = String(colDef.type).toLowerCase();
+    if (['json', 'array', 'object'].includes(t) && typeof row[field] === 'string') {
+      try { out[field] = JSON.parse(row[field]); } catch (e) { out[field] = row[field]; }
+    } else if ((t === 'integer' || t === 'int' || t === 'bigint') && typeof row[field] === 'string' && /^-?\d+$/.test(row[field])) {
+      out[field] = Number(row[field]);
+    } else if ((t === 'float' || t === 'double' || t === 'number') && typeof row[field] === 'string' && !Number.isNaN(Number(row[field]))) {
+      out[field] = Number(row[field]);
+    } else {
+      out[field] = row[field];
+    }
+  }
+  return out;
+}
+
 function encodeBatch(rows) {
   if (rows.length === 0) return new Uint8Array(0);
   const fieldNames = Object.keys(rows[0]);
@@ -257,27 +320,45 @@ class JSQL {
   _runHooks(hookName, args) {
     const hooks = this._hooks[hookName];
     if (!hooks || hooks.length === 0) return true;
-    for (const fn of hooks) {
-      const r = fn(...args);
-      if (r === false) return false;
-      if (r !== undefined && args.length > 0) {
-        args[0] = r;
+    if (this._inHook) {
+      // 防止插件 hook 内重入 native 调用导致 N-API 崩溃（段错误）
+      throw new Error('ER_PLUGIN_REENTRY: plugin hook "' + hookName + '" re-entered native call; plugin must not call engine methods inside its own hook');
+    }
+    this._inHook = true;
+    try {
+      for (const fn of hooks) {
+        const r = fn(...args);
+        if (r === false) return false;
+        if (r !== undefined && args.length > 0) {
+          args[0] = r;
+        }
       }
+      return true;
+    } finally {
+      this._inHook = false;
     }
-    return true;
   }
 
   async start() {
     if (this._mode !== 'memory') {
       if (!this._path) throw new Error('hybrid/disk mode requires a directory path');
-      const r = JSON.parse(native.jsqlOpen(this._path, this._mode));
+      let r;
+      try {
+        r = safeParse(native.jsqlOpen(this._path, this._mode));
+      } catch (e) {
+        throw new Error('failed to open native storage: ' + e.message);
+      }
       if (r && r.ok === false) throw new Error(r.error || 'open storage failed');
       if (r && Array.isArray(r.tables)) {
         this._tableNames = new Set(r.tables);
         if (r.schemas) this._schemas = r.schemas;
       }
     } else {
-      JSON.parse(native.jsqlOpen('', 'memory'));
+      try {
+        JSON.parse(native.jsqlOpen('', 'memory'));
+      } catch (e) {
+        throw new Error('failed to open native memory storage: ' + e.message);
+      }
     }
     if (this._mode !== 'memory') {
       if (this._flushInterval > 0) {
@@ -310,8 +391,19 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    const schema = this._schemas[table];
+    if (schema) {
+      rows = rows.map(row => {
+        const out = {};
+        for (const [k, v] of Object.entries(row)) {
+          if (v instanceof Date) out[k] = v.toISOString();
+          else out[k] = v;
+        }
+        return out;
+      });
+    }
     const bin = encodeBatch(rows);
-    const r = JSON.parse(native.jsqlInsertBuf(table, bin));
+    const r = safeParse(native.jsqlInsertBuf(table, bin));
     if (r && r.error) throw new Error(r.error);
     return r;
   }
@@ -331,13 +423,13 @@ class JSQL {
       var ids = remove[table];
       if (ids.size === 0) continue;
       var idsArr = Array.from(ids);
-      var r = JSON.parse(native.jsqlRemoveByIds(table, JSON.stringify(idsArr)));
+      var r = safeParse(native.jsqlRemoveByIds(table, JSON.stringify(idsArr)));
       this._emit('delete', { table, ids: idsArr, result: r });
     }
     for (var table in update) {
       var entries = update[table];
       if (entries.length === 0) continue;
-      var r = JSON.parse(native.jsqlUpdateByIds(table, JSON.stringify(entries)));
+      var r = safeParse(native.jsqlUpdateByIds(table, JSON.stringify(entries)));
       this._emit('update', { table, entries, result: r });
     }
     this._opBuffer = { remove: {}, update: {} };
@@ -401,7 +493,7 @@ class JSQL {
   async createTable(name, schema) {
     await this._flush();
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
-    const r = JSON.parse(native.jsqlCreateTable(name, JSON.stringify(schema)));
+    const r = safeParse(native.jsqlCreateTable(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
     this._tableNames.add(name);
     this._schemas[name] = schema;
@@ -413,7 +505,7 @@ class JSQL {
   async dropTable(name) {
     await this._flush();
     if (!this._runHooks('beforeDropTable', [name])) return null;
-    const r = JSON.parse(native.jsqlDropTable(name));
+    const r = safeParse(native.jsqlDropTable(name));
     if (r && r.ok === false) throw new Error(r.error || 'drop table failed');
     this._tableNames.delete(name);
     delete this._schemas[name];
@@ -425,9 +517,11 @@ class JSQL {
   findById(table, id) {
     this._flushOpsNow();
     if (!this._runHooks('beforeFind', [table, { id }])) return null;
-    const raw = JSON.parse(native.jsqlFindById(table, Number(id)));
+    const raw = safeParse(native.jsqlFindById(table, Number(id)));
     if (raw && raw.error) throw new Error(raw.error);
     this._runHooks('afterFind', [table, { id }, raw]);
+    const schema = this._schemas[table];
+    if (schema && raw && typeof raw === 'object') return restoreRow(raw, schema);
     return raw;
   }
 
@@ -435,9 +529,11 @@ class JSQL {
     this._flushOpsNow();
     if (!this._runHooks('beforeFind', [table, { ids }])) return null;
     const resultStr = native.jsqlFindByIds(table, JSON.stringify(ids));
-    const r = JSON.parse(resultStr);
+    const r = safeParse(resultStr);
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { ids }, r]);
+    const schema = this._schemas[table];
+    if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
   }
 
@@ -450,9 +546,11 @@ class JSQL {
     if (!this._runHooks('beforeFind', [table, { filter, opts }])) return [];
     const filterStr = filter ? JSON.stringify(filter) : '';
     const { limit = 100, offset = 0 } = opts;
-    const r = JSON.parse(native.jsqlFind(table, filterStr, limit, offset));
+    const r = safeParse(native.jsqlFind(table, filterStr, limit, offset));
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { filter, opts }, r]);
+    const schema = this._schemas[table];
+    if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
   }
 
@@ -520,19 +618,19 @@ class JSQL {
 
   async beginTx() {
     this._flushOpsNow();
-    const r = JSON.parse(native.jsqlBeginTx());
+    const r = safeParse(native.jsqlBeginTx());
     if (r && r.ok === false) throw new Error(r.error || 'begin transaction failed');
     return r.txId;
   }
 
   async commitTx(txId) {
-    const r = JSON.parse(native.jsqlCommitTx(String(txId)));
+    const r = safeParse(native.jsqlCommitTx(String(txId)));
     if (r && r.ok === false) throw new Error(r.error || 'commit transaction failed');
     return true;
   }
 
   async rollbackTx(txId) {
-    const r = JSON.parse(native.jsqlRollbackTx(String(txId)));
+    const r = safeParse(native.jsqlRollbackTx(String(txId)));
     if (r && r.ok === false) throw new Error(r.error || 'rollback transaction failed');
     return true;
   }

package/lib/sql.js

@@ -55,7 +55,8 @@ const KEYWORDS = new Set([
   'GROUP', 'HAVING', 'UNION', 'ALL', 'CASE', 'WHEN', 'THEN', 'ELSE', 'END',
   'BETWEEN', 'USING', 'FULL', 'UNSIGNED', 'ZEROFILL', 'TRUNCATE', 'COLLATE', 'CHARACTER',
   'ALTER', 'ADD', 'COLUMN', 'MODIFY', 'CHANGE', 'INDEX', 'FOREIGN', 'REFERENCES',
-  'CONSTRAINT', 'RENAME', 'TO', 'AFTER', 'FIRST', 'ENGINE', 'AUTO_INCREMENT', 'SPATIAL'
+  'CONSTRAINT', 'RENAME', 'TO', 'AFTER', 'FIRST', 'ENGINE', 'AUTO_INCREMENT', 'SPATIAL',
+  'REGEXP', 'TRUE', 'FALSE', 'RLIKE'
 ]);
 
 function tokenize(sql) {
@@ -284,16 +285,28 @@ class Parser {
         if (t.value === 'PRIMARY') {
           this.expectKeyword('PRIMARY'); this.expectKeyword('KEY');
           this.expect('op', '(');
-          const pkCol = this.parseTableName();
+          const pkCols = [this.parseTableName()];
+          while (this.peek().type === 'op' && this.peek().value === ',') {
+            this.next();
+            pkCols.push(this.parseTableName());
+          }
           this.expect('op', ')');
-          if (schema[pkCol]) schema[pkCol].primaryKey = true;
+          for (const pkCol of pkCols) {
+            if (schema[pkCol]) schema[pkCol].primaryKey = true;
+          }
           hasPk = true;
         } else {
           this.expectKeyword('UNIQUE');
           this.expect('op', '(');
-          const uCol = this.parseTableName();
+          const uCols = [this.parseTableName()];
+          while (this.peek().type === 'op' && this.peek().value === ',') {
+            this.next();
+            uCols.push(this.parseTableName());
+          }
           this.expect('op', ')');
-          if (schema[uCol]) schema[uCol].unique = true;
+          for (const uCol of uCols) {
+            if (schema[uCol]) schema[uCol].unique = true;
+          }
         }
       } else if (t.type === 'keyword' && t.value === 'CONSTRAINT') {
         this.expectKeyword('CONSTRAINT');
@@ -573,8 +586,9 @@ class Parser {
     if (this.isKeyword('LIMIT')) {
       this.next();
       limit = this.parseValue();
-      if (this.isKeyword('OFFSET')) { this.next(); offset = this.parseValue(); }
-      else if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); offset = limit; limit = this.parseValue(); }
+      if (typeof limit === 'number' && limit < 0) throw new Error(`LIMIT must be a non-negative integer, got ${limit}`);
+      if (this.isKeyword('OFFSET')) { this.next(); offset = this.parseValue(); if (typeof offset === 'number' && offset < 0) throw new Error(`OFFSET must be a non-negative integer, got ${offset}`); }
+      else if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); offset = limit; limit = this.parseValue(); if (typeof limit === 'number' && limit < 0) throw new Error(`LIMIT must be a non-negative integer, got ${limit}`); }
     }
     let union = null;
     if (this.isKeyword('UNION')) {
@@ -672,7 +686,7 @@ class Parser {
     while (true) {
       const col = this.parseColumnRef();
       this.expect('op', '=');
-      assignments.push([col, this.parseValue()]);
+      assignments.push([col, this.parseScalar()]);
       if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
       break;
     }
@@ -1012,7 +1026,7 @@ class Parser {
     if (t.type === 'sysvar') return { type: 'sysvar', name: t.value };
     if (t.type === 'keyword' && t.value === 'NULL') return { type: 'value', value: null };
     if (t.type === 'keyword' && t.value === 'CASE') return this.parseCase();
-    if (t.type === 'keyword' && this.peek().type === 'op' && this.peek().value === '(') {
+    if (t.type === 'keyword' && !['SUM', 'AVG', 'MIN', 'MAX', 'COUNT'].includes(t.value) && this.peek().type === 'op' && this.peek().value === '(') {
       const name = t.value;
       this.next();
       const args = [];
@@ -1061,6 +1075,39 @@ class Parser {
       }
       break;
     }
+    // 后缀：expr IN (...)、expr IS [NOT] TRUE/FALSE/NULL（标量上下文，如 SELECT 1 IN (...))
+    for (;;) {
+      const t = this.peek();
+      if (t.type === 'keyword' && t.value === 'IN') {
+        this.next();
+        this.expect('op', '(');
+        if (this.isKeyword('SELECT')) {
+          const sub = this.parseSelect();
+          this.expect('op', ')');
+          node = { type: 'in', operand: node, subquery: sub };
+        } else {
+          const list = [];
+          while (true) {
+            list.push(this.parseValue());
+            if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
+            break;
+          }
+          this.expect('op', ')');
+          node = { type: 'in', operand: node, list };
+        }
+        continue;
+      }
+      if (t.type === 'keyword' && t.value === 'IS') {
+        this.next();
+        const not = this.isKeyword('NOT');
+        if (not) this.next();
+        if (this.isKeyword('NULL')) { this.next(); node = { type: 'isNull', operand: node, not: !!not }; continue; }
+        if (this.isKeyword('TRUE')) { this.next(); node = { type: 'isTruth', operand: node, not: !!not, truth: true }; continue; }
+        if (this.isKeyword('FALSE')) { this.next(); node = { type: 'isTruth', operand: node, not: !!not, truth: false }; continue; }
+        throw new Error(`Expected NULL, TRUE or FALSE after IS, got '${this.peek().value}'`);
+      }
+      break;
+    }
     return node;
   }
 
@@ -1108,23 +1155,39 @@ class Parser {
   parseComparison() {
     const left = this.parseOperand();
     const t = this.peek();
+    let not = false;
+    if (t.type === 'keyword' && t.value === 'NOT') {
+      this.next();
+      not = true;
+      // NOT 后必须紧跟比较关键字
+      const n = this.peek();
+      if (!['IN', 'BETWEEN', 'LIKE', 'REGEXP'].includes(n.value)) {
+        throw new Error(`Expected IN, BETWEEN, LIKE or REGEXP after NOT, got '${n.value}'`);
+      }
+    }
+    const t2 = this.peek();
 
-    if (t.type === 'keyword' && t.value === 'IS') {
+    if (t2.type === 'keyword' && t2.value === 'IS') {
       this.next();
-      const not = this.isKeyword('NOT');
-      if (not) this.next();
-      this.expectKeyword('NULL');
-      return { type: 'isNull', operand: left, not: !!not };
+      const n = this.isKeyword('NOT');
+      if (n) this.next();
+      if (this.isKeyword('NULL')) {
+        this.next();
+        return { type: 'isNull', operand: left, not: not || !!n };
+      }
+      if (this.isKeyword('TRUE')) { this.next(); return { type: 'isTruth', operand: left, not: not || !!n, truth: true }; }
+      if (this.isKeyword('FALSE')) { this.next(); return { type: 'isTruth', operand: left, not: not || !!n, truth: false }; }
+      throw new Error(`Expected NULL, TRUE or FALSE after IS, got '${this.peek().value}'`);
     }
 
-    if (t.type === 'keyword' && t.value === 'IN') {
+    if (t2.type === 'keyword' && t2.value === 'IN') {
       this.next();
       this.expect('op', '(');
       // IN (SELECT ...) 子查询
       if (this.isKeyword('SELECT')) {
         const sub = this.parseSelect();
         this.expect('op', ')');
-        return { type: 'in', operand: left, subquery: sub };
+        return { type: 'in', operand: left, subquery: sub, not };
       }
       const list = [];
       while (true) {
@@ -1133,13 +1196,12 @@ class Parser {
         break;
       }
       this.expect('op', ')');
-      return { type: 'in', operand: left, list };
+      return { type: 'in', operand: left, list, not };
     }
 
-    if (t.type === 'keyword' && t.value === 'BETWEEN') {
+    if (t2.type === 'keyword' && t2.value === 'BETWEEN') {
       this.next();
       const low = this.parseOperand();
-      const not = false;
       let andTok = this.peek();
       if (andTok.type === 'keyword' && andTok.value === 'AND') {
         this.next();
@@ -1149,19 +1211,25 @@ class Parser {
       throw new Error(`Expected AND in BETWEEN, got '${andTok.value}'`);
     }
 
-    if (t.type === 'keyword' && t.value === 'LIKE') {
+    if (t2.type === 'keyword' && t2.value === 'LIKE') {
+      this.next();
+      const pattern = this.parseValue();
+      return { type: 'like', operand: left, pattern, not };
+    }
+
+    if (t2.type === 'keyword' && t2.value === 'REGEXP') {
       this.next();
       const pattern = this.parseValue();
-      return { type: 'like', operand: left, pattern };
+      return { type: 'regexp', operand: left, pattern, not };
     }
 
-    if (t.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>='].includes(t.value)) {
+    if (t2.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>='].includes(t2.value)) {
       this.next();
       const right = this.parseOperand();
-      return { type: 'compare', op: t.value === '<>' ? '!=' : t.value, left, right };
+      return { type: 'compare', op: t2.value === '<>' ? '!=' : t2.value, left, right };
     }
 
-    throw new Error(`Expected comparison operator, got '${t.value}'`);
+    throw new Error(`Expected comparison operator, got '${t2.value}'`);
   }
 }
 
@@ -1232,6 +1300,13 @@ function resolveOperand(operand, row, ctx) {
       return applyScalarFunction(operand, row, ctx);
     case 'case':
       return evaluateCaseVal(operand, row, ctx);
+    case 'in':
+    case 'isNull':
+    case 'isTruth':
+    case 'regexp':
+    case 'like':
+    case 'between':
+      return evaluateExpr(operand, row, ctx);
     case 'aggregate':
     case 'subquery':
       return undefined;
@@ -1262,7 +1337,10 @@ function applyScalarFunction(fnNode, row, ctx) {
     case 'CURTIME': return new Date().toISOString().slice(11, 19);
     case 'UTC_TIMESTAMP': return new Date().toISOString().slice(0, 19).replace('T', ' ') + ' UTC';
     case 'CONCAT': return args.map(a => a === null || a === undefined ? '' : String(a)).join('');
-    case 'CONCAT_WS': return (args.slice(1).map(a => a === null || a === undefined ? '' : String(a))).join(args[0] == null ? ',' : String(args[0]));
+    case 'CONCAT_WS': {
+      const sep = args[0] == null ? ',' : String(args[0]);
+      return args.slice(1).filter(a => a !== null && a !== undefined).map(a => String(a)).join(sep);
+    }
     case 'UPPER': case 'UCASE': return args[0] == null ? null : String(args[0]).toUpperCase();
     case 'LOWER': case 'LCASE': return args[0] == null ? null : String(args[0]).toLowerCase();
     case 'LENGTH': case 'CHAR_LENGTH': case 'CHARACTER_LENGTH': return args[0] == null ? null : String(args[0]).length;
@@ -1284,8 +1362,16 @@ function applyScalarFunction(fnNode, row, ctx) {
     case 'SUBSTRING': case 'SUBSTR': {
       if (args[0] == null) return null;
       const s = String(args[0]);
-      const start = Number(args[1]);
-      if (args[2] !== undefined) return s.substr(start - 1, Number(args[2]));
+      const len = s.length;
+      let start = Number(args[1]);
+      // MySQL 语义：1-based；负数从末尾倒数；0 视为 1（MySQL 返回空串）
+      if (start === 0) return '';
+      if (start < 0) start = len + start + 1;
+      if (args[2] !== undefined) {
+        let n = Number(args[2]);
+        if (n < 0) return '';
+        return s.substr(start - 1, n);
+      }
       return s.substr(start - 1);
     }
     case 'LEFT': return args[0] == null ? null : String(args[0]).slice(0, Number(args[1]));
@@ -1295,6 +1381,33 @@ function applyScalarFunction(fnNode, row, ctx) {
       const idx = String(args[1]).indexOf(String(args[0]));
       return idx + 1;
     }
+    case 'REVERSE': return args[0] == null ? null : String(args[0]).split('').reverse().join('');
+    case 'LPAD': {
+      if (args[0] == null) return null;
+      let s = String(args[0]);
+      const n = Number(args[1]);
+      const pad = args[2] == null ? ' ' : String(args[2]);
+      if (n <= s.length) return s.slice(0, n);
+      while (s.length < n) s = pad + s;
+      return s;
+    }
+    case 'RPAD': {
+      if (args[0] == null) return null;
+      let s = String(args[0]);
+      const n = Number(args[1]);
+      const pad = args[2] == null ? ' ' : String(args[2]);
+      if (n <= s.length) return s.slice(0, n);
+      while (s.length < n) s = s + pad;
+      return s;
+    }
+    case 'RAND': return args.length > 0 && args[0] != null ? seedRand(Number(args[0]))() : Math.random();
+    case 'UNIX_TIMESTAMP': {
+      if (args.length > 0 && args[0] != null) {
+        const d = new Date(String(args[0]).replace(' ', 'T'));
+        return isNaN(d.getTime()) ? 0 : Math.floor(d.getTime() / 1000);
+      }
+      return Math.floor(Date.now() / 1000);
+    }
     case 'GREATEST': return args.reduce((m, a) => a > m ? a : m, args[0]);
     case 'LEAST': return args.reduce((m, a) => a < m ? a : m, args[0]);
     case 'UUID': return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
@@ -1307,6 +1420,15 @@ function applyScalarFunction(fnNode, row, ctx) {
   }
 }
 
+function seedRand(seed) {
+  let s = Math.abs(seed) % 2147483647;
+  if (s <= 0) s = 1;
+  return () => {
+    s = (s * 16807) % 2147483647;
+    return (s - 1) / 2147483646;
+  };
+}
+
 function likeMatch(value, pattern) {
   if (typeof value !== 'string') return false;
   const regex = pattern
@@ -1350,8 +1472,9 @@ function evaluateExpr(expr, row, ctx) {
     case 'compare': {
       const l = resolveOperand(expr.left, row, ctx);
       const r = resolveOperand(expr.right, row, ctx);
-      if (expr.op === '=') return l === r || (l === null && r === null) || (l !== null && r !== null && String(l) === String(r));
+      // SQL 标准：任何与 NULL 的比较结果为 UNKNOWN（在 WHERE/ON/HAVING 中视为 false）
       if (l === null || r === null) return false;
+      if (expr.op === '=') return l === r || (l !== null && r !== null && String(l) === String(r));
       const fn = OPERATORS[expr.op];
       return typeof l === 'number' && typeof r === 'number' ? fn(l, r) : fn(String(l), String(r));
     }
@@ -1366,7 +1489,24 @@ function evaluateExpr(expr, row, ctx) {
       if (!expr.list) return false;
       return expr.list.some(x => x === v || String(x) === String(v));
     }
-    case 'like': return likeMatch(resolveOperand(expr.operand, row, ctx), expr.pattern);
+    case 'like': {
+      const r = likeMatch(resolveOperand(expr.operand, row, ctx), expr.pattern);
+      return expr.not ? !r : r;
+    }
+    case 'regexp': {
+      const v = resolveOperand(expr.operand, row, ctx);
+      if (v === null || v === undefined) return false;
+      const re = new RegExp(String(expr.pattern), 'i');
+      const r = re.test(String(v));
+      return expr.not ? !r : r;
+    }
+    case 'isTruth': {
+      const v = resolveOperand(expr.operand, row, ctx);
+      const isTrue = v === true || v === 1 || v === '1' || v === 'true' || v === 'TRUE' || v === 't' || (typeof v === 'number' && v !== 0);
+      const isFalse = !isTrue && v !== null && v !== undefined;
+      const result = expr.truth ? isTrue : isFalse;
+      return expr.not ? !result : result;
+    }
     case 'between': {
       const v = resolveOperand(expr.operand, row, ctx);
       const lo = resolveOperand(expr.low, row, ctx);
@@ -1608,7 +1748,10 @@ class SQLExecutor {
           if (explicit.length > 0) {
             const all = (await this.engine.find(statement.name, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
             const pkMap = new Map();
-            for (const row of all) pkMap.set(keyOf(row), row.id);
+            for (const row of all) {
+              const keys = pkCols.map(c => row[c]).filter(v => v !== undefined && v !== null);
+              if (keys.length === pkCols.length) pkMap.set(keyOf(row), keys);
+            }
             const conflicts = [];
             const fresh = [];
             for (const d of dataRows) {
@@ -1626,7 +1769,13 @@ class SQLExecutor {
               for (const { d, existingId } of conflicts) {
                 const data = {};
                 for (const [col, val] of statement.onDuplicate) data[col] = val;
-                this.engine.updateById(statement.name, existingId, data);
+                if (this.engine.updateById && existingId.length === 1) {
+                  this.engine.updateById(statement.name, existingId[0], data);
+                } else if (this.engine.update) {
+                  const filter = {};
+                  pkCols.forEach((c, i) => { filter[c] = existingId[i]; });
+                  this.engine.update(statement.name, filter, data);
+                }
                 updated++;
               }
               await this.engine.flush();
@@ -1677,7 +1826,9 @@ class SQLExecutor {
             const id = row._rid !== undefined ? row._rid : row.id;
             if (id !== undefined) {
               const data = {};
-              for (const [col, val] of statement.assignments) data[col] = val;
+              for (const [col, val] of statement.assignments) {
+                data[col] = typeof val === 'object' && val !== null && val.type ? resolveOperand(val, row, this.ctx) : val;
+              }
               this.engine.updateById(statement.table, id, data);
               count++;
             }

package/lib/wasm_client.js

@@ -5,6 +5,64 @@ function safeJsonParse(str) {
   try { return JSON.parse(str); } catch { return str; }
 }
 
+const NATIVE_TYPE_MAP = {
+  text: 'string',
+  varchar: 'string',
+  double: 'float',
+  number: 'float',
+  numeric: 'float',
+  decimal: 'float',
+  date: 'string',
+  timestamp: 'string',
+  datetime: 'string',
+  json: 'string',
+  array: 'string',
+  object: 'string',
+  bool: 'boolean',
+  bigint: 'string',
+  int: 'integer',
+};
+
+function mapNativeSchema(schema) {
+  const mapped = {};
+  for (const [field, def] of Object.entries(schema || {})) {
+    if (typeof def === 'string') {
+      mapped[field] = { type: NATIVE_TYPE_MAP[def.toLowerCase()] || def.toLowerCase() };
+    } else if (def && typeof def === 'object') {
+      const t = (def.type || 'string').toLowerCase();
+      mapped[field] = { ...def, type: NATIVE_TYPE_MAP[t] || t };
+    } else {
+      mapped[field] = { type: 'string' };
+    }
+  }
+  return mapped;
+}
+
+function restoreRow(row, schema) {
+  if (!schema || typeof row !== 'object' || row === null) return row;
+  const out = {};
+  for (const [field, def] of Object.entries(row)) {
+    if (field === 'fields' && typeof row[field] === 'object' && row[field] !== null) {
+      out[field] = restoreRow(row[field], schema);
+      continue;
+    }
+    const colDef = schema[field];
+    let t = null;
+    if (typeof colDef === 'string') t = colDef.toLowerCase();
+    else if (colDef && typeof colDef === 'object' && colDef.type) t = String(colDef.type).toLowerCase();
+    if (['json', 'array', 'object'].includes(t) && typeof row[field] === 'string') {
+      try { out[field] = JSON.parse(row[field]); } catch (e) { out[field] = row[field]; }
+    } else if ((t === 'integer' || t === 'int' || t === 'bigint') && typeof row[field] === 'string' && /^-?\d+$/.test(row[field])) {
+      out[field] = Number(row[field]);
+    } else if ((t === 'float' || t === 'double' || t === 'number') && typeof row[field] === 'string' && !Number.isNaN(Number(row[field]))) {
+      out[field] = Number(row[field]);
+    } else {
+      out[field] = row[field];
+    }
+  }
+  return out;
+}
+
 const INT64_TAG = 1;
 const FLOAT_TAG = 2;
 const STR_TAG = 3;
@@ -267,6 +325,26 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    const schema = this._schemas[table];
+    if (schema) {
+      rows = rows.map(row => {
+        const out = {};
+        for (const [k, v] of Object.entries(row)) {
+          const def = schema[k];
+          let t = null;
+          if (typeof def === 'string') t = def.toLowerCase();
+          else if (def && typeof def === 'object' && def.type) t = String(def.type).toLowerCase();
+          if (v !== null && v !== undefined && ['json', 'array', 'object'].includes(t) && typeof v !== 'string') {
+            out[k] = JSON.stringify(v);
+          } else if (v instanceof Date) {
+            out[k] = v.toISOString();
+          } else {
+            out[k] = v;
+          }
+        }
+        return out;
+      });
+    }
     const r = safeJsonParse(wasmBindings.jsql_insert_json(table, JSON.stringify(rows)));
     if (r && r.error) throw new Error(r.error);
     return r;
@@ -320,7 +398,7 @@ class JSQL {
   async createTable(name, schema) {
     await this._flush();
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
-    const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(schema)));
+    const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
     this._tableNames.add(name);
     this._schemas[name] = schema;
@@ -347,6 +425,8 @@ class JSQL {
     const r = safeJsonParse(wasmBindings.jsql_find_by_id(table, BigInt(id)));
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { id }, r]);
+    const schema = this._schemas[table];
+    if (schema && r && typeof r === 'object') return restoreRow(r, schema);
     return r;
   }
 
@@ -358,6 +438,8 @@ class JSQL {
     const r = safeJsonParse(wasmBindings.jsql_find(table, filterStr, limit, offset));
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { filter, opts }, r]);
+    const schema = this._schemas[table];
+    if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
   }
 
@@ -397,6 +479,8 @@ class JSQL {
     const r = safeJsonParse(wasmBindings.jsql_find_by_ids(table, JSON.stringify(ids)));
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { ids }, r]);
+    const schema = this._schemas[table];
+    if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
   }
 

package/package.json

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