refactor: fix race conditions, nil panics, O(n) hotpaths and code duplication across codebase

Author: Chahine-tech

README.md

@@ -1,4 +1,4 @@
-# sql-parser-go
+# SQLens
 
 [![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://golang.org)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

cmd/sqlparser/main.go

@@ -6,7 +6,9 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 	"time"
 
 	"github.com/Chahine-tech/sql-parser-go/internal/config"
@@ -287,6 +289,7 @@ func watchLogFile(filename string, cfg *config.Config, verbose bool, tailLines i
 
 	// Handle Ctrl+C
 	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
 
 	fmt.Println("📊 Real-time monitoring started. Press Ctrl+C to stop.")
 	fmt.Println(strings.Repeat("=", 80))

internal/performance/monitor.go

@@ -75,6 +75,5 @@ func (pm *PerformanceMonitor) GetMetrics() map[string]interface{} {
 // ForceGC forces garbage collection and returns memory stats
 func ForceGC() MemoryStats {
 	runtime.GC()
-	runtime.GC() // Double GC to ensure cleanup
 	return GetMemoryStats()
 }

pkg/analyzer/analyzer.go

@@ -14,6 +14,7 @@ const (
 	defaultJoinCapacity      = 4
 	defaultConditionCapacity = 8
 	defaultCacheCapacity     = 64
+	maxCacheSize             = 512
 )
 
 type Analyzer struct {
@@ -99,6 +100,13 @@ func (a *Analyzer) AnalyzeWithCache(stmt parser.Statement, cacheKey string) Quer
 
 	if cacheKey != "" {
 		a.mu.Lock()
+		if len(a.cache) >= maxCacheSize {
+			// Evict one arbitrary entry to cap memory usage.
+			for k := range a.cache {
+				delete(a.cache, k)
+				break
+			}
+		}
 		a.cache[cacheKey] = analysis
 		a.mu.Unlock()
 	}
@@ -126,10 +134,14 @@ func (a *Analyzer) analyzeSelectStatement(stmt *parser.SelectStatement) {
 			Usage:  "SELECT",
 		})
 
+		condition := ""
+		if join.Condition != nil {
+			condition = join.Condition.String()
+		}
 		a.analysis.Joins = append(a.analysis.Joins, JoinInfo{
 			Type:       join.JoinType,
 			RightTable: join.Table.Name,
-			Condition:  join.Condition.String(),
+			Condition:  condition,
 		})
 
 		a.analyzeExpression(join.Condition, "JOIN")
@@ -312,29 +324,33 @@ func (a *Analyzer) SuggestOptimizations(stmt *parser.SelectStatement) []Optimiza
 	return suggestions
 }
 
-// GetEnhancedOptimizations returns comprehensive optimization suggestions using the new engine
+// GetEnhancedOptimizations returns comprehensive optimization suggestions using the new engine.
 func (a *Analyzer) GetEnhancedOptimizations(stmt parser.Statement) []EnhancedOptimizationSuggestion {
-	if a.optimizationEngine == nil {
-		// Fallback to basic suggestions if no optimization engine is available
-		basicSuggestions := a.SuggestOptimizations(stmt.(*parser.SelectStatement))
-		enhanced := make([]EnhancedOptimizationSuggestion, len(basicSuggestions))
-		for i, basic := range basicSuggestions {
-			enhanced[i] = EnhancedOptimizationSuggestion{
-				Type:        basic.Type,
-				Description: basic.Description,
-				Severity:    basic.Severity,
-				Category:    "GENERAL",
-				Rule:        basic.Type,
-				Line:        basic.Line,
-				Suggestion:  "Review query for optimization opportunities",
-				Impact:      "MEDIUM",
-				AutoFixable: false,
-			}
-		}
-		return enhanced
+	if a.optimizationEngine != nil {
+		return a.optimizationEngine.AnalyzeOptimizations(stmt)
 	}
 
-	return a.optimizationEngine.AnalyzeOptimizations(stmt)
+	// Fallback: only SELECT statements support basic suggestions.
+	sel, ok := stmt.(*parser.SelectStatement)
+	if !ok {
+		return nil
+	}
+	basicSuggestions := a.SuggestOptimizations(sel)
+	enhanced := make([]EnhancedOptimizationSuggestion, len(basicSuggestions))
+	for i, basic := range basicSuggestions {
+		enhanced[i] = EnhancedOptimizationSuggestion{
+			Type:        basic.Type,
+			Description: basic.Description,
+			Severity:    basic.Severity,
+			Category:    "GENERAL",
+			Rule:        basic.Type,
+			Line:        basic.Line,
+			Suggestion:  "Review query for optimization opportunities",
+			Impact:      "MEDIUM",
+			AutoFixable: false,
+		}
+	}
+	return enhanced
 }
 
 // SetOptimizationEngine allows setting a custom optimization engine

pkg/analyzer/concurrent.go

@@ -41,19 +41,24 @@ type AnalysisResult struct {
 	Error    error
 }
 
-// AnalyzeConcurrently analyzes multiple queries concurrently
+// AnalyzeConcurrently analyzes multiple queries concurrently.
 func (ca *ConcurrentAnalyzer) AnalyzeConcurrently(ctx context.Context, jobs []AnalysisJob) []AnalysisResult {
 	jobChan := make(chan AnalysisJob, len(jobs))
 	resultChan := make(chan AnalysisResult, len(jobs))
 
-	// Start workers
 	var wg sync.WaitGroup
 	for i := 0; i < ca.workerCount; i++ {
 		wg.Add(1)
 		go ca.worker(ctx, &wg, jobChan, resultChan)
 	}
 
-	// Send jobs
+	// Close resultChan only after all workers are done.
+	go func() {
+		wg.Wait()
+		close(resultChan)
+	}()
+
+	// Send jobs; close jobChan when done so workers can exit.
 	go func() {
 		defer close(jobChan)
 		for _, job := range jobs {
@@ -65,24 +70,20 @@ func (ca *ConcurrentAnalyzer) AnalyzeConcurrently(ctx context.Context, jobs []An
 		}
 	}()
 
-	// Collect results
+	// Collect results until the channel is closed or context is cancelled.
 	results := make([]AnalysisResult, 0, len(jobs))
-	for i := 0; i < len(jobs); i++ {
+	for {
 		select {
-		case result := <-resultChan:
+		case result, ok := <-resultChan:
+			if !ok {
+				return results
+			}
 			results = append(results, result)
 		case <-ctx.Done():
-			results = append(results, AnalysisResult{
-				Error: ctx.Err(),
-			})
+			results = append(results, AnalysisResult{Error: ctx.Err()})
+			return results
 		}
 	}
-
-	// Wait for workers to finish
-	wg.Wait()
-	close(resultChan)
-
-	return results
 }
 
 // worker processes analysis jobs

pkg/dialect/oracle.go

@@ -57,15 +57,16 @@ func (d *OracleDialect) GetDataTypes() []string {
 	return append(CommonDataTypes, oracle...)
 }
 
-func (d *OracleDialect) IsReservedWord(word string) bool {
-	keywords := d.GetKeywords()
-	upper := strings.ToUpper(word)
-	for _, keyword := range keywords {
-		if keyword == upper {
-			return true
-		}
+var oracleReserved = func() map[string]bool {
+	m := make(map[string]bool)
+	for _, k := range (&OracleDialect{}).GetKeywords() {
+		m[k] = true
 	}
-	return false
+	return m
+}()
+
+func (d *OracleDialect) IsReservedWord(word string) bool {
+	return oracleReserved[strings.ToUpper(word)]
 }
 
 func (d *OracleDialect) GetLimitSyntax() LimitSyntax {

pkg/dialect/sqlite.go

@@ -50,15 +50,16 @@ func (d *SQLiteDialect) GetDataTypes() []string {
 	return append(CommonDataTypes, sqlite...)
 }
 
-func (d *SQLiteDialect) IsReservedWord(word string) bool {
-	keywords := d.GetKeywords()
-	upper := strings.ToUpper(word)
-	for _, keyword := range keywords {
-		if keyword == upper {
-			return true
-		}
+var sqliteReserved = func() map[string]bool {
+	m := make(map[string]bool)
+	for _, k := range (&SQLiteDialect{}).GetKeywords() {
+		m[k] = true
 	}
-	return false
+	return m
+}()
+
+func (d *SQLiteDialect) IsReservedWord(word string) bool {
+	return sqliteReserved[strings.ToUpper(word)]
 }
 
 func (d *SQLiteDialect) GetLimitSyntax() LimitSyntax {

pkg/dialect/sqlserver.go

@@ -52,15 +52,16 @@ func (d *SQLServerDialect) GetDataTypes() []string {
 	return append(CommonDataTypes, sqlserver...)
 }
 
-func (d *SQLServerDialect) IsReservedWord(word string) bool {
-	keywords := d.GetKeywords()
-	upper := strings.ToUpper(word)
-	for _, keyword := range keywords {
-		if keyword == upper {
-			return true
-		}
+var sqlserverReserved = func() map[string]bool {
+	m := make(map[string]bool)
+	for _, k := range (&SQLServerDialect{}).GetKeywords() {
+		m[k] = true
 	}
-	return false
+	return m
+}()
+
+func (d *SQLServerDialect) IsReservedWord(word string) bool {
+	return sqlserverReserved[strings.ToUpper(word)]
 }
 
 func (d *SQLServerDialect) GetLimitSyntax() LimitSyntax {

pkg/lexer/lexer.go

@@ -48,20 +48,11 @@ func (l *Lexer) readChar() {
 	}
 }
 
-// lookupIdent checks if an identifier is a keyword using the dialect
+// lookupIdent returns the token type for an identifier, checking common SQL keywords first.
 func (l *Lexer) lookupIdent(ident string) TokenType {
-	// First check common SQL keywords
 	if tok, ok := keywords[ident]; ok {
 		return tok
 	}
-
-	// If not found in common keywords, check if it's a dialect-specific reserved word
-	if l.dialect.IsReservedWord(ident) {
-		// For dialect-specific keywords, we'll treat them as identifiers for now
-		// but could extend this to have dialect-specific token types
-		return IDENT
-	}
-
 	return IDENT
 }
 
@@ -150,10 +141,10 @@ func (l *Lexer) NextToken() Token {
 		// Double quotes can be string literals or identifiers depending on dialect
 		if l.dialect.Name() == "PostgreSQL" || l.dialect.Name() == "SQLite" || l.dialect.Name() == "Oracle" {
 			tok.Type = IDENT
-			tok.Literal = l.readDoubleQuotedIdentifier()
+			tok.Literal = l.readDoubleQuoted()
 		} else {
 			tok.Type = STRING
-			tok.Literal = l.readDoubleQuotedString()
+			tok.Literal = l.readDoubleQuoted()
 		}
 		tok.Position = l.position
 		tok.Line = l.line
@@ -289,18 +280,7 @@ func (l *Lexer) readString() string {
 	return result
 }
 
-func (l *Lexer) readDoubleQuotedString() string {
-	position := l.position + 1
-	for {
-		l.readChar()
-		if l.ch == '"' || l.ch == 0 {
-			break
-		}
-	}
-	return l.input[position:l.position]
-}
-
-func (l *Lexer) readDoubleQuotedIdentifier() string {
+func (l *Lexer) readDoubleQuoted() string {
 	position := l.position + 1
 	for {
 		l.readChar()

pkg/logger/formats.go

@@ -2,6 +2,7 @@ package logger
 
 import "strings"
 
+
 // Supported log formats for SQL Server
 type LogFormat int
 
@@ -69,12 +70,8 @@ func (d *LogFormatDetector) DetectFormat(sample string) LogFormat {
 
 func containsAny(text string, patterns []string) bool {
 	for _, pattern := range patterns {
-		if len(text) >= len(pattern) {
-			for i := 0; i <= len(text)-len(pattern); i++ {
-				if text[i:i+len(pattern)] == pattern {
-					return true
-				}
-			}
+		if strings.Contains(text, pattern) {
+			return true
 		}
 	}
 	return false