jsql-neo 4.1.1 → 4.2.0-beta.1

package/lib/database.js

@@ -92,8 +92,8 @@ class Database {
         this._walPath = this._filePath ? this._filePath + '.wal' : null;
         this._walOps = [];          // WAL 操作日志
 
-        // 事务隔离
-        this._isolationLevel = options.isolationLevel || 'READ_COMMITTED';
+        // 事务隔离：默认 REPEATABLE_READ（begin 时保存行快照，rollback 可回滚）
+        this._isolationLevel = options.isolationLevel || 'REPEATABLE_READ';
 
         // JSql 格式 (binary block-based)
         this._jsqlMode = this._filePath && this._filePath.endsWith('.jsql');
@@ -1286,6 +1286,49 @@ class Database {
         return { ok: true, count: removed };
     }
 
+    insertMany(tableName, items) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        const arr = Array.isArray(items) ? items : [items];
+        if (!this._runHooks('beforeInsert', [tableName, arr])) return [];
+        const inserted = table.insertMany(arr);
+        this._emit('insert', { table: tableName, count: arr.length });
+        this._runHooks('afterInsert', [tableName, arr, inserted]);
+        this._markDirty(tableName);
+        return inserted;
+    }
+
+    update(tableName, query, updates) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeUpdate', [tableName, query, updates])) return 0;
+        const count = table.update(query, updates);
+        this._emit('update', { table: tableName, query, count });
+        this._runHooks('afterUpdate', [tableName, query, updates, count]);
+        this._markDirty(tableName);
+        return count;
+    }
+
+    delete(tableName, query = {}) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeDelete', [tableName, query])) return 0;
+        const count = table.remove(query);
+        this._emit('delete', { table: tableName, query, count });
+        this._runHooks('afterDelete', [tableName, query, count]);
+        this._markDirty(tableName);
+        return count;
+    }
+
+    truncate(tableName) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        const count = table.truncate();
+        this._emit('delete', { table: tableName, count });
+        this._markDirty(tableName);
+        return count;
+    }
+
     async stop() {
         this._runHooks('onStop', []);
         this._emit('stop', {});

package/lib/mysql_server.js

@@ -458,6 +458,7 @@ class MysqlConnection {
           return;
         }
         try {
+          if (!this.server._dbExists(db)) await this.server.createDatabase(db);
           await this.server._getDatabase(db);
           this.currentDb = db;
         } catch (e) {
@@ -525,8 +526,10 @@ class MysqlConnection {
             default:
               break;
           }
-          const engine = await this.server._getEngine(this.currentDb);
-          const r = await executeSQL(engine, stmtSql, {
+          const routed = await this.server._route(stmt, stmtSql, this.currentDb, this.user);
+          const engine = routed.engine;
+          const sqlToRun = routed.sql;
+          const r = await executeSQL(engine, sqlToRun, {
             allowComments: this.server.allowComments,
             safety: this.server.safety,
             maxStatements: 1,
@@ -571,6 +574,7 @@ class MysqlServer {
     this._ownEngine = false;
     this._databases = new Map();
     this._dbDir = options.dataDir ? path.resolve(options.dataDir) : null;
+    this._defaultDbName = options.defaultDatabase || 'default';
     this._connectionCounter = 0;
     this._sockets = new Set();
     this._securityHandler = typeof options.onSecurityEvent === 'function' ? options.onSecurityEvent : null;
@@ -585,9 +589,7 @@ class MysqlServer {
   async _getEngine(dbName) {
     if (dbName) return this._getDatabase(dbName);
     if (this._dbDir) {
-      const err = new Error(`No database selected`);
-      err.code = 1046;
-      throw err;
+      return this._getDatabase(this._defaultDbName, { autoCreate: true });
     }
     if (this._engine) return this._engine;
     if (this.options.engine || this.options.database) {
@@ -601,6 +603,64 @@ class MysqlServer {
     return this._engine;
   }
 
+  _dbExists(name) {
+    if (this._databases.has(name)) return true;
+    const dir = this._dbPath(name);
+    return !!(dir && fs.existsSync(dir));
+  }
+
+  // 语句路由：解析库前缀（db.table）与 SHOW TABLES FROM db，
+  // 决定执行引擎，并把 db.table 改写为 table 后交给对应库引擎执行。
+  async _route(stmt, sql, currentDb, user) {
+    if (stmt.type === 'showTables' && stmt.database) {
+      return { engine: await this._getDatabase(stmt.database), sql };
+    }
+    const tables = [];
+    const collect = (s) => {
+      if (!s) return;
+      if (s.type === 'createTable') tables.push(s.name);
+      else if (s.type === 'dropTable') tables.push(s.table);
+      else if (s.type === 'insert') tables.push(s.name);
+      else if (s.type === 'update') tables.push(s.table);
+      else if (s.type === 'delete') tables.push(s.table);
+      else if (s.type === 'describe') tables.push(s.table);
+      else if (s.type === 'select' && s.from) {
+        for (const t of s.from.tables) tables.push(t.table);
+        for (const j of s.from.joins) tables.push(j.item.table);
+      }
+    };
+    collect(stmt);
+    let db = null;
+    for (const t of tables) {
+      if (t && t.indexOf('.') !== -1) {
+        const d = t.split('.')[0];
+        if (db && d !== db) {
+          const err = new Error(`Cross-database references are not supported in one statement`);
+          err.code = 1105;
+          throw err;
+        }
+        db = d;
+      }
+    }
+    if (db) {
+      if (!this._dbExists(db)) await this.createDatabase(db);
+      const engine = await this._getDatabase(db);
+      let s = sql;
+      for (const t of tables) {
+        if (t && t.indexOf('.') !== -1) {
+          s = s.replace(new RegExp('\\b' + t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b', 'g'), t.split('.')[1]);
+        }
+      }
+      return { engine, sql: s };
+    }
+    if (this._dbDir && !currentDb && this.auth && !this._canAccessDb(user, this._defaultDbName)) {
+      const err = new Error('No database selected');
+      err.code = 1046;
+      throw err;
+    }
+    return { engine: await this._getEngine(currentDb), sql };
+  }
+
   _safeDbName(name) {
     if (typeof name !== 'string' || name.length === 0 || name.length > 64) return false;
     if (!/^[a-zA-Z0-9_$.\-]+$/.test(name)) return false;
@@ -614,7 +674,7 @@ class MysqlServer {
     return path.join(this._dbDir, name);
   }
 
-  async _getDatabase(name) {
+  async _getDatabase(name, opts = {}) {
     if (!this._safeDbName(name)) {
       const err = new Error(`Unknown database '${name}'`);
       err.code = 1049;
@@ -623,9 +683,13 @@ class MysqlServer {
     if (this._databases.has(name)) return this._databases.get(name);
     const dir = this._dbPath(name);
     if (dir && !fs.existsSync(dir)) {
-      const err = new Error(`Unknown database '${name}'`);
-      err.code = 1049;
-      throw err;
+      if (opts.autoCreate) {
+        fs.mkdirSync(dir, { recursive: true });
+      } else {
+        const err = new Error(`Unknown database '${name}'`);
+        err.code = 1049;
+        throw err;
+      }
     }
     const engine = dir ? new Database(dir, { mode: 'hybrid' }) : new Database(':memory:');
     if (typeof engine.start === 'function') await engine.start();

package/lib/sql.js

@@ -227,6 +227,12 @@ class Parser {
   parseTableName() {
     const t = this.next();
     if (t.type !== 'ident') throw new Error(`Expected table name, got '${t.value}'`);
+    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}'`);
+      return t.value + '.' + t2.value;
+    }
     return t.value;
   }
 
@@ -668,7 +674,13 @@ class Parser {
 
   parseShow() {
     this.expectKeyword('SHOW');
-    if (this.isKeyword('TABLES')) { this.next(); this.optionalTailSemicolon(); return { type: 'showTables' }; }
+    if (this.isKeyword('TABLES')) {
+      this.next();
+      let database = null;
+      if (this.isKeyword('FROM')) { this.next(); database = this.parseTableName(); }
+      this.optionalTailSemicolon();
+      return { type: 'showTables', database };
+    }
     if (this.isKeyword('DATABASES')) { this.next(); this.optionalTailSemicolon(); return { type: 'showDatabases' }; }
     throw new Error('Unsupported SHOW statement');
   }

package/lib/table.js

@@ -133,10 +133,11 @@ class Table {
         this._dateFields = {};       // { fieldName: 'date'|'datetime'|'timestamp' }
 
         for (const [field, def] of Object.entries(schema)) {
-            if (def.primaryKey) this._primaryKey = field;
+            const isPk = !!(def.primaryKey || def.primary === true);
+            if (isPk) this._primaryKey = field;
             if (def.autoIncrement) {
                 this._autoIncrementField = field;
-                if (def.primaryKey) this._primaryKey = field;
+                if (isPk) this._primaryKey = field;
             }
             if (def.default !== undefined) {
                 this._defaults[field] = def.default;
@@ -177,7 +178,7 @@ class Table {
     _autoCreateBTrees() {
         for (const [field, def] of Object.entries(this._schema)) {
             if (field === '_softDelete') continue;
-            if (def.primaryKey || def.unique) {
+            if (def.primaryKey || def.primary === true || def.unique) {
                 this._btrees[field] = new BTree(64, true);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jsql-neo",
-    "version": "4.1.1",
+    "version": "4.2.0-beta.1",
     "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
     "main": "index.js",
     "bin": {