fdb2 1.0.13 → 1.0.15

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

@@ -1,407 +0,0 @@
-import { DataSource } from 'typeorm';
-import { 
-  DatabaseEntity, 
-  TableEntity, 
-  ColumnEntity, 
-  IndexEntity, 
-  ForeignKeyEntity 
-} from '../../model/database.entity';
-
-/**
- * 数据库服务基础类
- * 提供所有数据库类型的通用操作
- */
-export abstract class BaseDatabaseService {
-
-  /**
-   * 获取数据库类型
-   */
-  abstract getDatabaseType(): string;
-
-  /**
-   * 获取数据库列表 - 子类实现
-   */
-  abstract getDatabases(dataSource: DataSource): Promise<string[]>;
-
-  /**
-   * 获取表列表 - 子类实现
-   */
-  abstract getTables(dataSource: DataSource, database: string): Promise<TableEntity[]>;
-
-  /**
-   * 获取列信息 - 子类实现
-   */
-  abstract getColumns(dataSource: DataSource, database: string, table: string): Promise<ColumnEntity[]>;
-
-  /**
-   * 获取索引信息 - 子类实现
-   */
-  abstract getIndexes(dataSource: DataSource, database: string, table: string): Promise<IndexEntity[]>;
-
-  /**
-   * 获取外键信息 - 子类实现
-   */
-  abstract getForeignKeys(dataSource: DataSource, database: string, table: string): Promise<ForeignKeyEntity[]>;
-
-  /**
-   * 获取数据库大小 - 子类实现
-   */
-  abstract getDatabaseSize(dataSource: DataSource, database: string): Promise<number>;
-
-  /**
-   * 通用方法：获取数据库详细信息
-   */
-  async getDatabaseInfo(dataSource: DataSource, databaseName: string): Promise<DatabaseEntity> {
-    const tables = await this.getTables(dataSource, databaseName);
-    
-    return {
-      name: databaseName,
-      tableCount: tables.length,
-      size: await this.getDatabaseSize(dataSource, databaseName),
-      tables
-    };
-  }
-
-  /**
-   * 通用方法：获取表详细信息
-   */
-  async getTableInfo(dataSource: DataSource, databaseName: string, tableName: string): Promise<TableEntity> {
-    const tables = await this.getTables(dataSource, databaseName);
-    const table = tables.find(t => t.name === tableName);
-    
-    if (!table) {
-      throw new Error(`表 ${tableName} 不存在`);
-    }
-
-    // 获取列信息
-    table.columns = await this.getColumns(dataSource, databaseName, tableName);
-    
-    // 获取索引信息
-    table.indexes = await this.getIndexes(dataSource, databaseName, tableName);
-    
-    // 获取外键信息
-    table.foreignKeys = await this.getForeignKeys(dataSource, databaseName, tableName);
-
-    return table;
-  }
-
-  /**
-   * 获取表结构（包含列信息）
-   */
-  async getTableStructure(dataSource: DataSource, databaseName: string, tableName: string): Promise<any> {
-    const table = await this.getTableInfo(dataSource, databaseName, tableName);
-    return {
-      columns: table.columns,
-      comment: table.comment
-    };
-  }
-
-  /**
-   * 通用方法：获取表数据
-   */
-  async getTableData(
-    dataSource: DataSource, 
-    databaseName: string, 
-    tableName: string,
-    page: number = 1,
-    pageSize: number = 100,
-    where?: string,
-    orderBy?: string
-  ): Promise<{ data: any[], total: number }> {
-    // 构建查询
-    let query = `SELECT * FROM ${this.quoteIdentifier(tableName)}`;
-    
-    if (where) {
-      query += ` WHERE ${where}`;
-    }
-    
-    if (orderBy) {
-      query += ` ORDER BY ${orderBy}`;
-    }
-    
-    const offset = (page - 1) * pageSize;
-    query += ` LIMIT ${pageSize} OFFSET ${offset}`;
-
-    // 执行数据查询
-    const data = await dataSource.query(query);
-
-    // 获取总数
-    let countQuery = `SELECT COUNT(*) as total FROM ${this.quoteIdentifier(tableName)}`;
-    if (where) {
-      countQuery += ` WHERE ${where}`;
-    }
-    const countResult = await dataSource.query(countQuery);
-    const total = countResult[0]?.total || 0;
-
-    return { data, total };
-  }
-
-  /**
-   * 通用方法：执行SQL查询
-   */
-  async executeQuery(dataSource: DataSource, sql: string): Promise<any> {
-    try {
-      const result = await dataSource.query(sql);
-      return result;
-    } catch (error) {
-      console.error('SQL执行失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 批量执行SQL查询（支持多条语句）
-   */
-  async executeBatchQuery(
-    dataSource: DataSource, 
-    sqlStatements: string[], 
-    options?: {
-      batchSize?: number;  // 每批执行的语句数量
-      useTransaction?: boolean;  // 是否使用事务
-      continueOnError?: boolean;  // 错误时是否继续执行
-    }
-  ): Promise<{ success: number; failed: number; errors: any[] }> {
-    const {
-      batchSize = 100,
-      useTransaction = true,
-      continueOnError = false
-    } = options || {};
-
-    let success = 0;
-    let failed = 0;
-    const errors: any[] = [];
-
-    // 分批处理SQL语句
-    for (let i = 0; i < sqlStatements.length; i += batchSize) {
-      const batch = sqlStatements.slice(i, i + batchSize);
-      
-      try {
-        if (useTransaction) {
-          // 使用事务执行批次
-          await dataSource.transaction(async (manager) => {
-            for (const statement of batch) {
-              try {
-                await manager.query(statement);
-                success++;
-              } catch (error) {
-                failed++;
-                errors.push({ statement, error: error instanceof Error ? error.message : String(error) });
-                if (!continueOnError) {
-                  throw error;
-                }
-              }
-            }
-          });
-        } else {
-          // 非事务执行批次
-          for (const statement of batch) {
-            try {
-              await dataSource.query(statement);
-              success++;
-            } catch (error) {
-              failed++;
-              errors.push({ statement, error: error instanceof Error ? error.message : String(error) });
-              if (!continueOnError) {
-                throw error;
-              }
-            }
-          }
-        }
-      } catch (batchError) {
-        console.error(`批次执行失败 (${i}-${i + batchSize}):`, batchError);
-        if (!continueOnError) {
-          throw new Error(`批次执行失败: ${batchError instanceof Error ? batchError.message : String(batchError)}`);
-        }
-      }
-    }
-
-    return { success, failed, errors };
-  }
-
-  /**
-   * 执行文件中的SQL（支持大文件）
-   */
-  async executeSqlFile(
-    dataSource: DataSource, 
-    filePath: string, 
-    options?: {
-      batchSize?: number;
-      useTransaction?: boolean;
-      continueOnError?: boolean;
-    }
-  ): Promise<{ success: number; failed: number; errors: any[] }> {
-    const fs = require('fs');
-    const sqlContent = fs.readFileSync(filePath, 'utf8');
-    
-    // 分割SQL语句
-    const sqlStatements = sqlContent
-      .split(';')
-      .map(statement => statement.trim())
-      .filter(statement => statement.length > 0);
-    
-    return this.executeBatchQuery(dataSource, sqlStatements, options);
-  }
-
-  /**
-   * 通用方法：测试连接
-   */
-  async testConnection(dataSource: DataSource): Promise<boolean> {
-    try {
-      await dataSource.query('SELECT 1');
-      return true;
-    } catch (error) {
-      //this.ctx.logger.error('数据库连接测试失败:', error);
-      console.error(error);
-      return false;
-    }
-  }
-
-  /**
-   * 通用方法：给标识符加引号
-   */
-  public quoteIdentifier(identifier: string): string {
-    return `"${identifier}"`;
-  }
-
-  /**
-   * 通用方法：构建分页查询
-   */
-  protected buildPaginationQuery(baseQuery: string, page: number, pageSize: number): string {
-    const offset = (page - 1) * pageSize;
-    return `${baseQuery} LIMIT ${pageSize} OFFSET ${offset}`;
-  }
-
-  /**
-   * 通用方法：构建计数查询
-   */
-  protected buildCountQuery(baseQuery: string): string {
-    return `SELECT COUNT(*) as total FROM (${baseQuery}) as count_query`;
-  }
-
-  /**
-   * 获取视图列表 - 子类实现（如果支持）
-   */
-  async getViews(dataSource: DataSource, database: string): Promise<any[]> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持视图`);
-  }
-
-  /**
-   * 获取视图定义 - 子类实现（如果支持）
-   */
-  async getViewDefinition(dataSource: DataSource, database: string, viewName: string): Promise<string> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持视图`);
-  }
-
-  /**
-   * 获取存储过程列表 - 子类实现（如果支持）
-   */
-  async getProcedures(dataSource: DataSource, database: string): Promise<any[]> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持存储过程`);
-  }
-
-  /**
-   * 获取存储过程定义 - 子类实现（如果支持）
-   */
-  async getProcedureDefinition(dataSource: DataSource, database: string, procedureName: string): Promise<string> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持存储过程`);
-  }
-
-  /**
-   * 导出数据库架构 - 子类实现
-   */
-  abstract exportSchema(dataSource: DataSource, database: string): Promise<string>;
-
-  /**
-   * 查看数据库日志 - 子类实现（如果支持）
-   */
-  abstract viewLogs(dataSource: DataSource, database?: string, limit?: number): Promise<any[]>;
-
-  /**
-   * 创建数据库 - 子类实现（如果支持）
-   */
-  async createDatabase(dataSource: DataSource, databaseName: string, options?: any): Promise<void> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持创建数据库`);
-  }
-
-  /**
-   * 删除数据库 - 子类实现（如果支持）
-   */
-  async dropDatabase(dataSource: DataSource, databaseName: string): Promise<void> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持删除数据库`);
-  }
-
-  /**
-   * 备份数据库 - 子类实现（如果支持）
-   */
-  async backupDatabase(dataSource: DataSource, databaseName: string, options?: any): Promise<string> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持备份数据库`);
-  }
-
-  /**
-   * 恢复数据库 - 子类实现（如果支持）
-   */
-  async restoreDatabase(dataSource: DataSource, databaseName: string, filePath: string, options?: any): Promise<void> {
-    // 默认实现，子类可以重写
-    throw new Error(`数据库类型 ${this.getDatabaseType()} 不支持恢复数据库`);
-  }
-
-  /**
-   * 导出表数据到 SQL 文件 - 子类实现
-   */
-  abstract exportTableDataToSQL(dataSource: DataSource, databaseName: string, tableName: string, options?: any): Promise<string>;
-
-  /**
-   * 导出表数据到 CSV 文件 - 子类实现
-   */
-  abstract exportTableDataToCSV(dataSource: DataSource, databaseName: string, tableName: string, options?: any): Promise<string>;
-
-  /**
-   * 导出表数据到 JSON 文件 - 子类实现
-   */
-  abstract exportTableDataToJSON(dataSource: DataSource, databaseName: string, tableName: string, options?: any): Promise<string>;
-
-  /**
-   * 导出表数据到 Excel 文件 - 子类实现
-   */
-  abstract exportTableDataToExcel(dataSource: DataSource, databaseName: string, tableName: string, options?: any): Promise<string>;
-
-  /**
-   * 修改表结构 - 子类实现
-   */
-  abstract alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any>;
-
-  /**
-   * 批量插入数据 - 子类实现
-   */
-  abstract bulkInsert(dataSource: DataSource, databaseName: string, tableName: string, data: any[]): Promise<void>;
-
-  /**
-   * 插入单条数据 - 子类实现
-   */
-  abstract insertData(dataSource: DataSource, databaseName: string, tableName: string, data: any): Promise<void>;
-
-  /**
-   * 删除表 - 子类实现
-   */
-  abstract dropTable(dataSource: DataSource, databaseName: string, tableName: string): Promise<void>;
-
-  /**
-   * 创建表 - 子类实现
-   */
-  abstract createTable(dataSource: DataSource, databaseName: string, table: any): Promise<void>;
-
-  /**
-   * 执行查询 - 通用方法
-   */
-  async query(dataSource: DataSource, queryOptions: { sql: string; params?: any[] }): Promise<any[]> {
-    const { sql, params = [] } = queryOptions;
-    return dataSource.query(sql, params);
-  }
-}