feat(#249): Dialect mode engine (Phase 1) - core plumbing

- Add Dialect field and SetDialect/NewWithDialect to Tokenizer
- Add WithDialect ParserOption and Dialect() getter to Parser
- Add ParseWithDialect/ValidateWithDialect convenience functions
- Wire --dialect flag through CLI validator to tokenizer and parser
- Add comprehensive dialect tests (flow, MySQL/PostgreSQL keywords, defaults)
- Backward compatible: default behavior unchanged (PostgreSQL dialect)

Author: Ajit Pratap Singh

cmd/gosqlx/cmd/validate.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ajitpratap0/GoSQLX/cmd/gosqlx/internal/config"
 	"github.com/ajitpratap0/GoSQLX/cmd/gosqlx/internal/output"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/parser"
 )
 
@@ -269,7 +270,12 @@ func validateFromStdin(cmd *cobra.Command) error {
 // validateInlineSQL validates inline SQL passed as a command argument.
 // Uses the fast-path Validate() which skips full AST construction (#274).
 func validateInlineSQL(cmd *cobra.Command, sql string) error {
-	err := parser.Validate(sql)
+	var err error
+	if validateDialect != "" {
+		err = parser.ValidateWithDialect(sql, keywords.SQLDialect(validateDialect))
+	} else {
+		err = parser.Validate(sql)
+	}
 	if err != nil {
 		if !validateQuiet {
 			fmt.Fprintf(cmd.ErrOrStderr(), "✗ Invalid SQL: %v\n", err)

cmd/gosqlx/cmd/validator.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ajitpratap0/GoSQLX/cmd/gosqlx/internal/config"
 	"github.com/ajitpratap0/GoSQLX/cmd/gosqlx/internal/output"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/parser"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/tokenizer"
 )
@@ -235,10 +236,15 @@ func (v *Validator) validateFile(filename string) output.FileValidationResult {
 		return result // Empty inputs are considered valid
 	}
 
-	// Use pooled tokenizer for performance
+	// Use pooled tokenizer for performance with dialect support
 	tkz := tokenizer.GetTokenizer()
 	defer tokenizer.PutTokenizer(tkz)
 
+	// Configure dialect if specified
+	if v.Opts.Dialect != "" {
+		tkz.SetDialect(keywords.SQLDialect(v.Opts.Dialect))
+	}
+
 	// Tokenize
 	tokens, err := tkz.Tokenize(data)
 	if err != nil {
@@ -254,7 +260,7 @@ func (v *Validator) validateFile(filename string) output.FileValidationResult {
 	// Convert TokenWithSpan to Token using centralized converter
 
 	// Parse to validate syntax with proper error handling for memory management
-	p := parser.NewParser()
+	p := parser.NewParser(parser.WithDialect(v.Opts.Dialect))
 	astObj, err := p.ParseFromModelTokens(tokens)
 	if err != nil {
 		result.Error = fmt.Errorf("parsing failed: %w", err)

pkg/sql/parser/dialect_test.go

@@ -0,0 +1,131 @@
+package parser
+
+import (
+	"testing"
+
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/tokenizer"
+)
+
+func TestParserWithDialectOption(t *testing.T) {
+	p := NewParser(WithDialect("mysql"))
+	if p.Dialect() != "mysql" {
+		t.Errorf("expected mysql, got %s", p.Dialect())
+	}
+
+	p2 := NewParser()
+	if p2.Dialect() != "postgresql" {
+		t.Errorf("expected postgresql default, got %s", p2.Dialect())
+	}
+}
+
+func TestTokenizerWithDialect(t *testing.T) {
+	tkz, err := tokenizer.NewWithDialect(keywords.DialectMySQL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tkz.Dialect() != keywords.DialectMySQL {
+		t.Errorf("expected mysql, got %s", tkz.Dialect())
+	}
+}
+
+func TestTokenizerSetDialect(t *testing.T) {
+	tkz := tokenizer.GetTokenizer()
+	defer tokenizer.PutTokenizer(tkz)
+
+	tkz.SetDialect(keywords.DialectMySQL)
+	if tkz.Dialect() != keywords.DialectMySQL {
+		t.Errorf("expected mysql, got %s", tkz.Dialect())
+	}
+}
+
+func TestTokenizerDefaultDialect(t *testing.T) {
+	tkz, err := tokenizer.NewWithDialect("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tkz.Dialect() != keywords.DialectPostgreSQL {
+		t.Errorf("expected postgresql default, got %s", tkz.Dialect())
+	}
+}
+
+func TestParseWithDialect(t *testing.T) {
+	// Basic SQL should parse with any dialect
+	for _, dialect := range []keywords.SQLDialect{
+		keywords.DialectPostgreSQL,
+		keywords.DialectMySQL,
+		keywords.DialectSQLServer,
+	} {
+		t.Run(string(dialect), func(t *testing.T) {
+			ast, err := ParseWithDialect("SELECT 1", dialect)
+			if err != nil {
+				t.Fatalf("ParseWithDialect(%s) failed: %v", dialect, err)
+			}
+			if ast == nil {
+				t.Fatal("expected non-nil AST")
+			}
+		})
+	}
+}
+
+func TestValidateWithDialect(t *testing.T) {
+	err := ValidateWithDialect("SELECT * FROM users WHERE id = 1", keywords.DialectMySQL)
+	if err != nil {
+		t.Fatalf("ValidateWithDialect(mysql) failed: %v", err)
+	}
+
+	err = ValidateWithDialect("SELECT * FROM users WHERE id = 1", keywords.DialectPostgreSQL)
+	if err != nil {
+		t.Fatalf("ValidateWithDialect(postgresql) failed: %v", err)
+	}
+}
+
+func TestDefaultBehaviorUnchanged(t *testing.T) {
+	// Validate() without dialect should still work (backward compatibility)
+	err := Validate("SELECT * FROM users")
+	if err != nil {
+		t.Fatalf("Validate() failed: %v", err)
+	}
+
+	ast, err := ParseBytes([]byte("SELECT 1"))
+	if err != nil {
+		t.Fatalf("ParseBytes() failed: %v", err)
+	}
+	if ast == nil {
+		t.Fatal("expected non-nil AST")
+	}
+}
+
+func TestMySQLKeywordsRecognized(t *testing.T) {
+	// UNSIGNED is a MySQL-specific keyword; tokenizer should recognize it
+	tkz, err := tokenizer.NewWithDialect(keywords.DialectMySQL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tokens, err := tkz.Tokenize([]byte("SELECT UNSIGNED"))
+	if err != nil {
+		t.Fatalf("tokenize failed: %v", err)
+	}
+
+	// Should have at least 2 tokens (SELECT, UNSIGNED)
+	if len(tokens) < 2 {
+		t.Fatalf("expected at least 2 tokens, got %d", len(tokens))
+	}
+}
+
+func TestPostgreSQLKeywordsRecognized(t *testing.T) {
+	tkz, err := tokenizer.NewWithDialect(keywords.DialectPostgreSQL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tokens, err := tkz.Tokenize([]byte("SELECT ILIKE"))
+	if err != nil {
+		t.Fatalf("tokenize failed: %v", err)
+	}
+
+	if len(tokens) < 2 {
+		t.Fatalf("expected at least 2 tokens, got %d", len(tokens))
+	}
+}

pkg/sql/parser/parser.go

@@ -208,6 +208,24 @@ func WithStrictMode() ParserOption {
 	}
 }
 
+// WithDialect sets the SQL dialect for dialect-aware parsing.
+// Supported values: "postgresql", "mysql", "sqlserver", "oracle", "sqlite", etc.
+// If not set, defaults to "postgresql" for backward compatibility.
+func WithDialect(dialect string) ParserOption {
+	return func(p *Parser) {
+		p.dialect = dialect
+	}
+}
+
+// Dialect returns the SQL dialect configured for this parser.
+// Returns "postgresql" if no dialect was explicitly set.
+func (p *Parser) Dialect() string {
+	if p.dialect == "" {
+		return "postgresql"
+	}
+	return p.dialect
+}
+
 type Parser struct {
 	tokens       []token.Token
 	currentPos   int
@@ -216,6 +234,7 @@ type Parser struct {
 	ctx          context.Context // Optional context for cancellation support
 	positions    []TokenPosition // Position mapping for error reporting
 	strict       bool            // Strict mode rejects empty statements
+	dialect      string          // SQL dialect for dialect-aware parsing (default: "postgresql")
 }
 
 // Parse parses a token stream into an Abstract Syntax Tree (AST).

pkg/sql/parser/validate.go

@@ -8,6 +8,7 @@ import (
 	goerrors "github.com/ajitpratap0/GoSQLX/pkg/errors"
 	"github.com/ajitpratap0/GoSQLX/pkg/models"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
+	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/token"
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/tokenizer"
 )
@@ -119,3 +120,72 @@ func ParseBytesWithTokens(input []byte) (*ast.AST, []token.Token, error) {
 
 	return astResult, converted, nil
 }
+
+// ValidateWithDialect checks whether the given SQL string is syntactically valid
+// using the specified SQL dialect for keyword recognition.
+func ValidateWithDialect(sql string, dialect keywords.SQLDialect) error {
+	return ValidateBytesWithDialect([]byte(sql), dialect)
+}
+
+// ValidateBytesWithDialect is like ValidateWithDialect but accepts []byte.
+func ValidateBytesWithDialect(input []byte, dialect keywords.SQLDialect) error {
+	if len(trimBytes(input)) == 0 {
+		return nil
+	}
+
+	tkz, err := tokenizer.NewWithDialect(dialect)
+	if err != nil {
+		return fmt.Errorf("tokenizer initialization: %w", err)
+	}
+
+	tokens, err := tkz.Tokenize(input)
+	if err != nil {
+		return fmt.Errorf("tokenization error: %w", err)
+	}
+
+	if len(tokens) == 0 {
+		return nil
+	}
+
+	p := NewParser(WithDialect(string(dialect)))
+	defer p.Release()
+
+	converted, convErr := convertModelTokens(tokens)
+	if convErr != nil {
+		return fmt.Errorf("token conversion failed: %w", convErr)
+	}
+
+	astResult, parseErr := p.Parse(converted)
+	if parseErr != nil {
+		return parseErr
+	}
+	ast.ReleaseAST(astResult)
+	return nil
+}
+
+// ParseWithDialect parses SQL using the specified dialect for keyword recognition.
+// This is a convenience function combining dialect-aware tokenization and parsing.
+func ParseWithDialect(sql string, dialect keywords.SQLDialect) (*ast.AST, error) {
+	return ParseBytesWithDialect([]byte(sql), dialect)
+}
+
+// ParseBytesWithDialect is like ParseWithDialect but accepts []byte.
+func ParseBytesWithDialect(input []byte, dialect keywords.SQLDialect) (*ast.AST, error) {
+	tkz, err := tokenizer.NewWithDialect(dialect)
+	if err != nil {
+		return nil, fmt.Errorf("tokenizer initialization: %w", err)
+	}
+
+	tokens, err := tkz.Tokenize(input)
+	if err != nil {
+		return nil, fmt.Errorf("tokenization error: %w", err)
+	}
+
+	if len(tokens) == 0 {
+		return nil, goerrors.IncompleteStatementError(models.Location{}, "")
+	}
+
+	p := NewParser(WithDialect(string(dialect)))
+
+	return p.ParseFromModelTokens(tokens)
+}

pkg/sql/tokenizer/tokenizer.go

@@ -244,6 +244,7 @@ type Tokenizer struct {
 	lineStarts []int              // Byte offsets of line starts (for position tracking)
 	line       int                // Current line number (1-based)
 	keywords   *keywords.Keywords // Keyword classifier for token type determination
+	dialect    keywords.SQLDialect // SQL dialect for dialect-specific keyword recognition
 	logger     *slog.Logger       // Optional structured logger for verbose tracing
 	Comments   []models.Comment   // Comments captured during tokenization
 }
@@ -267,11 +268,43 @@ func New() (*Tokenizer, error) {
 	kw := keywords.NewKeywords()
 	return &Tokenizer{
 		keywords:   kw,
+		dialect:    keywords.DialectPostgreSQL,
 		pos:        NewPosition(1, 0),
 		lineStarts: []int{0},
 	}, nil
 }
 
+// NewWithDialect creates a new Tokenizer configured for the given SQL dialect.
+// Dialect-specific keywords are recognized based on the dialect parameter.
+// If dialect is empty or unknown, defaults to DialectPostgreSQL.
+func NewWithDialect(dialect keywords.SQLDialect) (*Tokenizer, error) {
+	if dialect == "" || dialect == keywords.DialectUnknown {
+		dialect = keywords.DialectPostgreSQL
+	}
+	kw := keywords.New(dialect, true)
+	return &Tokenizer{
+		keywords:   kw,
+		dialect:    dialect,
+		pos:        NewPosition(1, 0),
+		lineStarts: []int{0},
+	}, nil
+}
+
+// Dialect returns the SQL dialect configured for this tokenizer.
+func (t *Tokenizer) Dialect() keywords.SQLDialect {
+	return t.dialect
+}
+
+// SetDialect reconfigures the tokenizer for a different SQL dialect.
+// This rebuilds the keyword set to include dialect-specific keywords.
+func (t *Tokenizer) SetDialect(dialect keywords.SQLDialect) {
+	if dialect == "" || dialect == keywords.DialectUnknown {
+		dialect = keywords.DialectPostgreSQL
+	}
+	t.dialect = dialect
+	t.keywords = keywords.New(dialect, true)
+}
+
 // NewWithKeywords initializes a Tokenizer with a custom keyword classifier.
 // This allows you to customize keyword recognition for specific SQL dialects
 // or to add custom keywords.