jsql-neo 2.1.1 → 2.1.3

package/lib/btree.js

@@ -322,6 +322,52 @@ class BTree {
             }
         }
     }
+
+    /**
+     * 批量加载：从已排序的 [key, rowIndex] 数组底部向上构建
+     * O(n) 时间，适合大数据量批量构建
+     */
+    bulkLoad(sortedPairs) {
+        if (sortedPairs.length === 0) { this.clear(); return; }
+        const order = this._order;
+        // 第一层：构建叶子节点
+        const leaves = [];
+        let i = 0;
+        while (i < sortedPairs.length) {
+            const node = new BTreeNode(true);
+            const end = Math.min(i + order - 1, sortedPairs.length);
+            for (; i < end; i++) {
+                const [key, val] = sortedPairs[i];
+                node.keys.push(key);
+                node.values.push(Array.isArray(val) ? val : [val]);
+            }
+            leaves.push(node);
+        }
+        for (let i = 0; i < leaves.length - 1; i++) leaves[i].next = leaves[i + 1];
+        if (leaves.length === 1) { this._root = leaves[0]; this._size = sortedPairs.length; return; }
+        // 逐层向上构建内部节点
+        let currentLevel = leaves;
+        while (currentLevel.length > 1) {
+            const parents = [];
+            let j = 0;
+            while (j < currentLevel.length) {
+                const node = new BTreeNode(false);
+                const end = Math.min(j + order, currentLevel.length);
+                for (; j < end; j++) {
+                    if (node.children.length > 0) {
+                        const child = currentLevel[j];
+                        node.keys.push(child.keys[0]);
+                        node.values.push(child.values[0]);
+                    }
+                    node.children.push(currentLevel[j]);
+                }
+                parents.push(node);
+            }
+            currentLevel = parents;
+        }
+        this._root = currentLevel[0];
+        this._size = sortedPairs.length;
+    }
 }
 
 module.exports = BTree;

package/lib/table.js

@@ -26,6 +26,7 @@ class Table {
         };
         this._softDelete = false;
         this._computedFields = {};
+        this._btreesDirty = false;
 
         this._primaryKey = null;
         this._autoIncrementField = null;
@@ -68,7 +69,10 @@ class Table {
             this._softDelete = true;
         }
 
-        // 自动为 primaryKey 和 unique 字段建 B-Tree 索引
+        this._cachedSchemaFields = Object.keys(schema).filter(f => f !== '_softDelete');
+        this._cachedDateFields = Object.keys(this._dateFields);
+        this._cachedUniqueFields = this._cachedSchemaFields.filter(f => schema[f].unique);
+        this._cachedRequiredFields = this._cachedSchemaFields.filter(f => schema[f].required);
         this._autoCreateBTrees();
     }
 
@@ -119,35 +123,73 @@ class Table {
     insertMany(items) {
         if (items.length === 0) return [];
         for (const hook of this._hooks.beforeInsert) {
-            items = items.map(data => hook({ ...data }) || data);
+            const mapped = new Array(items.length);
+            for (let i = 0; i < items.length; i++) mapped[i] = hook({ ...items[i] }) || items[i];
+            items = mapped;
         }
+        const N = items.length;
         const uniqueTracker = {};
-        for (const [field, def] of Object.entries(this._schema)) {
-            if (def.unique) uniqueTracker[field] = new Set();
-        }
-        const results = [];
-        for (const item of items) {
-            let data = this._applyDefaults(item);
-            data = this._applyComputed(data);
-            data = this._validateDataTypes(data);
-            this._validateConstraints(data, -1, uniqueTracker);
-            if (this._autoIncrementField && data[this._autoIncrementField] === undefined) {
+        for (const field of this._cachedUniqueFields) uniqueTracker[field] = new Set();
+        const dateFields = this._cachedDateFields;
+        const hasDateFields = dateFields.length > 0;
+        const autoIncField = this._autoIncrementField;
+        const defaults = this._defaults;
+        const computedFields = this._computedFields;
+        const schema = this._schema;
+        const checkConstraints = this._checkConstraints;
+        const foreignKeys = this._foreignKeys;
+        for (let i = 0; i < N; i++) {
+            let data = items[i];
+            for (const [f, dv] of Object.entries(defaults)) {
+                if (data[f] === undefined) data[f] = typeof dv === 'function' ? dv() : dv === 'CURRENT_TIMESTAMP' ? now() : dv;
+            }
+            for (const f of Object.keys(computedFields)) data[f] = computedFields[f](data);
+            if (hasDateFields) {
+                for (const f of dateFields) {
+                    if (data[f] !== undefined && data[f] !== null) data[f] = validateDateType(data[f], this._dateFields[f], f);
+                }
+            }
+            for (const field of this._cachedSchemaFields) {
+                const def = schema[field];
+                if (def.required && (data[field] === undefined || data[field] === null)) throw createError('ER_BAD_NULL_ERROR', field);
+                if (def.unique && data[field] !== undefined) {
+                    if (uniqueTracker[field].has(data[field])) throw createError('ER_DUP_ENTRY', String(data[field]), field);
+                    uniqueTracker[field].add(data[field]);
+                }
+                if (def.length && typeof data[field] === 'string' && data[field].length > def.length) throw createError('ER_DATA_TOO_LONG', field);
+                if (def.type === 'integer' || def.type === 'number') {
+                    const v = def.type === 'integer' ? Number(data[field]) : data[field];
+                    if (data[field] !== undefined && data[field] !== null && def.min !== undefined && v < def.min) throw createError('ER_OUT_OF_RANGE', field);
+                    if (data[field] !== undefined && data[field] !== null && def.max !== undefined && v > def.max) throw createError('ER_OUT_OF_RANGE', field);
+                }
+                if (def.check && data[field] !== undefined && !def.check(data[field], data)) throw createError('ER_CHECK_CONSTRAINT', this._name + '.' + field);
+            }
+            for (const fk of foreignKeys) {
+                if (data[fk.field] !== undefined && data[fk.field] !== null) {
+                    const refTable = this._resolveTable(fk.table);
+                    if (refTable) {
+                        const exists = refTable.findOne({ [fk.refField]: data[fk.field] });
+                        if (!exists) throw createError('ER_NO_REFERENCED_ROW');
+                    }
+                }
+            }
+            if (autoIncField && data[autoIncField] === undefined) {
                 this._autoIncrement++;
-                data[this._autoIncrementField] = this._autoIncrement;
-            } else if (this._autoIncrementField && data[this._autoIncrementField] > this._autoIncrement) {
-                this._autoIncrement = data[this._autoIncrementField];
+                data[autoIncField] = this._autoIncrement;
+            } else if (autoIncField && data[autoIncField] > this._autoIncrement) {
+                this._autoIncrement = data[autoIncField];
             }
-            this._rows.push({ ...data });
-            results.push(data);
+            this._rows.push(Object.assign({}, data));
+            items[i] = data;
         }
-        this._rebuildAllBTrees();
+        this._btreesDirty = true;
         this._dirty = true;
         this._db._markDirty();
         for (const hook of this._hooks.afterInsert) {
-            for (const data of results) hook(data);
+            for (let i = 0; i < N; i++) hook(items[i]);
         }
-        for (const data of results) this._db._emitChange('insert', this._name, data);
-        return results;
+        this._db._emitChange('insertMany', this._name, { count: N });
+        return items;
     }
 
     upsert(data) {
@@ -180,7 +222,7 @@ class Table {
 
     findById(id) {
         if (!this._primaryKey) throw createError('ER_PARSE_ERROR', 'Table has no primary key');
-        // B-Tree 加速
+        this._ensureBTrees();
         if (this._btrees[this._primaryKey]) {
             const indices = this._btrees[this._primaryKey].search(id);
             if (indices.length > 0) {
@@ -517,6 +559,21 @@ class Table {
         }
     }
 
+    _ensureBTrees() {
+        if (!this._btreesDirty) return;
+        this._btreesDirty = false;
+        for (const field of Object.keys(this._btrees)) {
+            this._btrees[field].clear();
+        }
+        for (let i = 0; i < this._rows.length; i++) {
+            const row = this._rows[i];
+            for (const [field, tree] of Object.entries(this._btrees)) {
+                const v = row[field];
+                if (v !== undefined && v !== null) tree.insert(v, i);
+            }
+        }
+    }
+
     _rebuildAllBTrees() {
         for (const field of Object.keys(this._btrees)) {
             this._rebuildBTree(field);
@@ -546,6 +603,7 @@ class Table {
     // ============================================================
 
     _applyFilterOptimized(rows, query) {
+        this._ensureBTrees();
         // 尝试用 B-Tree 加速
         for (const [field, condition] of Object.entries(query)) {
             if (field === '$or' || field === '$and' || field === '$not') continue;
@@ -715,13 +773,22 @@ class Table {
                 throw createError('ER_BAD_NULL_ERROR', field);
             }
 
-            // UNIQUE
+            // UNIQUE（B-Tree 优化 O(log n)）
             if (def.unique && data[field] !== undefined) {
                 if (uniqueTracker && uniqueTracker[field]) {
                     if (uniqueTracker[field].has(data[field])) {
                         throw createError('ER_DUP_ENTRY', String(data[field]), field);
                     }
                     uniqueTracker[field].add(data[field]);
+                } else if (this._btrees[field]) {
+                    const found = this._btrees[field].search(data[field]);
+                    if (found.length > 0) {
+                        for (const idx of found) {
+                            if (idx !== excludeIndex && this._rows[idx] && this._rows[idx][field] === data[field]) {
+                                throw createError('ER_DUP_ENTRY', String(data[field]), field);
+                            }
+                        }
+                    }
                 } else {
                     for (let i = 0; i < this._rows.length; i++) {
                         if (i === excludeIndex) continue;
@@ -834,6 +901,7 @@ class Table {
     }
 
     _addToIndexes(rowIndex, data) {
+        this._ensureBTrees();
         for (const field of Object.keys(this._indexes)) {
             const value = data[field];
             if (value !== undefined) {
@@ -852,6 +920,7 @@ class Table {
     }
 
     _removeFromIndexes(rowIndex, data) {
+        this._ensureBTrees();
         for (const field of Object.keys(this._indexes)) {
             const value = data[field];
             if (value !== undefined && this._indexes[field].has(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jsql-neo",
-    "version": "2.1.1",
+    "version": "2.1.3",
     "description": "JSQL-NEO — Pure JavaScript embedded database with B-Tree indexes, WAL, hash JOIN, Redis-compatible Cache, and MySQL-style error codes",
     "main": "index.js",
     "files": [