@wowoengine/sawitdb 2.5.0 → 2.6.0

package/src/WowoEngine.js

@@ -1,15 +1,34 @@
 const Pager = require('./modules/Pager');
 const QueryParser = require('./modules/QueryParser');
-const BTreeIndex = require('./modules/BTreeIndex');
 const WAL = require('./modules/WAL');
+const DBEventHandler = require("./services/event/DBEventHandler");
+const DBEvent = require("./services/event/DBEvent");
+
+// Services
+const TableManager = require('./services/TableManager');
+const IndexManager = require('./services/IndexManager');
+const ConditionEvaluator = require('./services/logic/ConditionEvaluator');
+
+// Executors
+const SelectExecutor = require('./services/executors/SelectExecutor');
+const InsertExecutor = require('./services/executors/InsertExecutor');
+const DeleteExecutor = require('./services/executors/DeleteExecutor');
+const UpdateExecutor = require('./services/executors/UpdateExecutor');
+const AggregateExecutor = require('./services/executors/AggregateExecutor');
 
 /**
  * SawitDB implements the Logic over the Pager
+ * Refactored to use modular services and executors.
  */
 class SawitDB {
     constructor(filePath, options = {}) {
         // WAL: Optional crash safety (backward compatible - disabled by default)
         this.wal = options.wal ? new WAL(filePath, options.wal) : null;
+        this.dbevent = options.dbevent ? options.dbevent : new DBEventHandler();
+
+        if (!this.dbevent instanceof DBEvent) {
+            console.error(`dbevent is not instanceof DBEvent`);
+        }
 
         // Recovery: Replay WAL if exists
         if (this.wal && this.wal.enabled) {
@@ -23,56 +42,38 @@ class SawitDB {
         this.indexes = new Map(); // Map of 'tableName.fieldName' -> BTreeIndex
         this.parser = new QueryParser();
 
-        // YEAR OF THE LINUX DESKTOP - just kidding. 
         // CACHE: Simple LRU for Parsed Queries
         this.queryCache = new Map();
         this.queryCacheLimit = 1000;
 
+        // Initialize Services
+        this.tableManager = new TableManager(this);
+        this.indexManager = new IndexManager(this);
+        this.conditionEvaluator = new ConditionEvaluator();
+
+        // Initialize Executors
+        this.selectExecutor = new SelectExecutor(this);
+        this.insertExecutor = new InsertExecutor(this);
+        this.deleteExecutor = new DeleteExecutor(this);
+        this.updateExecutor = new UpdateExecutor(this);
+        this.aggregateExecutor = new AggregateExecutor(this);
+
         // PERSISTENCE: Initialize System Tables
         this._initSystem();
     }
 
     _initSystem() {
         // Check if _indexes table exists, if not create it
-        if (!this._findTableEntry('_indexes')) {
+        if (!this.tableManager.findTableEntry('_indexes')) {
             try {
-                this._createTable('_indexes');
+                this.tableManager.createTable('_indexes', true); // true = system table
             } catch (e) {
                 // Ignore if it effectively exists or concurrency issue
             }
         }
 
         // Load Indexes
-        this._loadIndexes();
-    }
-
-    _loadIndexes() {
-        const indexRecords = this._select('_indexes', null);
-        for (const rec of indexRecords) {
-            const table = rec.table;
-            const field = rec.field;
-            const indexKey = `${table}.${field}`;
-
-            if (!this.indexes.has(indexKey)) {
-                // Rebuild Index in Memory
-                const index = new BTreeIndex();
-                index.name = indexKey;
-                index.keyField = field;
-
-                // Populate Index
-                try {
-                    const allRecords = this._select(table, null);
-                    for (const record of allRecords) {
-                        if (record.hasOwnProperty(field)) {
-                            index.insert(record[field], record);
-                        }
-                    }
-                    this.indexes.set(indexKey, index);
-                } catch (e) {
-                    console.error(`Failed to rebuild index ${indexKey}: ${e.message}`);
-                }
-            }
-        }
+        this.indexManager.loadIndexes();
     }
 
     close() {
@@ -85,44 +86,42 @@ class SawitDB {
         }
     }
 
-    query(queryString, params) {
-        if (!this.pager) return "Error: Database is closed.";
+    /**
+     * Shallow clone a command object for cache retrieval
+     * Faster than JSON.parse(JSON.stringify()) for simple objects
+     */
+    _shallowCloneCmd(cmd) {
+        const clone = { ...cmd };
+        // Deep clone arrays (criteria, joins, cols, sort)
+        if (cmd.criteria) clone.criteria = { ...cmd.criteria };
+        if (cmd.joins) clone.joins = cmd.joins.map(j => ({ ...j, on: { ...j.on } }));
+        if (cmd.cols) clone.cols = [...cmd.cols];
+        if (cmd.sort) clone.sort = { ...cmd.sort };
+        if (cmd.values) clone.values = { ...cmd.values };
+        return clone;
+    }
 
+    query(queryString, params) {
         if (!this.pager) return "Error: Database is closed.";
 
-        // QUERY CACHE
+        // QUERY CACHE - Optimized with shallow clone
         let cmd;
-        if (this.queryCache.has(queryString)) {
-            // Clone to avoid mutation issues if cmd is modified later (bind params currently mutates)
-            // Ideally we store "Plan" and "Params" separate, but parser returns bound object.
-            // Wait, parser.bindParameters happens inside parse if params provided.
-            // If params provided, caching key must include params? No, that defeats point.
-            // We should cache the UNBOUND command, then bind.
-            // But parser.parse does both.
-            // Refactor: parse(query) -> cmd. bind(cmd, params) -> readyCmd.
-            // Since we can't easily refactor parser signature safely without check,
-            // let's cache only if no params OR blindly cache and hope bind handles it?
-            // Current parser.parse takes params.
-            // We will optimize: Use cache only if key matches. 
-            // If params exist, we can't blindly reuse result from cache if it was bound to different params.
-            // Strategy: Cache raw tokens/structure? 
-            // Better: Parser.parse(sql) (no params) -> Cache. Then bind.
-            // We need to change how we call parser.
-        }
-
-        // OPTIMIZATION: Split Parse and Bind
+        this.queryString = queryString;
         const cacheKey = queryString;
+
         if (this.queryCache.has(cacheKey) && !params) {
-            cmd = JSON.parse(JSON.stringify(this.queryCache.get(cacheKey))); // Deep clone simple object
+            const cached = this.queryCache.get(cacheKey);
+            cmd = this._shallowCloneCmd(cached);
+            this.queryCache.delete(cacheKey);
+            this.queryCache.set(cacheKey, cached);
         } else {
-            // Parse without params first to get template
             const templateCmd = this.parser.parse(queryString);
             if (templateCmd.type !== 'ERROR') {
-                // Clone for cache
                 if (!params) {
-                    this.queryCache.set(cacheKey, JSON.parse(JSON.stringify(templateCmd)));
-                    if (this.queryCache.size > this.queryCacheLimit) {
-                        this.queryCache.delete(this.queryCache.keys().next().value);
+                    this.queryCache.set(cacheKey, templateCmd);
+                    while (this.queryCache.size > this.queryCacheLimit) {
+                        const firstKey = this.queryCache.keys().next().value;
+                        this.queryCache.delete(firstKey);
                     }
                 }
                 cmd = templateCmd;
@@ -130,56 +129,47 @@ class SawitDB {
                 return `Error: ${templateCmd.message}`;
             }
 
-            // Bind now if params exist
             if (params) {
                 this.parser._bindParameters(cmd, params);
             }
         }
 
-        // Re-check error type just in case
         if (cmd.type === 'ERROR') return `Error: ${cmd.message}`;
-        // const cmd = this.parser.parse(queryString, params);
 
         try {
             switch (cmd.type) {
                 case 'CREATE_TABLE':
-                    return this._createTable(cmd.table);
+                    return this.tableManager.createTable(cmd.table);
 
                 case 'SHOW_TABLES':
-                    return this._showTables();
+                    return this.tableManager.showTables();
 
                 case 'SHOW_INDEXES':
-                    return this._showIndexes(cmd.table); // cmd.table can be null
+                    return this.indexManager.showIndexes(cmd.table);
 
                 case 'INSERT':
-                    return this._insert(cmd.table, cmd.data);
+                    return this.insertExecutor.execute(cmd);
 
                 case 'SELECT':
-                    // Map generic generic Select Logic
-                    const rows = this._select(cmd.table, cmd.criteria, cmd.sort, cmd.limit, cmd.offset, cmd.joins);
-
-                    if (cmd.cols.length === 1 && cmd.cols[0] === '*') return rows;
-
-                    return rows.map(r => {
-                        const newRow = {};
-                        cmd.cols.forEach(c => newRow[c] = r[c] !== undefined ? r[c] : null);
-                        return newRow;
-                    });
+                    return this.selectExecutor.execute(cmd);
 
                 case 'DELETE':
-                    return this._delete(cmd.table, cmd.criteria);
+                    return this.deleteExecutor.execute(cmd);
 
                 case 'UPDATE':
-                    return this._update(cmd.table, cmd.updates, cmd.criteria);
+                    return this.updateExecutor.execute(cmd);
 
                 case 'DROP_TABLE':
-                    return this._dropTable(cmd.table);
+                    return this.tableManager.dropTable(cmd.table);
 
                 case 'CREATE_INDEX':
-                    return this._createIndex(cmd.table, cmd.field);
+                    return this.indexManager.createIndex(cmd.table, cmd.field);
 
                 case 'AGGREGATE':
-                    return this._aggregate(cmd.table, cmd.func, cmd.field, cmd.criteria, cmd.groupBy);
+                    return this.aggregateExecutor.execute(cmd);
+
+                case 'EXPLAIN':
+                    return this._explain(cmd.innerCommand);
 
                 default:
                     return `Perintah tidak dikenal atau belum diimplementasikan di Engine Refactor.`;
@@ -189,428 +179,27 @@ class SawitDB {
         }
     }
 
-    // --- Core Logic ---
-
-    // --- Core Logic ---
+    // --- Core Data Access (Low Level) ---
+    // Kept here as it's the fundamental connection between Pager and Logic
+    // Could eventually move to TableScanner service
 
+    // Backward compatibility wrapper for old internal calls (if any remain)
     _findTableEntry(name) {
-        const p0 = this.pager.readPage(0);
-        const numTables = p0.readUInt32LE(8);
-        let offset = 12;
-
-        for (let i = 0; i < numTables; i++) {
-            const tName = p0.toString('utf8', offset, offset + 32).replace(/\0/g, '');
-            if (tName === name) {
-                return {
-                    index: i,
-                    offset: offset,
-                    startPage: p0.readUInt32LE(offset + 32),
-                    lastPage: p0.readUInt32LE(offset + 36)
-                };
-            }
-            offset += 40;
-        }
-        return null;
-    }
-
-    _showTables() {
-        const p0 = this.pager.readPage(0);
-        const numTables = p0.readUInt32LE(8);
-        const tables = [];
-        let offset = 12;
-        for (let i = 0; i < numTables; i++) {
-            const tName = p0.toString('utf8', offset, offset + 32).replace(/\0/g, '');
-            if (!tName.startsWith('_')) { // Hide system tables
-                tables.push(tName);
-            }
-            offset += 40;
-        }
-        return tables;
-    }
-
-    _createTable(name) {
-        if (!name) throw new Error("Nama kebun tidak boleh kosong");
-        if (name.length > 32) throw new Error("Nama kebun max 32 karakter");
-        if (this._findTableEntry(name)) return `Kebun '${name}' sudah ada.`;
-
-        const p0 = this.pager.readPage(0);
-        const numTables = p0.readUInt32LE(8);
-        let offset = 12 + (numTables * 40);
-        if (offset + 40 > Pager.PAGE_SIZE) throw new Error("Lahan penuh (Page 0 full)");
-
-        const newPageId = this.pager.allocPage();
-
-        const nameBuf = Buffer.alloc(32);
-        nameBuf.write(name);
-        nameBuf.copy(p0, offset);
-
-        p0.writeUInt32LE(newPageId, offset + 32);
-        p0.writeUInt32LE(newPageId, offset + 36);
-        p0.writeUInt32LE(numTables + 1, 8);
-
-        this.pager.writePage(0, p0);
-        return `Kebun '${name}' telah dibuka.`;
-    }
-
-    _dropTable(name) {
-        if (name === '_indexes') return "Tidak boleh membakar catatan sistem.";
-
-        const entry = this._findTableEntry(name);
-        if (!entry) return `Kebun '${name}' tidak ditemukan.`;
-
-        // Remove associated indexes
-        const toRemove = [];
-        for (const key of this.indexes.keys()) {
-            if (key.startsWith(name + '.')) {
-                toRemove.push(key);
-            }
-        }
-
-        // Remove from memory
-        toRemove.forEach(key => this.indexes.delete(key));
-
-        // Remove from _indexes table
-        try {
-            this._delete('_indexes', {
-                type: 'compound',
-                logic: 'AND',
-                conditions: [
-                    { key: 'table', op: '=', val: name }
-                ]
-            });
-        } catch (e) { /* Ignore if fails, maybe recursive? No, _delete uses basic ops */ }
-
-
-        const p0 = this.pager.readPage(0);
-        const numTables = p0.readUInt32LE(8);
-
-        // Move last entry to this spot to fill gap
-        if (numTables > 1 && entry.index < numTables - 1) {
-            const lastOffset = 12 + ((numTables - 1) * 40);
-            const lastEntryBuf = p0.slice(lastOffset, lastOffset + 40);
-            lastEntryBuf.copy(p0, entry.offset);
-        }
-
-        // Clear last spot
-        const lastOffset = 12 + ((numTables - 1) * 40);
-        p0.fill(0, lastOffset, lastOffset + 40);
-
-        p0.writeUInt32LE(numTables - 1, 8);
-        this.pager.writePage(0, p0);
-
-        return `Kebun '${name}' telah dibakar (Drop).`;
-    }
-
-    _updateTableLastPage(name, newLastPageId) {
-        const entry = this._findTableEntry(name);
-        if (!entry) throw new Error("Internal Error: Table missing for update");
-
-        // Update Disk/Page 0
-        const p0 = this.pager.readPage(0);
-        p0.writeUInt32LE(newLastPageId, entry.offset + 36);
-        this.pager.writePage(0, p0);
-    }
-
-    _insert(table, data) {
-        if (!data || Object.keys(data).length === 0) {
-            throw new Error("Data kosong / fiktif? Ini melanggar integritas (Korupsi Data).");
-        }
-        return this._insertMany(table, [data]);
-    }
-
-    // NEW: Batch Insert for High Performance (50k+ TPS)
-    _insertMany(table, dataArray) {
-        if (!dataArray || dataArray.length === 0) return "Tidak ada bibit untuk ditanam.";
-
-        const entry = this._findTableEntry(table);
-        if (!entry) throw new Error(`Kebun '${table}' tidak ditemukan.`);
-
-        let currentPageId = entry.lastPage;
-        let pData = this.pager.readPage(currentPageId);
-        let freeOffset = pData.readUInt16LE(6);
-        let count = pData.readUInt16LE(4);
-        let startPageChanged = false;
-
-        for (const data of dataArray) {
-            const dataStr = JSON.stringify(data);
-            const dataBuf = Buffer.from(dataStr, 'utf8');
-            const recordLen = dataBuf.length;
-            const totalLen = 2 + recordLen;
-
-            // Check if fits
-            if (freeOffset + totalLen > Pager.PAGE_SIZE) {
-                // Determine new page ID (predictive or alloc)
-                // allocPage reads/writes Page 0, which is expensive in loop.
-                // Optimally we should batch Page 0 update too, but Pager.allocPage handles it.
-                // For now rely on Pager caching Page 0.
-
-                // Write current full page
-                pData.writeUInt16LE(count, 4);
-                pData.writeUInt16LE(freeOffset, 6);
-                this.pager.writePage(currentPageId, pData);
-
-                const newPageId = this.pager.allocPage();
-
-                // Link old page to new
-                pData.writeUInt32LE(newPageId, 0);
-                this.pager.writePage(currentPageId, pData); // Rewrite link
-
-                currentPageId = newPageId;
-                pData = this.pager.readPage(currentPageId);
-                freeOffset = pData.readUInt16LE(6);
-                count = pData.readUInt16LE(4);
-                startPageChanged = true;
-            }
-
-
-            pData.writeUInt16LE(recordLen, freeOffset);
-            dataBuf.copy(pData, freeOffset + 2);
-            freeOffset += totalLen;
-            count++;
-
-            // Inject Page Hint for Index
-            Object.defineProperty(data, '_pageId', {
-                value: currentPageId,
-                enumerable: false,
-                writable: true
-            });
-
-            // Index update (can be batched later if needed, but BTree is fast)
-            if (table !== '_indexes') {
-                this._updateIndexes(table, data, null);
-            }
-        }
-
-        // Final write
-        pData.writeUInt16LE(count, 4);
-        pData.writeUInt16LE(freeOffset, 6);
-        this.pager.writePage(currentPageId, pData);
-
-        if (startPageChanged) {
-            this._updateTableLastPage(table, currentPageId);
-        }
-
-        return `${dataArray.length} bibit tertanam.`;
-    }
-
-    _updateIndexes(table, newObj, oldObj) {
-        // If oldObj is null, it's an INSERT. If newObj is null, it's a DELETE. Both? Update.
-
-        for (const [indexKey, index] of this.indexes) {
-            const [tbl, field] = indexKey.split('.');
-            if (tbl !== table) continue; // Wrong table
-
-            // 1. Remove old value from index (if exists and changed)
-            if (oldObj && oldObj.hasOwnProperty(field)) {
-                // Only remove if value changed OR it's a delete (newObj is null)
-                // If update, check if value diff
-                if (!newObj || newObj[field] !== oldObj[field]) {
-                    index.delete(oldObj[field]);
-                }
-            }
-
-            // 2. Insert new value (if exists)
-            if (newObj && newObj.hasOwnProperty(field)) {
-                // Only insert if it's new OR value changed
-                if (!oldObj || newObj[field] !== oldObj[field]) {
-                    index.insert(newObj[field], newObj);
-                }
-            }
-        }
+        return this.tableManager.findTableEntry(name);
     }
 
+    // Backward compatibility wrapper for internal calls
     _checkMatch(obj, criteria) {
-        if (!criteria) return true;
-
-        if (criteria.type === 'compound') {
-            let result = (criteria.logic === 'OR') ? false : true;
-
-            for (let i = 0; i < criteria.conditions.length; i++) {
-                const cond = criteria.conditions[i];
-                const matches = (cond.type === 'compound')
-                    ? this._checkMatch(obj, cond)
-                    : this._checkSingleCondition(obj, cond);
-
-                if (criteria.logic === 'OR') {
-                    result = result || matches;
-                    if (result) return true; // Short circuit
-                } else {
-                    result = result && matches;
-                    if (!result) return false; // Short circuit
-                }
-            }
-            return result;
-        }
-
-        return this._checkSingleCondition(obj, criteria);
+        return this.conditionEvaluator.checkMatch(obj, criteria);
     }
 
-    _checkSingleCondition(obj, criteria) {
-        const val = obj[criteria.key];
-        const target = criteria.val;
-        switch (criteria.op) {
-            case '=': return val == target;
-            case '!=': return val != target;
-            case '>': return val > target;
-            case '<': return val < target;
-            case '>=': return val >= target;
-            case '<=': return val <= target;
-            case 'IN': return Array.isArray(target) && target.includes(val);
-            case 'NOT IN': return Array.isArray(target) && !target.includes(val);
-            case 'LIKE':
-                const regexStr = '^' + target.replace(/%/g, '.*') + '$';
-                const re = new RegExp(regexStr, 'i');
-                return re.test(String(val));
-            case 'BETWEEN':
-                return val >= target[0] && val <= target[1];
-            case 'IS NULL':
-                return val === null || val === undefined;
-            case 'IS NOT NULL':
-                return val !== null && val !== undefined;
-            default: return false;
-        }
-    }
-
-    _select(table, criteria, sort, limit, offsetCount, joins) {
-        const entry = this._findTableEntry(table);
-        if (!entry) throw new Error(`Kebun '${table}' tidak ditemukan.`);
-
-        let results = [];
-
-        if (joins && joins.length > 0) {
-            // ... (Existing Join Logic - Unchanged but ensure recursion safe)
-            // 1. Scan Main Table
-            let currentRows = this._scanTable(entry, null).map(row => {
-                const newRow = { ...row };
-                for (const k in row) {
-                    newRow[`${table}.${k}`] = row[k];
-                }
-                return newRow;
-            });
-
-            // 2. Perform Joins
-            // 2. Perform Joins
-            for (const join of joins) {
-                const joinEntry = this._findTableEntry(join.table);
-                if (!joinEntry) throw new Error(`Kebun '${join.table}' tidak ditemukan.`);
-
-                // OPTIMIZATION: Hash Join for Equi-Joins (op === '=')
-                // O(M+N) instead of O(M*N)
-                let useHashJoin = false;
-                if (join.on.op === '=') useHashJoin = true;
-
-                const nextRows = [];
-
-                if (useHashJoin) {
-                    // Build Hash Map of Right Table
-                    // Key = val, Value = [rows]
-                    const joinMap = new Map();
-                    // We need to scan right table. 
-                    // Optimization: If criteria on right table exists, filter here? No complex logic yet.
-                    const joinRows = this._scanTable(joinEntry, null);
-
-                    for (const row of joinRows) {
-                        // Fix: Strip prefix if present in join.on.right
-                        let rightKey = join.on.right;
-                        if (rightKey.startsWith(join.table + '.')) {
-                            rightKey = rightKey.substring(join.table.length + 1);
-                        }
-                        const val = row[rightKey]; // e.g. 'lokasi_ref'
-                        if (val === undefined || val === null) continue;
-
-                        if (!joinMap.has(val)) joinMap.set(val, []);
-                        joinMap.get(val).push(row);
-                    }
-
-                    // Probe with Left Table (currentRows)
-                    for (const leftRow of currentRows) {
-                        const lVal = leftRow[join.on.left]; // e.g. 'user_id'
-                        if (joinMap.has(lVal)) {
-                            const matches = joinMap.get(lVal);
-                            for (const rightRow of matches) {
-                                const rightRowPrefixed = { ...rightRow }; // Clone needed?
-                                // Prefixing
-                                const prefixed = {};
-                                for (const k in rightRow) prefixed[`${join.table}.${k}`] = rightRow[k];
-                                nextRows.push({ ...leftRow, ...prefixed });
-                            }
-                        }
-                    }
-
-                } else {
-                    // Fallback to Nested Loop
-                    const joinRows = this._scanTable(joinEntry, null);
-                    for (const leftRow of currentRows) {
-                        for (const rightRow of joinRows) {
-                            const rightRowPrefixed = { ...rightRow };
-                            for (const k in rightRow) {
-                                rightRowPrefixed[`${join.table}.${k}`] = rightRow[k];
-                            }
-                            const lVal = leftRow[join.on.left];
-                            const rVal = rightRowPrefixed[join.on.right];
-                            let match = false;
-
-                            // Loose equality for cross-type (string vs number)
-                            if (join.on.op === '=') match = lVal == rVal;
-                            // Add other ops if needed
-
-                            if (match) {
-                                nextRows.push({ ...leftRow, ...rightRowPrefixed });
-                            }
-                        }
-                    }
-                }
-                currentRows = nextRows;
-            }
-            results = currentRows;
+    // Wrapper for index update/removal if needed by old code (though logic moved to indexManager)
+    _updateIndexes(t, n, o) { this.indexManager.updateIndexes(t, n, o); }
+    _removeFromIndexes(t, d) { this.indexManager.removeFromIndexes(t, d); }
+    _insert(t, d) { return this.insertExecutor.insertMany(t, [d]); }
+    _updateTableLastPage(t, p) { this.tableManager.updateTableLastPage(t, p); }
+    _delete(t, c, f) { return this.deleteExecutor.delete(t, c, f); }
 
-            if (criteria) {
-                results = results.filter(r => this._checkMatch(r, criteria));
-            }
-
-        } else {
-            // OPTIMIZATION: Use index for = queries
-            if (criteria && criteria.op === '=' && !sort) {
-                const indexKey = `${table}.${criteria.key}`;
-                if (this.indexes.has(indexKey)) {
-                    const index = this.indexes.get(indexKey);
-                    results = index.search(criteria.val);
-                } else {
-                    // If sorting, we cannot limit the scan early
-                    const scanLimit = sort ? null : limit;
-                    results = this._scanTable(entry, criteria, scanLimit);
-                }
-            } else {
-                // If sorting, we cannot limit the scan early
-                const scanLimit = sort ? null : limit;
-                results = this._scanTable(entry, criteria, scanLimit);
-            }
-        }
-
-        // Sorting
-        if (sort) {
-            results.sort((a, b) => {
-                const valA = a[sort.key];
-                const valB = b[sort.key];
-                if (valA < valB) return sort.dir === 'asc' ? -1 : 1;
-                if (valA > valB) return sort.dir === 'asc' ? 1 : -1;
-                return 0;
-            });
-        }
-
-        // Limit & Offset
-        let start = 0;
-        let end = results.length;
-
-        if (offsetCount) start = offsetCount;
-        if (limit) end = start + limit;
-        if (end > results.length) end = results.length;
-        if (start > results.length) start = results.length;
-
-        return results.slice(start, end);
-    }
-
-    // Modifiy _scanTable to allow returning extended info (pageId) for internal use
     // Modifiy _scanTable to allow returning extended info (pageId) for internal use
     _scanTable(entry, criteria, limit = null, returnRaw = false) {
         let currentPageId = entry.startPage;
@@ -624,7 +213,6 @@ class SawitDB {
         const criteriaVal = hasSimpleCriteria ? criteria.val : null;
 
         while (currentPageId !== 0 && results.length < effectiveLimit) {
-            // NEW: Use Object Cache
             // Returns { next: uint32, items: Array<Object> }
             const pageData = this.pager.readPageObjects(currentPageId);
 
@@ -635,6 +223,7 @@ class SawitDB {
                 let matches = true;
                 if (hasSimpleCriteria) {
                     const val = obj[criteriaKey];
+                    // Inline simple checks for speed
                     switch (criteriaOp) {
                         case '=': matches = (val == criteriaVal); break;
                         case '>': matches = (val > criteriaVal); break;
@@ -646,16 +235,16 @@ class SawitDB {
                             const pattern = criteriaVal.replace(/%/g, '.*').replace(/_/g, '.');
                             matches = new RegExp('^' + pattern + '$', 'i').test(val);
                             break;
-                        default: matches = this._checkMatch(obj, criteria);
+                        default:
+                            matches = this.conditionEvaluator.checkSingleCondition(obj, criteria);
                     }
                 } else if (criteria) {
-                    matches = this._checkMatch(obj, criteria);
+                    matches = this.conditionEvaluator.checkMatch(obj, criteria);
                 }
 
                 if (matches) {
                     if (returnRaw) {
                         // Inject Page Hint
-                        // Safe to modify cached object (it's non-enumerable)
                         Object.defineProperty(obj, '_pageId', {
                             value: currentPageId,
                             enumerable: false, // Hidden
@@ -673,356 +262,188 @@ class SawitDB {
         return results;
     }
 
-    _loadIndexes() {
-        // Re-implement load indexes to include Hints
-        const indexRecords = this._select('_indexes', null);
-        for (const rec of indexRecords) {
-            const table = rec.table;
-            const field = rec.field;
-            const indexKey = `${table}.${field}`;
-
-            if (!this.indexes.has(indexKey)) {
-                const index = new BTreeIndex();
-                index.name = indexKey;
-                index.keyField = field;
-
-                try {
-                    // Fetch all records with Hints
-                    const entry = this._findTableEntry(table);
-                    if (entry) {
-                        const allRecords = this._scanTable(entry, null, null, true); // true for Hints
-                        for (const record of allRecords) {
-                            if (record.hasOwnProperty(field)) {
-                                index.insert(record[field], record);
-                            }
-                        }
-                        this.indexes.set(indexKey, index);
-                    }
-                } catch (e) {
-                    console.error(`Failed to rebuild index ${indexKey}: ${e.message}`);
+    /**
+     * EXPLAIN - Analyze query execution plan
+     * Returns information about how the query would be executed
+     */
+    _explain(cmd) {
+        const plan = {
+            type: cmd.type,
+            table: cmd.table,
+            steps: []
+        };
+
+        switch (cmd.type) {
+            case 'SELECT': {
+                const entry = this.tableManager.findTableEntry(cmd.table);
+                if (!entry) {
+                    plan.error = `Table '${cmd.table}' not found`;
+                    return plan;
                 }
-            }
-        }
-    }
 
-    _delete(table, criteria) {
-        const entry = this._findTableEntry(table);
-        if (!entry) throw new Error(`Kebun '${table}' tidak ditemukan.`);
-
-        // OPTIMIZATION: Check Index Hint for simple equality delete
-        let hintPageId = -1;
-        if (criteria && criteria.op === '=' && criteria.key) {
-            const indexKey = `${table}.${criteria.key}`;
-            if (this.indexes.has(indexKey)) {
-                const index = this.indexes.get(indexKey);
-                const searchRes = index.search(criteria.val);
-                if (searchRes.length > 0 && searchRes[0]._pageId !== undefined) {
-                    // Use the hint! Scan ONLY this page
-                    hintPageId = searchRes[0]._pageId;
-                    // Note: If multiple results, we might need to check multiple pages.
-                    // For now simple single record optimization.
-                }
-            }
-        }
-
-        let currentPageId = (hintPageId !== -1) ? hintPageId : entry.startPage;
-        let deletedCount = 0;
-
-        // Loop: If hint used, only loop once (unless next page logic needed, but pageId is specific)
-        // We modify the while condition
-
-        while (currentPageId !== 0) {
-            let pData = this.pager.readPage(currentPageId);
-            const count = pData.readUInt16LE(4);
-            let offset = 8;
-            const recordsToKeep = [];
-            let pageModified = false;
-
-            for (let i = 0; i < count; i++) {
-                const len = pData.readUInt16LE(offset);
-                const jsonStr = pData.toString('utf8', offset + 2, offset + 2 + len);
-                let shouldDelete = false;
-                try {
-                    const obj = JSON.parse(jsonStr);
-                    if (this._checkMatch(obj, criteria)) shouldDelete = true;
-                } catch (e) { }
+                // Check if joins are used
+                if (cmd.joins && cmd.joins.length > 0) {
+                    plan.steps.push({
+                        operation: 'SCAN',
+                        table: cmd.table,
+                        method: 'Full Table Scan',
+                        reason: 'Base table for JOIN'
+                    });
 
-                if (shouldDelete) {
-                    deletedCount++;
-                    // Remove from Index if needed
-                    if (table !== '_indexes') {
-                        this._removeFromIndexes(table, JSON.parse(jsonStr));
+                    for (const join of cmd.joins) {
+                        const joinType = join.type || 'INNER';
+                        const useHashJoin = join.on && join.on.op === '=';
+                        plan.steps.push({
+                            operation: `${joinType} JOIN`,
+                            table: join.table,
+                            method: useHashJoin ? 'Hash Join' : 'Nested Loop Join',
+                            condition: join.on ? `${join.on.left} ${join.on.op} ${join.on.right}` : 'CROSS'
+                        });
+                    }
+                } else if (cmd.criteria) {
+                    // Check index usage
+                    const indexKey = `${cmd.table}.${cmd.criteria.key}`;
+                    const hasIndex = this.indexes.has(indexKey);
+
+                    if (hasIndex && cmd.criteria.op === '=') {
+                        plan.steps.push({
+                            operation: 'INDEX SCAN',
+                            table: cmd.table,
+                            index: indexKey,
+                            method: 'B-Tree Index Lookup',
+                            condition: `${cmd.criteria.key} ${cmd.criteria.op} ${JSON.stringify(cmd.criteria.val)}`
+                        });
+                    } else {
+                        plan.steps.push({
+                            operation: 'TABLE SCAN',
+                            table: cmd.table,
+                            method: hasIndex ? 'Full Scan (index not usable for this operator)' : 'Full Table Scan',
+                            condition: `${cmd.criteria.key} ${cmd.criteria.op} ${JSON.stringify(cmd.criteria.val)}`
+                        });
                     }
-                    pageModified = true;
                 } else {
-                    recordsToKeep.push({ len, data: pData.slice(offset + 2, offset + 2 + len) });
+                    plan.steps.push({
+                        operation: 'TABLE SCAN',
+                        table: cmd.table,
+                        method: 'Full Table Scan',
+                        reason: 'No WHERE clause'
+                    });
                 }
-                offset += 2 + len;
-            }
-
-            if (pageModified) {
-                let writeOffset = 8;
-                pData.writeUInt16LE(recordsToKeep.length, 4);
 
-                for (let rec of recordsToKeep) {
-                    pData.writeUInt16LE(rec.len, writeOffset);
-                    rec.data.copy(pData, writeOffset + 2);
-                    writeOffset += 2 + rec.len;
+                // DISTINCT step
+                if (cmd.distinct) {
+                    plan.steps.push({
+                        operation: 'DISTINCT',
+                        method: 'Hash-based deduplication'
+                    });
                 }
-                pData.writeUInt16LE(writeOffset, 6); // New free offset
-                pData.fill(0, writeOffset); // Zero out rest
-
-                this.pager.writePage(currentPageId, pData);
-            }
-
-            // Next page logic
-            if (hintPageId !== -1) {
-                break; // Optimized single page scan done
-            }
-            currentPageId = pData.readUInt32LE(0);
-        }
-
-        // If hint failed (record moved?), fallback to full scan? 
-        // For now assume hint is good. If record moved, it's effectively deleted from old page already (during move).
-        // If we missed it, it means inconsistency. But with this engine, move only happens on Update overflow.
 
-        if (hintPageId !== -1 && deletedCount === 0) {
-            // Hint failed (maybe race condition or stale index?), fallback to full scan
-            // This ensures safety.
-            return this._deleteFullScan(entry, criteria);
-        }
-
-        return `Berhasil menggusur ${deletedCount} bibit.`;
-    }
-
-    _deleteFullScan(entry, criteria) {
-        let currentPageId = entry.startPage;
-        let deletedCount = 0;
-        while (currentPageId !== 0) {
-            // ... (Duplicate logic or refactor? For brevity, I'll rely on the main loop above if I set hintPageId = -1)
-            // But since function is big, let's keep it simple.
-            // If fallback needed, recursive call:
-            return this._delete(entry.name, criteria); // But wait, entry.name not passed.
-            // Refactor _delete to take (table, criteria, forceFullScan=false)
-        }
-        return `Fallback deleted ${deletedCount}`;
-    }
-
-    _removeFromIndexes(table, data) {
-        for (const [indexKey, index] of this.indexes) {
-            const [tbl, field] = indexKey.split('.');
-            if (tbl === table && data.hasOwnProperty(field)) {
-                index.delete(data[field]); // Basic deletion from B-Tree
-            }
-        }
-    }
-
-    _update(table, updates, criteria) {
-        const entry = this._findTableEntry(table);
-        if (!entry) throw new Error(`Kebun '${table}' tidak ditemukan.`);
-
-        // OPTIMIZATION: Check Index Hint for simple equality update
-        let hintPageId = -1;
-        if (criteria && criteria.op === '=' && criteria.key) {
-            const indexKey = `${table}.${criteria.key}`;
-            if (this.indexes.has(indexKey)) {
-                const index = this.indexes.get(indexKey);
-                const searchRes = index.search(criteria.val);
-                if (searchRes.length > 0 && searchRes[0]._pageId !== undefined) {
-                    hintPageId = searchRes[0]._pageId;
+                // Sorting step
+                if (cmd.sort) {
+                    plan.steps.push({
+                        operation: 'SORT',
+                        field: cmd.sort.by,
+                        direction: cmd.sort.order || 'ASC'
+                    });
                 }
-            }
-        }
-
-        let currentPageId = (hintPageId !== -1) ? hintPageId : entry.startPage;
-        let updatedCount = 0;
-
-        // OPTIMIZATION: In-place update instead of DELETE+INSERT
-        while (currentPageId !== 0) {
-            let pData = this.pager.readPage(currentPageId);
-            const count = pData.readUInt16LE(4);
-            let offset = 8;
-            let modified = false;
-
-            for (let i = 0; i < count; i++) {
-                const len = pData.readUInt16LE(offset);
-                const jsonStr = pData.toString('utf8', offset + 2, offset + 2 + len);
-
-                try {
-                    const obj = JSON.parse(jsonStr);
-
-                    if (this._checkMatch(obj, criteria)) {
-                        // Apply updates
-
-                        for (const k in updates) {
-                            obj[k] = updates[k];
-                        }
-
-                        // Update index if needed
-                        // FIX: Inject _pageId hint so the index knows where this record lives
-                        Object.defineProperty(obj, '_pageId', {
-                            value: currentPageId,
-                            enumerable: false,
-                            writable: true
-                        });
-
-                        this._updateIndexes(table, JSON.parse(jsonStr), obj);
-
-                        // Serialize updated object
-                        const newJsonStr = JSON.stringify(obj);
-                        const newLen = Buffer.byteLength(newJsonStr, 'utf8');
-
-                        // Check if it fits in same space
-                        if (newLen <= len) {
-                            // In-place update
-                            pData.writeUInt16LE(newLen, offset);
-                            pData.write(newJsonStr, offset + 2, newLen, 'utf8');
-                            // Zero out remaining space
-                            if (newLen < len) {
-                                pData.fill(0, offset + 2 + newLen, offset + 2 + len);
-                            }
-                            modified = true;
-                            updatedCount++;
-                        } else {
-                            // Fallback: DELETE + INSERT (rare case)
-                            this._delete(table, criteria);
-                            this._insert(table, obj);
-                            updatedCount++;
-                            break; // Exit loop as page structure changed
-                        }
-                    }
-                } catch (err) { }
 
-                offset += 2 + len;
-            }
+                // Limit/Offset step
+                if (cmd.limit || cmd.offset) {
+                    plan.steps.push({
+                        operation: 'LIMIT/OFFSET',
+                        limit: cmd.limit || 'none',
+                        offset: cmd.offset || 0
+                    });
+                }
 
-            if (modified) {
-                this.pager.writePage(currentPageId, pData);
+                // Projection step
+                if (cmd.cols && !(cmd.cols.length === 1 && cmd.cols[0] === '*')) {
+                    plan.steps.push({
+                        operation: 'PROJECT',
+                        columns: cmd.cols
+                    });
+                }
+                break;
             }
 
-            if (hintPageId !== -1) break; // Scan only one page
-
-            currentPageId = pData.readUInt32LE(0);
-        }
-
-        if (hintPageId !== -1 && updatedCount === 0) {
-            // Hint failed, fallback (not implemented fully for update, assume safe)
-            // But to be safe, restart scan? For now let's hope hint works.
-            // TODO: Fallback to full scan logic if mission critical.
-        }
-
-        return `Berhasil memupuk ${updatedCount} bibit.`;
-    }
-
-    _createIndex(table, field) {
-        const entry = this._findTableEntry(table);
-        if (!entry) throw new Error(`Kebun '${table}' tidak ditemukan.`);
+            case 'DELETE':
+            case 'UPDATE': {
+                const entry = this.tableManager.findTableEntry(cmd.table);
+                if (!entry) {
+                    plan.error = `Table '${cmd.table}' not found`;
+                    return plan;
+                }
 
-        const indexKey = `${table}.${field}`;
-        if (this.indexes.has(indexKey)) {
-            return `Indeks pada '${table}.${field}' sudah ada.`;
-        }
+                if (cmd.criteria) {
+                    const indexKey = `${cmd.table}.${cmd.criteria.key}`;
+                    const hasIndex = this.indexes.has(indexKey);
 
-        // Create index
-        const index = new BTreeIndex();
-        index.name = indexKey;
-        index.keyField = field;
+                    plan.steps.push({
+                        operation: 'SCAN',
+                        table: cmd.table,
+                        method: hasIndex && cmd.criteria.op === '=' ? 'Index-assisted scan' : 'Full Table Scan',
+                        condition: `${cmd.criteria.key} ${cmd.criteria.op} ${JSON.stringify(cmd.criteria.val)}`
+                    });
+                } else {
+                    plan.steps.push({
+                        operation: 'SCAN',
+                        table: cmd.table,
+                        method: 'Full Table Scan',
+                        reason: 'No WHERE clause - affects all rows'
+                    });
+                }
 
-        // Build index from existing data
-        const allRecords = this._select(table, null);
-        for (const record of allRecords) {
-            if (record.hasOwnProperty(field)) {
-                index.insert(record[field], record);
+                plan.steps.push({
+                    operation: cmd.type,
+                    table: cmd.table,
+                    method: 'In-place modification'
+                });
+                break;
             }
-        }
 
-        this.indexes.set(indexKey, index);
-
-        // PERSISTENCE: Save to _indexes table
-        try {
-            this._insert('_indexes', { table, field });
-        } catch (e) {
-            console.error("Failed to persist index definition", e);
-        }
+            case 'AGGREGATE': {
+                plan.steps.push({
+                    operation: 'SCAN',
+                    table: cmd.table,
+                    method: cmd.criteria ? 'Filtered Scan' : 'Full Table Scan'
+                });
+
+                if (cmd.groupBy) {
+                    plan.steps.push({
+                        operation: 'GROUP',
+                        field: cmd.groupBy,
+                        method: 'Hash-based grouping'
+                    });
+                }
 
-        return `Indeks dibuat pada '${table}.${field}' (${allRecords.length} records indexed)`;
-    }
+                plan.steps.push({
+                    operation: 'AGGREGATE',
+                    function: cmd.func,
+                    field: cmd.field || '*'
+                });
 
-    _showIndexes(table) {
-        if (table) {
-            const indexes = [];
-            for (const [key, index] of this.indexes) {
-                if (key.startsWith(table + '.')) {
-                    indexes.push(index.stats());
+                if (cmd.having) {
+                    plan.steps.push({
+                        operation: 'HAVING',
+                        condition: `${cmd.having.field} ${cmd.having.op} ${cmd.having.val}`
+                    });
                 }
+                break;
             }
-            return indexes.length > 0 ? indexes : `Tidak ada indeks pada '${table}'`;
-        } else {
-            const allIndexes = [];
-            for (const index of this.indexes.values()) {
-                allIndexes.push(index.stats());
-            }
-            return allIndexes;
-        }
-    }
-
-    _aggregate(table, func, field, criteria, groupBy) {
-        const records = this._select(table, criteria);
-
-        if (groupBy) {
-            return this._groupedAggregate(records, func, field, groupBy);
         }
 
-        switch (func.toUpperCase()) {
-            case 'COUNT':
-                return { count: records.length };
-
-            case 'SUM':
-                if (!field) throw new Error("SUM requires a field");
-                const sum = records.reduce((acc, r) => acc + (Number(r[field]) || 0), 0);
-                return { sum, field };
-
-            case 'AVG':
-                if (!field) throw new Error("AVG requires a field");
-                const avg = records.reduce((acc, r) => acc + (Number(r[field]) || 0), 0) / records.length;
-                return { avg, field, count: records.length };
-
-            case 'MIN':
-                if (!field) throw new Error("MIN requires a field");
-                const min = Math.min(...records.map(r => Number(r[field]) || Infinity));
-                return { min, field };
-
-            case 'MAX':
-                if (!field) throw new Error("MAX requires a field");
-                const max = Math.max(...records.map(r => Number(r[field]) || -Infinity));
-                return { max, field };
-
-            default:
-                throw new Error(`Unknown aggregate function: ${func}`);
+        // Add available indexes info
+        const tableIndexes = [];
+        for (const [key] of this.indexes) {
+            if (key.startsWith(cmd.table + '.')) {
+                tableIndexes.push(key);
+            }
         }
-    }
-
-    _groupedAggregate(records, func, field, groupBy) {
-        const groups = {};
-        for (const record of records) {
-            const key = record[groupBy];
-            if (!groups[key]) groups[key] = [];
-            groups[key].push(record);
+        if (tableIndexes.length > 0) {
+            plan.availableIndexes = tableIndexes;
         }
 
-        const results = [];
-        for (const [key, groupRecords] of Object.entries(groups)) {
-            const result = { [groupBy]: key };
-            switch (func.toUpperCase()) {
-                case 'COUNT': result.count = groupRecords.length; break;
-                case 'SUM': result.sum = groupRecords.reduce((acc, r) => acc + (Number(r[field]) || 0), 0); break;
-                case 'AVG': result.avg = groupRecords.reduce((acc, r) => acc + (Number(r[field]) || 0), 0) / groupRecords.length; break;
-                case 'MIN': result.min = Math.min(...groupRecords.map(r => Number(r[field]) || Infinity)); break;
-                case 'MAX': result.max = Math.max(...groupRecords.map(r => Number(r[field]) || -Infinity)); break;
-            }
-            results.push(result);
-        }
-        return results;
+        return plan;
     }
 }