jsql-neo 1.3.0 → 2.0.0

package/lib/date-types.js

@@ -0,0 +1,183 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * JSQL Date Types — DATE / DATETIME / TIMESTAMP 类型处理
+ */
+
+const { createError } = require('./errors');
+
+/**
+ * 验证并规范化日期类型值
+ * @param {*} value - 输入值
+ * @param {string} type - 'date' | 'datetime' | 'timestamp'
+ * @param {string} fieldName - 字段名（用于错误提示）
+ * @returns {*} 规范化后的值
+ */
+function validateDateType(value, type, fieldName) {
+    if (value === null || value === undefined) return value;
+
+    switch (type) {
+        case 'date':
+            return validateDate(value, fieldName);
+        case 'datetime':
+            return validateDateTime(value, fieldName);
+        case 'timestamp':
+            return validateTimestamp(value, fieldName);
+        case 'time':
+            return validateTime(value, fieldName);
+        default:
+            return value;
+    }
+}
+
+// ============================================================
+// DATE: YYYY-MM-DD
+// ============================================================
+
+function validateDate(value, fieldName) {
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    if (typeof value === 'number') {
+        // Unix timestamp → date
+        return new Date(value * 1000).toISOString().slice(0, 10);
+    }
+    if (typeof value === 'string') {
+        const d = parseDateString(value);
+        if (d) return d.toISOString().slice(0, 10);
+    }
+    throw createError('ER_INVALID_DATE', fieldName, String(value));
+}
+
+function parseDateString(str) {
+    // YYYY-MM-DD
+    let m = str.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (m) {
+        const d = new Date(parseInt(m[1]), parseInt(m[2]) - 1, parseInt(m[3]));
+        if (d.getFullYear() === parseInt(m[1])) return d;
+    }
+    // YYYY/MM/DD
+    m = str.match(/^(\d{4})\/(\d{2})\/(\d{2})$/);
+    if (m) {
+        const d = new Date(parseInt(m[1]), parseInt(m[2]) - 1, parseInt(m[3]));
+        if (d.getFullYear() === parseInt(m[1])) return d;
+    }
+    // MM/DD/YYYY
+    m = str.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (m) {
+        const d = new Date(parseInt(m[3]), parseInt(m[1]) - 1, parseInt(m[2]));
+        if (d.getFullYear() === parseInt(m[3])) return d;
+    }
+    // Try native parse
+    const d = new Date(str);
+    if (!isNaN(d.getTime())) return d;
+    return null;
+}
+
+// ============================================================
+// DATETIME: YYYY-MM-DD HH:MM:SS
+// ============================================================
+
+function validateDateTime(value, fieldName) {
+    if (value instanceof Date) {
+        return value.toISOString().replace('T', ' ').slice(0, 19);
+    }
+    if (typeof value === 'number') {
+        return new Date(value * 1000).toISOString().replace('T', ' ').slice(0, 19);
+    }
+    if (typeof value === 'string') {
+        // ISO format: 2024-01-15T10:30:00.000Z
+        const isoMatch = value.match(/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})/);
+        if (isoMatch) {
+            return isoMatch[1] + ' ' + isoMatch[2];
+        }
+        // MySQL format: YYYY-MM-DD HH:MM:SS
+        const myMatch = value.match(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})$/);
+        if (myMatch) {
+            const d = new Date(value.replace(' ', 'T') + 'Z');
+            if (!isNaN(d.getTime())) return value;
+        }
+        const d = new Date(value);
+        if (!isNaN(d.getTime())) {
+            return d.toISOString().replace('T', ' ').slice(0, 19);
+        }
+    }
+    throw createError('ER_INVALID_DATE', fieldName, String(value));
+}
+
+// ============================================================
+// TIMESTAMP: Unix 时间戳（秒）
+// ============================================================
+
+function validateTimestamp(value, fieldName) {
+    if (value instanceof Date) {
+        return Math.floor(value.getTime() / 1000);
+    }
+    if (typeof value === 'number') {
+        // 自动检测毫秒时间戳
+        if (value > 1e12) return Math.floor(value / 1000);
+        return value;
+    }
+    if (typeof value === 'string') {
+        const d = new Date(value);
+        if (!isNaN(d.getTime())) {
+            return Math.floor(d.getTime() / 1000);
+        }
+        const n = parseInt(value, 10);
+        if (!isNaN(n)) {
+            if (n > 1e12) return Math.floor(n / 1000);
+            return n;
+        }
+    }
+    throw createError('ER_INVALID_DATE', fieldName, String(value));
+}
+
+// ============================================================
+// TIME: HH:MM:SS
+// ============================================================
+
+function validateTime(value, fieldName) {
+    if (typeof value === 'string') {
+        const m = value.match(/^(\d{2}):(\d{2}):(\d{2})$/);
+        if (m) {
+            const h = parseInt(m[1]), min = parseInt(m[2]), sec = parseInt(m[3]);
+            if (h >= 0 && h < 24 && min >= 0 && min < 60 && sec >= 0 && sec < 60) {
+                return value;
+            }
+        }
+        // 负时间: -HH:MM:SS
+        const neg = value.match(/^-(\d{2}):(\d{2}):(\d{2})$/);
+        if (neg) return value;
+    }
+    throw createError('ER_INVALID_DATE', fieldName, String(value));
+}
+
+// ============================================================
+// 类型转换辅助
+// ============================================================
+
+function now(type = 'datetime') {
+    const d = new Date();
+    switch (type) {
+        case 'date': return d.toISOString().slice(0, 10);
+        case 'timestamp': return Math.floor(d.getTime() / 1000);
+        case 'time': return d.toISOString().slice(11, 19);
+        default: return d.toISOString().replace('T', ' ').slice(0, 19);
+    }
+}
+
+function formatDate(value, format = 'YYYY-MM-DD') {
+    if (!value) return value;
+    const d = value instanceof Date ? value : new Date(value);
+    if (isNaN(d.getTime())) return String(value);
+
+    const pad = n => String(n).padStart(2, '0');
+    return format
+        .replace('YYYY', d.getFullYear())
+        .replace('MM', pad(d.getMonth() + 1))
+        .replace('DD', pad(d.getDate()))
+        .replace('HH', pad(d.getHours()))
+        .replace('mm', pad(d.getMinutes()))
+        .replace('ss', pad(d.getSeconds()));
+}
+
+module.exports = { validateDateType, now, formatDate };

package/lib/errors.js

@@ -0,0 +1,84 @@
+// © Vexify 2026 All Rights Reserved.
+/**
+ * JSQL Error Codes — MySQL 风格错误码体系
+ */
+
+class JSQL_Error extends Error {
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'JSQL_Error';
+        this.code = code;
+        this.details = details;
+        this.timestamp = new Date().toISOString();
+    }
+
+    toJSON() {
+        return {
+            error: true,
+            code: this.code,
+            message: this.message,
+            details: this.details,
+            timestamp: this.timestamp
+        };
+    }
+}
+
+// MySQL 兼容错误码
+const ErrorCodes = {
+    // 表/库操作
+    ER_TABLE_EXISTS:          { code: 1050,  msg: "Table '%s' already exists" },
+    ER_NO_SUCH_TABLE:         { code: 1146,  msg: "Table '%s' doesn't exist" },
+    ER_DB_CREATE_EXISTS:      { code: 1007,  msg: "Can't create database '%s'; database exists" },
+
+    // 列操作
+    ER_DUP_FIELDNAME:         { code: 1060,  msg: "Duplicate column name '%s'" },
+    ER_BAD_FIELD_ERROR:       { code: 1054,  msg: "Unknown column '%s' in '%s'" },
+    ER_CANT_DROP_FIELD:       { code: 1091,  msg: "Can't DROP '%s'; check that column exists" },
+
+    // 约束
+    ER_DUP_ENTRY:             { code: 1062,  msg: "Duplicate entry '%s' for key '%s'" },
+    ER_NO_DEFAULT_FOR_FIELD:  { code: 1364,  msg: "Field '%s' doesn't have a default value" },
+    ER_BAD_NULL_ERROR:        { code: 1048,  msg: "Column '%s' cannot be null" },
+    ER_CHECK_CONSTRAINT:      { code: 3819,  msg: "Check constraint '%s' is violated" },
+    ER_NO_REFERENCED_ROW:     { code: 1216,  msg: "Cannot add or update: foreign key constraint fails" },
+    ER_ROW_IS_REFERENCED:     { code: 1217,  msg: "Cannot delete or update: a foreign key constraint fails" },
+
+    // 数据类型
+    ER_TRUNCATED_WRONG_VALUE: { code: 1292,  msg: "Truncated incorrect %s value: '%s'" },
+    ER_INVALID_DATE:          { code: 1292,  msg: "Incorrect date value: '%s'" },
+    ER_DATA_TOO_LONG:         { code: 1406,  msg: "Data too long for column '%s'" },
+    ER_OUT_OF_RANGE:          { code: 1264,  msg: "Out of range value for column '%s'" },
+
+    // 事务
+    ER_TRANSACTION_ACTIVE:    { code: 1568,  msg: "Transaction already in progress" },
+    ER_NO_TRANSACTION:        { code: 1569,  msg: "No transaction in progress" },
+
+    // 其他
+    ER_NOT_SUPPORTED:         { code: 1235,  msg: "This version doesn't yet support '%s'" },
+    ER_PARSE_ERROR:           { code: 1064,  msg: "You have an error in your syntax: %s" },
+    ER_LOCK_WAIT_TIMEOUT:     { code: 1205,  msg: "Lock wait timeout exceeded; try restarting transaction" },
+    ER_FILE_NOT_FOUND:        { code: 1017,  msg: "Can't find file: '%s'" },
+    ER_VIEW_EXISTS:           { code: 1050,  msg: "View '%s' already exists" },
+    ER_TRIGGER_EXISTS:        { code: 1359,  msg: "Trigger '%s' already exists" },
+    ER_TRIGGER_NOT_FOUND:     { code: 1360,  msg: "Trigger '%s' does not exist" },
+    ER_PLUGIN_ERR:            { code: 1125,  msg: "Plugin error: %s" },
+};
+
+/**
+ * 创建错误
+ */
+function createError(codeKey, ...args) {
+    const template = ErrorCodes[codeKey];
+    if (!template) {
+        return new JSQL_Error('UNKNOWN', `Unknown error: ${codeKey}`, { codeKey, args });
+    }
+
+    let msg = template.msg;
+    for (let i = 0; i < args.length; i++) {
+        msg = msg.replace('%s', String(args[i]));
+    }
+
+    return new JSQL_Error(template.code, msg, { args });
+}
+
+module.exports = { JSQL_Error, ErrorCodes, createError };

package/lib/query.js

@@ -1,9 +1,11 @@
 // © Vexify 2026 All Rights Reserved.
 /**
- * JSQL Query — 链式查询构建器
- * 支持 JOIN、DISTINCT、HAVING、UNION、窗口函数、缓存、CASE WHEN、toSQL
+ * JSQL Query — 链式查询构建器 v2.0
+ * 哈希 JOIN 优化、B-Tree 加速、字符串表名、查询优化器
  */
 
+const { createError } = require('./errors');
+
 class Query {
     constructor(table, conditions = {}) {
         this._table = table;
@@ -22,6 +24,7 @@ class Query {
         this._window = null;
         this._cache = null;        // { ttl, result, timestamp }
         this._caseExpr = null;     // [{ when, then }, ...] + else
+        this._optimizerHints = {}; // { useHashJoin: true }
     }
 
     // ============================================================
@@ -139,9 +142,36 @@ class Query {
     }
 
     // ============================================================
-    // JOIN
+    // 查询优化器提示
+    // ============================================================
+
+    /**
+     * 强制使用哈希 JOIN
+     */
+    useHashJoin() {
+        this._optimizerHints.useHashJoin = true;
+        return this;
+    }
+
+    /**
+     * 强制使用嵌套循环 JOIN
+     */
+    useNestedLoop() {
+        this._optimizerHints.useHashJoin = false;
+        return this;
+    }
+
+    // ============================================================
+    // JOIN（支持字符串表名 + 哈希 JOIN 优化）
     // ============================================================
 
+    /**
+     * INNER JOIN
+     * @param {string|Table} otherTable - 表名或 Table 对象
+     * @param {string} localField - 本地字段
+     * @param {string} foreignField - 外键字段
+     * @param {string} as - 别名前缀
+     */
     join(otherTable, localField, foreignField, as) {
         this._joins.push({ type: 'inner', table: otherTable, localField, foreignField, as });
         return this;
@@ -200,11 +230,11 @@ class Query {
             return this._cache.result;
         }
 
-        let rows = this._table._applyFilter(this._table._rows, this._conditions);
+        let rows = this._table._applyFilterOptimized(this._table._rows, this._conditions);
 
         // JOIN
         for (const join of this._joins) {
-            rows = this._applyJoin(rows, join);
+            rows = this._applyJoinOptimized(rows, join);
         }
 
         // UNION
@@ -331,8 +361,8 @@ class Query {
     }
 
     groupStats(field) {
-        if (!this._groupBy) throw new Error('groupStats() requires groupBy()');
-        const rows = this._table._applyFilter(this._table._rows, this._conditions);
+        if (!this._groupBy) throw createError('ER_PARSE_ERROR', 'groupStats() requires groupBy()');
+        const rows = this._table._applyFilterOptimized(this._table._rows, this._conditions);
         const groups = {};
 
         for (const row of rows) {
@@ -396,6 +426,12 @@ class Query {
             parts.push('WHERE', JSON.stringify(this._conditions));
         }
 
+        for (const join of this._joins) {
+            const tableName = typeof join.table === 'string' ? join.table : join.table._name;
+            parts.push(join.type.toUpperCase() + ' JOIN', tableName,
+                'ON', `${this._table._name}.${join.localField} = ${tableName}.${join.foreignField}`);
+        }
+
         if (this._groupBy) {
             parts.push('GROUP BY', this._groupBy);
             if (this._having) parts.push('HAVING', JSON.stringify(this._having));
@@ -421,13 +457,172 @@ class Query {
     // ============================================================
 
     _getFilteredRows() {
-        return this._table._applyFilter(this._table._rows, this._conditions);
+        return this._table._applyFilterOptimized(this._table._rows, this._conditions);
     }
 
     _countRaw() {
-        return this._table._applyFilter(this._table._rows, this._conditions).length;
+        return this._table._applyFilterOptimized(this._table._rows, this._conditions).length;
+    }
+
+    // ============================================================
+    // 内部: JOIN 优化
+    // ============================================================
+
+    /**
+     * 解析 JOIN 表引用（支持字符串表名和 Table 对象）
+     */
+    _resolveJoinTable(tableRef) {
+        if (typeof tableRef === 'string') {
+            const resolved = this._table._db._tables[tableRef];
+            if (!resolved) {
+                throw createError('ER_NO_SUCH_TABLE', tableRef);
+            }
+            return resolved;
+        }
+        return tableRef;
+    }
+
+    /**
+     * 优化的 JOIN 执行
+     * 自动选择哈希 JOIN 或嵌套循环
+     */
+    _applyJoinOptimized(localRows, join) {
+        const foreignTable = this._resolveJoinTable(join.table);
+
+        // 如果强制或自动选择哈希 JOIN
+        const useHash = this._optimizerHints.useHashJoin !== false
+            && (this._optimizerHints.useHashJoin === true
+                || localRows.length > 100
+                || foreignTable._rows.length > 100);
+
+        if (useHash) {
+            return this._applyHashJoin(localRows, foreignTable, join);
+        }
+        return this._applyNestedLoopJoin(localRows, foreignTable, join);
+    }
+
+    /**
+     * 哈希 JOIN — O(n + m) 时间复杂度
+     * 构建外键表的哈希映射，然后一次遍历本地行完成 JOIN
+     */
+    _applyHashJoin(localRows, foreignTable, join) {
+        // 构建哈希表：foreignField -> [foreignRows]
+        const hashMap = new Map();
+        for (const fr of foreignTable._rows) {
+            const key = fr[join.foreignField];
+            if (key === undefined || key === null) continue;
+            if (!hashMap.has(key)) {
+                hashMap.set(key, []);
+            }
+            hashMap.get(key).push(fr);
+        }
+
+        const result = [];
+
+        if (join.type === 'left') {
+            for (const lr of localRows) {
+                const matches = hashMap.get(lr[join.localField]) || [];
+                if (matches.length === 0) {
+                    result.push({ ...lr, ...this._nullRow(foreignTable) });
+                } else {
+                    for (const fr of matches) {
+                        result.push(this._mergeJoinRow(lr, fr, join));
+                    }
+                }
+            }
+        } else if (join.type === 'right') {
+            for (const fr of foreignTable._rows) {
+                const key = fr[join.foreignField];
+                const matches = localRows.filter(lr => lr[join.localField] === key);
+                if (matches.length === 0) {
+                    result.push({ ...fr, ...this._nullRow(join, true) });
+                } else {
+                    for (const lr of matches) {
+                        result.push(this._mergeJoinRow(lr, fr, join));
+                    }
+                }
+            }
+        } else {
+            // INNER JOIN
+            for (const lr of localRows) {
+                const matches = hashMap.get(lr[join.localField]);
+                if (matches) {
+                    for (const fr of matches) {
+                        result.push(this._mergeJoinRow(lr, fr, join));
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 嵌套循环 JOIN — O(n * m) 时间复杂度
+     * 用于小数据量场景
+     */
+    _applyNestedLoopJoin(localRows, foreignTable, join) {
+        const result = [];
+        const foreignRows = foreignTable._rows;
+
+        if (join.type === 'left') {
+            for (const lr of localRows) {
+                const matches = foreignRows.filter(fr => fr[join.foreignField] === lr[join.localField]);
+                if (matches.length === 0) {
+                    result.push({ ...lr, ...this._nullRow(foreignTable) });
+                } else {
+                    for (const fr of matches) {
+                        result.push(this._mergeJoinRow(lr, fr, join));
+                    }
+                }
+            }
+        } else if (join.type === 'right') {
+            for (const fr of foreignRows) {
+                const matches = localRows.filter(lr => lr[join.localField] === fr[join.foreignField]);
+                if (matches.length === 0) {
+                    result.push({ ...fr, ...this._nullRow(join, true) });
+                } else {
+                    for (const lr of matches) {
+                        result.push(this._mergeJoinRow(lr, fr, join));
+                    }
+                }
+            }
+        } else {
+            // INNER JOIN
+            for (const lr of localRows) {
+                for (const fr of foreignRows) {
+                    if (fr[join.foreignField] === lr[join.localField]) {
+                        result.push(this._mergeJoinRow(lr, fr, join));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    _mergeJoinRow(lr, fr, join) {
+        const merged = { ...lr };
+        const prefix = join.as ? join.as + '_' : '';
+        for (const [key, value] of Object.entries(fr)) {
+            merged[prefix + key] = value;
+        }
+        return merged;
     }
 
+    _nullRow(tableRef) {
+        // tableRef 可能是 join 对象（用于 right join 的本地表）或 Table 对象
+        const schema = tableRef._schema || tableRef.table?._schema || {};
+        const nulls = {};
+        for (const field of Object.keys(schema)) {
+            if (field !== '_softDelete') nulls[field] = null;
+        }
+        return nulls;
+    }
+
+    // ============================================================
+    // 内部: 排序
+    // ============================================================
+
     _applyOrderBy(rows) {
         return [...rows].sort((a, b) => {
             for (const { field, dir } of this._orderBy) {
@@ -440,11 +635,14 @@ class Query {
         });
     }
 
+    // ============================================================
+    // 内部: 窗口函数
+    // ============================================================
+
     _applyWindow(rows) {
         const { fn, field, partitionBy, dir } = this._window;
 
         if (partitionBy) {
-            // 分组
             const groups = {};
             for (const row of rows) {
                 const key = String(row[partitionBy] ?? '__null__');
@@ -465,7 +663,6 @@ class Query {
     }
 
     _applyWindowToGroup(rows, fn, field, dir) {
-        // 按字段排序
         if (field) {
             rows.sort((a, b) => {
                 const va = a[field];
@@ -502,60 +699,9 @@ class Query {
         }
     }
 
-    _applyJoin(localRows, join) {
-        const result = [];
-        const foreignRows = join.table._rows;
-
-        if (join.type === 'left') {
-            for (const lr of localRows) {
-                const matches = foreignRows.filter(fr => fr[join.foreignField] === lr[join.localField]);
-                if (matches.length === 0) {
-                    result.push({ ...lr, ...this._nullRow(join.table) });
-                } else {
-                    for (const fr of matches) {
-                        result.push(this._mergeJoinRow(lr, fr, join));
-                    }
-                }
-            }
-        } else if (join.type === 'right') {
-            for (const fr of foreignRows) {
-                const matches = localRows.filter(lr => lr[join.localField] === fr[join.foreignField]);
-                if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join.table, true) });
-                } else {
-                    for (const lr of matches) {
-                        result.push(this._mergeJoinRow(lr, fr, join));
-                    }
-                }
-            }
-        } else {
-            for (const lr of localRows) {
-                for (const fr of foreignRows) {
-                    if (fr[join.foreignField] === lr[join.localField]) {
-                        result.push(this._mergeJoinRow(lr, fr, join));
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
-    _mergeJoinRow(lr, fr, join) {
-        const merged = { ...lr };
-        const prefix = join.as ? join.as + '_' : '';
-        for (const [key, value] of Object.entries(fr)) {
-            merged[prefix + key] = value;
-        }
-        return merged;
-    }
-
-    _nullRow(table) {
-        const nulls = {};
-        for (const field of Object.keys(table._schema)) {
-            nulls[field] = null;
-        }
-        return nulls;
-    }
+    // ============================================================
+    // 内部: GROUP BY
+    // ============================================================
 
     _applyGroupBy(rows) {
         const groups = {};
@@ -578,36 +724,71 @@ class Query {
         return result;
     }
 
+    // ============================================================
+    // 内部: EXPLAIN（增强版）
+    // ============================================================
+
     _getExplain() {
         const totalRows = this._table._rows.length;
-        const filtered = this._table._applyFilter(this._table._rows, this._conditions);
+        const filtered = this._table._applyFilterOptimized(this._table._rows, this._conditions);
         const plan = {
             table: this._table._name,
             totalRows,
             conditions: this._conditions,
             filteredRows: filtered.length,
             selectivity: totalRows > 0 ? (filtered.length / totalRows * 100).toFixed(1) + '%' : '0%',
-            hasIndex: false,
+            hasBTree: false,
+            hasHashIndex: false,
             indexUsed: null,
-            joins: this._joins.length,
+            btreeIndexes: Object.keys(this._table._btrees),
+            hashIndexes: Object.keys(this._table._indexes),
+            joins: [],
             groupBy: this._groupBy,
             having: this._having,
             window: this._window ? this._window.fn : null,
             orderBy: this._orderBy.map(o => `${o.field} ${o.dir}`),
             limit: this._limitCount,
             offset: this._offsetCount,
-            estimatedCost: filtered.length * (1 + this._joins.length)
+            estimatedCost: filtered.length * (1 + this._joins.length),
+            optimizerHints: this._optimizerHints
         };
 
+        // 检查 B-Tree 使用
         for (const [field] of Object.entries(this._conditions)) {
+            if (this._table._btrees[field]) {
+                plan.hasBTree = true;
+                plan.indexUsed = field;
+                plan.estimatedCost = Math.floor(plan.estimatedCost * 0.05);
+                break;
+            }
             if (this._table._indexes[field]) {
-                plan.hasIndex = true;
+                plan.hasHashIndex = true;
                 plan.indexUsed = field;
                 plan.estimatedCost = Math.floor(plan.estimatedCost * 0.1);
                 break;
             }
         }
 
+        // JOIN 分析
+        for (const join of this._joins) {
+            const foreignTable = this._resolveJoinTable(join.table);
+            const joinInfo = {
+                type: join.type,
+                table: foreignTable._name,
+                localField: join.localField,
+                foreignField: join.foreignField,
+                foreignRows: foreignTable._rows.length,
+                strategy: (this._optimizerHints.useHashJoin !== false
+                    && (filtered.length > 100 || foreignTable._rows.length > 100))
+                    ? 'hash' : 'nested_loop'
+            };
+            // 检查外键表是否有索引
+            if (foreignTable._btrees[join.foreignField]) {
+                joinInfo.hasBTree = true;
+            }
+            plan.joins.push(joinInfo);
+        }
+
         return plan;
     }
 }