befly 3.9.40 → 3.10.0

package/sync/syncDb/constants.ts

@@ -1,119 +0,0 @@
-/**
- * syncDb 常量定义模块
- *
- * 包含：
- * - 数据库类型判断
- * - 版本要求
- * - 数据类型映射
- * - 系统字段定义
- */
-
-/**
- * 数据库版本要求
- */
-export const DB_VERSION_REQUIREMENTS = {
-    MYSQL_MIN_MAJOR: 8,
-    POSTGRES_MIN_MAJOR: 17,
-    SQLITE_MIN_VERSION: "3.50.0",
-    SQLITE_MIN_VERSION_NUM: 35000 // 3 * 10000 + 50 * 100
-} as const;
-
-/**
- * 需要创建索引的系统字段
- */
-export const SYSTEM_INDEX_FIELDS = ["created_at", "updated_at", "state"] as const;
-
-/**
- * 字段变更类型的中文标签映射
- */
-export const CHANGE_TYPE_LABELS = {
-    length: "长度",
-    datatype: "类型",
-    comment: "注释",
-    default: "默认值",
-    nullable: "可空约束",
-    unique: "唯一约束"
-} as const;
-
-/**
- * MySQL 表配置
- *
- * 固定配置说明：
- * - ENGINE: InnoDB（支持事务、外键）
- * - CHARSET: utf8mb4（完整 Unicode 支持，包括 Emoji）
- * - COLLATE: utf8mb4_0900_ai_ci（MySQL 8.0 推荐，不区分重音和大小写）
- */
-export const MYSQL_TABLE_CONFIG = {
-    ENGINE: "InnoDB",
-    CHARSET: "utf8mb4",
-    COLLATE: "utf8mb4_0900_ai_ci"
-} as const;
-
-// 是否为计划模式（仅输出 SQL 不执行）
-export const IS_PLAN = process.argv.includes("--plan");
-
-// 数据库类型（运行时设置，默认 mysql）
-let _dbType: string = "mysql";
-
-/**
- * 设置数据库类型（由 syncDbCommand 调用）
- * @param dbType - 数据库类型（mysql/postgresql/postgres/sqlite）
- */
-export function setDbType(dbType: string): void {
-    _dbType = (dbType || "mysql").toLowerCase();
-}
-
-/**
- * 获取当前数据库类型
- */
-export function getDbType(): string {
-    return _dbType;
-}
-
-// 数据库类型判断（getter 函数，运行时动态计算）
-export function isMySQL(): boolean {
-    return _dbType === "mysql";
-}
-
-export function isPG(): boolean {
-    return _dbType === "postgresql" || _dbType === "postgres";
-}
-
-export function isSQLite(): boolean {
-    return _dbType === "sqlite";
-}
-
-// 兼容旧代码的静态别名（通过 getter 实现动态获取）
-export const DB_TYPE = {
-    get current(): string {
-        return _dbType;
-    },
-    get IS_MYSQL(): boolean {
-        return isMySQL();
-    },
-    get IS_PG(): boolean {
-        return isPG();
-    },
-    get IS_SQLITE(): boolean {
-        return isSQLite();
-    }
-};
-
-/**
- * 获取字段类型映射（根据当前数据库类型）
- */
-export function getTypeMapping(): Record<string, string> {
-    const isSqlite = isSQLite();
-    const isPg = isPG();
-    const isMysql = isMySQL();
-
-    return {
-        number: isSqlite ? "INTEGER" : isPg ? "BIGINT" : "BIGINT",
-        string: isSqlite ? "TEXT" : isPg ? "character varying" : "VARCHAR",
-        text: isMysql ? "MEDIUMTEXT" : "TEXT",
-        array_string: isSqlite ? "TEXT" : isPg ? "character varying" : "VARCHAR",
-        array_text: isMysql ? "MEDIUMTEXT" : "TEXT",
-        array_number_string: isSqlite ? "TEXT" : isPg ? "character varying" : "VARCHAR",
-        array_number_text: isMysql ? "MEDIUMTEXT" : "TEXT"
-    };
-}

package/sync/syncDb/ddl.ts

@@ -1,251 +0,0 @@
-/**
- * syncDb DDL 构建模块
- *
- * 包含：
- * - 构建索引 SQL
- * - 生成 DDL 子句（添加/修改列）
- * - 安全执行 DDL（MySQL 降级策略）
- * - 构建系统列和业务列定义
- */
-
-import type { FieldDefinition } from "../../types/validate.js";
-import type { SQL } from "bun";
-
-import { snakeCase } from "es-toolkit/string";
-
-import { isMySQL, isPG } from "./constants.js";
-import { quoteIdentifier, escapeComment } from "./helpers.js";
-import { resolveDefaultValue, generateDefaultSql, getSqlType } from "./types.js";
-
-/**
- * 构建索引操作 SQL（统一使用在线策略）
- *
- * @param tableName - 表名
- * @param indexName - 索引名
- * @param fieldName - 字段名
- * @param action - 操作类型（create/drop）
- * @returns SQL 语句
- */
-export function buildIndexSQL(tableName: string, indexName: string, fieldName: string, action: "create" | "drop"): string {
-    const tableQuoted = quoteIdentifier(tableName);
-    const indexQuoted = quoteIdentifier(indexName);
-    const fieldQuoted = quoteIdentifier(fieldName);
-
-    if (isMySQL()) {
-        const parts = [];
-        if (action === "create") {
-            parts.push(`ADD INDEX ${indexQuoted} (${fieldQuoted})`);
-        } else {
-            parts.push(`DROP INDEX ${indexQuoted}`);
-        }
-        // 始终使用在线算法
-        parts.push("ALGORITHM=INPLACE");
-        parts.push("LOCK=NONE");
-        return `ALTER TABLE ${tableQuoted} ${parts.join(", ")}`;
-    }
-
-    if (isPG()) {
-        if (action === "create") {
-            // 始终使用 CONCURRENTLY
-            return `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${indexQuoted} ON ${tableQuoted}(${fieldQuoted})`;
-        }
-        return `DROP INDEX CONCURRENTLY IF EXISTS ${indexQuoted}`;
-    }
-
-    // SQLite
-    if (action === "create") {
-        return `CREATE INDEX IF NOT EXISTS ${indexQuoted} ON ${tableQuoted}(${fieldQuoted})`;
-    }
-    return `DROP INDEX IF EXISTS ${indexQuoted}`;
-}
-
-/**
- * 获取单个系统字段的列定义（用于 ADD COLUMN 或 CREATE TABLE）
- *
- * @param fieldName - 系统字段名（id, created_at, updated_at, deleted_at, state）
- * @returns 列定义字符串，如果不是系统字段则返回 null
- */
-export function getSystemColumnDef(fieldName: string): string | null {
-    const mysqlDefs: Record<string, string> = {
-        id: '`id` BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT COMMENT "主键ID"',
-        created_at: '`created_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "创建时间"',
-        updated_at: '`updated_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "更新时间"',
-        deleted_at: '`deleted_at` BIGINT UNSIGNED NOT NULL DEFAULT 0 COMMENT "删除时间"',
-        state: '`state` BIGINT UNSIGNED NOT NULL DEFAULT 1 COMMENT "状态字段"'
-    };
-    const pgDefs: Record<string, string> = {
-        id: '"id" INTEGER PRIMARY KEY',
-        created_at: '"created_at" INTEGER NOT NULL DEFAULT 0',
-        updated_at: '"updated_at" INTEGER NOT NULL DEFAULT 0',
-        deleted_at: '"deleted_at" INTEGER NOT NULL DEFAULT 0',
-        state: '"state" INTEGER NOT NULL DEFAULT 1'
-    };
-
-    const defs = isMySQL() ? mysqlDefs : pgDefs;
-    return defs[fieldName] || null;
-}
-
-/**
- * 构建系统字段列定义
- *
- * @returns 系统字段的列定义数组
- */
-export function buildSystemColumnDefs(): string[] {
-    return [getSystemColumnDef("id")!, getSystemColumnDef("created_at")!, getSystemColumnDef("updated_at")!, getSystemColumnDef("deleted_at")!, getSystemColumnDef("state")!];
-}
-
-/**
- * 构建业务字段列定义
- *
- * @param fields - 字段定义对象
- * @returns 业务字段的列定义数组
- */
-export function buildBusinessColumnDefs(fields: Record<string, FieldDefinition>): string[] {
-    const colDefs: string[] = [];
-
-    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        const sqlType = getSqlType(fieldDef.type, fieldDef.max, fieldDef.unsigned);
-
-        // 使用公共函数处理默认值
-        const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
-        const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
-
-        // 构建约束
-        const uniqueSql = fieldDef.unique ? " UNIQUE" : "";
-        const nullableSql = fieldDef.nullable ? " NULL" : " NOT NULL";
-
-        if (isMySQL()) {
-            colDefs.push(`\`${dbFieldName}\` ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(fieldDef.name)}"`);
-        } else {
-            colDefs.push(`"${dbFieldName}" ${sqlType}${uniqueSql}${nullableSql}${defaultSql}`);
-        }
-    }
-
-    return colDefs;
-}
-
-/**
- * 生成字段 DDL 子句（不含 ALTER TABLE 前缀）
- *
- * @param fieldKey - 字段键名
- * @param fieldDef - 字段定义对象
- * @param isAdd - 是否为添加字段（true）还是修改字段（false）
- * @returns DDL 子句
- */
-export function generateDDLClause(fieldKey: string, fieldDef: FieldDefinition, isAdd: boolean = false): string {
-    // 转换字段名为下划线格式
-    const dbFieldName = snakeCase(fieldKey);
-
-    const sqlType = getSqlType(fieldDef.type, fieldDef.max, fieldDef.unsigned);
-
-    // 使用公共函数处理默认值
-    const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
-    const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
-
-    // 构建约束
-    const uniqueSql = fieldDef.unique ? " UNIQUE" : "";
-    const nullableSql = fieldDef.nullable ? " NULL" : " NOT NULL";
-
-    if (isMySQL()) {
-        return `${isAdd ? "ADD COLUMN" : "MODIFY COLUMN"} \`${dbFieldName}\` ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(fieldDef.name)}"`;
-    }
-    if (isPG()) {
-        if (isAdd) return `ADD COLUMN IF NOT EXISTS "${dbFieldName}" ${sqlType}${uniqueSql}${nullableSql}${defaultSql}`;
-        // PG 修改：类型与非空可分条执行，生成 TYPE 改变；非空另由上层统一控制
-        return `ALTER COLUMN "${dbFieldName}" TYPE ${sqlType}`;
-    }
-    // SQLite 仅支持 ADD COLUMN（>=3.50.0：支持 IF NOT EXISTS）
-    if (isAdd) return `ADD COLUMN IF NOT EXISTS "${dbFieldName}" ${sqlType}${uniqueSql}${nullableSql}${defaultSql}`;
-    return "";
-}
-
-/**
- * 安全执行 DDL 语句（MySQL 降级策略）
- *
- * 执行 DDL 时按以下顺序尝试：
- * 1. ALGORITHM=INSTANT (最快，无表锁)
- * 2. ALGORITHM=INPLACE (在线 DDL)
- * 3. 传统 DDL (可能需要表锁)
- *
- * @param sql - SQL 客户端实例
- * @param stmt - DDL 语句
- * @returns 是否执行成功
- * @throws {Error} 如果所有尝试都失败
- */
-export async function executeDDLSafely(sql: SQL, stmt: string): Promise<boolean> {
-    try {
-        await sql.unsafe(stmt);
-        return true;
-    } catch (error: any) {
-        // MySQL 专用降级路径
-        if (stmt.includes("ALGORITHM=INSTANT")) {
-            const inplaceSql = stmt.replace(/ALGORITHM=INSTANT/g, "ALGORITHM=INPLACE");
-            try {
-                await sql.unsafe(inplaceSql);
-                return true;
-            } catch {
-                // 最后尝试传统DDL：移除 ALGORITHM/LOCK 附加子句后执行
-                const traditionSql = stmt
-                    .replace(/,\s*ALGORITHM=INPLACE/g, "")
-                    .replace(/,\s*ALGORITHM=INSTANT/g, "")
-                    .replace(/,\s*LOCK=(NONE|SHARED|EXCLUSIVE)/g, "");
-                await sql.unsafe(traditionSql);
-                return true;
-            }
-        } else {
-            throw error;
-        }
-    }
-}
-
-/**
- * 判断是否为兼容的类型变更（宽化型变更，无数据丢失风险）
- *
- * 允许的变更：
- * - MySQL: INT -> BIGINT, TINYINT -> INT/BIGINT, etc.
- * - MySQL: VARCHAR -> TEXT/MEDIUMTEXT
- * - PG: INTEGER -> BIGINT
- * - PG: VARCHAR -> TEXT
- *
- * @param currentType - 当前数据库中的类型
- * @param newType - 目标类型
- * @returns 是否为兼容变更
- */
-export function isCompatibleTypeChange(currentType: string, newType: string): boolean {
-    const c = String(currentType || "").toLowerCase();
-    const n = String(newType || "").toLowerCase();
-
-    // 相同类型不算变更
-    if (c === n) return false;
-
-    // 提取基础类型（去掉 unsigned、长度等修饰）
-    const extractBaseType = (t: string): string => {
-        // 移除 unsigned 和括号内容
-        return t
-            .replace(/\s*unsigned/gi, "")
-            .replace(/\([^)]*\)/g, "")
-            .trim();
-    };
-
-    const cBase = extractBaseType(c);
-    const nBase = extractBaseType(n);
-
-    // MySQL/通用 整数类型宽化（小 -> 大）
-    const intTypes = ["tinyint", "smallint", "mediumint", "int", "integer", "bigint"];
-    const cIntIdx = intTypes.indexOf(cBase);
-    const nIntIdx = intTypes.indexOf(nBase);
-    if (cIntIdx !== -1 && nIntIdx !== -1 && nIntIdx > cIntIdx) {
-        return true;
-    }
-
-    // 字符串类型宽化
-    // MySQL: varchar -> text/mediumtext/longtext
-    if (cBase === "varchar" && (nBase === "text" || nBase === "mediumtext" || nBase === "longtext")) return true;
-    // PG: character varying -> text
-    if (cBase === "character varying" && nBase === "text") return true;
-
-    return false;
-}

package/sync/syncDb/helpers.ts

@@ -1,84 +0,0 @@
-/**
- * syncDb 辅助工具模块
- *
- * 包含：
- * - 标识符引用（反引号/双引号转义）
- * - 日志输出格式化
- * - 字段默认值应用
- */
-
-import { Logger } from "../../lib/logger.js";
-import { isMySQL, isPG } from "./constants.js";
-
-/**
- * 根据数据库类型引用标识符
- *
- * @param identifier - 标识符（表名、列名等）
- * @returns 引用后的标识符
- *
- * @example
- * quoteIdentifier('user_table')
- * // MySQL: `user_table`
- * // PostgreSQL: "user_table"
- * // SQLite: user_table
- */
-export function quoteIdentifier(identifier: string): string {
-    if (isMySQL()) return `\`${identifier}\``;
-    if (isPG()) return `"${identifier}"`;
-    return identifier; // SQLite 无需引用
-}
-
-/**
- * 转义 SQL 注释中的双引号
- *
- * @param str - 注释字符串
- * @returns 转义后的字符串
- *
- * @example
- * escapeComment('用户名称') // => '用户名称'
- * escapeComment('用户"昵称"') // => '用户\\"昵称\\"'
- */
-export function escapeComment(str: string): string {
-    return String(str).replace(/"/g, '\\"');
-}
-
-/**
- * 记录字段变更信息（紧凑格式）
- *
- * @param tableName - 表名
- * @param fieldName - 字段名
- * @param changeType - 变更类型（length/datatype/comment/default）
- * @param oldValue - 旧值
- * @param newValue - 新值
- * @param changeLabel - 变更类型的中文标签
- */
-export function logFieldChange(tableName: string, fieldName: string, changeType: string, oldValue: any, newValue: any, changeLabel: string): void {
-    Logger.debug(`  ~ 修改 ${fieldName} ${changeLabel}: ${oldValue} -> ${newValue}`);
-}
-
-/**
- * 格式化字段列表为可读字符串
- *
- * @param fields - 字段名数组
- * @returns 格式化的字符串（逗号分隔）
- */
-export function formatFieldList(fields: string[]): string {
-    return fields.map((f) => quoteIdentifier(f)).join(", ");
-}
-
-/**
- * 为字段定义应用默认值
- *
- * @param fieldDef - 字段定义对象
- */
-export function applyFieldDefaults(fieldDef: any): void {
-    fieldDef.detail = fieldDef.detail ?? "";
-    fieldDef.min = fieldDef.min ?? 0;
-    fieldDef.max = fieldDef.max ?? (fieldDef.type === "number" ? Number.MAX_SAFE_INTEGER : 100);
-    fieldDef.default = fieldDef.default ?? null;
-    fieldDef.index = fieldDef.index ?? false;
-    fieldDef.unique = fieldDef.unique ?? false;
-    fieldDef.nullable = fieldDef.nullable ?? false;
-    fieldDef.unsigned = fieldDef.unsigned ?? true;
-    fieldDef.regexp = fieldDef.regexp ?? null;
-}

package/sync/syncDb/schema.ts

@@ -1,202 +0,0 @@
-/**
- * syncDb 表结构查询模块
- *
- * 包含：
- * - 判断表是否存在
- * - 获取表的列信息
- * - 获取表的索引信息
- */
-
-import type { ColumnInfo, IndexInfo } from "../../types/sync.js";
-import type { SQL } from "bun";
-
-import { isMySQL, isPG, isSQLite } from "./constants.js";
-
-/**
- * 判断表是否存在（返回布尔值）
- *
- * @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 客户端未初始化");
-
-    try {
-        if (isMySQL()) {
-            const res = await sql`SELECT COUNT(*) AS count FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${dbName} AND TABLE_NAME = ${tableName}`;
-            return (res[0]?.count || 0) > 0;
-        }
-
-        if (isPG()) {
-            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 (isSQLite()) {
-            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 } = {};
-
-    try {
-        if (isMySQL()) {
-            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 = ${dbName} 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,
-                    length: row.CHARACTER_MAXIMUM_LENGTH,
-                    max: row.CHARACTER_MAXIMUM_LENGTH,
-                    nullable: row.IS_NULLABLE === "YES",
-                    defaultValue: defaultValue,
-                    comment: row.COLUMN_COMMENT
-                };
-            }
-        } else if (isPG()) {
-            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,
-                    length: row.character_maximum_length,
-                    max: row.character_maximum_length,
-                    nullable: String(row.is_nullable).toUpperCase() === "YES",
-                    defaultValue: row.column_default,
-                    comment: commentMap[row.column_name] ?? null
-                };
-            }
-        } else if (isSQLite()) {
-            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(),
-                    length: max,
-                    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 = {};
-
-    try {
-        if (isMySQL()) {
-            const result = await sql`
-                SELECT INDEX_NAME, COLUMN_NAME
-                FROM information_schema.STATISTICS
-                WHERE TABLE_SCHEMA = ${dbName}
-                    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 (isPG()) {
-            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, "").trim();
-                    indexes[row.indexname] = [col];
-                }
-            }
-        } else if (isSQLite()) {
-            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: any) => r.name);
-                if (cols.length === 1) indexes[idx.name] = cols;
-            }
-        }
-
-        return indexes;
-    } catch (error: any) {
-        throw new Error(`获取表索引信息失败 [${tableName}]: ${error.message}`);
-    }
-}