fdb2 1.0.5 → 1.0.7

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

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

@@ -710,4 +710,124 @@ export class SAPHANADatabaseService extends BaseDatabaseService {
   public quoteIdentifier(identifier: string): string {
     return `"${identifier}"`;
   }
+
+  /**
+   * 修改表结构
+   */
+  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.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', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${column.defaultValue}'`;
+          }
+        }
+
+        columnSQL += ')';
+        sqlStatements.push(columnSQL + ';');
+
+        // 添加列注释
+        if (column.comment) {
+          sqlStatements.push(`ALTER TABLE "${tableName}" ("${column.name}" COMMENT '${column.comment}')`);
+        }
+      });
+
+      // 修改列
+      tableDiff.modifiedColumns.forEach((modification: any) => {
+        const { oldColumn, newColumn } = modification;
+
+        // 检查type是否已经包含长度信息（括号）
+        const typeHasLength = /\(\d+\)/.test(newColumn.type);
+
+        let columnSQL = `ALTER TABLE "${tableName}" ("${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 (['CURRENT_TIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+            columnSQL += ` DEFAULT ${upperDefault}`;
+          } else {
+            columnSQL += ` DEFAULT '${newColumn.defaultValue}'`;
+          }
+        }
+
+        columnSQL += ')';
+        sqlStatements.push(columnSQL + ';');
+
+        // 修改列注释
+        if (newColumn.comment) {
+          sqlStatements.push(`ALTER TABLE "${tableName}" ("${newColumn.name}" COMMENT '${newColumn.comment}')`);
+        }
+      });
+
+      // 删除列
+      tableDiff.deletedColumns.forEach((column: any) => {
+        sqlStatements.push(`ALTER TABLE "${tableName}" DROP ("${column.name}")`);
+      });
+
+      // 执行SQL语句
+      if (sqlStatements.length > 0) {
+        await this.executeBatchQuery(dataSource, sqlStatements, { useTransaction: true });
+      }
+
+      return { ret: 0, message: '表结构修改成功' };
+    } catch (error) {
+      console.error('SAP HANA修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }

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

@@ -556,4 +556,154 @@ export class SQLiteService extends BaseDatabaseService {
       throw new Error(`导出表数据到Excel失败: ${error.message}`);
     }
   }
+
+  /**
+   * 修改表结构
+   * SQLite的ALTER TABLE操作非常有限，需要通过重建表来实现复杂的表结构修改
+   */
+  async alterTable(dataSource: DataSource, databaseName: string, tableDiff: any): Promise<any> {
+    try {
+      const tableName = tableDiff.tableName;
+      const sqlStatements: string[] = [];
+
+      // SQLite不支持直接修改表注释，只能忽略
+
+      // 如果有修改或删除列，需要重建表
+      if (tableDiff.modifiedColumns.length > 0 || tableDiff.deletedColumns.length > 0) {
+        const tempTableName = `_temp_${tableName}_${Date.now()}`;
+        
+        // 获取所有列（包括新增的和未修改的）
+        const allColumns = [...tableDiff.addedColumns];
+        const existingColumns = await this.getColumns(dataSource, databaseName, tableName);
+        
+        // 添加未修改的现有列
+        existingColumns.forEach(col => {
+          const isDeleted = tableDiff.deletedColumns.some((dc: any) => dc.name === col.name);
+          const isModified = tableDiff.modifiedColumns.some((mc: any) => mc.oldColumn.name === col.name);
+          if (!isDeleted && !isModified) {
+            allColumns.push(col);
+          }
+        });
+
+        // 添加修改后的列
+        tableDiff.modifiedColumns.forEach((modification: any) => {
+          allColumns.push(modification.newColumn);
+        });
+
+        // 创建临时表
+        let createTableSQL = `CREATE TABLE "${tempTableName}" (`;
+        const columnDefinitions: string[] = [];
+
+        allColumns.forEach(column => {
+          // 检查type是否已经包含长度信息（括号）
+          const typeHasLength = /\(\d+\)/.test(column.type);
+
+          let definition = `"${column.name}" ${column.type}`;
+
+          // 处理长度和精度（仅当type中没有指定长度时才添加）
+          if (!typeHasLength) {
+            if (column.length) {
+              definition += `(${column.length})`;
+            } else if (column.precision) {
+              if (column.scale) {
+                definition += `(${column.precision},${column.scale})`;
+              } else {
+                definition += `(${column.precision})`;
+              }
+            }
+          }
+
+          // 处理NULL约束
+          if (!column.nullable) {
+            definition += ' NOT NULL';
+          }
+
+          // 处理默认值
+          if (column.defaultValue) {
+            const upperDefault = column.defaultValue.toString().toUpperCase();
+            if (['CURRENT_TIMESTAMP', 'NOW()', 'CURRENT_DATE', 'CURRENT_TIME'].includes(upperDefault)) {
+              definition += ` DEFAULT ${upperDefault}`;
+            } else {
+              definition += ` DEFAULT '${column.defaultValue}'`;
+            }
+          }
+
+          // 处理主键和自增
+          if (column.isPrimary) {
+            if (column.isAutoIncrement) {
+              definition += ' PRIMARY KEY AUTOINCREMENT';
+            } else {
+              definition += ' PRIMARY KEY';
+            }
+          }
+
+          columnDefinitions.push(definition);
+        });
+
+        createTableSQL += columnDefinitions.join(',\n');
+        createTableSQL += ')';
+        sqlStatements.push(createTableSQL + ';');
+
+        // 复制数据到临时表
+        const existingColumnNames = existingColumns.map(col => `"${col.name}"`).join(', ');
+        const newColumnNames = allColumns.map(col => `"${col.name}"`).join(', ');
+        sqlStatements.push(`INSERT INTO "${tempTableName}" (${newColumnNames}) SELECT ${existingColumnNames} FROM "${tableName}";`);
+
+        // 删除旧表
+        sqlStatements.push(`DROP TABLE "${tableName}";`);
+
+        // 重命名临时表
+        sqlStatements.push(`ALTER TABLE "${tempTableName}" RENAME TO "${tableName}";`);
+
+      } else if (tableDiff.addedColumns.length > 0) {
+        // 只有添加列，可以直接使用ALTER TABLE ADD COLUMN
+        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 + ';');
+        });
+      }
+
+      // 执行SQL语句
+      if (sqlStatements.length > 0) {
+        await this.executeBatchQuery(dataSource, sqlStatements, { useTransaction: true });
+      }
+
+      return { ret: 0, message: '表结构修改成功' };
+    } catch (error) {
+      console.error('SQLite修改表结构失败:', error);
+      return { ret: 1, message: `修改表结构失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
 }

package/server/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "outDir": "./dist/server",
+    "rootDir": "./",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noEmit": false,
+    "resolveJsonModule": true
+  },
+  "include": ["**/*"],
+  "exclude": ["**/__tests__/*", "**/*.spec.ts", "node_modules", "dist"]
+}

package/server.js

@@ -122,7 +122,7 @@ const PORT = portFromArgs || process.env.PORT || 9800;
 app.listen(PORT, () => {
   
   // 将 PID 写入 PID 文件
-  const pidFilePath = path.join(__dirname, 'server.pid');
+  const pidFilePath = path.join(__dirname, 'fdb2.server.pid');
   fs.writeFileSync(pidFilePath, process.pid.toString());
   console.log(`PID ${process.pid} written to ${pidFilePath}`);
   

package/src/components/connection-editor/index.vue

@@ -317,7 +317,6 @@ function showEditModal(connection: ConnectionEntity) {
 // 保存连接配置（不测试连接）
 async function saveConnection(closeModal = true) {
   try {
-    debugger
     // 先进行前端验证
     const validation = validateConnection(connectionForm.value);
     if (!validation.isValid) {