refactor: split parser.go into logical modules (Issue #78) (#120)

Split the monolithic parser.go (2523 lines) into focused modules:

New files created:
- expressions.go (583 lines): Expression parsing logic
  - parseExpression, parseAndExpression, parseComparisonExpression
  - parsePrimaryExpression, parseCaseExpression, parseSubquery

- window.go (285 lines): Window function support
  - parseFunctionCall, parseWindowSpec
  - parseWindowFrame, parseFrameBound, parseNullsClause

- grouping.go (156 lines): SQL-99 grouping operations
  - parseGroupingExpressionList, parseRollup
  - parseCube, parseGroupingSets

- select.go (524 lines): SELECT statement parsing
  - parseSelectStatement, parseSelectWithSetOperations
  - parseColumnDef, parseTableConstraint

- dml.go (512 lines): DML operations
  - parseInsertStatement, parseUpdateStatement
  - parseDeleteStatement, parseMergeStatement
  - parseMergeWhenClause, parseMergeAction

- cte.go (175 lines): Common Table Expressions
  - parseWithStatement, parseCommonTableExpr
  - parseMainStatementAfterWith

Reduced parser.go to 356 lines (core):
- Parser struct and Parse/ParseContext methods
- Basic utilities: advance, peekToken, matchToken
- parseStatement switch
- Helper functions for identifiers and table references

Benefits:
- Each file < 600 lines (was 2523)
- Logical grouping of related functions
- Easier navigation and maintenance
- No breaking changes - all tests pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Ajit Pratap Singh <ajitpratapsingh@Ajits-Mac-mini.local>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

pkg/sql/parser/cte.go

@@ -0,0 +1,175 @@
+// Package parser - cte.go
+// Common Table Expression (CTE) parsing with recursive CTE support.
+
+package parser
+
+import (
+	"fmt"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+)
+
+// WITH summary(region, total) AS (SELECT region, SUM(amount) FROM sales GROUP BY region) SELECT * FROM summary
+func (p *Parser) parseWithStatement() (ast.Statement, error) {
+	// Consume WITH
+	p.advance()
+
+	// Check for RECURSIVE keyword
+	recursive := false
+	if p.currentToken.Type == "RECURSIVE" {
+		recursive = true
+		p.advance()
+	}
+
+	// Parse Common Table Expressions
+	ctes := []*ast.CommonTableExpr{}
+
+	for {
+		cte, err := p.parseCommonTableExpr()
+		if err != nil {
+			return nil, fmt.Errorf("error parsing CTE: %v", err)
+		}
+		ctes = append(ctes, cte)
+
+		// Check for more CTEs (comma-separated)
+		if p.currentToken.Type == "," {
+			p.advance() // Consume comma
+			continue
+		}
+		break
+	}
+
+	// Create WITH clause
+	withClause := &ast.WithClause{
+		Recursive: recursive,
+		CTEs:      ctes,
+	}
+
+	// Parse the main statement that follows the WITH clause
+	mainStmt, err := p.parseMainStatementAfterWith()
+	if err != nil {
+		return nil, fmt.Errorf("error parsing statement after WITH: %v", err)
+	}
+
+	// Attach WITH clause to the main statement
+	switch stmt := mainStmt.(type) {
+	case *ast.SelectStatement:
+		stmt.With = withClause
+		return stmt, nil
+	case *ast.SetOperation:
+		// For set operations, attach WITH to the left statement if it's a SELECT
+		if leftSelect, ok := stmt.Left.(*ast.SelectStatement); ok {
+			leftSelect.With = withClause
+		}
+		return stmt, nil
+	case *ast.InsertStatement:
+		stmt.With = withClause
+		return stmt, nil
+	case *ast.UpdateStatement:
+		stmt.With = withClause
+		return stmt, nil
+	case *ast.DeleteStatement:
+		stmt.With = withClause
+		return stmt, nil
+	default:
+		return nil, fmt.Errorf("WITH clause not supported with statement type: %T", stmt)
+	}
+}
+
+// parseCommonTableExpr parses a single Common Table Expression.
+// It handles CTE name, optional column list, AS keyword, and the CTE query in parentheses.
+//
+// Syntax: cte_name [(column_list)] AS (query)
+func (p *Parser) parseCommonTableExpr() (*ast.CommonTableExpr, error) {
+	// Check recursion depth to prevent stack overflow in recursive CTEs
+	// This is critical since CTEs can call parseStatement which leads back to more CTEs
+	p.depth++
+	defer func() { p.depth-- }()
+
+	if p.depth > MaxRecursionDepth {
+		return nil, fmt.Errorf("maximum recursion depth exceeded (%d) - CTE too deeply nested", MaxRecursionDepth)
+	}
+
+	// Parse CTE name
+	if p.currentToken.Type != "IDENT" {
+		return nil, p.expectedError("CTE name")
+	}
+	name := p.currentToken.Literal
+	p.advance()
+
+	// Parse optional column list
+	var columns []string
+	if p.currentToken.Type == "(" {
+		p.advance() // Consume (
+
+		for {
+			if p.currentToken.Type != "IDENT" {
+				return nil, p.expectedError("column name")
+			}
+			columns = append(columns, p.currentToken.Literal)
+			p.advance()
+
+			if p.currentToken.Type == "," {
+				p.advance() // Consume comma
+				continue
+			}
+			break
+		}
+
+		if p.currentToken.Type != ")" {
+			return nil, p.expectedError(")")
+		}
+		p.advance() // Consume )
+	}
+
+	// Parse AS keyword
+	if p.currentToken.Type != "AS" {
+		return nil, p.expectedError("AS")
+	}
+	p.advance()
+
+	// Parse the CTE query (must be in parentheses)
+	if p.currentToken.Type != "(" {
+		return nil, p.expectedError("( before CTE query")
+	}
+	p.advance() // Consume (
+
+	// Parse the inner statement
+	stmt, err := p.parseStatement()
+	if err != nil {
+		return nil, fmt.Errorf("error parsing CTE statement: %v", err)
+	}
+
+	if p.currentToken.Type != ")" {
+		return nil, p.expectedError(") after CTE query")
+	}
+	p.advance() // Consume )
+
+	return &ast.CommonTableExpr{
+		Name:      name,
+		Columns:   columns,
+		Statement: stmt,
+	}, nil
+}
+
+// parseMainStatementAfterWith parses the main statement after WITH clause.
+// It supports SELECT, INSERT, UPDATE, and DELETE statements, routing them to the appropriate
+// parsers while preserving set operation support for SELECT statements.
+func (p *Parser) parseMainStatementAfterWith() (ast.Statement, error) {
+	switch p.currentToken.Type {
+	case "SELECT":
+		p.advance() // Consume SELECT
+		return p.parseSelectWithSetOperations()
+	case "INSERT":
+		p.advance() // Consume INSERT
+		return p.parseInsertStatement()
+	case "UPDATE":
+		p.advance() // Consume UPDATE
+		return p.parseUpdateStatement()
+	case "DELETE":
+		p.advance() // Consume DELETE
+		return p.parseDeleteStatement()
+	default:
+		return nil, p.expectedError("SELECT, INSERT, UPDATE, or DELETE after WITH")
+	}
+}