fdb2 1.0.5 → 1.0.7

package/server/model/database.entity.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * 数据库信息实体
+ * 用于存储数据库的基本信息和结构
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKeyEntity = exports.IndexEntity = exports.ColumnEntity = exports.TableEntity = exports.DatabaseEntity = void 0;
+class DatabaseEntity {
+}
+exports.DatabaseEntity = DatabaseEntity;
+/**
+ * 数据库表实体
+ */
+class TableEntity {
+}
+exports.TableEntity = TableEntity;
+/**
+ * 数据库列实体
+ */
+class ColumnEntity {
+}
+exports.ColumnEntity = ColumnEntity;
+/**
+ * 数据库索引实体
+ */
+class IndexEntity {
+}
+exports.IndexEntity = IndexEntity;
+/**
+ * 外键实体
+ */
+class ForeignKeyEntity {
+}
+exports.ForeignKeyEntity = ForeignKeyEntity;
+//# sourceMappingURL=database.entity.js.map

package/server/model/database.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.entity.js","sourceRoot":"","sources":["database.entity.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,MAAa,cAAc;CAmC1B;AAnCD,wCAmCC;AAED;;GAEG;AACH,MAAa,WAAW;CAsEvB;AAtED,kCAsEC;AAED;;GAEG;AACH,MAAa,YAAY;CA4DxB;AA5DD,oCA4DC;AAED;;GAEG;AACH,MAAa,WAAW;CAyBvB;AAzBD,kCAyBC;AAED;;GAEG;AACH,MAAa,gBAAgB;CA8B5B;AA9BD,4CA8BC"}

package/server/service/connection.service.ts

@@ -41,6 +41,7 @@ export class ConnectionService {
    */
   async getAllConnections(): Promise<ConnectionEntity[]> {
     try {
+      console.log('configPath', this.configPath);
       if (!fs.existsSync(this.configPath)) {
         return [];
       }

package/server/service/database/base.service.ts

@@ -174,7 +174,7 @@ export abstract class BaseDatabaseService {
                 success++;
               } catch (error) {
                 failed++;
-                errors.push({ statement, error: error.message });
+                errors.push({ statement, error: error instanceof Error ? error.message : String(error) });
                 if (!continueOnError) {
                   throw error;
                 }
@@ -189,7 +189,7 @@ export abstract class BaseDatabaseService {
               success++;
             } catch (error) {
               failed++;
-              errors.push({ statement, error: error.message });
+              errors.push({ statement, error: error instanceof Error ? error.message : String(error) });
               if (!continueOnError) {
                 throw error;
               }
@@ -199,7 +199,7 @@ export abstract class BaseDatabaseService {
       } catch (batchError) {
         console.error(`批次执行失败 (${i}-${i + batchSize}):`, batchError);
         if (!continueOnError) {
-          throw new Error(`批次执行失败: ${batchError.message}`);
+          throw new Error(`批次执行失败: ${batchError instanceof Error ? batchError.message : String(batchError)}`);
         }
       }
     }
@@ -360,4 +360,9 @@ export abstract class BaseDatabaseService {
    * 导出表数据到 Excel 文件 - 子类实现
    */
   abstract exportTableDataToExcel(dataSource: DataSource, databaseName: string, tableName: string, options?: any): Promise<string>;
+
+  /**
+   * 修改表结构 - 子类实现
+   */
+  abstract alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any>;
 }

package/server/service/database/cockroachdb.service.ts

@@ -656,4 +656,127 @@ export class CockroachDBService extends BaseDatabaseService {
   public quoteIdentifier(identifier: string): string {
     return `"${identifier}"`;
   }
+
+  /**
+   * 修改表结构
+   * CockroachDB与PostgreSQL兼容，使用类似的语法
+   */
+  async alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any> {
+    try {
+      const tableName = tableDiff.tableName;
+      const sqlStatements: string[] = [];
+
+      // 修改表注释
+      if (tableDiff.tableCommentChanged) {
+        sqlStatements.push(`COMMENT ON TABLE "${tableName}" IS '${tableDiff.tableComment}';`);
+      }
+
+      // 添加新列
+      tableDiff.addedColumns.forEach((column: any) => {
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(column.type);
+
+        let columnSQL = `ALTER TABLE "${tableName}" ADD COLUMN "${column.name}" ${column.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (column.length) {
+            columnSQL += `(${column.length})`;
+          } else if (column.precision) {
+            if (column.scale) {
+              columnSQL += `(${column.precision},${column.scale})`;
+            } else {
+              columnSQL += `(${column.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!column.nullable) {
+          columnSQL += ' NOT NULL';
+        }
+
+        // 处理默认值
+        if (column.defaultValue) {
+          const upperDefault = column.defaultValue.toString().toUpperCase();
+          if (['CURRENT_TIMESTAMP', 'NOW()', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${column.defaultValue}'`;
+          }
+        }
+
+        sqlStatements.push(columnSQL + ';');
+
+        // 添加列注释
+        if (column.comment) {
+          sqlStatements.push(`COMMENT ON COLUMN "${tableName}"."${column.name}" IS '${column.comment}';`);
+        }
+      });
+
+      // 修改列
+      tableDiff.modifiedColumns.forEach((modification: any) => {
+        const { oldColumn, newColumn } = modification;
+
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(newColumn.type);
+
+        let columnSQL = `ALTER TABLE "${tableName}" ALTER COLUMN "${newColumn.name}" SET DATA TYPE ${newColumn.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (newColumn.length) {
+            columnSQL += `(${newColumn.length})`;
+          } else if (newColumn.precision) {
+            if (newColumn.scale) {
+              columnSQL += `(${newColumn.precision},${newColumn.scale})`;
+            } else {
+              columnSQL += `(${newColumn.precision})`;
+            }
+          }
+        }
+
+        sqlStatements.push(columnSQL + ';');
+
+        // 修改NULL约束
+        if (!newColumn.nullable) {
+          sqlStatements.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${newColumn.name}" SET NOT NULL;`);
+        } else {
+          sqlStatements.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${newColumn.name}" DROP NOT NULL;`);
+        }
+
+        // 修改默认值
+        if (newColumn.defaultValue) {
+          const upperDefault = newColumn.defaultValue.toString().toUpperCase();
+          if (['CURRENT_TIMESTAMP', 'NOW()', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+            sqlStatements.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${newColumn.name}" SET DEFAULT ${upperDefault};`);
+          } else {
+            sqlStatements.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${newColumn.name}" SET DEFAULT '${newColumn.defaultValue}';`);
+          }
+        } else {
+          sqlStatements.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${newColumn.name}" DROP DEFAULT;`);
+        }
+
+        // 修改列注释
+        if (newColumn.comment) {
+          sqlStatements.push(`COMMENT ON COLUMN "${tableName}"."${newColumn.name}" IS '${newColumn.comment}';`);
+        }
+      });
+
+      // 删除列
+      tableDiff.deletedColumns.forEach((column: any) => {
+        sqlStatements.push(`ALTER TABLE "${tableName}" DROP COLUMN "${column.name}";`);
+      });
+
+      // 执行SQL语句
+      if (sqlStatements.length > 0) {
+        await this.executeBatchQuery(dataSource, sqlStatements, { useTransaction: true });
+      }
+
+      return { ret: 0, message: '表结构修改成功' };
+    } catch (error) {
+      console.error('CockroachDB修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }

package/server/service/database/database.service.ts

@@ -144,6 +144,15 @@ export class DatabaseService {
     return databaseService.executeQuery(dataSource, sql);
   }
 
+  /**
+   * 修改表结构
+   */
+  async alterTable(connectionId: string, databaseName: string, tableDiff: any): Promise<any> {
+    const dataSource = await this.connectionService.getActiveConnection(connectionId, databaseName);
+    const databaseService = this.getDatabaseService(dataSource.options.type as string);
+    return databaseService.alterTable(dataSource, databaseName, tableDiff);
+  }
+
   /**
    * 获取视图列表
    */

package/server/service/database/mongodb.service.ts

@@ -436,6 +436,15 @@ export class MongoDBService extends BaseDatabaseService {
   public quoteIdentifier(identifier: string): string {
     return `\`${identifier}\``;
   }
+
+  /**
+   * 修改表结构
+   * MongoDB是文档数据库，没有传统的表结构概念
+   * 集合中的文档可以有不同的结构，因此不需要ALTER TABLE
+   */
+  async alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any> {
+    return { ret: 0, message: 'MongoDB是文档数据库，不需要修改表结构' };
+  }
 }
 
 /**

package/server/service/database/mssql.service.ts

@@ -720,4 +720,122 @@ export class SQLServerService extends BaseDatabaseService {
       throw new Error(`导出表数据到Excel失败: ${error.message}`);
     }
   }
+
+  /**
+   * 修改表结构
+   */
+  async alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any> {
+    try {
+      const tableName = tableDiff.tableName;
+      const sqlStatements: string[] = [];
+
+      // 修改表注释（使用扩展属性）
+      if (tableDiff.tableCommentChanged) {
+        sqlStatements.push(`EXEC sp_addextendedproperty @name = N'MS_Description', @value = '${tableDiff.tableComment}', @level0type = N'SCHEMA', @level0name = N'dbo', @level1type = N'TABLE', @level1name = N'${tableName}';`);
+      }
+
+      // 添加新列
+      tableDiff.addedColumns.forEach((column: any) => {
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(column.type);
+
+        let columnSQL = `ALTER TABLE [${databaseName}].[dbo].[${tableName}] ADD [${column.name}] ${column.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (column.length) {
+            columnSQL += `(${column.length})`;
+          } else if (column.precision) {
+            if (column.scale) {
+              columnSQL += `(${column.precision},${column.scale})`;
+            } else {
+              columnSQL += `(${column.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!column.nullable) {
+          columnSQL += ' NOT NULL';
+        }
+
+        // 处理默认值
+        if (column.defaultValue) {
+          const upperDefault = column.defaultValue.toString().toUpperCase();
+          if (['GETDATE()', 'GETUTCDATE()', 'CURRENT_TIMESTAMP', 'SYSDATETIME()'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${column.defaultValue}'`;
+          }
+        }
+
+        // 处理自增（MSSQL使用IDENTITY）
+        if (column.isAutoIncrement) {
+          if (column.type.toLowerCase().includes('int') || column.type.toLowerCase().includes('bigint')) {
+            columnSQL += ' IDENTITY(1,1)';
+          }
+        }
+
+        sqlStatements.push(columnSQL + ';');
+
+        // 添加列注释
+        if (column.comment) {
+          sqlStatements.push(`EXEC sp_addextendedproperty @name = N'MS_Description', @value = '${column.comment}', @level0type = N'SCHEMA', @level0name = N'dbo', @level1type = N'TABLE', @level1name = N'${tableName}', @level2type = N'COLUMN', @level2name = N'${column.name}';`);
+        }
+      });
+
+      // 修改列
+      tableDiff.modifiedColumns.forEach((modification: any) => {
+        const { oldColumn, newColumn } = modification;
+
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(newColumn.type);
+
+        // 修改列类型和长度
+        let columnSQL = `ALTER TABLE [${databaseName}].[dbo].[${tableName}] ALTER COLUMN [${newColumn.name}] ${newColumn.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (newColumn.length) {
+            columnSQL += `(${newColumn.length})`;
+          } else if (newColumn.precision) {
+            if (newColumn.scale) {
+              columnSQL += `(${newColumn.precision},${newColumn.scale})`;
+            } else {
+              columnSQL += `(${newColumn.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!newColumn.nullable) {
+          columnSQL += ' NOT NULL';
+        } else {
+          columnSQL += ' NULL';
+        }
+
+        sqlStatements.push(columnSQL + ';');
+
+        // 修改列注释
+        if (newColumn.comment) {
+          sqlStatements.push(`EXEC sp_addextendedproperty @name = N'MS_Description', @value = '${newColumn.comment}', @level0type = N'SCHEMA', @level0name = N'dbo', @level1type = N'TABLE', @level1name = N'${tableName}', @level2type = N'COLUMN', @level2name = N'${newColumn.name}';`);
+        }
+      });
+
+      // 删除列
+      tableDiff.deletedColumns.forEach((column: any) => {
+        sqlStatements.push(`ALTER TABLE [${databaseName}].[dbo].[${tableName}] DROP COLUMN [${column.name}];`);
+      });
+
+      // 执行SQL语句
+      if (sqlStatements.length > 0) {
+        await this.executeBatchQuery(dataSource, sqlStatements, { useTransaction: true });
+      }
+
+      return { ret: 0, message: '表结构修改成功' };
+    } catch (error) {
+      console.error('SQL Server修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }

package/server/service/database/mysql.service.ts

@@ -758,4 +758,134 @@ export class MySQLService extends BaseDatabaseService {
       throw new Error(`导出表数据失败: ${error.message}`);
     }
   }
+
+  /**
+   * 修改表结构
+   */
+  async alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any> {
+    try {
+      const tableName = tableDiff.tableName;
+      const sqlStatements: string[] = [];
+
+      // 修改表注释
+      if (tableDiff.tableCommentChanged) {
+        sqlStatements.push(`ALTER TABLE \`${tableName}\` COMMENT='${tableDiff.tableComment}';`);
+      }
+
+      // 添加新列
+      tableDiff.addedColumns.forEach((column: any) => {
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(column.type);
+
+        let columnSQL = `ALTER TABLE \`${tableName}\` ADD COLUMN \`${column.name}\` ${column.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (column.length) {
+            columnSQL += `(${column.length})`;
+          } else if (column.precision) {
+            if (column.scale) {
+              columnSQL += `(${column.precision},${column.scale})`;
+            } else {
+              columnSQL += `(${column.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!column.nullable) {
+          columnSQL += ' NOT NULL';
+        }
+
+        // 处理默认值
+        if (column.defaultValue) {
+          const upperDefault = column.defaultValue.toString().toUpperCase();
+          if (['CURRENT_TIMESTAMP', 'NOW()', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${column.defaultValue}'`;
+          }
+        }
+
+        // 处理自增
+        if (column.isAutoIncrement) {
+          columnSQL += ' AUTO_INCREMENT';
+        }
+
+        // 处理注释
+        if (column.comment) {
+          columnSQL += ` COMMENT '${column.comment}'`;
+        }
+
+        sqlStatements.push(columnSQL + ';');
+      });
+
+      // 修改列
+      tableDiff.modifiedColumns.forEach((modification: any) => {
+        const { oldColumn, newColumn } = modification;
+
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(newColumn.type);
+
+        let columnSQL = `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${newColumn.name}\` ${newColumn.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (newColumn.length) {
+            columnSQL += `(${newColumn.length})`;
+          } else if (newColumn.precision) {
+            if (newColumn.scale) {
+              columnSQL += `(${newColumn.precision},${newColumn.scale})`;
+            } else {
+              columnSQL += `(${newColumn.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!newColumn.nullable) {
+          columnSQL += ' NOT NULL';
+        } else {
+          columnSQL += ' NULL';
+        }
+
+        // 处理默认值
+        if (newColumn.defaultValue) {
+          const upperDefault = newColumn.defaultValue.toString().toUpperCase();
+          if (['CURRENT_TIMESTAMP', 'NOW()', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${newColumn.defaultValue}'`;
+          }
+        }
+
+        // 处理自增
+        if (newColumn.isAutoIncrement) {
+          columnSQL += ' AUTO_INCREMENT';
+        }
+
+        // 处理注释
+        if (newColumn.comment) {
+          columnSQL += ` COMMENT '${newColumn.comment}'`;
+        }
+
+        sqlStatements.push(columnSQL + ';');
+      });
+
+      // 删除列
+      tableDiff.deletedColumns.forEach((column: any) => {
+        sqlStatements.push(`ALTER TABLE \`${tableName}\` DROP COLUMN \`${column.name}\`;`);
+      });
+
+      // 执行SQL语句
+      if (sqlStatements.length > 0) {
+        await this.executeBatchQuery(dataSource, sqlStatements, { useTransaction: true });
+      }
+
+      return { ret: 0, message: '表结构修改成功' };
+    } catch (error) {
+      console.error('MySQL修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }

package/server/service/database/oracle.service.ts

@@ -829,4 +829,132 @@ ALTER DATABASE OPEN;
       throw new Error(`导出表数据到Excel失败: ${error.message}`);
     }
   }
+
+  /**
+   * 修改表结构
+   */
+  async alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any> {
+    try {
+      const tableName = tableDiff.tableName;
+      const sqlStatements: string[] = [];
+
+      // 修改表注释
+      if (tableDiff.tableCommentChanged) {
+        sqlStatements.push(`COMMENT ON TABLE "${tableName}" IS '${tableDiff.tableComment}';`);
+      }
+
+      // 添加新列
+      tableDiff.addedColumns.forEach((column: any) => {
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(column.type);
+
+        let columnSQL = `ALTER TABLE "${tableName}" ADD ("${column.name}" ${column.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (column.length) {
+            columnSQL += `(${column.length})`;
+          } else if (column.precision) {
+            if (column.scale) {
+              columnSQL += `(${column.precision},${column.scale})`;
+            } else {
+              columnSQL += `(${column.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!column.nullable) {
+          columnSQL += ' NOT NULL';
+        }
+
+        // 处理默认值
+        if (column.defaultValue) {
+          const upperDefault = column.defaultValue.toString().toUpperCase();
+          if (['SYSDATE', 'SYSTIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIMESTAMP'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${column.defaultValue}'`;
+          }
+        }
+
+        // 处理自增（Oracle使用GENERATED ALWAYS AS IDENTITY或SEQUENCE）
+        if (column.isAutoIncrement) {
+          if (column.type.toLowerCase().includes('number')) {
+            columnSQL += ' GENERATED ALWAYS AS IDENTITY';
+          }
+        }
+
+        columnSQL += ')';
+        sqlStatements.push(columnSQL + ';');
+
+        // 添加列注释
+        if (column.comment) {
+          sqlStatements.push(`COMMENT ON COLUMN "${tableName}"."${column.name}" IS '${column.comment}';`);
+        }
+      });
+
+      // 修改列
+      tableDiff.modifiedColumns.forEach((modification: any) => {
+        const { oldColumn, newColumn } = modification;
+
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(newColumn.type);
+
+        // 修改列类型和长度
+        let columnSQL = `ALTER TABLE "${tableName}" MODIFY ("${newColumn.name}" ${newColumn.type}`;
+
+        // 处理长度和精度（仅当type中没有指定长度时才添加）
+        if (!typeHasLength) {
+          if (newColumn.length) {
+            columnSQL += `(${newColumn.length})`;
+          } else if (newColumn.precision) {
+            if (newColumn.scale) {
+              columnSQL += `(${newColumn.precision},${newColumn.scale})`;
+            } else {
+              columnSQL += `(${newColumn.precision})`;
+            }
+          }
+        }
+
+        // 处理NULL约束
+        if (!newColumn.nullable) {
+          columnSQL += ' NOT NULL';
+        }
+
+        // 处理默认值
+        if (newColumn.defaultValue) {
+          const upperDefault = newColumn.defaultValue.toString().toUpperCase();
+          if (['SYSDATE', 'SYSTIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIMESTAMP'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${newColumn.defaultValue}'`;
+          }
+        }
+
+        columnSQL += ')';
+        sqlStatements.push(columnSQL + ';');
+
+        // 修改列注释
+        if (newColumn.comment) {
+          sqlStatements.push(`COMMENT ON COLUMN "${tableName}"."${newColumn.name}" IS '${newColumn.comment}';`);
+        }
+      });
+
+      // 删除列
+      tableDiff.deletedColumns.forEach((column: any) => {
+        sqlStatements.push(`ALTER TABLE "${tableName}" DROP COLUMN "${column.name}";`);
+      });
+
+      // 执行SQL语句
+      if (sqlStatements.length > 0) {
+        await this.executeBatchQuery(dataSource, sqlStatements, { useTransaction: true });
+      }
+
+      return { ret: 0, message: '表结构修改成功' };
+    } catch (error) {
+      console.error('Oracle修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }