fix: correct progress calculation when using worker-based generation

Author: minju-22

src/main/services/data-generator/data-generator-service.ts

@@ -44,7 +44,10 @@ export async function runDataGenerator(
   const schema = await fetchSchema(projectId)
 
   const ruleIds = new Set<number>()
+  let totalRows = 0
+  let progressRows = 0
   for (const table of tables) {
+    totalRows += table.recordCnt
     for (const column of table.columns) {
       if (
         (column.dataSource === 'FAKER' || column.dataSource === 'AI') &&
@@ -133,6 +136,11 @@ export async function runDataGenerator(
         if (data.type) {
           if (data.type === 'worker-result') {
             results.push(data.result)
+          } else if (data.type === 'row-progress') {
+            progressRows += data.progress
+            const progress = Math.floor((progressRows / totalRows) * 100)
+            data.progress = progress
+            mainWindow.webContents.send('data-generator:progress', data)
           } else {
             mainWindow.webContents.send('data-generator:progress', data)
           }

src/main/services/data-generator/worker-runner.ts

@@ -347,7 +347,6 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
     }
 
     logger.info(`[${tableName}] 시작: ${recordCnt.toLocaleString()}행, ${columns.length}컬럼`)
-    const startTime = Date.now()
     let totalProcessed = 0
     const numChunks = Math.max(1, Math.ceil(recordCnt / CHUNK_SIZE))
 
@@ -359,22 +358,16 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
         continue
       }
 
-      logger.info(`\n[${tableName}] 청크 ${chunkIdx + 1}/${numChunks} 처리 중 (${chunkSize}행)`)
-      const chunkStartTime = Date.now()
-
       const columnStreams = columns.map((col) => createColumnStream(col, task, chunkSize))
       const { aiColumns, nonAiColumns } = separateColumnsByType(columns)
       const chunkColumnValues: (string | typeof INVALID)[][] = new Array(columns.length)
 
       // === Non-AI 컬럼 처리 (예외 처리 일관화) ===
       if (nonAiColumns.length > 0) {
-        logger.info(`[${tableName}] Non-AI 컬럼 동시 처리:`)
         const nonAiResults = await Promise.all(
           nonAiColumns.map(async (colIdx) => {
             const col = columns[colIdx]
             const stream = columnStreams[colIdx]
-            const colStart = Date.now()
-            logger.info(`  ▶ [${col.columnName}] 처리 (${col.dataSource})`)
 
             const values: (string | typeof INVALID)[] = []
             for (let i = 0; i < chunkSize; i++) {
@@ -394,9 +387,6 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
               }
             }
 
-            const colDuration = ((Date.now() - colStart) / 1000).toFixed(2)
-            logger.info(`  ✓ [${col.columnName}] 완료 (${colDuration}초)`)
-
             return { colIdx, values }
           })
         )
@@ -408,17 +398,13 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
 
       // === AI 컬럼 처리 (동시 MAX_AI_CONCURRENT개, 예외 처리 통일) ===
       if (aiColumns.length > 0) {
-        logger.info(`[${tableName}] AI 컬럼 처리 (동시 ${MAX_AI_CONCURRENT}개):`)
-
         for (let i = 0; i < aiColumns.length; i += MAX_AI_CONCURRENT) {
           const batch = aiColumns.slice(i, i + MAX_AI_CONCURRENT)
 
           const batchResults = await Promise.all(
             batch.map(async (colIdx) => {
               const col = columns[colIdx]
               const stream = columnStreams[colIdx]
-              const colStart = Date.now()
-              logger.info(`  ▶ [${col.columnName}] 처리 (${col.dataSource})`)
 
               const values: (string | typeof INVALID)[] = []
               for (let j = 0; j < chunkSize; j++) {
@@ -438,9 +424,6 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
                 }
               }
 
-              const colDuration = ((Date.now() - colStart) / 1000).toFixed(2)
-              logger.info(`  ✓ [${col.columnName}] 완료 (${colDuration}초)`)
-
               return { colIdx, values }
             })
           )
@@ -450,7 +433,6 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
           })
 
           if (i + MAX_AI_CONCURRENT < aiColumns.length) {
-            logger.info(`  … 다음 AI 컬럼 대기 (1초)...`)
             await new Promise((res) => setTimeout(res, 1000))
           }
         }
@@ -529,47 +511,18 @@ async function runWorker(task: WorkerTask): Promise<WorkerResult> {
         totalProcessed += successOnThisChunk // 성공한 row만 증가
         totalFailed += failedOnThisChunk // fallback에서 실패한 row
 
-        process.parentPort.postMessage({
-          type: 'row-delta',
-          tableName,
-          success: successOnThisChunk,
-          fail: failedOnThisChunk
-        })
-
         await fs.promises.appendFile(sqlPath, bulkSQL + '\n', 'utf8')
       }
 
-      const chunkDuration = ((Date.now() - chunkStartTime) / 1000).toFixed(2)
-      logger.info(`\n[${tableName}] 청크 ${chunkIdx + 1} 완료 (${chunkDuration}초)`)
-
-      const progressPercent =
-        chunkIdx + 1 === numChunks ? 100 : Math.floor((chunkEnd / recordCnt) * 100)
-
       process.parentPort.postMessage({
         type: 'row-progress',
         tableName,
-        progress: progressPercent
+        progress: chunkSize
       })
 
       await new Promise((res) => setTimeout(res, 100))
-
-      if (chunkEnd === recordCnt) {
-        columns.forEach((col) => {
-          process.parentPort.postMessage({
-            type: 'column-progress',
-            tableName,
-            columnName: col.columnName,
-            progress: 100
-          })
-        })
-      }
     }
 
-    const totalDuration = ((Date.now() - startTime) / 1000).toFixed(2)
-    logger.info(
-      `\n[${tableName}] 전체 완료 (${totalDuration}초, ${totalProcessed.toLocaleString()}행)`
-    )
-
     if (directContext) {
       await directContext.commit()
       await directContext.close()

src/renderer/src/views/DummyInsertView.tsx

@@ -86,11 +86,6 @@ const DummyInsertView: React.FC = () => {
         setProgress(message.progress)
       }
 
-      if (message.type === 'row-delta') {
-        setSuccessRows((prev) => prev + (message.successDelta ?? 0))
-        setFailedRows((prev) => prev + (message.failDelta ?? 0))
-      }
-
       if (message.type === 'table-complete' && message.tableName) {
         const hasFail = (message.failedRows ?? 0) > 0