jsql-neo 5.2.1 → 5.3.1

package/bin/jsql

@@ -215,6 +215,19 @@ const cli = yaggs({ pkg: require('../package.json') })
       setInterval(() => {}, 1 << 30);
     } catch (e) { console.error(`Error: ${e.message}`); process.exitCode = 1; }
   })
+  .command('tui', 'Interactive SQL terminal (zero-dependency TUI)', (sub) => {
+    sub.option('data-dir', { alias: ['d'], type: 'string', description: 'Data directory (default: in-memory)' });
+    sub.option('db', { type: 'string', description: 'Database name (default: default)' });
+    sub.option('dialect', { alias: ['t'], type: 'string', description: 'SQL dialect: mysql|pg (default: mysql)' });
+  }, (argv) => {
+    const { createTUI } = require('../lib/tui');
+    const tui = createTUI({
+      dataDir: argv['data-dir'],
+      db: argv.db || 'default',
+      dialect: argv.dialect || 'mysql',
+    });
+    tui.run().catch((e) => { console.error(`Error: ${e.message}`); process.exit(1); });
+  })
   .command('redis', 'Run the Redis-compatible server', (sub) => {
     sub.option('port', { alias: ['p'], type: 'number', description: 'Listen port (default 6379)' });
     sub.option('host', { type: 'string', description: 'Listen host (default 127.0.0.1)' });

package/index.js

@@ -22,6 +22,10 @@ const { createMysqlServer, MysqlServer } = require('./lib/mysql_server');
 const migrate = require('./lib/migrate');
 const { WebUI } = require('./lib/web_ui');
 const { RedisServer, createRedisServer } = require('./lib/redis_server');
+const { PgServer, createPgServer } = require('./lib/pg_server');
+const { MongoServer, createMongoServer } = require('./lib/mongo_server');
+const { MultiServer, createMultiServer } = require('./lib/multiserver');
+const { TUIShell, createTUI } = require('./lib/tui');
 
 /**
  * 全局注入：把项目内 `require('mysql2')` 全部替换为 jsql-neo 内存引擎兼容层。
@@ -99,4 +103,16 @@ module.exports = {
     // Redis 兼容服务器
     RedisServer,
     createRedisServer,
+    // PostgreSQL wire protocol 服务器
+    PgServer,
+    createPgServer,
+    // MongoDB wire protocol 服务器
+    MongoServer,
+    createMongoServer,
+    // 多协议嗅探服务器（MySQL + PG + Redis + Mongo 同端口）
+    MultiServer,
+    createMultiServer,
+    // 交互式 TUI
+    TUIShell,
+    createTUI,
 };

package/lib/mongo_server.js

@@ -322,7 +322,7 @@ class MongoServer {
           localTime: new Date(), logicalSessionTimeoutMinutes: 30, connectionId: 1,
         };
       case 'ping': return { ok: 1 };
-      case 'buildInfo': return { ok: 1, version: '5.2.1-jsql-neo', gitVersion: 'jsql-neo', versionArray: [5, 2, 1, 0] };
+      case 'buildInfo': return { ok: 1, version: '5.3.1-jsql-neo', gitVersion: 'jsql-neo', versionArray: [5, 3, 1, 0] };
       case 'getParameter': return { ok: 1 };
       case 'endSessions': return { ok: 1 };
       case 'listDatabases':
@@ -357,13 +357,53 @@ class MongoServer {
         }
         return { ok: 1, n: docs.length };
       }
+      case 'findAndModify': {
+        const coll = String(doc.findAndModify);
+        const engine = await this._ensureCollection(coll);
+        const q = doc.query || {};
+        const rows = this._matching(engine, coll, q);
+        const found = rows[0] || null;
+        const set = doc.update && doc.update.$set ? doc.update.$set : (doc.update || {});
+        let value = null;
+        if (found) {
+          if (doc.remove) {
+            this._removeRows(engine, coll, [found]);
+            value = found;
+          } else {
+            const patched = { ...found, ...set };
+            this._patchRows(engine, coll, [found], set);
+            value = doc.new ? patched : found;
+          }
+        } else if (doc.upsert) {
+          const merged = { ...q, ...set };
+          const id = engine.insert(coll, merged);
+          value = doc.new ? { ...merged, _id: id } : null;
+        }
+        return { ok: 1, value, lastErrorObject: { n: found ? 1 : (doc.upsert ? 1 : 0), updatedExisting: !!found && !doc.remove } };
+      }
+      case 'distinct': {
+        const coll = String(doc.distinct);
+        const engine = await this._ensureCollection(coll);
+        const key = String(doc.key || '');
+        const rows = this._matching(engine, coll, doc.query);
+        const seen = new Set();
+        const values = [];
+        for (const r of rows) {
+          const v = r[key];
+          if (!seen.has(JSON.stringify(v))) { seen.add(JSON.stringify(v)); values.push(v); }
+        }
+        return { ok: 1, values };
+      }
+      case 'dropDatabase':
+        return { ok: 1, dropped: String(doc.dropDatabase || this._dbOf(doc)) };
       case 'find': {
         const coll = String(doc.find);
         const engine = await this._ensureCollection(coll);
-        const rows = engine.find(coll, doc.filter || {}, {
-          limit: typeof doc.limit === 'number' ? doc.limit : 0,
-          offset: typeof doc.skip === 'number' ? doc.skip : 0,
-        });
+        let rows = this._matching(engine, coll, doc.filter);
+        const skip = typeof doc.skip === 'number' ? doc.skip : 0;
+        if (skip > 0) rows = rows.slice(skip);
+        const limit = typeof doc.limit === 'number' ? doc.limit : 0;
+        if (limit > 0) rows = rows.slice(0, limit);
         return { ok: 1, cursor: { id: { $long: 0 }, ns: `${this._dbOf(doc)}.${coll}`, firstBatch: rows } };
       }
       case 'getMore':
@@ -377,7 +417,8 @@ class MongoServer {
           const q = u.q || {};
           const set = u.u && u.u.$set ? u.u.$set : (u.u || {});
           // 单文档更新
-          let target = engine.find(coll, q, { limit: 1 })[0] || null;
+          let targets = this._matching(engine, coll, q);
+          let target = targets[0] || null;
           if (!target && u.upsert) {
             const merged = { ...q, ...set };
             engine.insert(coll, merged);
@@ -385,7 +426,7 @@ class MongoServer {
             continue;
           }
           if (target) {
-            engine.update(coll, q, set);
+            this._patchRows(engine, coll, [target], set);
             n++;
           }
         }
@@ -396,15 +437,16 @@ class MongoServer {
         const engine = await this._ensureCollection(coll);
         let n = 0;
         for (const d of (doc.deletes || [])) {
-          const res = engine.removeWhere(coll, d.q || {});
-          n += res.count;
+          const rows = this._matching(engine, coll, d.q || {});
+          if (rows.length > 0) this._removeRows(engine, coll, rows);
+          n += rows.length;
         }
         return { ok: 1, n };
       }
       case 'count': {
         const coll = String(doc.count);
         const engine = await this._ensureCollection(coll);
-        const rows = engine.find(coll, doc.query || {});
+        const rows = this._matching(engine, coll, doc.query);
         return { ok: 1, n: Number(doc.limit) > 0 ? Math.min(rows.length, doc.limit) : rows.length };
       }
       case 'aggregate': {
@@ -416,6 +458,46 @@ class MongoServer {
           if (stage.$match) rows = rows.filter((r) => this._match(r, stage.$match));
           else if (stage.$count) rows = [{ [stage.$count]: rows.length }];
           else if (stage.$limit) rows = rows.slice(0, stage.$limit);
+          else if (stage.$skip) rows = rows.slice(Number(stage.$skip) || 0);
+          else if (stage.$sort) {
+            const sortKeys = Object.entries(stage.$sort);
+            rows = [...rows].sort((a, b) => {
+              for (const [k, dir] of sortKeys) {
+                const av = a[k]; const bv = b[k];
+                if (av === bv) continue;
+                if (av == null) return 1;
+                if (bv == null) return -1;
+                const cmp = av < bv ? -1 : 1;
+                return Number(dir) < 0 ? -cmp : cmp;
+              }
+              return 0;
+            });
+          }
+          else if (stage.$project) {
+            const proj = stage.$project;
+            rows = rows.map((r) => {
+              const out = {};
+              for (const [k, v] of Object.entries(proj)) {
+                if (k === '_id' && v === 0) continue;
+                if (v === 0) continue;
+                if (typeof v === 'string' && v.startsWith('$')) out[k] = r[v.slice(1)];
+                else if (v === 1) out[k] = r[k];
+                else if (v === 0) { /* exclude */ }
+                else out[k] = v;
+              }
+              return out;
+            });
+          }
+          else if (stage.$unwind) {
+            const field = String(stage.$unwind).replace(/^\$/, '');
+            const out = [];
+            for (const r of rows) {
+              const arr = r[field];
+              if (!Array.isArray(arr) || arr.length === 0) { out.push({ ...r, [field]: null }); continue; }
+              for (const item of arr) out.push({ ...r, [field]: item });
+            }
+            rows = out;
+          }
           else if (stage.$group) {
             const acc = {};
             for (const [k, v] of Object.entries(stage.$group)) {
@@ -435,12 +517,45 @@ class MongoServer {
     return row._id != null ? row._id : row.id;
   }
 
+  _matching(engine, coll, filter) {
+    return engine.find(coll, {}).filter((r) => this._match(r, filter || {}));
+  }
+
+  _patchRows(engine, coll, rows, set) {
+    const table = engine._ensureTable(coll);
+    for (const r of rows) Object.assign(r, set);
+    table._rebuildPKIndex && table._rebuildPKIndex();
+    table._rebuildAllBTrees && table._rebuildAllBTrees();
+    engine._markDirty && engine._markDirty(coll);
+  }
+
+  _removeRows(engine, coll, rows) {
+    const table = engine._ensureTable(coll);
+    const gone = new Set(rows);
+    table._rows = table._rows.filter((r) => !gone.has(r));
+    table._rebuildPKIndex && table._rebuildPKIndex();
+    table._rebuildAllBTrees && table._rebuildAllBTrees();
+    engine._markDirty && engine._markDirty(coll);
+  }
+
   _match(row, filter) {
     for (const [k, cond] of Object.entries(filter || {})) {
       if (k === '$or') {
         if (!cond.some((f) => this._match(row, f))) return false;
         continue;
       }
+      if (k === '$and') {
+        if (!cond.every((f) => this._match(row, f))) return false;
+        continue;
+      }
+      if (k === '$nor') {
+        if (cond.some((f) => this._match(row, f))) return false;
+        continue;
+      }
+      if (k === '$not') {
+        if (this._match(row, cond)) return false;
+        continue;
+      }
       if (cond && typeof cond === 'object' && !Array.isArray(cond)) {
         for (const [op, v] of Object.entries(cond)) {
           const rv = row[k];
@@ -452,6 +567,16 @@ class MongoServer {
           if (op === '$in' && !(v.includes(rv))) return false;
           if (op === '$nin' && v.includes(rv)) return false;
           if (op === '$exists' && (v ? (rv === undefined) : (rv !== undefined))) return false;
+          if (op === '$regex') {
+            const flags = String(cond.$options || '').includes('i') ? 'i' : '';
+            if (typeof rv !== 'string' || !new RegExp(String(v), flags).test(rv)) return false;
+          }
+          if (op === '$type') {
+            const t = v === 'string' ? 'string' : v === 'int' || v === 'long' || v === 'double' || v === 'number' ? 'number' : v === 'bool' ? 'boolean' : v === 'null' ? 'null' : v === 'array' ? 'array' : typeof rv;
+            if (typeof rv !== t) return false;
+          }
+          if (op === '$size' && !(Array.isArray(rv) && rv.length === v)) return false;
+          if (op === '$elemMatch' && !(Array.isArray(rv) && rv.some((el) => this._match(el, v)))) return false;
         }
       } else if (row[k] !== cond) {
         return false;

package/lib/query.js

@@ -537,7 +537,7 @@ class Query {
                 const key = fr[join.foreignField];
                 const matches = localRows.filter(lr => lr[join.localField] === key);
                 if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join, true) });
+                    result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {
                         result.push(this._mergeJoinRow(lr, fr, join));
@@ -582,7 +582,7 @@ class Query {
             for (const fr of foreignRows) {
                 const matches = localRows.filter(lr => lr[join.localField] === fr[join.foreignField]);
                 if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join, true) });
+                    result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {
                         result.push(this._mergeJoinRow(lr, fr, join));
@@ -621,6 +621,24 @@ class Query {
         return nulls;
     }
 
+    /**
+     * RIGHT JOIN 未匹配右表行：保留右表数据，本地表字段填 null。
+     * 返回 { localNulls, merged }，其中 merged = { ...nulls, ...fr }
+     */
+    _rightNullRow(localRows, foreignRow, join) {
+        const localSchema = this._table._schema || {};
+        const localNulls = {};
+        for (const field of Object.keys(localSchema)) {
+            if (field !== '_softDelete') localNulls[field] = null;
+        }
+        const prefix = join.as ? join.as + '_' : '';
+        const foreignPrefixed = {};
+        for (const [key, value] of Object.entries(foreignRow)) {
+            foreignPrefixed[prefix + key] = value;
+        }
+        return { ...localNulls, ...foreignPrefixed };
+    }
+
     // ============================================================
     // 内部: 排序
     // ============================================================

package/lib/redis_server.js

@@ -24,9 +24,11 @@ const TYPE_SIGNATURES = {
   PING: 0, ECHO: 1, SET: 2, SETNX: 2, GET: 1, DEL: -1, EXISTS: -1, KEYS: 1,
   TYPE: 1, EXPIRE: 2, TTL: 1, PERSIST: 1,
   INCR: 1, DECR: 1, INCRBY: 2, DECRBY: 2, APPEND: 2, STRLEN: 1,
+  MSET: -2, MGET: -1,
   HSET: -3, HGET: 2, HGETALL: 1, HDEL: -2, HEXISTS: 2, HLEN: 1, HKEYS: 1, HVALS: 1,
   LPUSH: -2, RPUSH: -2, LPOP: 1, RPOP: 1, LLEN: 1, LRANGE: 3, LINDEX: 2, LREM: 3,
   SADD: -2, SREM: -2, SMEMBERS: 1, SISMEMBER: 2, SCARD: 1,
+  ZADD: -3, ZRANGE: -3, ZREVRANGE: -3, ZSCORE: 2, ZCARD: 1, ZREM: -2, ZINCRBY: 3,
   DBSIZE: 0, FLUSHALL: 0, FLUSHDB: 0, SELECT: 1, INFO: 0, AUTH: 1, QUIT: 0,
 };
 
@@ -333,6 +335,109 @@ class RedisServer {
         const v = this._get(args[0]);
         return v && v.type === 'set' ? v.val.length : 0;
       }
+      case 'ZADD': {
+        const key = args[0];
+        const v = this._get(key);
+        let zset;
+        if (v && v.type === 'zset') zset = v.val;
+        else if (v) throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        else { this.db.set(key, { type: 'zset', val: {} }); zset = this.db.get(key).val; }
+        const rest = args.slice(1);
+        if (rest.length % 2 !== 0) throw new Error('ERR syntax error');
+        let added = 0;
+        for (let i = 0; i < rest.length; i += 2) {
+          const score = parseFloat(rest[i]);
+          const member = rest[i + 1];
+          if (isNaN(score)) throw new Error('ERR value is not a valid float');
+          if (!(member in zset)) added++;
+          zset[member] = score;
+        }
+        this._scheduleSnapshot();
+        return added;
+      }
+      case 'ZRANGE': {
+        const v = this._get(args[0]);
+        if (!v) return [];
+        if (v.type !== 'zset') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        const start = parseInt(args[1], 10);
+        const stop = parseInt(args[2], 10);
+        const withScores = args[3] && args[3].toUpperCase() === 'WITHSCORES';
+        const entries = Object.entries(v.val).sort((a, b) => a[1] - b[1] || (a[0] < b[0] ? -1 : 1));
+        const from = start < 0 ? Math.max(0, entries.length + start) : start;
+        const to = stop < 0 ? entries.length + stop : stop;
+        const out = [];
+        for (let i = from; i <= to && i < entries.length; i++) {
+          out.push(entries[i][0]);
+          if (withScores) out.push(entries[i][1]);
+        }
+        return out;
+      }
+      case 'ZREVRANGE': {
+        const v = this._get(args[0]);
+        if (!v) return [];
+        if (v.type !== 'zset') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        const start = parseInt(args[1], 10);
+        const stop = parseInt(args[2], 10);
+        const withScores = args[3] && args[3].toUpperCase() === 'WITHSCORES';
+        const entries = Object.entries(v.val).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? 1 : -1));
+        const from = start < 0 ? Math.max(0, entries.length + start) : start;
+        const to = stop < 0 ? entries.length + stop : stop;
+        const out = [];
+        for (let i = from; i <= to && i < entries.length; i++) {
+          out.push(entries[i][0]);
+          if (withScores) out.push(entries[i][1]);
+        }
+        return out;
+      }
+      case 'ZSCORE': {
+        const v = this._get(args[0]);
+        if (!v || v.type !== 'zset' || !(args[1] in v.val)) return null;
+        return v.val[args[1]];
+      }
+      case 'ZCARD': {
+        const v = this._get(args[0]);
+        if (!v) return 0;
+        if (v.type !== 'zset') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        return Object.keys(v.val).length;
+      }
+      case 'ZREM': {
+        const v = this._get(args[0]);
+        if (!v) return 0;
+        if (v.type !== 'zset') throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        let n = 0;
+        for (const m of args.slice(1)) {
+          if (m in v.val) { delete v.val[m]; n++; }
+        }
+        this._scheduleSnapshot();
+        return n;
+      }
+      case 'ZINCRBY': {
+        const key = args[0];
+        const inc = parseFloat(args[1]);
+        if (isNaN(inc)) throw new Error('ERR value is not a valid float');
+        const v = this._get(key);
+        let zset;
+        if (v && v.type === 'zset') zset = v.val;
+        else if (v) throw new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+        else { this.db.set(key, { type: 'zset', val: {} }); zset = this.db.get(key).val; }
+        const member = args[2];
+        zset[member] = (zset[member] || 0) + inc;
+        this._scheduleSnapshot();
+        return zset[member];
+      }
+      case 'MSET': {
+        const rest = args;
+        if (rest.length % 2 !== 0) throw new Error('ERR wrong number of arguments');
+        for (let i = 0; i < rest.length; i += 2) this.db.set(rest[i], { type: 'string', val: rest[i + 1], ttl: null });
+        this._scheduleSnapshot();
+        return 'OK';
+      }
+      case 'MGET': {
+        return args.map((k) => {
+          const v = this._get(k);
+          return v && v.type === 'string' ? v.val : null;
+        });
+      }
       case 'DBSIZE': return this.db.size;
       case 'FLUSHALL': case 'FLUSHDB':
         this.db.clear();

package/lib/sql.js

@@ -261,12 +261,18 @@ class Parser {
     if (this.peek().type === 'op' && this.peek().value === '.') {
       this.next();
       const t2 = this.next();
-      if (t2.type !== 'ident') throw new Error(`Expected table name after '.', got '${t2.value}'`);
+      if (t2.type !== 'ident' && !(t2.type === 'keyword' && this._isSchemaView(t2.value))) {
+        throw new Error(`Expected table name after '.', got '${t2.value}'`);
+      }
       return t.value + '.' + t2.value;
     }
     return t.value;
   }
 
+  _isSchemaView(v) {
+    return ['TABLES', 'COLUMNS', 'SCHEMATA', 'STATISTICS', 'KEY_COLUMN_USAGE', 'REFERENTIAL_CONSTRAINTS', 'TABLE_CONSTRAINTS', 'VIEWS'].includes(String(v).toUpperCase());
+  }
+
   parseCreateTable() {
     this.expectKeyword('CREATE');
     this.expectKeyword('TABLE');
@@ -1870,11 +1876,12 @@ class SQLExecutor {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
+        const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         let count = 0;
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = row._rid !== undefined ? row._rid : row.id;
+            const id = this._rowPkId(row, pkCols);
             if (id !== undefined) {
               const data = {};
               for (const [col, val] of statement.assignments) {
@@ -1892,11 +1899,12 @@ class SQLExecutor {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
+        const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         const ids = [];
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = row._rid !== undefined ? row._rid : row.id;
+            const id = this._rowPkId(row, pkCols);
             if (id !== undefined) ids.push(id);
           }
         }
@@ -2166,6 +2174,19 @@ class SQLExecutor {
     return schema;
   }
 
+  /**
+   * 取行的行 ID：优先内部 _rid，否则用实际主键字段值（不再硬编码 id）。
+   */
+  _rowPkId(row, pkCols) {
+    if (row && row._rid !== undefined) return row._rid;
+    if (pkCols.length > 0) {
+      for (const c of pkCols) {
+        if (row[c] !== undefined && row[c] !== null) return row[c];
+      }
+    }
+    return row ? row.id : undefined;
+  }
+
   async _readTable(table) {
     const schema = await this._getSchema(table);
     const rows = (await this.engine.find(table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
@@ -2366,6 +2387,19 @@ class SQLExecutor {
     return out;
   }
 
+  /**
+   * 生成对端表的前缀 null 行：仅含 `prefix.col` 键（值为 null），
+   * 用于 JOIN 未匹配行补齐限定列，避免回退到未前缀副本拿错值。
+   */
+  _nullPrefixedRow(schema, prefix) {
+    const out = {};
+    for (const k of Object.keys(schema)) {
+      if (k === '_softDelete') continue;
+      out[prefix + '.' + k] = null;
+    }
+    return out;
+  }
+
   _aggValue(rows, fn, column) {
     if (fn === 'COUNT') return rows.length;
     const op = typeof column === 'string' ? { type: 'column', name: column } : column;
@@ -2445,6 +2479,7 @@ class SQLExecutor {
 
     let schema = null;
     let all;
+    let rowsAll;
     if (!statement.from) {
       // 无 FROM：虚拟行（SELECT 1, 'a'）
       all = [{ _virtual: true }];
@@ -2469,7 +2504,6 @@ class SQLExecutor {
         const rows = filtered.map(r => outCols.map(c => (c in r ? r[c] : null)));
         return { ok: true, type: 'select', table: firstItem.table, columns: outCols, rows, raw: filtered };
       }
-      let rowsAll;
       if (firstItem.subquery) {
         const res = await this.executeSelect(firstItem.subquery);
         rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
@@ -2495,6 +2529,10 @@ class SQLExecutor {
         }
         const matched = [];
         const unmatchedRight = new Set(rightRows.map((r, i) => i));
+        // 未匹配行补对端表的前缀 null 列：限定列名（如 a.id / b.id）按前缀解析，
+        // 避免回退到未前缀副本拿到错误值。
+        const rightNulls = (rightRes.schema) ? this._nullPrefixedRow(rightRes.schema, rightPrefix) : null;
+        const leftNulls = (rowsAll && rowsAll.schema) ? this._nullPrefixedRow(rowsAll.schema, firstPrefix) : null;
         rows.forEach(l => {
           let m = null;
           for (let ri = 0; ri < rightRows.length; ri++) {
@@ -2507,11 +2545,11 @@ class SQLExecutor {
             matched.push({ ...l, ...rightRows[m] });
             unmatchedRight.delete(m);
           } else if (j.type === 'left') {
-            matched.push({ ...l });
+            matched.push(rightNulls ? { ...rightNulls, ...l } : { ...l });
           }
         });
         if (j.type === 'right') {
-          for (const ri of unmatchedRight) matched.push({ ...rightRows[ri] });
+          for (const ri of unmatchedRight) matched.push(leftNulls ? { ...leftNulls, ...rightRows[ri] } : { ...rightRows[ri] });
         }
         rows = matched;
       }

package/lib/table.js

@@ -242,6 +242,23 @@ class Table {
         const schema = this._schema;
         const checkConstraints = this._checkConstraints;
         const foreignKeys = this._foreignKeys;
+        // 批量预分配自增 ID 范围：先扫描显式提供的最大值，一次性推进计数器，
+        // 再在循环内用本地序号递增，避免批量内重复读取/写入同一计数器字段。
+        const baseAutoInc = this._autoIncrement;
+        if (autoIncField) {
+            let maxExplicit = 0;
+            for (const it of items) {
+                const v = it[autoIncField];
+                if (v !== undefined && v !== null) {
+                    const n = Number(v);
+                    if (!isNaN(n) && n > maxExplicit) maxExplicit = n;
+                }
+            }
+            if (maxExplicit > baseAutoInc) {
+                this._autoIncrement = maxExplicit;
+            }
+        }
+        let autoIncSeq = 0;
         for (let i = 0; i < N; i++) {
             let data = items[i];
             for (const [f, dv] of Object.entries(defaults)) {
@@ -279,8 +296,9 @@ class Table {
                 }
             }
             if (autoIncField && data[autoIncField] === undefined) {
-                this._autoIncrement++;
-                data[autoIncField] = this._autoIncrement;
+                autoIncSeq++;
+                data[autoIncField] = baseAutoInc + autoIncSeq;
+                this._autoIncrement = data[autoIncField];
             } else if (autoIncField && data[autoIncField] > this._autoIncrement) {
                 this._autoIncrement = data[autoIncField];
             }