jsql-neo 1.3.0 → 2.0.1

package/lib/table.js

@@ -1,10 +1,13 @@
 // © Vexify 2026 All Rights Reserved.
 /**
- * JSQL Table — 表操作引擎
- * 支持 DEFAULT、CHECK、外键、UPSERT、TRUNCATE、ALTER TABLE、计算字段、JSON 路径、软删除
+ * JSQL Table — 表操作引擎 v2.0
+ * B-Tree 自动索引、日期类型、错误码、外键 CASCADE、长度/精度校验
  */
 
 const Query = require('./query');
+const BTree = require('./btree');
+const { validateDateType, now } = require('./date-types');
+const { createError } = require('./errors');
 
 class Table {
     constructor(name, schema, db) {
@@ -12,7 +15,8 @@ class Table {
         this._schema = schema;
         this._db = db;
         this._rows = [];
-        this._indexes = {};
+        this._indexes = {};          // 旧版 hash 索引（兼容）
+        this._btrees = {};           // B-Tree 索引 { fieldName: BTree }
         this._autoIncrement = 0;
         this._dirty = false;
         this._hooks = {
@@ -20,15 +24,15 @@ class Table {
             beforeUpdate: [], afterUpdate: [],
             beforeRemove: [], afterRemove: []
         };
-        this._softDelete = false;        // 是否启用软删除
-        this._computedFields = {};       // 计算字段
+        this._softDelete = false;
+        this._computedFields = {};
 
-        // 解析列定义
         this._primaryKey = null;
         this._autoIncrementField = null;
         this._foreignKeys = [];
         this._checkConstraints = [];
         this._defaults = {};
+        this._dateFields = {};       // { fieldName: 'date'|'datetime'|'timestamp' }
 
         for (const [field, def] of Object.entries(schema)) {
             if (def.primaryKey) this._primaryKey = field;
@@ -46,17 +50,35 @@ class Table {
                 this._foreignKeys.push({
                     field,
                     table: def.foreignKey.table,
-                    onDelete: def.foreignKey.onDelete || 'restrict'
+                    refField: def.foreignKey.field || 'id',
+                    onDelete: def.foreignKey.onDelete || 'restrict',
+                    onUpdate: def.foreignKey.onUpdate || 'restrict'
                 });
             }
             if (def.computed) {
                 this._computedFields[field] = def.computed;
             }
+            // 日期类型
+            if (['date', 'datetime', 'timestamp', 'time'].includes(def.type)) {
+                this._dateFields[field] = def.type;
+            }
         }
 
         if (schema._softDelete) {
             this._softDelete = true;
         }
+
+        // 自动为 primaryKey 和 unique 字段建 B-Tree 索引
+        this._autoCreateBTrees();
+    }
+
+    _autoCreateBTrees() {
+        for (const [field, def] of Object.entries(this._schema)) {
+            if (field === '_softDelete') continue;
+            if (def.primaryKey || def.unique) {
+                this._btrees[field] = new BTree(64, true);
+            }
+        }
     }
 
     // ============================================================
@@ -68,39 +90,11 @@ class Table {
             data = hook({ ...data }) || data;
         }
 
-        // 填充默认值
         data = this._applyDefaults(data);
-
-        // 计算字段
         data = this._applyComputed(data);
+        data = this._validateDataTypes(data);
+        this._validateConstraints(data, -1);
 
-        // 校验必填
-        for (const [field, def] of Object.entries(this._schema)) {
-            if (field === '_softDelete') continue;
-            if (def.required && (data[field] === undefined || data[field] === null)) {
-                throw new Error(`Field '${field}' is required in table '${this._name}'`);
-            }
-        }
-
-        // CHECK 约束
-        for (const { field, fn } of this._checkConstraints) {
-            if (data[field] !== undefined && !fn(data[field], data)) {
-                throw new Error(`CHECK constraint failed on '${this._name}.${field}'`);
-            }
-        }
-
-        // 唯一约束
-        for (const [field, def] of Object.entries(this._schema)) {
-            if (def.unique && data[field] !== undefined) {
-                for (const row of this._rows) {
-                    if (row[field] === data[field]) {
-                        throw new Error(`Duplicate value for unique field '${field}': ${data[field]}`);
-                    }
-                }
-            }
-        }
-
-        // 自增
         if (this._autoIncrementField && data[this._autoIncrementField] === undefined) {
             this._autoIncrement++;
             data[this._autoIncrementField] = this._autoIncrement;
@@ -110,14 +104,13 @@ class Table {
 
         const rowIndex = this._rows.length;
         this._rows.push({ ...data });
-        this._updateIndexes(rowIndex, data);
+        this._addToIndexes(rowIndex, data);
         this._dirty = true;
         this._db._markDirty();
 
         for (const hook of this._hooks.afterInsert) {
             hook(data);
         }
-
         this._db._emitChange('insert', this._name, data);
 
         return data;
@@ -127,10 +120,6 @@ class Table {
         return items.map(item => this.insert(item));
     }
 
-    /**
-     * UPSERT — 有则更新，无则插入
-     * 按主键或唯一字段判断
-     */
     upsert(data) {
         if (this._primaryKey && data[this._primaryKey] !== undefined) {
             const existing = this.findById(data[this._primaryKey]);
@@ -143,13 +132,13 @@ class Table {
     }
 
     // ============================================================
-    // 查询
+    // 查询（支持 B-Tree 加速）
     // ============================================================
 
     find(query = {}) {
         let rows = this._getVisibleRows();
         if (Object.keys(query).length > 0) {
-            rows = this._applyFilter(rows, query);
+            rows = this._applyFilterOptimized(rows, query);
         }
         return rows.map(r => ({ ...r }));
     }
@@ -160,7 +149,16 @@ class Table {
     }
 
     findById(id) {
-        if (!this._primaryKey) throw new Error(`Table '${this._name}' has no primary key`);
+        if (!this._primaryKey) throw createError('ER_PARSE_ERROR', 'Table has no primary key');
+        // B-Tree 加速
+        if (this._btrees[this._primaryKey]) {
+            const indices = this._btrees[this._primaryKey].search(id);
+            if (indices.length > 0) {
+                const row = this._rows[indices[0]];
+                if (row && !row._deleted) return { ...row };
+            }
+            return null;
+        }
         return this.findOne({ [this._primaryKey]: id });
     }
 
@@ -170,7 +168,7 @@ class Table {
 
     count(query = {}) {
         if (Object.keys(query).length === 0) return this._getVisibleRows().length;
-        return this._applyFilter(this._getVisibleRows(), query).length;
+        return this._applyFilterOptimized(this._getVisibleRows(), query).length;
     }
 
     where(conditions) {
@@ -186,7 +184,8 @@ class Table {
             updates = hook(query, { ...updates }) || updates;
         }
 
-        const matched = this._applyFilter(this._getVisibleRows(), query);
+        updates = this._validateDataTypes(updates, true);
+        const matched = this._applyFilterOptimized(this._getVisibleRows(), query);
         let count = 0;
 
         for (const row of matched) {
@@ -194,29 +193,12 @@ class Table {
             if (index === -1) continue;
 
             const oldData = { ...this._rows[index] };
-
-            // 唯一约束
-            for (const [field, def] of Object.entries(this._schema)) {
-                if (def.unique && updates[field] !== undefined) {
-                    for (let i = 0; i < this._rows.length; i++) {
-                        if (i !== index && this._rows[i][field] === updates[field]) {
-                            throw new Error(`Duplicate value for unique field '${field}': ${updates[field]}`);
-                        }
-                    }
-                }
-            }
-
-            // CHECK 约束
             const merged = { ...this._rows[index], ...updates };
-            for (const { field, fn } of this._checkConstraints) {
-                if (merged[field] !== undefined && !fn(merged[field], merged)) {
-                    throw new Error(`CHECK constraint failed on '${this._name}.${field}'`);
-                }
-            }
+            this._validateConstraints(merged, index);
 
-            Object.assign(this._rows[index], updates);
             this._removeFromIndexes(index, oldData);
-            this._updateIndexes(index, this._rows[index]);
+            Object.assign(this._rows[index], updates);
+            this._addToIndexes(index, this._rows[index]);
             count++;
         }
 
@@ -232,12 +214,12 @@ class Table {
     }
 
     updateById(id, updates) {
-        if (!this._primaryKey) throw new Error(`Table '${this._name}' has no primary key`);
+        if (!this._primaryKey) throw createError('ER_PARSE_ERROR', 'Table has no primary key');
         return this.update({ [this._primaryKey]: id }, updates);
     }
 
     // ============================================================
-    // 删除
+    // 删除 & 外键 CASCADE
     // ============================================================
 
     remove(query = {}) {
@@ -249,22 +231,15 @@ class Table {
             return this._truncate();
         }
 
-        const toRemove = this._applyFilter(this._getVisibleRows(), query);
+        const toRemove = this._applyFilterOptimized(this._getVisibleRows(), query);
         let count = 0;
 
         for (const row of toRemove) {
             const index = this._rows.indexOf(row);
             if (index === -1) continue;
 
-            // 外键级联删除
-            for (const fk of this._foreignKeys) {
-                if (fk.onDelete === 'cascade') {
-                    const refTable = this._db._tables[fk.table];
-                    if (refTable) {
-                        refTable.remove({ [fk.field]: row[this._primaryKey] });
-                    }
-                }
-            }
+            // 外键 CASCADE / SET NULL：查找所有引用此表的子表
+            this._cascadeForeignKeys(row);
 
             if (this._softDelete) {
                 this._rows[index]._deleted = true;
@@ -272,7 +247,7 @@ class Table {
             } else {
                 this._removeFromIndexes(index, row);
                 this._rows.splice(index, 1);
-                this._adjustIndexesAfterRemove(index);
+                this._adjustBTreeAfterRemove(index);
             }
             count++;
         }
@@ -289,24 +264,17 @@ class Table {
     }
 
     removeById(id) {
-        if (!this._primaryKey) throw new Error(`Table '${this._name}' has no primary key`);
+        if (!this._primaryKey) throw createError('ER_PARSE_ERROR', 'Table has no primary key');
         return this.remove({ [this._primaryKey]: id });
     }
 
-    /**
-     * 软删除 — 标记为已删除，可恢复
-     */
     removeSoft(query = {}) {
         this._softDelete = true;
-        const result = this.remove(query);
-        return result;
+        return this.remove(query);
     }
 
-    /**
-     * 恢复软删除的行
-     */
     restore(query = {}) {
-        if (!this._softDelete) throw new Error('Soft delete is not enabled');
+        if (!this._softDelete) throw createError('ER_NOT_SUPPORTED', 'Soft delete is not enabled');
         const matched = this._applyFilter(this._rows, { ...query, _deleted: true });
         for (const row of matched) {
             const index = this._rows.indexOf(row);
@@ -318,9 +286,6 @@ class Table {
         return matched.length;
     }
 
-    /**
-     * 清空表（保留结构）
-     */
     truncate() {
         return this._truncate();
     }
@@ -328,6 +293,9 @@ class Table {
     _truncate() {
         const count = this._rows.length;
         this._rows = [];
+        for (const key of Object.keys(this._btrees)) {
+            this._btrees[key].clear();
+        }
         this._indexes = {};
         this._autoIncrement = 0;
         this._dirty = true;
@@ -340,11 +308,10 @@ class Table {
     // ============================================================
 
     addColumn(field, definition) {
-        if (this._schema[field]) throw new Error(`Column '${field}' already exists`);
+        if (this._schema[field]) throw createError('ER_DUP_FIELDNAME', field);
         this._schema[field] = definition;
         if (definition.default !== undefined) {
             this._defaults[field] = definition.default;
-            // 填充现有行的默认值
             for (const row of this._rows) {
                 if (row[field] === undefined) {
                     row[field] = typeof definition.default === 'function' ? definition.default() : definition.default;
@@ -356,40 +323,57 @@ class Table {
             this._foreignKeys.push({
                 field,
                 table: definition.foreignKey.table,
-                onDelete: definition.foreignKey.onDelete || 'restrict'
+                refField: definition.foreignKey.field || 'id',
+                onDelete: definition.foreignKey.onDelete || 'restrict',
+                onUpdate: definition.foreignKey.onUpdate || 'restrict'
             });
         }
         if (definition.computed) this._computedFields[field] = definition.computed;
+        if (['date', 'datetime', 'timestamp', 'time'].includes(definition.type)) {
+            this._dateFields[field] = definition.type;
+        }
+        if (definition.primaryKey || definition.unique) {
+            this._btrees[field] = new BTree(64, true);
+            this._rebuildBTree(field);
+        }
         this._dirty = true;
         this._db._markDirty();
         return this;
     }
 
     dropColumn(field) {
-        if (!this._schema[field]) throw new Error(`Column '${field}' does not exist`);
+        if (!this._schema[field]) throw createError('ER_CANT_DROP_FIELD', field);
         delete this._schema[field];
         delete this._defaults[field];
+        delete this._btrees[field];
+        delete this._indexes[field];
         this._checkConstraints = this._checkConstraints.filter(c => c.field !== field);
         this._foreignKeys = this._foreignKeys.filter(fk => fk.field !== field);
         delete this._computedFields[field];
-        // 移除所有行中的该字段
+        delete this._dateFields[field];
         for (const row of this._rows) {
             delete row[field];
         }
+        if (this._primaryKey === field) this._primaryKey = null;
+        if (this._autoIncrementField === field) this._autoIncrementField = null;
         this._dirty = true;
         this._db._markDirty();
         return this;
     }
 
     renameColumn(oldName, newName) {
-        if (!this._schema[oldName]) throw new Error(`Column '${oldName}' does not exist`);
-        if (this._schema[newName]) throw new Error(`Column '${newName}' already exists`);
+        if (!this._schema[oldName]) throw createError('ER_BAD_FIELD_ERROR', oldName, this._name);
+        if (this._schema[newName]) throw createError('ER_DUP_FIELDNAME', newName);
         this._schema[newName] = this._schema[oldName];
         delete this._schema[oldName];
         if (this._defaults[oldName] !== undefined) {
             this._defaults[newName] = this._defaults[oldName];
             delete this._defaults[oldName];
         }
+        if (this._btrees[oldName]) {
+            this._btrees[newName] = this._btrees[oldName];
+            delete this._btrees[oldName];
+        }
         for (const row of this._rows) {
             row[newName] = row[oldName];
             delete row[oldName];
@@ -402,40 +386,35 @@ class Table {
     }
 
     modifyColumn(field, definition) {
-        if (!this._schema[field]) throw new Error(`Column '${field}' does not exist`);
+        if (!this._schema[field]) throw createError('ER_BAD_FIELD_ERROR', field, this._name);
         this._schema[field] = { ...this._schema[field], ...definition };
         if (definition.default !== undefined) this._defaults[field] = definition.default;
         this._checkConstraints = this._checkConstraints.filter(c => c.field !== field);
         if (definition.check) this._checkConstraints.push({ field, fn: definition.check });
+        if (definition.primaryKey || definition.unique) {
+            if (!this._btrees[field]) this._btrees[field] = new BTree(64, true);
+            this._rebuildBTree(field);
+        }
         this._dirty = true;
         this._db._markDirty();
         return this;
     }
 
-    /**
-     * 获取表结构
-     */
     describe() {
         return {
             name: this._name,
             columns: { ...this._schema },
             primaryKey: this._primaryKey,
             rowCount: this._getVisibleRows().length,
-            indexCount: Object.keys(this._indexes).length,
+            btreeIndexes: Object.keys(this._btrees),
+            hashIndexes: Object.keys(this._indexes),
             softDelete: this._softDelete,
             foreignKeys: this._foreignKeys.map(fk => ({ field: fk.field, table: fk.table }))
         };
     }
 
-    // ============================================================
-    // SELECT INTO
-    // ============================================================
-
-    /**
-     * 从查询结果创建新表
-     */
     selectInto(newTableName, newSchema, query = {}) {
-        const rows = this._applyFilter(this._getVisibleRows(), query);
+        const rows = this._applyFilterOptimized(this._getVisibleRows(), query);
         this._db.createTable(newTableName, newSchema);
         const newTable = this._db._tables[newTableName];
         for (const row of rows) {
@@ -444,21 +423,10 @@ class Table {
         return newTable;
     }
 
-    // ============================================================
-    // 全文搜索评分
-    // ============================================================
-
-    /**
-     * 全文搜索并返回带相关性评分的排序结果
-     * @param {string} field - 搜索字段
-     * @param {string|string[]} terms - 搜索词
-     * @returns {Array} 按 _score 降序排列的结果
-     */
     textSearch(field, terms) {
         const searchTerms = Array.isArray(terms) ? terms : terms.split(/\s+/);
         const rows = this._getVisibleRows();
         const scored = [];
-
         for (const row of rows) {
             const value = String(row[field] || '').toLowerCase();
             let score = 0;
@@ -466,17 +434,12 @@ class Table {
                 const t = term.toLowerCase();
                 const idx = value.indexOf(t);
                 if (idx !== -1) {
-                    score += 10;  // 基础命中
-                    if (idx === 0) score += 5;  // 开头匹配加分
-                    if (value === t) score += 20;  // 完全匹配加更多
-                    score += (value.length - idx) / value.length * 5;  // 靠前加权
+                    score += 10 + (idx === 0 ? 5 : 0) + (value === t ? 20 : 0)
+                        + (value.length - idx) / value.length * 5;
                 }
             }
-            if (score > 0) {
-                scored.push({ ...row, _score: score });
-            }
+            if (score > 0) scored.push({ ...row, _score: score });
         }
-
         return scored.sort((a, b) => b._score - a._score);
     }
 
@@ -500,6 +463,34 @@ class Table {
 
     dropIndex(field) {
         delete this._indexes[field];
+        delete this._btrees[field];
+    }
+
+    /**
+     * 创建 B-Tree 索引（O(log n) 查询）
+     */
+    createBTreeIndex(field, unique = false) {
+        this._btrees[field] = new BTree(64, unique);
+        this._rebuildBTree(field);
+        return this._btrees[field];
+    }
+
+    _rebuildBTree(field) {
+        if (this._btrees[field]) {
+            this._btrees[field].clear();
+            for (let i = 0; i < this._rows.length; i++) {
+                const val = this._rows[i][field];
+                if (val !== undefined && val !== null) {
+                    this._btrees[field].insert(val, i);
+                }
+            }
+        }
+    }
+
+    _rebuildAllBTrees() {
+        for (const field of Object.keys(this._btrees)) {
+            this._rebuildBTree(field);
+        }
     }
 
     // ============================================================
@@ -521,9 +512,41 @@ class Table {
     }
 
     // ============================================================
-    // 内部: 过滤器
+    // 内部: 过滤器（B-Tree 加速）
     // ============================================================
 
+    _applyFilterOptimized(rows, query) {
+        // 尝试用 B-Tree 加速
+        for (const [field, condition] of Object.entries(query)) {
+            if (field === '$or' || field === '$and' || field === '$not') continue;
+            // 等值查询用 B-Tree
+            if (typeof condition !== 'object' || condition === null || Array.isArray(condition) || condition instanceof RegExp) {
+                if (this._btrees[field]) {
+                    const indices = this._btrees[field].search(condition);
+                    if (indices.length > 0) {
+                        const subset = indices.map(i => this._rows[i]).filter(r => r);
+                        return this._applyFilter(subset, query);
+                    }
+                    return [];
+                }
+            }
+            // 范围查询用 B-Tree
+            if (condition && typeof condition === 'object') {
+                if (condition.$gt !== undefined && condition.$lt !== undefined && this._btrees[field]) {
+                    const indices = this._btrees[field].range(condition.$gt, condition.$lt);
+                    const subset = indices.map(i => this._rows[i]).filter(r => r);
+                    return this._applyFilter(subset, query);
+                }
+                if (condition.$gte !== undefined && condition.$lte !== undefined && this._btrees[field]) {
+                    const indices = this._btrees[field].range(condition.$gte, condition.$lte);
+                    const subset = indices.map(i => this._rows[i]).filter(r => r);
+                    return this._applyFilter(subset, query);
+                }
+            }
+        }
+        return this._applyFilter(rows, query);
+    }
+
     _applyFilter(rows, query) {
         const result = [];
         for (let i = 0; i < rows.length; i++) {
@@ -536,7 +559,6 @@ class Table {
 
     _matchRow(row, query) {
         for (const [field, condition] of Object.entries(query)) {
-            // 顶层 $or / $and / $not
             if (field === '$or') {
                 if (!Array.isArray(condition) || !condition.some(sub => this._matchRow(row, sub))) return false;
                 continue;
@@ -550,21 +572,16 @@ class Table {
                 continue;
             }
 
-            // JSON 路径: 'profile.city' 或 'data.profile.city'
             const value = this._resolvePath(row, field);
 
             if (condition !== null && typeof condition === 'object' && !Array.isArray(condition) && !(condition instanceof RegExp)) {
-                // 检查是否是操作符
                 const keys = Object.keys(condition);
                 const isOperator = keys.every(k => k.startsWith('$'));
                 if (isOperator && keys.length > 0) {
                     for (const [op, target] of Object.entries(condition)) {
-                        if (!this._matchOperator(value, op, target)) {
-                            return false;
-                        }
+                        if (!this._matchOperator(value, op, target)) return false;
                     }
                 } else {
-                    // 普通对象：递归匹配子文档
                     if (value !== null && typeof value === 'object') {
                         if (!this._matchRow(value, condition)) return false;
                     } else {
@@ -590,15 +607,13 @@ class Table {
             case '$nin': return Array.isArray(target) && !target.includes(value);
             case '$like':
                 if (typeof value !== 'string' || typeof target !== 'string') return false;
-                const likeRegex = target.replace(/%/g, '.*').replace(/_/g, '.');
-                return new RegExp('^' + likeRegex + '$', 'i').test(value);
+                return new RegExp('^' + target.replace(/%/g, '.*').replace(/_/g, '.') + '$', 'i').test(value);
             case '$regex':
                 return new RegExp(target).test(String(value));
             case '$exists':
                 return target ? value !== undefined : value === undefined;
             case '$between':
-                return Array.isArray(target) && target.length === 2
-                    && value >= target[0] && value <= target[1];
+                return Array.isArray(target) && target.length === 2 && value >= target[0] && value <= target[1];
             case '$and':
                 return Array.isArray(target) && target.every(sub => this._matchRow({ _val: value }, { _val: sub }));
             case '$or':
@@ -613,8 +628,7 @@ class Table {
                 return Array.isArray(value) && value.length === target;
             case '$elemMatch':
                 return Array.isArray(value) && value.some(el =>
-                    typeof el === 'object' ? this._matchRow(el, target) : el === target
-                );
+                    typeof el === 'object' ? this._matchRow(el, target) : el === target);
             case '$isNull':
                 return target ? value === null || value === undefined : value !== null && value !== undefined;
             case '$startsWith':
@@ -622,18 +636,14 @@ class Table {
             case '$endsWith':
                 return typeof value === 'string' && value.endsWith(target);
             case '$search':
-                // 全文搜索（简单实现）
                 if (typeof value !== 'string') return false;
                 const terms = Array.isArray(target) ? target : [target];
                 return terms.every(t => value.toLowerCase().includes(t.toLowerCase()));
             case '$textSearch':
-                // 高级全文搜索，带相关性评分（返回 true 即可，评分在 _textScore 中）
                 if (typeof value !== 'string') return false;
-                const searchTerms = Array.isArray(target) ? target : target.split(/\s+/);
-                const lower = value.toLowerCase();
-                return searchTerms.some(t => lower.includes(t.toLowerCase()));
+                const sTerms = Array.isArray(target) ? target : target.split(/\s+/);
+                return sTerms.some(t => value.toLowerCase().includes(t.toLowerCase()));
             case '$inSub':
-                // 子查询：$inSub: { table: otherTable, field: 'col', query: {} }
                 if (!target || !target.table) return false;
                 const subRows = target.table._applyFilter(target.table._rows, target.query || {});
                 return subRows.some(r => r[target.field] === value);
@@ -642,7 +652,6 @@ class Table {
                 const subRows2 = target.table._applyFilter(target.table._rows, target.query || {});
                 return !subRows2.some(r => r[target.field] === value);
             case '$expr':
-                // 表达式：$expr: (value, row) => boolean
                 if (typeof target === 'function') return target(value);
                 return false;
             default:
@@ -650,9 +659,6 @@ class Table {
         }
     }
 
-    /**
-     * 解析 JSON 路径，如 'profile.city' -> row.profile.city
-     */
     _resolvePath(row, field) {
         if (field.includes('.') && !field.startsWith('$')) {
             const parts = field.split('.');
@@ -666,6 +672,102 @@ class Table {
         return row[field];
     }
 
+    // ============================================================
+    // 内部: 约束校验
+    // ============================================================
+
+    _validateConstraints(data, excludeIndex) {
+        for (const [field, def] of Object.entries(this._schema)) {
+            if (field === '_softDelete') continue;
+
+            // NOT NULL
+            if (def.required && (data[field] === undefined || data[field] === null)) {
+                throw createError('ER_BAD_NULL_ERROR', field);
+            }
+
+            // UNIQUE
+            if (def.unique && data[field] !== undefined) {
+                for (let i = 0; i < this._rows.length; i++) {
+                    if (i === excludeIndex) continue;
+                    if (this._rows[i][field] === data[field]) {
+                        throw createError('ER_DUP_ENTRY', String(data[field]), field);
+                    }
+                }
+            }
+
+            // CHECK
+            for (const { field: cf, fn } of this._checkConstraints) {
+                if (cf === field && data[field] !== undefined && !fn(data[field], data)) {
+                    throw createError('ER_CHECK_CONSTRAINT', this._name + '.' + field);
+                }
+            }
+
+            // 长度限制
+            if (def.length && typeof data[field] === 'string' && data[field].length > def.length) {
+                throw createError('ER_DATA_TOO_LONG', field);
+            }
+
+            // 数值范围
+            if (def.type === 'integer' && data[field] !== undefined && data[field] !== null) {
+                const v = Number(data[field]);
+                if (def.min !== undefined && v < def.min) throw createError('ER_OUT_OF_RANGE', field);
+                if (def.max !== undefined && v > def.max) throw createError('ER_OUT_OF_RANGE', field);
+            }
+        }
+
+        // FOREIGN KEY 校验
+        for (const fk of this._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');
+                    }
+                }
+            }
+        }
+    }
+
+    _resolveTable(tableRef) {
+        if (typeof tableRef === 'string') {
+            return this._db._tables[tableRef] || this._db._attached[tableRef]?._tables[tableRef];
+        }
+        return tableRef;
+    }
+
+    /**
+     * 级联外键操作：当删除当前表的行时，查找所有引用此表的子表
+     * 并执行 CASCADE 或 SET NULL
+     */
+    _cascadeForeignKeys(row) {
+        for (const [, table] of Object.entries(this._db._tables)) {
+            if (table._name === this._name) continue;
+            for (const fk of table._foreignKeys) {
+                const refTable = table._resolveTable(fk.table);
+                if (!refTable || refTable._name !== this._name) continue;
+
+                // 检查子表行是否引用当前行
+                if (fk.onDelete === 'cascade') {
+                    table.remove({ [fk.field]: row[fk.refField] });
+                } else if (fk.onDelete === 'set null') {
+                    table.update({ [fk.field]: row[fk.refField] }, { [fk.field]: null });
+                }
+            }
+        }
+    }
+
+    _validateDataTypes(data, partial = false) {
+        const result = { ...data };
+        for (const [field, type] of Object.entries(this._dateFields)) {
+            if (partial && data[field] === undefined) continue;
+            if (data[field] !== undefined && data[field] !== null) {
+                result[field] = validateDateType(data[field], type, field);
+            }
+        }
+        return result;
+    }
+
     // ============================================================
     // 内部: 辅助
     // ============================================================
@@ -674,7 +776,9 @@ class Table {
         const result = { ...data };
         for (const [field, defaultValue] of Object.entries(this._defaults)) {
             if (result[field] === undefined) {
-                result[field] = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+                result[field] = typeof defaultValue === 'function'
+                    ? defaultValue()
+                    : (defaultValue === 'CURRENT_TIMESTAMP' ? now() : defaultValue);
             }
         }
         return result;
@@ -688,13 +792,11 @@ class Table {
     }
 
     _getVisibleRows() {
-        if (this._softDelete) {
-            return this._rows.filter(r => !r._deleted);
-        }
+        if (this._softDelete) return this._rows.filter(r => !r._deleted);
         return this._rows;
     }
 
-    _updateIndexes(rowIndex, data) {
+    _addToIndexes(rowIndex, data) {
         for (const field of Object.keys(this._indexes)) {
             const value = data[field];
             if (value !== undefined) {
@@ -704,6 +806,12 @@ class Table {
                 this._indexes[field].get(value).push(rowIndex);
             }
         }
+        for (const [field, tree] of Object.entries(this._btrees)) {
+            const value = data[field];
+            if (value !== undefined && value !== null) {
+                tree.insert(value, rowIndex);
+            }
+        }
     }
 
     _removeFromIndexes(rowIndex, data) {
@@ -718,21 +826,18 @@ class Table {
                 }
             }
         }
+        for (const [field, tree] of Object.entries(this._btrees)) {
+            const value = data[field];
+            if (value !== undefined && value !== null) {
+                tree.remove(value, rowIndex);
+            }
+        }
     }
 
-    _adjustIndexesAfterRemove(removedIndex) {
-        for (const idxName of Object.keys(this._indexes)) {
-            const idx = this._indexes[idxName];
-            for (const [key, positions] of idx) {
-                const newPositions = positions
-                    .filter(p => p !== removedIndex)
-                    .map(p => p > removedIndex ? p - 1 : p);
-                if (newPositions.length === 0) {
-                    idx.delete(key);
-                } else {
-                    idx.set(key, newPositions);
-                }
-            }
+    _adjustBTreeAfterRemove(removedIndex) {
+        // 重建受影响的 B-Tree
+        for (const field of Object.keys(this._btrees)) {
+            this._rebuildBTree(field);
         }
     }
 
@@ -746,6 +851,7 @@ class Table {
                 }
             }
         }
+        this._rebuildAllBTrees();
         for (const field of Object.keys(this._indexes)) {
             this.createIndex(field);
         }