gosqlx

func ErrorCode ¶ added in v1.15.0

func ErrorCode(err error) errors.ErrorCode

ErrorCode extracts the structured error code from an error returned by Parse, Validate, or other gosqlx functions. It unwraps through fmt.Errorf wrapping to find the underlying *errors.Error.

Returns the ErrorCode (e.g., "E2001") if found, or empty string if the error is not a structured GoSQLX error.

Example:

_, err := gosqlx.Parse("SELECT * FORM users")
code := gosqlx.ErrorCode(err)
if code == errors.ErrCodeExpectedToken {
    // handle expected-token error
}

func ErrorHint ¶ added in v1.15.0

func ErrorHint(err error) string

ErrorHint extracts the hint/suggestion from an error returned by Parse, Validate, or other gosqlx functions.

Returns the hint string if found, or empty string if the error is not a structured GoSQLX error or has no hint.

Example:

_, err := gosqlx.Parse("SELECT * FORM users")
if hint := gosqlx.ErrorHint(err); hint != "" {
    fmt.Printf("Hint: %s\n", hint)
}

func ErrorLocation ¶ added in v1.15.0

func ErrorLocation(err error) *models.Location

ErrorLocation extracts the source location (line/column) from an error returned by Parse, Validate, or other gosqlx functions. It unwraps through fmt.Errorf wrapping to find the underlying *errors.Error.

Returns a pointer to the Location if found, or nil if the error is not a structured GoSQLX error.

Example:

_, err := gosqlx.Parse("SELECT * FORM users")
if loc := gosqlx.ErrorLocation(err); loc != nil {
    fmt.Printf("Error at line %d, column %d\n", loc.Line, loc.Column)
}

func ExtractColumns ¶ added in v1.6.0

func ExtractColumns(astNode *ast.AST) []string

ExtractColumns extracts all column references from an AST.

This function traverses the AST and collects column references from:

• SELECT lists
• WHERE conditions
• GROUP BY clauses
• ORDER BY clauses
• JOIN conditions
• HAVING clauses

Returns a deduplicated slice of column names (without table qualifiers).

Example:

sql := "SELECT u.name, u.email FROM users u WHERE u.active = true ORDER BY u.created_at"
ast, _ := gosqlx.Parse(sql)
columns := gosqlx.ExtractColumns(ast)
// columns = ["name", "email", "active", "created_at"]

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT u.name, u.email FROM users u WHERE u.active = true ORDER BY u.created_at"

	ast, err := gosqlx.Parse(sql)
	if err != nil {
		log.Fatal(err)
	}

	columns := gosqlx.ExtractColumns(ast)
	fmt.Printf("Found %d columns\n", len(columns))
}

Output:
Found 4 columns

func ExtractFunctions ¶ added in v1.6.0

func ExtractFunctions(astNode *ast.AST) []string

ExtractFunctions extracts all function calls from an AST.

This function traverses the AST and collects all function names, including:

• Aggregate functions (COUNT, SUM, AVG, etc.)
• Window functions (ROW_NUMBER, RANK, etc.)
• Scalar functions (UPPER, LOWER, NOW, etc.)

Returns a deduplicated slice of function names.

Example:

sql := "SELECT COUNT(*), UPPER(name) FROM users"
ast, _ := gosqlx.Parse(sql)
functions := gosqlx.ExtractFunctions(ast)
// functions = ["COUNT", "UPPER"]

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT COUNT(*), AVG(salary), UPPER(name) FROM employees"

	ast, err := gosqlx.Parse(sql)
	if err != nil {
		log.Fatal(err)
	}

	functions := gosqlx.ExtractFunctions(ast)
	fmt.Printf("Found %d functions\n", len(functions))
}

Output:
Found 3 functions

func ExtractTables ¶ added in v1.6.0

func ExtractTables(astNode *ast.AST) []string

ExtractTables extracts all table names from an AST.

This function traverses the AST and collects all table references from:

• FROM clauses
• JOIN clauses
• Subqueries and CTEs
• INSERT/UPDATE/DELETE statements

Returns a deduplicated slice of table names.

Example:

sql := "SELECT * FROM users u JOIN orders o ON u.id = o.user_id"
ast, _ := gosqlx.Parse(sql)
tables := gosqlx.ExtractTables(ast)
// tables = ["users", "orders"]

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT * FROM users u JOIN orders o ON u.id = o.user_id"

	ast, err := gosqlx.Parse(sql)
	if err != nil {
		log.Fatal(err)
	}

	tables := gosqlx.ExtractTables(ast)
	fmt.Printf("Found %d tables\n", len(tables))
}

Output:
Found 2 tables

func Fingerprint ¶ added in v1.14.0

func Fingerprint(sql string) (string, error)

Fingerprint returns a stable 64-character SHA-256 hex digest for the given SQL. Structurally identical queries with different literal values produce the same fingerprint, making this suitable for query deduplication, caching, and slow-query grouping.

Example:

fp1, _ := gosqlx.Fingerprint("SELECT * FROM users WHERE id = 1")
fp2, _ := gosqlx.Fingerprint("SELECT * FROM users WHERE id = 999")
// fp1 == fp2

func Format ¶

func Format(sql string, options FormatOptions) (string, error)

Format parses SQL into an AST and renders it back to text using the AST-based formatting engine. The result is syntactically valid, consistently styled SQL controlled by the provided FormatOptions.

Example:

sql := "select * from users where active=true"
opts := gosqlx.DefaultFormatOptions()
opts.UppercaseKeywords = true
formatted, err := gosqlx.Format(sql, opts)

Returns the formatted SQL string or an error if SQL is invalid.

sql := "SELECT * FROM users WHERE active = true"
opts := DefaultFormatOptions()
opts.AddSemicolon = true

formatted, err := Format(sql, opts)
if err != nil {
	panic(err)
}

_ = formatted

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT * FROM users WHERE active = true"

	opts := gosqlx.DefaultFormatOptions()
	opts.AddSemicolon = true

	formatted, err := gosqlx.Format(sql, opts)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Formatted SQL ends with semicolon: %v\n", formatted[len(formatted)-1] == ';')
}

Output:
Formatted SQL ends with semicolon: true

func FormatAST ¶ added in v1.15.0

func FormatAST(a *ast.AST, opts ...FormatOption) string

FormatAST renders a raw *ast.AST back to SQL text. This is the escape-hatch equivalent of FormatTree for callers that hold the underlying AST directly (e.g., from the low-level parser API). Internally it delegates to pkg/formatter.FormatAST — it does not re-parse.

func FormatTree ¶ added in v1.15.0

func FormatTree(t *Tree, opts ...FormatOption) string

FormatTree renders a Tree back to SQL text using the AST-based formatter. It does not re-tokenize or re-parse; if you already have a Tree, prefer this over the top-level Format(sql, opts) function.

func LoadSchema ¶ added in v1.14.0

func LoadSchema(db *sql.DB, loader dbschema.Loader, schemaName string) (*dbschema.DatabaseSchema, error)

LoadSchema connects to a live database and returns its schema metadata. Pass a dialect-specific loader from pkg/schema/postgres, pkg/schema/mysql, or pkg/schema/sqlite. schemaName may be empty to use the database default.

Example - SQLite:

import (
    _ "modernc.org/sqlite"
    "github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
    sqschema "github.com/ajitpratap0/GoSQLX/pkg/schema/sqlite"
)

db, _ := sql.Open("sqlite", ":memory:")
loader := sqschema.NewLoader()
s, err := gosqlx.LoadSchema(db, loader, "main")

Example - PostgreSQL:

import (
    _ "github.com/lib/pq"
    pgschema "github.com/ajitpratap0/GoSQLX/pkg/schema/postgres"
)

db, _ := sql.Open("postgres", "host=localhost user=app dbname=mydb sslmode=disable")
loader := pgschema.NewLoader()
s, err := gosqlx.LoadSchema(db, loader, "public")

func MustParse ¶

func MustParse(sql string) *ast.AST

MustParse is like Parse but panics on error.

This is useful for parsing SQL literals at startup or in tests where parse errors indicate a programming bug.

Example:

// In test or init()
ast := gosqlx.MustParse("SELECT 1")

package main

import (
	"fmt"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	// Use MustParse only with SQL literals you control
	ast := gosqlx.MustParse("SELECT 1")

	fmt.Printf("Type: %T\n", ast)
}

Output:
Type: *ast.AST

func Normalize ¶ added in v1.14.0

func Normalize(sql string) (string, error)

Normalize parses sql, replaces all literal values (strings, numbers, booleans, NULLs) with "?" placeholders, and returns the re-formatted SQL.

Two queries that differ only in literal values (e.g., WHERE id = 1 vs WHERE id = 42) produce identical output. Existing parameter placeholders ($1, ?, :name) are preserved.

Returns an error if the SQL cannot be parsed.

Example:

norm, err := gosqlx.Normalize("SELECT * FROM users WHERE id = 42")
// norm == "SELECT * FROM users WHERE id = ?"

func Parse ¶

func Parse(sql string) (*ast.AST, error)

Parse tokenizes and parses SQL in one call, returning an Abstract Syntax Tree (AST).

This function handles all object pool management internally, making it ideal for simple use cases. The parser supports comprehensive SQL features including:

SQL Standards (v1.6.0):

• DML: SELECT, INSERT, UPDATE, DELETE with complex expressions
• DDL: CREATE TABLE/VIEW/INDEX, ALTER TABLE, DROP statements
• Window Functions: ROW_NUMBER, RANK, DENSE_RANK, NTILE, LAG, LEAD, etc.
• CTEs: WITH clause including RECURSIVE support
• Set Operations: UNION, EXCEPT, INTERSECT with proper precedence
• JOIN Types: INNER, LEFT, RIGHT, FULL OUTER, CROSS, NATURAL
• MERGE: WHEN MATCHED/NOT MATCHED clauses (SQL:2003)
• Grouping: GROUPING SETS, ROLLUP, CUBE (SQL-99 T431)
• FETCH: FETCH FIRST/NEXT with ROWS ONLY, WITH TIES, PERCENT
• TRUNCATE: TRUNCATE TABLE with CASCADE/RESTRICT options
• Materialized Views: CREATE/DROP/REFRESH MATERIALIZED VIEW

PostgreSQL Extensions (v1.6.0):

• LATERAL JOIN: Correlated subqueries in FROM clause
• JSON/JSONB Operators: ->, ->>, #>, #>>, @>, <@, ?, ?|, ?&, #-
• DISTINCT ON: PostgreSQL-specific row selection
• FILTER Clause: Conditional aggregation (SQL:2003 T612)
• RETURNING Clause: Return modified rows from INSERT/UPDATE/DELETE
• Aggregate ORDER BY: ORDER BY inside aggregate functions

Performance: This function achieves 1.38M+ operations/second sustained throughput with <1μs latency through intelligent object pooling.

Thread Safety: This function is thread-safe and can be called concurrently from multiple goroutines. Object pools are managed safely with sync.Pool.

Error Handling: Returns structured errors with error codes (E1xxx for tokenization, E2xxx for parsing, E3xxx for semantic errors). Errors include precise line/column information and helpful suggestions.

Example - Basic parsing:

sql := "SELECT * FROM users WHERE active = true"
ast, err := gosqlx.Parse(sql)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Parsed: %T\n", ast)

Example - PostgreSQL JSON operators:

sql := "SELECT data->>'name' FROM users WHERE data @> '{\"status\":\"active\"}'"
ast, err := gosqlx.Parse(sql)

Example - Window functions:

sql := `SELECT name, salary,
    RANK() OVER (PARTITION BY dept ORDER BY salary DESC) as rank
    FROM employees`
ast, err := gosqlx.Parse(sql)

Example - LATERAL JOIN:

sql := `SELECT u.name, o.order_date FROM users u,
    LATERAL (SELECT * FROM orders WHERE user_id = u.id LIMIT 3) o`
ast, err := gosqlx.Parse(sql)

For batch processing or performance-critical code, use the lower-level tokenizer and parser APIs directly to reuse objects across multiple queries.

See also: ParseWithContext, ParseWithTimeout, ParseMultiple for specialized use cases.

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT * FROM users WHERE active = true"
	ast, err := gosqlx.Parse(sql)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Parsed %d statement(s)\n", len(ast.Statements))
}

Output:
Parsed 1 statement(s)

sql := "SELECT * FROM users WHERE active = true"

ast, err := Parse(sql)
if err != nil {
	panic(err)
}

// Use the AST
_ = ast

func ParseBytes ¶

func ParseBytes(sql []byte) (*ast.AST, error)

ParseBytes is like Parse but accepts a byte slice.

This avoids the string-to-byte conversion that Parse performs internally, making it more efficient when you already have SQL as bytes (e.g., from file I/O or network reads).

Example:

sqlBytes := []byte("SELECT * FROM users")
astNode, err := gosqlx.ParseBytes(sqlBytes)

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sqlBytes := []byte("SELECT * FROM users")

	ast, err := gosqlx.ParseBytes(sqlBytes)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Parsed from bytes: %d statement(s)\n", len(ast.Statements))
}

Output:
Parsed from bytes: 1 statement(s)

func ParseMultiple ¶

func ParseMultiple(queries []string) ([]*ast.AST, error)

ParseMultiple parses multiple SQL statements efficiently by reusing pooled objects.

This function is significantly more efficient than calling Parse() repeatedly because it obtains tokenizer and parser objects from the pool once and reuses them for all queries. This provides:

• 30-40% performance improvement for batch operations
• Reduced pool contention from fewer get/put operations
• Lower memory allocation overhead
• Better CPU cache locality

Thread Safety: This function is thread-safe. However, if processing queries concurrently, use Parse() in parallel goroutines instead for better throughput.

Performance: For N queries, this function has approximately O(N) performance with the overhead of object pool operations amortized across all queries. Benchmarks show:

• 10 queries: ~40% faster than 10x Parse() calls
• 100 queries: ~45% faster than 100x Parse() calls
• 1000 queries: ~50% faster than 1000x Parse() calls

Error Handling: Returns an error for the first query that fails to parse. The error includes the query index (0-based) to identify which query failed. Already-parsed ASTs are not returned on error.

Memory Management: All pooled objects are properly returned to pools via defer, even if an error occurs during parsing.

Example - Batch parsing:

queries := []string{
    "SELECT * FROM users",
    "SELECT * FROM orders",
    "INSERT INTO logs (message) VALUES ('test')",
}
asts, err := gosqlx.ParseMultiple(queries)
if err != nil {
    log.Fatalf("Batch parsing failed: %v", err)
}
fmt.Printf("Parsed %d queries\n", len(asts))

Example - Processing migration scripts:

migrationSQL := []string{
    "CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(100))",
    "CREATE INDEX idx_users_name ON users(name)",
    "INSERT INTO users VALUES (1, 'admin')",
}
asts, err := gosqlx.ParseMultiple(migrationSQL)

Example - Analyzing query logs:

queryLog := loadQueryLog() // []string of SQL queries
asts, err := gosqlx.ParseMultiple(queryLog)
for i, ast := range asts {
    tables := gosqlx.ExtractTables(ast)
    fmt.Printf("Query %d uses tables: %v\n", i, tables)
}

For concurrent processing of independent queries, use Parse() in parallel:

var wg sync.WaitGroup
for _, sql := range queries {
    wg.Add(1)
    go func(s string) {
        defer wg.Done()
        ast, _ := gosqlx.Parse(s)
        // Process ast
    }(sql)
}
wg.Wait()

See also: ValidateMultiple for validation-only batch processing.

package main

import (
	"fmt"
	"log"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	queries := []string{
		"SELECT * FROM users",
		"SELECT * FROM orders",
		"SELECT * FROM products",
	}

	asts, err := gosqlx.ParseMultiple(queries)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Parsed %d queries\n", len(asts))
}

Output:
Parsed 3 queries

queries := []string{
	"SELECT * FROM users",
	"SELECT * FROM orders",
}

asts, err := ParseMultiple(queries)
if err != nil {
	panic(err)
}

for i, ast := range asts {
	_ = i
	_ = ast
}

func ParseWithContext ¶

func ParseWithContext(ctx context.Context, sql string) (*ast.AST, error)

ParseWithContext tokenizes and parses SQL with context support for cancellation and timeouts.

This function handles all object pool management internally and supports cancellation via the provided context. It's ideal for long-running operations, web servers, or any application that needs to gracefully handle timeouts and cancellation.

The function checks the context before starting and periodically during parsing to ensure responsive cancellation. This makes it suitable for user-facing applications where parsing needs to be interrupted if the user cancels the operation or the request timeout expires.

Thread Safety: This function is thread-safe and can be called concurrently from multiple goroutines. Each call operates on independent pooled objects.

Context Handling:

• Returns context.Canceled if ctx.Done() is closed during parsing
• Returns context.DeadlineExceeded if the context timeout expires
• Checks context state before tokenization and parsing phases
• Supports context.WithTimeout, context.WithDeadline, context.WithCancel

Performance: Same as Parse() - 1.38M+ ops/sec sustained with minimal context checking overhead (<1% performance impact).

Example - Basic timeout:

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

ast, err := gosqlx.ParseWithContext(ctx, sql)
if err == context.DeadlineExceeded {
    log.Println("Parsing timed out after 5 seconds")
}

Example - User cancellation:

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

go func() {
    ast, err := gosqlx.ParseWithContext(ctx, complexSQL)
    if err == context.Canceled {
        log.Println("User cancelled parsing")
    }
}()

// User clicks cancel button
cancel()

Example - HTTP request timeout:

func handleParse(w http.ResponseWriter, r *http.Request) {
    ast, err := gosqlx.ParseWithContext(r.Context(), sql)
    if err == context.Canceled {
        http.Error(w, "Request cancelled", http.StatusRequestTimeout)
        return
    }
}

See also: ParseWithTimeout for a simpler timeout-only API.

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	sql := "SELECT * FROM users"
	ast, err := gosqlx.ParseWithContext(ctx, sql)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Parsed with context: %d statement(s)\n", len(ast.Statements))
}

Output:
Parsed with context: 1 statement(s)

func ParseWithDialect ¶ added in v1.9.3

func ParseWithDialect(sql string, dialect keywords.SQLDialect) (*ast.AST, error)

ParseWithDialect tokenizes and parses SQL using a specific SQL dialect for keyword recognition and dialect-aware parsing rules.

This is a top-level convenience wrapper around pkg/sql/parser.ParseWithDialect. It is equivalent to calling Parse but instructs the tokenizer and parser to apply dialect-specific rules (e.g., MySQL-specific syntax, PostgreSQL extensions).

Supported dialects:

• keywords.DialectGeneric - generic SQL (default fallback)
• keywords.DialectMySQL - MySQL / MariaDB
• keywords.DialectPostgreSQL - PostgreSQL
• keywords.DialectSQLite - SQLite
• keywords.DialectSQLServer - Microsoft SQL Server (T-SQL)
• keywords.DialectOracle - Oracle Database (PL/SQL)
• keywords.DialectSnowflake - Snowflake SQL

Example - parse MySQL-specific syntax:

sql := "INSERT INTO t (id, name) VALUES (1, 'Alice') ON DUPLICATE KEY UPDATE name=VALUES(name)"
ast, err := gosqlx.ParseWithDialect(sql, keywords.DialectMySQL)
if err != nil {
    log.Fatal(err)
}

Example - parse PostgreSQL JSON operators:

sql := "SELECT data->>'name' FROM users"
ast, err := gosqlx.ParseWithDialect(sql, keywords.DialectPostgreSQL)

Returns an error if the dialect is unknown or if SQL is syntactically invalid. Errors are wrapped with gosqlx sentinel errors (ErrUnsupportedDialect, ErrSyntax, ErrTokenize) so callers can match via errors.Is.

func ParseWithRecovery ¶ added in v1.9.3

func ParseWithRecovery(sql string) ([]ast.Statement, []error)

ParseWithRecovery tokenizes and parses SQL with error recovery, returning partial AST statements and all collected errors. Unlike Parse, it does not stop at the first error - it synchronises and continues, collecting every error it can find. This is ideal for IDE / LSP use-cases where the user wants to see all diagnostics at once.

Thread Safety: safe for concurrent use; each call uses pooled objects.

func ParseWithTimeout ¶

func ParseWithTimeout(sql string, timeout time.Duration) (*ast.AST, error)

ParseWithTimeout is a convenience function that parses SQL with a timeout.

This is a wrapper around ParseWithContext that creates a timeout context automatically. It's useful for quick timeout-based parsing without manual context management.

Example:

astNode, err := gosqlx.ParseWithTimeout(sql, 5*time.Second)
if err == context.DeadlineExceeded {
    log.Println("Parsing timed out after 5 seconds")
}

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT * FROM users"
	ast, err := gosqlx.ParseWithTimeout(sql, 5*time.Second)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Parsed with timeout: %d statement(s)\n", len(ast.Statements))
}

Output:
Parsed with timeout: 1 statement(s)

func SplitStatements ¶ added in v1.15.0

func SplitStatements(sql, dialect string) []string

SplitStatements splits a SQL source string into top-level statements on unquoted semicolons. It is dialect-aware: depending on the supplied dialect it understands features that the conservative ANSI-compatible path cannot, notably PostgreSQL dollar-quoting, MySQL/ClickHouse backtick identifiers, SQL Server bracketed identifiers, PostgreSQL E-string backslash escapes, and PostgreSQL nested block comments.

Recognised dialect strings (case-insensitive) — unknown values fall back to the conservative ANSI profile:

"postgresql", "postgres", "pg" — dollar-quotes, E-strings, nested /*…*/
"mysql", "mariadb"            — backtick identifiers
"clickhouse"                  — backtick identifiers
"sqlserver", "mssql", "tsql"  — [bracketed identifiers]
""                            — ANSI only (single/double quotes, line/block comments)

The returned slice preserves the original byte ranges between semicolons (the terminating ';' itself is stripped). Empty or whitespace-only segments are NOT filtered out here; callers such as ParseReaderMultiple trim and skip them. This mirrors the long-standing behaviour of the splitter that this function replaces.

The splitter is intentionally a hand-written state machine rather than a full tokenizer: it only needs to know what it is inside of, not what the tokens mean. That keeps it fast, allocation-free on the hot path, and robust against partial or syntactically invalid SQL (the parser still gets a chance to report those problems downstream).

func Transpile ¶ added in v1.14.0

func Transpile(sql string, from, to keywords.SQLDialect) (string, error)

Transpile converts SQL from one dialect to another.

Supported dialect pairs:

• MySQL → PostgreSQL (AUTO_INCREMENT→SERIAL, TINYINT(1)→BOOLEAN)
• PostgreSQL → MySQL (SERIAL→AUTO_INCREMENT, ILIKE→LOWER() LIKE LOWER())
• PostgreSQL → SQLite (SERIAL→INTEGER, array types→TEXT)

For unsupported dialect pairs the SQL is parsed and reformatted without any dialect-specific rewrites (passthrough with normalisation).

Example:

result, err := gosqlx.Transpile(
    "CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY)",
    keywords.DialectMySQL,
    keywords.DialectPostgreSQL,
)
// result: "CREATE TABLE t (id SERIAL PRIMARY KEY)"

func Validate ¶

func Validate(sql string) error

Validate checks if the given SQL is syntactically valid.

This is a convenience function that only validates syntax without building the full AST, making it slightly faster than Parse().

Example:

if err := gosqlx.Validate("SELECT * FROM users"); err != nil {
    fmt.Printf("Invalid SQL: %v\n", err)
}

Returns nil if SQL is valid, or an error describing the problem.

if err := Validate("SELECT * FROM users"); err != nil {
	panic(err)
}

package main

import (
	"fmt"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	sql := "SELECT * FROM users"
	if err := gosqlx.Validate(sql); err != nil {
		fmt.Printf("Invalid SQL: %v\n", err)
		return
	}

	fmt.Println("Valid SQL")
}

Output:
Valid SQL

func ValidateMultiple ¶

func ValidateMultiple(queries []string) error

ValidateMultiple validates multiple SQL statements.

Returns nil if all statements are valid, or an error for the first invalid statement encountered.

Example:

queries := []string{
    "SELECT * FROM users",
    "INVALID SQL HERE",
}
if err := gosqlx.ValidateMultiple(queries); err != nil {
    fmt.Printf("Validation failed: %v\n", err)
}

package main

import (
	"fmt"

	"github.com/ajitpratap0/GoSQLX/pkg/gosqlx"
)

func main() {
	queries := []string{
		"SELECT * FROM users",
		"INSERT INTO users (name) VALUES ('test')",
		"UPDATE users SET active = true WHERE id = 1",
	}

	if err := gosqlx.ValidateMultiple(queries); err != nil {
		fmt.Printf("Validation failed: %v\n", err)
		return
	}

	fmt.Println("All queries valid")
}

Output:
All queries valid

func WalkBy ¶ added in v1.15.0

func WalkBy[T ast.Node](t *Tree, fn func(T) bool)

WalkBy traverses the tree in depth-first, pre-order fashion and invokes fn for every node whose concrete type is T. Children of the matched node are descended unless fn returns false.

WalkBy is a generic helper that removes the type-assertion boilerplate required when using Tree.Walk. It is implemented on top of ast.Inspect so it follows the same Node.Children() contract and descends into every reachable subtree (subqueries, CTEs, UNION arms, etc.).

Nodes whose concrete type does not match T are skipped but still descended into — returning false from fn only prunes children of a matched node.

Example — collect every table reference inside nested subqueries:

var names []string
gosqlx.WalkBy(tree, func(t *ast.TableReference) bool {
    names = append(names, t.Name)
    return true
})

Example — short-circuit on the first SELECT with a Where clause:

var found *ast.SelectStatement
gosqlx.WalkBy(tree, func(s *ast.SelectStatement) bool {
    if s.Where != nil {
        found = s
        return false // prune this subtree (siblings still visited)
    }
    return true
})