func()

in internal/enricher/enricher.go [364:481]
102 lines of code
21 McCabe index (conditional complexity)

func (mc *MetadataCollector) GenerateDeleteCommentSQLs(ctx context.Context) ([]string, error) {
	startTime := time.Now()
	log.Println("INFO: Starting metadata collection and SQL comment deletion generation...")

	tables, err := mc.db.ListTables()
	if err != nil {
		return nil, fmt.Errorf("failed to list tables: %w", err)
	}

	// Apply table filtering
	filteredTables := []string{}
	if len(mc.TableFilters) > 0 {
		for table := range mc.TableFilters {
			filteredTables = append(filteredTables, table)
		}
	} else {
		filteredTables = tables
	}
	tables = filteredTables

	var allSQLs []string
	var wg sync.WaitGroup
	errorChannel := make(chan error, len(tables))

	for _, table := range tables {
		wg.Add(1)
		go func(table string) {
			defer wg.Done()
			// Generate SQL for deleting TABLE comments
			tableSQL, genTableErr := withRetry[string](ctx, DefaultRetryOptions, func(ctx context.Context) (string, error) {
				return mc.db.GenerateDeleteTableCommentSQL(ctx, table)
			})
			if genTableErr != nil {
				log.Printf("WARN: Failed to generate delete table comment SQL for %s: %v", table, genTableErr)
				errorChannel <- genTableErr
				return
			}
			if tableSQL != "" {
				mc.mu.Lock()
				allSQLs = append(allSQLs, tableSQL)
				mc.mu.Unlock()
			} else {
				log.Printf("INFO: No SQL generated for deleting table comment in %s, possibly no gemini tag.", table)
			}

			columnInfos, err := mc.db.ListColumns(table)
			if err != nil {
				log.Println("ERROR: Failed to list columns for table:", table, "error:", err)
				errorChannel <- err
				return
			}

			// Apply column filtering
			filteredColumnInfos := []database.ColumnInfo{}
			if columnFilters, ok := mc.TableFilters[table]; ok && columnFilters != nil {
				for _, colInfo := range columnInfos {
					for _, filteredCol := range columnFilters {
						if colInfo.Name == filteredCol {
							filteredColumnInfos = append(filteredColumnInfos, colInfo)
							break
						}
					}
				}
			} else {
				filteredColumnInfos = columnInfos
			}
			columnInfos = filteredColumnInfos

			for _, colInfo := range columnInfos {
				wg.Add(1)
				go func(colInfo database.ColumnInfo) {
					defer wg.Done()

					sql, genErr := withRetry[string](ctx, DefaultRetryOptions, func(ctx context.Context) (string, error) {
						return mc.db.GenerateDeleteCommentSQL(ctx, table, colInfo.Name)
					})
					if genErr != nil {
						log.Printf("WARN: Failed to generate delete comment SQL for %s.%s: %v", table, colInfo.Name, genErr)
						errorChannel <- genErr
						return
					}
					if sql != "" {
						mc.mu.Lock()
						allSQLs = append(allSQLs, sql)
						mc.mu.Unlock()
					} else {
						log.Printf("INFO: No SQL generated for deleting comment in %s.%s, possibly no gemini tag.", table, colInfo.Name)
					}
				}(colInfo)
			}
		}(table)
	}

	wg.Wait()
	close(errorChannel)

	// Check for and combine errors
	var combinedErr error
	for err := range errorChannel {
		if err != nil {
			if combinedErr == nil {
				combinedErr = err
			} else {
				combinedErr = fmt.Errorf("%w; %v", combinedErr, err)
			}
		}
	}
	if combinedErr != nil {
		return nil, combinedErr
	}

	if len(allSQLs) == 0 {
		log.Println("INFO: No SQL statements generated for deleting comments. Possibly no gemini tags found.")
	}

	log.Println("INFO: SQL comment deletion generation completed in:", time.Since(startTime))
	return allSQLs, nil
}