fdb2 1.0.6 → 1.0.8

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)}` };
+    }
+  }
 }

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

@@ -738,4 +738,135 @@ export class PostgreSQLService 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(`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}'`;
+          }
+        }
+
+        // 处理自增（PostgreSQL使用SERIAL或GENERATED AS IDENTITY）
+        if (column.isAutoIncrement) {
+          if (column.type.toLowerCase().includes('serial') || column.type.toLowerCase().includes('bigserial')) {
+            // 类型已经包含自增
+          } else {
+            columnSQL += ' GENERATED ALWAYS AS IDENTITY';
+          }
+        }
+
+        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('PostgreSQL修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }