befly 3.8.19 → 3.8.20

package/sync/syncDb/schema.ts

@@ -0,0 +1,201 @@
+/**
+ * syncDb 表结构查询模块
+ *
+ * 包含：
+ * - 判断表是否存在
+ * - 获取表的列信息
+ * - 获取表的索引信息
+ */
+
+import { IS_MYSQL, IS_PG, IS_SQLITE } from './constants.js';
+import type { ColumnInfo, IndexInfo } from '../../types.js';
+import type { SQL } from 'bun';
+
+/**
+ * 判断表是否存在（返回布尔值）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param dbName - 数据库名称
+ * @returns 表是否存在
+ */
+export async function tableExists(sql: SQL, tableName: string, dbName?: string): Promise<boolean> {
+    if (!sql) throw new Error('SQL 客户端未初始化');
+    const database = dbName || process.env.DB_NAME;
+
+    try {
+        if (IS_MYSQL) {
+            const res = await sql`SELECT COUNT(*) AS count FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${database} AND TABLE_NAME = ${tableName}`;
+            return (res[0]?.count || 0) > 0;
+        }
+
+        if (IS_PG) {
+            const res = await sql`SELECT COUNT(*)::int AS count FROM information_schema.tables WHERE table_schema = 'public' AND table_name = ${tableName}`;
+            return (res[0]?.count || 0) > 0;
+        }
+
+        if (IS_SQLITE) {
+            const res = await sql`SELECT name FROM sqlite_master WHERE type='table' AND name = ${tableName}`;
+            return res.length > 0;
+        }
+
+        return false;
+    } catch (error: any) {
+        throw new Error(`查询表是否存在失败 [${tableName}]: ${error.message}`);
+    }
+}
+
+/**
+ * 获取表的现有列信息（按方言）
+ *
+ * 查询数据库元数据，获取表的所有列信息，包括：
+ * - 列名
+ * - 数据类型
+ * - 字符最大长度
+ * - 是否可为空
+ * - 默认值
+ * - 列注释（MySQL/PG）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param dbName - 数据库名称
+ * @returns 列信息对象，键为列名，值为列详情
+ */
+export async function getTableColumns(sql: SQL, tableName: string, dbName?: string): Promise<{ [key: string]: ColumnInfo }> {
+    const columns: { [key: string]: ColumnInfo } = {};
+    const database = dbName || process.env.DB_NAME;
+
+    try {
+        if (IS_MYSQL) {
+            const result = await sql`
+                SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_COMMENT, COLUMN_TYPE
+                FROM information_schema.COLUMNS
+                WHERE TABLE_SCHEMA = ${database} AND TABLE_NAME = ${tableName}
+                ORDER BY ORDINAL_POSITION
+            `;
+            for (const row of result) {
+                // MySQL 的 COLUMN_DEFAULT 已经是解析后的实际值，无需处理：
+                // - 空字符串 DEFAULT '': 返回 '' (空字符串)
+                // - 字符串 DEFAULT 'admin': 返回 admin (无引号)
+                // - 单引号 DEFAULT '''': 返回 ' (单引号字符)
+                // - 数字 DEFAULT 0: 返回 0
+                // - NULL: 返回 null
+                const defaultValue = row.COLUMN_DEFAULT;
+
+                columns[row.COLUMN_NAME] = {
+                    type: row.DATA_TYPE,
+                    columnType: row.COLUMN_TYPE,
+                    max: row.CHARACTER_MAXIMUM_LENGTH,
+                    nullable: row.IS_NULLABLE === 'YES',
+                    defaultValue: defaultValue,
+                    comment: row.COLUMN_COMMENT
+                };
+            }
+        } else if (IS_PG) {
+            const result = await sql`
+                SELECT column_name, data_type, character_maximum_length, is_nullable, column_default
+                FROM information_schema.columns
+                WHERE table_schema = 'public' AND table_name = ${tableName}
+                ORDER BY ordinal_position
+            `;
+            // 获取列注释
+            const comments = await sql`
+                SELECT a.attname AS column_name, col_description(c.oid, a.attnum) AS column_comment
+                FROM pg_class c
+                JOIN pg_attribute a ON a.attrelid = c.oid
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE c.relkind = 'r' AND n.nspname = 'public' AND c.relname = ${tableName} AND a.attnum > 0
+            `;
+            const commentMap: { [key: string]: string } = {};
+            for (const r of comments) commentMap[r.column_name] = r.column_comment;
+
+            for (const row of result) {
+                columns[row.column_name] = {
+                    type: row.data_type,
+                    columnType: row.data_type,
+                    max: row.character_maximum_length,
+                    nullable: String(row.is_nullable).toUpperCase() === 'YES',
+                    defaultValue: row.column_default,
+                    comment: commentMap[row.column_name] ?? null
+                };
+            }
+        } else if (IS_SQLITE) {
+            const result = await sql.unsafe(`PRAGMA table_info(${tableName})`);
+            for (const row of result) {
+                let baseType = String(row.type || '').toUpperCase();
+                let max = null;
+                const m = /^(\w+)\s*\((\d+)\)/.exec(baseType);
+                if (m) {
+                    baseType = m[1];
+                    max = Number(m[2]);
+                }
+                columns[row.name] = {
+                    type: baseType.toLowerCase(),
+                    columnType: baseType.toLowerCase(),
+                    max: max,
+                    nullable: row.notnull === 0,
+                    defaultValue: row.dflt_value,
+                    comment: null
+                };
+            }
+        }
+
+        return columns;
+    } catch (error: any) {
+        throw new Error(`获取表列信息失败 [${tableName}]: ${error.message}`);
+    }
+}
+
+/**
+ * 获取表的现有索引信息（单列索引）
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param dbName - 数据库名称
+ * @returns 索引信息对象，键为索引名，值为列名数组
+ */
+export async function getTableIndexes(sql: SQL, tableName: string, dbName?: string): Promise<IndexInfo> {
+    const indexes: IndexInfo = {};
+    const database = dbName || process.env.DB_NAME;
+
+    try {
+        if (IS_MYSQL) {
+            const result = await sql`
+                SELECT INDEX_NAME, COLUMN_NAME
+                FROM information_schema.STATISTICS
+                WHERE TABLE_SCHEMA = ${database}
+                    AND TABLE_NAME = ${tableName}
+                    AND INDEX_NAME != 'PRIMARY'
+                ORDER BY INDEX_NAME
+            `;
+            for (const row of result) {
+                if (!indexes[row.INDEX_NAME]) indexes[row.INDEX_NAME] = [];
+                indexes[row.INDEX_NAME].push(row.COLUMN_NAME);
+            }
+        } else if (IS_PG) {
+            const result = await sql`
+                SELECT indexname, indexdef
+                FROM pg_indexes
+                WHERE schemaname = 'public' AND tablename = ${tableName}
+            `;
+            for (const row of result) {
+                const m = /\(([^)]+)\)/.exec(row.indexdef);
+                if (m) {
+                    const col = m[1].replace(/\"/g, '').replace(/"/g, '').trim();
+                    indexes[row.indexname] = [col];
+                }
+            }
+        } else if (IS_SQLITE) {
+            const list = await sql.unsafe(`PRAGMA index_list(${tableName})`);
+            for (const idx of list) {
+                const info = await sql.unsafe(`PRAGMA index_info(${idx.name})`);
+                const cols = info.map((r) => r.name);
+                if (cols.length === 1) indexes[idx.name] = cols;
+            }
+        }
+
+        return indexes;
+    } catch (error: any) {
+        throw new Error(`获取表索引信息失败 [${tableName}]: ${error.message}`);
+    }
+}

package/sync/syncDb/sqlite.ts

@@ -0,0 +1,50 @@
+/**
+ * syncDb SQLite 特殊处理模块
+ *
+ * 包含：
+ * - SQLite 重建表迁移（处理列修改等不支持的操作）
+ */
+
+import { Logger } from '../../lib/logger.js';
+import { createTable } from './tableCreate.js';
+import type { SQL } from 'bun';
+
+// 是否为计划模式（从环境变量读取）
+const IS_PLAN = process.argv.includes('--plan');
+
+/**
+ * SQLite 重建表迁移（简化版）
+ *
+ * SQLite 不支持修改列类型等操作，需要通过重建表实现：
+ * 1. 创建临时表（新结构）
+ * 2. 拷贝数据（仅公共列）
+ * 3. 删除旧表
+ * 4. 重命名临时表
+ *
+ * 注意：仅处理新增/修改字段，不处理复杂约束与复合索引
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param fields - 字段定义对象
+ */
+export async function rebuildSqliteTable(sql: SQL, tableName: string, fields: Record<string, string>): Promise<void> {
+    // 1. 读取现有列顺序
+    const info = await sql.unsafe(`PRAGMA table_info(${tableName})`);
+    const existingCols = info.map((r) => r.name);
+    const targetCols = ['id', 'created_at', 'updated_at', 'deleted_at', 'state', ...Object.keys(fields)];
+    const tmpTable = `${tableName}__tmp__${Date.now()}`;
+
+    // 2. 创建新表（使用当前定义）
+    await createTable(sql, tmpTable, fields);
+
+    // 3. 拷贝数据（按交集列）
+    const commonCols = targetCols.filter((c) => existingCols.includes(c));
+    if (commonCols.length > 0) {
+        const colsSql = commonCols.map((c) => `"${c}"`).join(', ');
+        await sql.unsafe(`INSERT INTO "${tmpTable}" (${colsSql}) SELECT ${colsSql} FROM "${tableName}"`);
+    }
+
+    // 4. 删除旧表并重命名
+    await sql.unsafe(`DROP TABLE "${tableName}"`);
+    await sql.unsafe(`ALTER TABLE "${tmpTable}" RENAME TO "${tableName}"`);
+}

package/sync/syncDb/table.ts

@@ -0,0 +1,321 @@
+/**
+ * syncDb 表操作模块
+ *
+ * 包含：
+ * - 修改表结构
+ * - 对比字段变化
+ * - 应用变更计划
+ */
+
+import { snakeCase } from 'es-toolkit/string';
+import { Logger } from '../../lib/logger.js';
+import { IS_MYSQL, IS_PG, IS_SQLITE, SYSTEM_INDEX_FIELDS, CHANGE_TYPE_LABELS, typeMapping } from './constants.js';
+import { quoteIdentifier, logFieldChange, resolveDefaultValue, generateDefaultSql, isStringOrArrayType, getSqlType } from './helpers.js';
+import { buildIndexSQL, generateDDLClause, isPgCompatibleTypeChange } from './ddl.js';
+import { getTableColumns, getTableIndexes } from './schema.js';
+import { compareFieldDefinition, applyTablePlan } from './apply.js';
+import { createTable } from './tableCreate.js';
+import type { TablePlan, ColumnInfo } from '../../types.js';
+import type { SQL } from 'bun';
+import type { FieldDefinition } from 'befly/types/common';
+
+// 是否为计划模式（从环境变量读取）
+const IS_PLAN = process.argv.includes('--plan');
+
+/**
+ * 同步表结构（对比和应用变更）
+ *
+ * 主要逻辑：
+ * 1. 获取表的现有列和索引信息
+ * 2. 对比每个字段的定义变化
+ * 3. 生成变更计划（添加/修改/删除列，添加/删除索引）
+ * 4. 执行变更 SQL
+ *
+ * @param sql - SQL 客户端实例
+ * @param tableName - 表名
+ * @param tableDefinition - 表定义（JSON）
+ * @param force - 是否强制同步（删除多余字段）
+ * @param dbName - 数据库名称
+ */
+export async function modifyTable(sql: SQL, tableName: string, tableDefinition: TablePlan, force: boolean, dbName?: string): Promise<void> {
+    try {
+        // 1. 获取现有表结构
+        const currentColumns = await getTableColumns(sql, tableName, dbName);
+        const currentIndexes = await getTableIndexes(sql, tableName, dbName);
+
+        // 2. 对比字段变化
+        const changes: string[] = [];
+        const processedColumns = new Set<string>();
+        const processedIndexes = new Set<string>();
+        const newColumns: string[] = []; // 记录新增的列名，用于后续添加索引
+
+        // 遍历定义中的字段
+        for (const [fieldName, fieldDef] of Object.entries(tableDefinition)) {
+            const snakeFieldName = snakeCase(fieldName);
+            processedColumns.add(snakeFieldName);
+
+            // 检查字段是否存在
+            if (!currentColumns[snakeFieldName]) {
+                // 新增字段
+                changes.push(generateDDLClause('ADD_COLUMN', tableName, snakeFieldName, fieldDef));
+                logFieldChange(tableName, snakeFieldName, 'add', '新增字段');
+                newColumns.push(snakeFieldName);
+            } else {
+                // 修改字段
+                const currentDef = currentColumns[snakeFieldName];
+                const diff = compareFieldDefinition(fieldDef, currentDef);
+                if (diff) {
+                    changes.push(generateDDLClause('MODIFY_COLUMN', tableName, snakeFieldName, fieldDef));
+                    logFieldChange(tableName, snakeFieldName, 'modify', `修改字段: ${diff}`);
+                }
+            }
+        }
+
+        // 检查多余字段（仅在 force 模式下删除）
+        if (force) {
+            for (const colName of Object.keys(currentColumns)) {
+                if (!processedColumns.has(colName)) {
+                    changes.push(generateDDLClause('DROP_COLUMN', tableName, colName));
+                    logFieldChange(tableName, colName, 'drop', '删除多余字段');
+                }
+            }
+        }
+
+        // 3. 对比索引变化
+        // 自动为 _id, _at 结尾的字段添加索引
+        // 以及 unique=true 的字段
+        const expectedIndexes: { [key: string]: string[] } = {};
+
+        for (const [fieldName, fieldDef] of Object.entries(tableDefinition)) {
+            const snakeFieldName = snakeCase(fieldName);
+
+            // 唯一索引
+            if (fieldDef.unique) {
+                const indexName = `uk_${tableName}_${snakeFieldName}`;
+                expectedIndexes[indexName] = [snakeFieldName];
+            }
+            // 普通索引 (index=true 或 _id/_at 结尾)
+            else if (fieldDef.index || snakeFieldName.endsWith('_id') || snakeFieldName.endsWith('_at')) {
+                // 排除主键 id
+                if (snakeFieldName === 'id') continue;
+
+                // 排除大文本类型
+                if (['text', 'longtext', 'json'].includes(fieldDef.type || '')) continue;
+
+                const indexName = `idx_${tableName}_${snakeFieldName}`;
+                expectedIndexes[indexName] = [snakeFieldName];
+            }
+        }
+
+        // 检查新增/修改索引
+        for (const [indexName, columns] of Object.entries(expectedIndexes)) {
+            processedIndexes.add(indexName);
+
+            const currentIndex = currentIndexes[indexName];
+            if (!currentIndex) {
+                // 新增索引
+                changes.push(buildIndexSQL('ADD', tableName, indexName, columns, indexName.startsWith('uk_')));
+                logFieldChange(tableName, indexName, 'add_index', `新增索引 (${columns.join(',')})`);
+            } else {
+                // 索引存在，检查是否一致
+                const isSame = currentIndex.length === columns.length && currentIndex.every((col, i) => col === columns[i]);
+
+                if (!isSame) {
+                    // 修改索引（先删后加）
+                    changes.push(buildIndexSQL('DROP', tableName, indexName));
+                    changes.push(buildIndexSQL('ADD', tableName, indexName, columns, indexName.startsWith('uk_')));
+                    logFieldChange(tableName, indexName, 'modify_index', `修改索引 (${columns.join(',')})`);
+                }
+            }
+        }
+
+        // 检查多余索引（仅在 force 模式下删除）
+        if (force) {
+            for (const indexName of Object.keys(currentIndexes)) {
+                // 跳过系统索引
+                if (SYSTEM_INDEX_FIELDS.includes(indexName)) continue;
+
+                if (!processedIndexes.has(indexName)) {
+                    changes.push(buildIndexSQL('DROP', tableName, indexName));
+                    logFieldChange(tableName, indexName, 'drop_index', '删除多余索引');
+                }
+            }
+        }
+
+        // 4. 执行变更
+        if (changes.length > 0) {
+            if (IS_PLAN) {
+                // 计划模式：只输出 SQL
+                Logger.info(`[PLAN] 表 ${tableName} 变更 SQL:`);
+                for (const sqlStr of changes) {
+                    console.log(sqlStr + ';');
+                }
+            } else {
+                // 执行模式
+                Logger.info(`正在同步表 ${tableName} 结构...`);
+                for (const sqlStr of changes) {
+                    try {
+                        await sql.unsafe(sqlStr);
+                    } catch (error: any) {
+                        Logger.warn(`执行 SQL 失败: ${sqlStr} - ${error.message}`);
+                        // 继续执行后续变更
+                    }
+                }
+            }
+        }
+    } catch (error: any) {
+        throw new Error(`同步表结构失败 [${tableName}]: ${error.message}`);
+    }
+}
+export async function modifyTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, force: boolean = false): Promise<TablePlan> {
+    const existingColumns = await getTableColumns(sql, tableName);
+    const existingIndexes = await getTableIndexes(sql, tableName);
+    let changed = false;
+
+    const addClauses = [];
+    const modifyClauses = [];
+    const defaultClauses = [];
+    const indexActions = [];
+
+    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+        // 转换字段名为下划线格式
+        const dbFieldName = snakeCase(fieldKey);
+
+        if (existingColumns[dbFieldName]) {
+            const comparison = compareFieldDefinition(existingColumns[dbFieldName], fieldDef, dbFieldName);
+            if (comparison.length > 0) {
+                for (const c of comparison) {
+                    // 使用统一的日志格式函数和常量标签
+                    const changeLabel = CHANGE_TYPE_LABELS[c.type] || '未知';
+                    logFieldChange(tableName, dbFieldName, c.type, c.current, c.expected, changeLabel);
+                }
+
+                if (isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max) {
+                    if (existingColumns[dbFieldName].max > fieldDef.max) {
+                        if (force) {
+                            Logger.warn(`[强制执行] ${tableName}.${dbFieldName} 长度收缩 ${existingColumns[dbFieldName].max} -> ${fieldDef.max}`);
+                        } else {
+                            Logger.warn(`[跳过危险变更] ${tableName}.${dbFieldName} 长度收缩 ${existingColumns[dbFieldName].max} -> ${fieldDef.max} 已被跳过（使用 --force 强制执行）`);
+                        }
+                    }
+                }
+
+                const hasTypeChange = comparison.some((c) => c.type === 'datatype');
+                const hasLengthChange = comparison.some((c) => c.type === 'length');
+                const onlyDefaultChanged = comparison.every((c) => c.type === 'default');
+                const defaultChanged = comparison.some((c) => c.type === 'default');
+
+                // 严格限制：除 string/array 互转外，禁止任何字段类型变更
+                if (hasTypeChange) {
+                    const typeChange = comparison.find((c) => c.type === 'datatype');
+                    const errorMsg = [`禁止字段类型变更: ${tableName}.${dbFieldName}`, `当前类型: ${typeChange?.current}`, `目标类型: ${typeChange?.expected}`, `说明: 仅允许 string<->array 互相切换，其他类型变更需要手动处理`].join('\n');
+                    throw new Error(errorMsg);
+                }
+
+                // 默认值变化处理
+                if (defaultChanged) {
+                    // 使用公共函数处理默认值
+                    const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
+
+                    // 生成 SQL DEFAULT 值（不包含前导空格，因为要用于 ALTER COLUMN）
+                    let v: string | null = null;
+                    if (actualDefault !== 'null') {
+                        const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
+                        // 移除前导空格 ' DEFAULT ' -> 'DEFAULT '
+                        v = defaultSql.trim().replace(/^DEFAULT\s+/, '');
+                    }
+
+                    if (v !== null && v !== '') {
+                        if (IS_PG) {
+                            defaultClauses.push(`ALTER COLUMN "${dbFieldName}" SET DEFAULT ${v}`);
+                        } else if (IS_MYSQL && onlyDefaultChanged) {
+                            // MySQL 的 TEXT/BLOB 不允许 DEFAULT，跳过 text 类型
+                            if (fieldDef.type !== 'text') {
+                                defaultClauses.push(`ALTER COLUMN \`${dbFieldName}\` SET DEFAULT ${v}`);
+                            }
+                        }
+                    }
+                }
+
+                // 若不仅仅是默认值变化，继续生成修改子句
+                if (!onlyDefaultChanged) {
+                    let skipModify = false;
+                    if (hasLengthChange && isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max) {
+                        const isShrink = existingColumns[dbFieldName].max > fieldDef.max;
+                        if (isShrink && !force) skipModify = true;
+                    }
+
+                    if (hasTypeChange) {
+                        if (IS_PG && isPgCompatibleTypeChange(existingColumns[dbFieldName].type, typeMapping[fieldDef.type].toLowerCase())) {
+                            Logger.debug(`[PG兼容类型变更] ${tableName}.${dbFieldName} ${existingColumns[dbFieldName].type} -> ${typeMapping[fieldDef.type].toLowerCase()} 允许执行`);
+                        }
+                    }
+
+                    if (!skipModify) modifyClauses.push(generateDDLClause(fieldKey, fieldDef, false));
+                }
+                changed = true;
+            }
+        } else {
+            const lenPart = isStringOrArrayType(fieldDef.type) ? ` 长度:${parseInt(String(fieldDef.max))}` : '';
+            Logger.debug(`  + 新增字段 ${dbFieldName} (${fieldDef.type}${lenPart})`);
+            addClauses.push(generateDDLClause(fieldKey, fieldDef, true));
+            changed = true;
+        }
+    }
+
+    // 检查系统字段索引
+    for (const sysField of ['created_at', 'updated_at', 'state']) {
+        const idxName = `idx_${sysField}`;
+        if (!existingIndexes[idxName]) {
+            indexActions.push({ action: 'create', indexName: idxName, fieldName: sysField });
+            changed = true;
+        }
+    }
+
+    // 检查业务字段索引
+    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+        // 转换字段名为下划线格式
+        const dbFieldName = snakeCase(fieldKey);
+
+        const indexName = `idx_${dbFieldName}`;
+        if (fieldDef.index && !existingIndexes[indexName]) {
+            indexActions.push({ action: 'create', indexName: indexName, fieldName: dbFieldName });
+            changed = true;
+        } else if (!fieldDef.index && existingIndexes[indexName] && existingIndexes[indexName].length === 1) {
+            indexActions.push({ action: 'drop', indexName: indexName, fieldName: dbFieldName });
+            changed = true;
+        }
+    }
+
+    // PG 列注释处理
+    const commentActions = [];
+    if (IS_PG) {
+        for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+            // 转换字段名为下划线格式
+            const dbFieldName = snakeCase(fieldKey);
+
+            if (existingColumns[dbFieldName]) {
+                const curr = existingColumns[dbFieldName].comment || '';
+                const want = fieldDef.name && fieldDef.name !== 'null' ? String(fieldDef.name) : '';
+                if (want !== curr) {
+                    // 防止 SQL 注入：转义单引号
+                    const escapedWant = want.replace(/'/g, "''");
+                    commentActions.push(`COMMENT ON COLUMN "${tableName}"."${dbFieldName}" IS ${want ? `'${escapedWant}'` : 'NULL'}`);
+                    changed = true;
+                }
+            }
+        }
+    }
+
+    // 仅当存在实际动作时才认为有变更（避免仅日志的收缩跳过被计为修改）
+    changed = addClauses.length > 0 || modifyClauses.length > 0 || defaultClauses.length > 0 || indexActions.length > 0 || commentActions.length > 0;
+
+    const plan = { changed, addClauses, modifyClauses, defaultClauses, indexActions, commentActions };
+
+    // 将计划应用（包含 --plan 情况下仅输出）
+    if (plan.changed) {
+        await applyTablePlan(sql, tableName, fields, plan);
+    }
+
+    return plan;
+}