jsql-neo 1.1.0 → 1.2.0

package/lib/table.js

@@ -1,36 +1,61 @@
 // © Vexify 2026 All Rights Reserved.
 /**
  * JSQL Table — 表操作引擎
- * 每张表是一个独立的数据集合，支持 CRUD、查询、索引
+ * 支持 DEFAULT、CHECK、外键、UPSERT、TRUNCATE、ALTER TABLE、计算字段、JSON 路径、软删除
  */
 
+const Query = require('./query');
+
 class Table {
     constructor(name, schema, db) {
         this._name = name;
         this._schema = schema;
         this._db = db;
-        this._rows = [];          // 数据行
-        this._indexes = {};       // 字段名 -> Map<value, [rowIndex, ...]>
-        this._autoIncrement = 0;  // 自增计数器
-        this._dirty = false;      // 是否有未保存的修改
-        this._hooks = {             // 事件钩子
-            beforeInsert: [],
-            afterInsert: [],
-            beforeUpdate: [],
-            afterUpdate: [],
-            beforeRemove: [],
-            afterRemove: []
+        this._rows = [];
+        this._indexes = {};
+        this._autoIncrement = 0;
+        this._dirty = false;
+        this._hooks = {
+            beforeInsert: [], afterInsert: [],
+            beforeUpdate: [], afterUpdate: [],
+            beforeRemove: [], afterRemove: []
         };
+        this._softDelete = false;        // 是否启用软删除
+        this._computedFields = {};       // 计算字段
 
-        // 解析主键和自增字段
+        // 解析列定义
         this._primaryKey = null;
         this._autoIncrementField = null;
+        this._foreignKeys = [];
+        this._checkConstraints = [];
+        this._defaults = {};
+
         for (const [field, def] of Object.entries(schema)) {
             if (def.primaryKey) this._primaryKey = field;
             if (def.autoIncrement) {
                 this._autoIncrementField = field;
                 if (def.primaryKey) this._primaryKey = field;
             }
+            if (def.default !== undefined) {
+                this._defaults[field] = def.default;
+            }
+            if (def.check) {
+                this._checkConstraints.push({ field, fn: def.check });
+            }
+            if (def.foreignKey) {
+                this._foreignKeys.push({
+                    field,
+                    table: def.foreignKey.table,
+                    onDelete: def.foreignKey.onDelete || 'restrict'
+                });
+            }
+            if (def.computed) {
+                this._computedFields[field] = def.computed;
+            }
+        }
+
+        if (schema._softDelete) {
+            this._softDelete = true;
         }
     }
 
@@ -39,19 +64,32 @@ class Table {
     // ============================================================
 
     insert(data) {
-        // 触发 beforeInsert 钩子
         for (const hook of this._hooks.beforeInsert) {
             data = hook({ ...data }) || data;
         }
 
-        // 校验必填字段
+        // 填充默认值
+        data = this._applyDefaults(data);
+
+        // 计算字段
+        data = this._applyComputed(data);
+
+        // 校验必填
         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) {
@@ -63,25 +101,19 @@ class Table {
         }
 
         // 自增
-        if (this._autoIncrementField) {
-            if (data[this._autoIncrementField] === undefined) {
-                this._autoIncrement++;
-                data[this._autoIncrementField] = this._autoIncrement;
-            } else if (data[this._autoIncrementField] > this._autoIncrement) {
-                this._autoIncrement = data[this._autoIncrementField];
-            }
+        if (this._autoIncrementField && data[this._autoIncrementField] === undefined) {
+            this._autoIncrement++;
+            data[this._autoIncrementField] = this._autoIncrement;
+        } else if (this._autoIncrementField && data[this._autoIncrementField] > this._autoIncrement) {
+            this._autoIncrement = data[this._autoIncrementField];
         }
 
         const rowIndex = this._rows.length;
         this._rows.push({ ...data });
-
-        // 更新索引
         this._updateIndexes(rowIndex, data);
-
         this._dirty = true;
         this._db._markDirty();
 
-        // 触发 afterInsert 钩子
         for (const hook of this._hooks.afterInsert) {
             hook(data);
         }
@@ -93,62 +125,52 @@ 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]);
+            if (existing) {
+                this.updateById(data[this._primaryKey], data);
+                return this.findById(data[this._primaryKey]);
+            }
+        }
+        return this.insert(data);
+    }
+
     // ============================================================
     // 查询
     // ============================================================
 
-    /**
-     * 查找所有匹配的行
-     */
     find(query = {}) {
-        let rows = this._rows;
-
+        let rows = this._getVisibleRows();
         if (Object.keys(query).length > 0) {
             rows = this._applyFilter(rows, query);
         }
-
         return rows.map(r => ({ ...r }));
     }
 
-    /**
-     * 查找第一条匹配的行
-     */
     findOne(query = {}) {
         const rows = this.find(query);
         return rows.length > 0 ? rows[0] : null;
     }
 
-    /**
-     * 按主键查找
-     */
     findById(id) {
-        if (!this._primaryKey) {
-            throw new Error(`Table '${this._name}' has no primary key`);
-        }
+        if (!this._primaryKey) throw new Error(`Table '${this._name}' has no primary key`);
         return this.findOne({ [this._primaryKey]: id });
     }
 
-    /**
-     * 获取所有行
-     */
     findAll() {
-        return this._rows.map(r => ({ ...r }));
+        return this._getVisibleRows().map(r => ({ ...r }));
     }
 
-    /**
-     * 计数
-     */
     count(query = {}) {
-        if (Object.keys(query).length === 0) {
-            return this._rows.length;
-        }
-        return this._applyFilter(this._rows, query).length;
+        if (Object.keys(query).length === 0) return this._getVisibleRows().length;
+        return this._applyFilter(this._getVisibleRows(), query).length;
     }
 
-    // ============================================================
-    // 链式查询
-    // ============================================================
-
     where(conditions) {
         return new Query(this, conditions);
     }
@@ -158,12 +180,11 @@ class Table {
     // ============================================================
 
     update(query, updates) {
-        // 触发 beforeUpdate 钩子
         for (const hook of this._hooks.beforeUpdate) {
             updates = hook(query, { ...updates }) || updates;
         }
 
-        const matched = this._applyFilter(this._rows, query);
+        const matched = this._applyFilter(this._getVisibleRows(), query);
         let count = 0;
 
         for (const row of matched) {
@@ -172,7 +193,7 @@ class Table {
 
             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++) {
@@ -183,21 +204,23 @@ class Table {
                 }
             }
 
-            // 更新
-            Object.assign(this._rows[index], updates);
+            // 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}'`);
+                }
+            }
 
-            // 更新索引
+            Object.assign(this._rows[index], updates);
             this._removeFromIndexes(index, oldData);
             this._updateIndexes(index, this._rows[index]);
-
             count++;
         }
 
         if (count > 0) {
             this._dirty = true;
             this._db._markDirty();
-
-            // 触发 afterUpdate 钩子
             for (const hook of this._hooks.afterUpdate) {
                 hook(query, updates, count);
             }
@@ -206,9 +229,7 @@ class Table {
     }
 
     updateById(id, updates) {
-        if (!this._primaryKey) {
-            throw new Error(`Table '${this._name}' has no primary key`);
-        }
+        if (!this._primaryKey) throw new Error(`Table '${this._name}' has no primary key`);
         return this.update({ [this._primaryKey]: id }, updates);
     }
 
@@ -217,65 +238,183 @@ class Table {
     // ============================================================
 
     remove(query = {}) {
-        // 触发 beforeRemove 钩子
         for (const hook of this._hooks.beforeRemove) {
-            const result = hook(query);
-            if (result === false) return 0; // 钩子取消删除
+            if (hook(query) === false) return 0;
         }
 
         if (Object.keys(query).length === 0) {
-            // 删除全部
-            const count = this._rows.length;
-            this._rows = [];
-            this._indexes = {};
-            this._autoIncrement = 0;
-            this._dirty = true;
-            this._db._markDirty();
-            return count;
+            return this._truncate();
         }
 
-        const toRemove = this._applyFilter(this._rows, query);
+        const toRemove = this._applyFilter(this._getVisibleRows(), query);
+        let count = 0;
+
         for (const row of toRemove) {
             const index = this._rows.indexOf(row);
-            if (index !== -1) {
-                this._removeFromIndexes(index, row);
-                this._rows.splice(index, 1);
-                // 调整后续索引
-                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 !== index)
-                            .map(p => p > index ? p - 1 : p);
-                        if (newPositions.length === 0) {
-                            idx.delete(key);
-                        } else {
-                            idx.set(key, newPositions);
-                        }
+            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] });
                     }
                 }
             }
+
+            if (this._softDelete) {
+                this._rows[index]._deleted = true;
+                this._rows[index]._deletedAt = Date.now();
+            } else {
+                this._removeFromIndexes(index, row);
+                this._rows.splice(index, 1);
+                this._adjustIndexesAfterRemove(index);
+            }
+            count++;
         }
 
-        if (toRemove.length > 0) {
+        if (count > 0) {
             this._dirty = true;
             this._db._markDirty();
-
-            // 触发 afterRemove 钩子
             for (const hook of this._hooks.afterRemove) {
-                hook(query, toRemove.length);
+                hook(query, count);
             }
         }
-        return toRemove.length;
+        return count;
     }
 
     removeById(id) {
-        if (!this._primaryKey) {
-            throw new Error(`Table '${this._name}' has no primary key`);
-        }
+        if (!this._primaryKey) throw new Error(`Table '${this._name}' has no primary key`);
         return this.remove({ [this._primaryKey]: id });
     }
 
+    /**
+     * 软删除 — 标记为已删除，可恢复
+     */
+    removeSoft(query = {}) {
+        this._softDelete = true;
+        const result = this.remove(query);
+        return result;
+    }
+
+    /**
+     * 恢复软删除的行
+     */
+    restore(query = {}) {
+        if (!this._softDelete) throw new Error('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);
+            if (index !== -1) {
+                delete this._rows[index]._deleted;
+                delete this._rows[index]._deletedAt;
+            }
+        }
+        return matched.length;
+    }
+
+    /**
+     * 清空表（保留结构）
+     */
+    truncate() {
+        return this._truncate();
+    }
+
+    _truncate() {
+        const count = this._rows.length;
+        this._rows = [];
+        this._indexes = {};
+        this._autoIncrement = 0;
+        this._dirty = true;
+        this._db._markDirty();
+        return count;
+    }
+
+    // ============================================================
+    // ALTER TABLE
+    // ============================================================
+
+    addColumn(field, definition) {
+        if (this._schema[field]) throw new Error(`Column '${field}' already exists`);
+        this._schema[field] = definition;
+        if (definition.default !== undefined) this._defaults[field] = definition.default;
+        if (definition.check) this._checkConstraints.push({ field, fn: definition.check });
+        if (definition.foreignKey) {
+            this._foreignKeys.push({
+                field,
+                table: definition.foreignKey.table,
+                onDelete: definition.foreignKey.onDelete || 'restrict'
+            });
+        }
+        if (definition.computed) this._computedFields[field] = definition.computed;
+        this._dirty = true;
+        this._db._markDirty();
+        return this;
+    }
+
+    dropColumn(field) {
+        if (!this._schema[field]) throw new Error(`Column '${field}' does not exist`);
+        delete this._schema[field];
+        delete this._defaults[field];
+        this._checkConstraints = this._checkConstraints.filter(c => c.field !== field);
+        this._foreignKeys = this._foreignKeys.filter(fk => fk.field !== field);
+        delete this._computedFields[field];
+        // 移除所有行中的该字段
+        for (const row of this._rows) {
+            delete row[field];
+        }
+        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`);
+        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];
+        }
+        for (const row of this._rows) {
+            row[newName] = row[oldName];
+            delete row[oldName];
+        }
+        if (this._primaryKey === oldName) this._primaryKey = newName;
+        if (this._autoIncrementField === oldName) this._autoIncrementField = newName;
+        this._dirty = true;
+        this._db._markDirty();
+        return this;
+    }
+
+    modifyColumn(field, definition) {
+        if (!this._schema[field]) throw new Error(`Column '${field}' does not exist`);
+        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 });
+        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,
+            softDelete: this._softDelete,
+            foreignKeys: this._foreignKeys.map(fk => ({ field: fk.field, table: fk.table }))
+        };
+    }
+
     // ============================================================
     // 索引
     // ============================================================
@@ -302,17 +441,6 @@ class Table {
     // 事件钩子
     // ============================================================
 
-    /**
-     * 注册事件钩子
-     * @param {string} event - 'beforeInsert' | 'afterInsert' | 'beforeUpdate' | 'afterUpdate' | 'beforeRemove' | 'afterRemove'
-     * @param {function} callback
-     *   - beforeInsert(data) => 返回修改后的 data
-     *   - afterInsert(data)
-     *   - beforeUpdate(query, updates) => 返回修改后的 updates
-     *   - afterUpdate(query, updates, count)
-     *   - beforeRemove(query) => 返回 false 阻止删除
-     *   - afterRemove(query, count)
-     */
     on(event, callback) {
         if (this._hooks[event]) {
             this._hooks[event].push(callback);
@@ -328,7 +456,7 @@ class Table {
     }
 
     // ============================================================
-    // 内部方法
+    // 内部: 过滤器
     // ============================================================
 
     _applyFilter(rows, query) {
@@ -343,20 +471,29 @@ class Table {
 
     _matchRow(row, query) {
         for (const [field, condition] of Object.entries(query)) {
-            const value = row[field];
-
-            // 操作符对象: { $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $like, $regex }
-            if (condition !== null && typeof condition === 'object' && !Array.isArray(condition)) {
-                for (const [op, target] of Object.entries(condition)) {
-                    if (!this._matchOperator(value, op, target)) {
+            // 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;
+                        }
+                    }
+                } else {
+                    // 普通对象：递归匹配子文档
+                    if (value !== null && typeof value === 'object') {
+                        if (!this._matchRow(value, condition)) return false;
+                    } else {
                         return false;
                     }
                 }
             } else {
-                // 简单等值匹配
-                if (value !== condition) {
-                    return false;
-                }
+                if (value !== condition) return false;
             }
         }
         return true;
@@ -374,8 +511,7 @@ class Table {
             case '$nin': return Array.isArray(target) && !target.includes(value);
             case '$like':
                 if (typeof value !== 'string' || typeof target !== 'string') return false;
-                const regex = new RegExp(target.replace(/%/g, '.*').replace(/_/g, '.'), 'i');
-                return regex.test(value);
+                return new RegExp(target.replace(/%/g, '.*').replace(/_/g, '.'), 'i').test(value);
             case '$regex':
                 return new RegExp(target).test(String(value));
             case '$exists':
@@ -383,13 +519,82 @@ class Table {
             case '$between':
                 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':
-                return Array.isArray(target) && target.some(sub => this._matchRow({ [op]: value }, { [op]: sub }));
+                return Array.isArray(target) && target.some(sub => this._matchRow({ _val: value }, { _val: sub }));
+            case '$not':
+                return !this._matchRow({ _val: value }, { _val: target });
+            case '$contains':
+                return Array.isArray(value) && value.includes(target);
+            case '$type':
+                return typeof value === target;
+            case '$size':
+                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
+                );
+            case '$isNull':
+                return target ? value === null || value === undefined : value !== null && value !== undefined;
+            case '$startsWith':
+                return typeof value === 'string' && value.startsWith(target);
+            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()));
             default:
                 return false;
         }
     }
 
+    /**
+     * 解析 JSON 路径，如 'profile.city' -> row.profile.city
+     */
+    _resolvePath(row, field) {
+        if (field.includes('.') && !field.startsWith('$')) {
+            const parts = field.split('.');
+            let value = row;
+            for (const part of parts) {
+                if (value === null || value === undefined) return undefined;
+                value = value[part];
+            }
+            return value;
+        }
+        return row[field];
+    }
+
+    // ============================================================
+    // 内部: 辅助
+    // ============================================================
+
+    _applyDefaults(data) {
+        const result = { ...data };
+        for (const [field, defaultValue] of Object.entries(this._defaults)) {
+            if (result[field] === undefined) {
+                result[field] = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+            }
+        }
+        return result;
+    }
+
+    _applyComputed(data) {
+        for (const [field, fn] of Object.entries(this._computedFields)) {
+            data[field] = fn(data);
+        }
+        return data;
+    }
+
+    _getVisibleRows() {
+        if (this._softDelete) {
+            return this._rows.filter(r => !r._deleted);
+        }
+        return this._rows;
+    }
+
     _updateIndexes(rowIndex, data) {
         for (const field of Object.keys(this._indexes)) {
             const value = data[field];
@@ -416,9 +621,24 @@ class Table {
         }
     }
 
+    _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);
+                }
+            }
+        }
+    }
+
     _loadRows(rows) {
         this._rows = rows;
-        // 重建自增
         if (this._autoIncrementField) {
             for (const row of rows) {
                 const val = row[this._autoIncrementField];
@@ -427,183 +647,14 @@ class Table {
                 }
             }
         }
-        // 重建所有索引
         for (const field of Object.keys(this._indexes)) {
             this.createIndex(field);
         }
     }
 
-    // ============================================================
-    // 导出
-    // ============================================================
-
     toJSON() {
         return this._rows;
     }
 }
 
-// ============================================================
-// 链式查询构建器
-// ============================================================
-
-class Query {
-    constructor(table, conditions) {
-        this._table = table;
-        this._conditions = conditions;
-        this._orderBy = null;
-        this._orderDir = 'asc';
-        this._limitCount = null;
-        this._offsetCount = 0;
-        this._selectFields = null;
-        this._groupBy = null;
-    }
-
-    orderBy(field, dir = 'asc') {
-        this._orderBy = field;
-        this._orderDir = dir;
-        return this;
-    }
-
-    limit(n) {
-        this._limitCount = n;
-        return this;
-    }
-
-    offset(n) {
-        this._offsetCount = n;
-        return this;
-    }
-
-    select(fields) {
-        this._selectFields = Array.isArray(fields) ? fields : [fields];
-        return this;
-    }
-
-    groupBy(field) {
-        this._groupBy = field;
-        return this;
-    }
-
-    get() {
-        let rows = this._table._applyFilter(this._table._rows, this._conditions);
-
-        // 排序
-        if (this._orderBy) {
-            rows = rows.sort((a, b) => {
-                const va = a[this._orderBy];
-                const vb = b[this._orderBy];
-                if (va < vb) return this._orderDir === 'asc' ? -1 : 1;
-                if (va > vb) return this._orderDir === 'asc' ? 1 : -1;
-                return 0;
-            });
-        }
-
-        // 分页
-        if (this._offsetCount > 0) {
-            rows = rows.slice(this._offsetCount);
-        }
-        if (this._limitCount !== null) {
-            rows = rows.slice(0, this._limitCount);
-        }
-
-        // 字段选择
-        rows = rows.map(r => ({ ...r }));
-        if (this._selectFields) {
-            rows = rows.map(r => {
-                const obj = {};
-                for (const f of this._selectFields) {
-                    obj[f] = r[f];
-                }
-                return obj;
-            });
-        }
-
-        return rows;
-    }
-
-    first() {
-        const rows = this.limit(1).get();
-        return rows.length > 0 ? rows[0] : null;
-    }
-
-    count() {
-        const rows = this._table._applyFilter(this._table._rows, this._conditions);
-        return rows.length;
-    }
-
-    sum(field) {
-        const rows = this._applyGroupedRows();
-        return rows.reduce((acc, r) => acc + (Number(r[field]) || 0), 0);
-    }
-
-    avg(field) {
-        const rows = this._applyGroupedRows();
-        if (rows.length === 0) return 0;
-        return this.sum(field) / rows.length;
-    }
-
-    min(field) {
-        const rows = this._applyGroupedRows();
-        if (rows.length === 0) return null;
-        return rows.reduce((min, r) => {
-            const v = Number(r[field]);
-            return (min === null || v < min) ? v : min;
-        }, null);
-    }
-
-    max(field) {
-        const rows = this._applyGroupedRows();
-        if (rows.length === 0) return null;
-        return rows.reduce((max, r) => {
-            const v = Number(r[field]);
-            return (max === null || v > max) ? v : max;
-        }, null);
-    }
-
-    /**
-     * 获取分组统计结果
-     * @returns {Array<{ _group: value, _count, _sum, _avg, _min, _max }>}
-     */
-    groupStats(field) {
-        if (!this._groupBy) throw new Error('groupStats() requires groupBy() to be called first');
-        const rows = this._table._applyFilter(this._table._rows, this._conditions);
-        const groups = {};
-
-        for (const row of rows) {
-            const key = String(row[this._groupBy] ?? '__null__');
-            if (!groups[key]) {
-                groups[key] = { _group: row[this._groupBy], _count: 0, _sum: 0, _min: null, _max: null, _rows: [] };
-            }
-            const g = groups[key];
-            g._count++;
-            const v = Number(row[field]) || 0;
-            g._sum += v;
-            g._min = g._min === null ? v : Math.min(g._min, v);
-            g._max = g._max === null ? v : Math.max(g._max, v);
-            g._rows.push(row);
-        }
-
-        const result = Object.values(groups);
-        result.forEach(g => {
-            g._avg = g._count > 0 ? g._sum / g._count : 0;
-            delete g._rows;
-        });
-
-        return result;
-    }
-
-    _applyGroupedRows() {
-        let rows = this._table._applyFilter(this._table._rows, this._conditions);
-        return rows;
-    }
-
-    update(updates) {
-        return this._table.update(this._conditions, updates);
-    }
-
-    remove() {
-        return this._table.remove(this._conditions);
-    }
-}
-
 module.exports = Table;