added table selector

Author: githubesson

.gitignore

@@ -1 +1 @@
-/sqlparser.exe
+/*.exe

cmd/sqlparser/main.go

@@ -27,11 +27,26 @@ func main() {
 	}
 
 	filename := args[0]
+
+	// Scan for tables and prompt for selection
+	tables, err := parser.ScanTables(filename)
+	if err != nil {
+		fmt.Printf("Error scanning tables: %v\n", err)
+		os.Exit(1)
+	}
+
+	selectedTable, err := parser.PromptTableSelection(tables)
+	if err != nil {
+		fmt.Printf("Error selecting table: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("\nSelected table: %s\n", selectedTable.Name)
+
 	outputFormat := models.OutputFormat(*format)
 
 	// Create output file or use stdout
 	var out *os.File
-	var err error
 	if *output != "" {
 		out, err = os.Create(*output)
 		if err != nil {
@@ -53,7 +68,7 @@ func main() {
 
 	// Process the file
 	fmt.Printf("Processing with %d workers...\n", *workers)
-	err = parser.ProcessSQLFileInBatches(filename, w, *workers)
+	err = parser.ProcessSQLFileInBatches(filename, w, *workers, selectedTable)
 	if err != nil {
 		fmt.Printf("Error processing SQL file: %v\n", err)
 		os.Exit(1)

pkg/parser/database.go

@@ -0,0 +1,93 @@
+package parser
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+)
+
+type TableInfo struct {
+	Name     string
+	LineFrom int
+	LineTo   int
+}
+
+func ScanTables(filename string) ([]TableInfo, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("error opening file: %v", err)
+	}
+	defer file.Close()
+
+	// Use a larger buffer for scanning
+	buf := make([]byte, 64*1024)
+	scanner := bufio.NewScanner(file)
+	scanner.Buffer(buf, 10*1024*1024) // 10MB max line length
+
+	// Use a map to track unique tables
+	tableMap := make(map[string]*TableInfo)
+
+	lineNum := 0
+	for scanner.Scan() {
+		lineNum++
+		line := strings.TrimSpace(scanner.Text())
+
+		// Skip empty lines and comments
+		if line == "" || strings.HasPrefix(line, "--") {
+			continue
+		}
+
+		// Check for INSERT INTO statements
+		if strings.HasPrefix(strings.ToUpper(line), "INSERT INTO") {
+			parts := strings.Split(line, "`")
+			if len(parts) >= 2 {
+				tableName := parts[1]
+				if _, exists := tableMap[tableName]; !exists {
+					tableMap[tableName] = &TableInfo{
+						Name:     tableName,
+						LineFrom: lineNum,
+					}
+				}
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error scanning file: %v", err)
+	}
+
+	// Convert map to slice
+	var tables []TableInfo
+	for _, table := range tableMap {
+		tables = append(tables, *table)
+	}
+
+	// Sort tables by name for consistent display
+	sort.Slice(tables, func(i, j int) bool {
+		return tables[i].Name < tables[j].Name
+	})
+
+	return tables, nil
+}
+
+func PromptTableSelection(tables []TableInfo) (*TableInfo, error) {
+	if len(tables) == 0 {
+		return nil, fmt.Errorf("no tables found in the file")
+	}
+
+	fmt.Println("\nFound the following tables with INSERT statements:")
+	for i, table := range tables {
+		fmt.Printf("%d. %s\n", i+1, table.Name)
+	}
+
+	var choice int
+	fmt.Print("\nEnter the number of the table you want to parse (1-" + fmt.Sprint(len(tables)) + "): ")
+	_, err := fmt.Scanf("%d", &choice)
+	if err != nil || choice < 1 || choice > len(tables) {
+		return nil, fmt.Errorf("invalid selection")
+	}
+
+	return &tables[choice-1], nil
+}

pkg/parser/parser.go

@@ -12,7 +12,7 @@ import (
 	"sqlparser/pkg/writer"
 )
 
-func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers int) error {
+func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers int, selectedTable *TableInfo) error {
 	startTime := time.Now()
 
 	file, err := os.Open(filename)
@@ -34,6 +34,7 @@ func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers i
 	}, numWorkers*2)
 
 	fmt.Printf("Starting to process file: %s at %s\n", filename, startTime.Format(time.RFC3339))
+	fmt.Printf("Processing table: %s (lines %d-%d)\n", selectedTable.Name, selectedTable.LineFrom, selectedTable.LineTo)
 
 	// Start worker pool
 	var wg sync.WaitGroup
@@ -70,27 +71,9 @@ func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers i
 				continue
 			}
 
-			if result.rows != nil {
+			if result.rows != nil && result.tableName == selectedTable.Name {
 				// Handle new table
 				if result.tableName != currentTableName {
-					if currentTableName != "" {
-						if len(currentBatch) > 0 {
-							if err := writer.WriteRows(currentBatch); err != nil {
-								fmt.Printf("Error writing rows: %v\n", err)
-								continue
-							}
-							batchCount++
-							fmt.Printf("Processed batch %d for table %s (%d rows)\n", batchCount, currentTableName, len(currentBatch))
-							currentBatch = nil // Help GC
-						}
-						if err := writer.WriteTableEnd(); err != nil {
-							fmt.Printf("Error ending table: %v\n", err)
-							continue
-						}
-						tableDuration := time.Since(tableStartTime)
-						fmt.Printf("Finished processing table %s (total %d rows in %d batches) in %v\n",
-							currentTableName, rowCount, batchCount, tableDuration)
-					}
 					currentTableName = result.tableName
 					if err := writer.WriteTableStart(currentTableName); err != nil {
 						fmt.Printf("Error starting table: %v\n", err)
@@ -100,7 +83,7 @@ func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers i
 					rowCount = 0
 					batchCount = 0
 					tableStartTime = time.Now()
-					fmt.Printf("Started processing new table: %s at %s\n", currentTableName, tableStartTime.Format(time.RFC3339))
+					fmt.Printf("Started processing table: %s at %s\n", currentTableName, tableStartTime.Format(time.RFC3339))
 				}
 
 				// Process rows immediately
@@ -132,19 +115,37 @@ func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers i
 
 	// Read and send statements to workers
 	var currentStatement strings.Builder
+	lineNum := 0
+	inSelectedTable := false
+
 	for scanner.Scan() {
+		lineNum++
 		line := scanner.Text()
 
+		// Skip empty lines and comments
 		if strings.TrimSpace(line) == "" || strings.HasPrefix(strings.TrimSpace(line), "--") {
 			continue
 		}
 
-		currentStatement.WriteString(line)
-		currentStatement.WriteString(" ")
+		// Check if we're in the selected table's INSERT statements
+		if strings.HasPrefix(strings.ToUpper(strings.TrimSpace(line)), "INSERT INTO") {
+			tableParts := strings.Split(line, "`")
+			if len(tableParts) >= 2 && tableParts[1] == selectedTable.Name {
+				inSelectedTable = true
+			} else {
+				inSelectedTable = false
+			}
+		}
 
-		if strings.HasSuffix(strings.TrimSpace(line), ";") {
-			statementChan <- currentStatement.String()
-			currentStatement.Reset()
+		// Only process INSERT statements for the selected table
+		if inSelectedTable {
+			currentStatement.WriteString(line)
+			currentStatement.WriteString(" ")
+
+			if strings.HasSuffix(strings.TrimSpace(line), ";") {
+				statementChan <- currentStatement.String()
+				currentStatement.Reset()
+			}
 		}
 	}
 
@@ -177,6 +178,7 @@ func ProcessSQLFileInBatches(filename string, writer writer.Writer, numWorkers i
 	totalDuration := time.Since(startTime)
 	fmt.Printf("\nProcessing Summary:\n")
 	fmt.Printf("File: %s\n", filename)
+	fmt.Printf("Table: %s\n", selectedTable.Name)
 	fmt.Printf("Total Statements: %d\n", totalStatements)
 	fmt.Printf("Total Duration: %v\n", totalDuration)
 	fmt.Printf("Average Time per Statement: %v\n", totalDuration/time.Duration(totalStatements))