refactor(fmt_test): use config-based engine detection and parser for statement boundaries

- Parse sqlc config file to determine database engine instead of
  hardcoding pgx/v5 path filter
- Use parser's StmtLocation/StmtLen for proper statement boundaries
  instead of naive semicolon splitting
- Handle both file and directory paths in queries config
- Only test PostgreSQL for now (formatting support is PostgreSQL-only)

This fixes issues with multi-query files containing semicolons in
strings, PL/pgSQL functions, or DO blocks.

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: kyleconroy

internal/endtoend/fmt_test.go

@@ -8,66 +8,120 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/debug"
 	"github.com/sqlc-dev/sqlc/internal/engine/postgresql"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 )
 
 func TestFormat(t *testing.T) {
 	t.Parallel()
-	parse := postgresql.NewParser()
 	for _, tc := range FindTests(t, "testdata", "base") {
 		tc := tc
-
-		if !strings.Contains(tc.Path, filepath.Join("pgx/v5")) {
-			continue
-		}
-
-		q := filepath.Join(tc.Path, "query.sql")
-		if _, err := os.Stat(q); os.IsNotExist(err) {
-			continue
-		}
-
 		t.Run(tc.Name, func(t *testing.T) {
-			contents, err := os.ReadFile(q)
+			// Parse the config file to determine the engine
+			configPath := filepath.Join(tc.Path, tc.ConfigName)
+			configFile, err := os.Open(configPath)
 			if err != nil {
 				t.Fatal(err)
 			}
-			for i, query := range bytes.Split(bytes.TrimSpace(contents), []byte(";")) {
-				if len(query) <= 1 {
-					continue
-				}
-				query := query
-				t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
-					expected, err := postgresql.Fingerprint(string(query))
-					if err != nil {
-						t.Fatal(err)
-					}
-					stmts, err := parse.Parse(bytes.NewReader(query))
-					if err != nil {
-						t.Fatal(err)
-					}
-					if len(stmts) != 1 {
-						t.Fatal("expected one statement")
-					}
-					if false {
-						r, err := postgresql.Parse(string(query))
-						debug.Dump(r, err)
-					}
+			conf, err := config.ParseConfig(configFile)
+			configFile.Close()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// Skip if there are no SQL packages configured
+			if len(conf.SQL) == 0 {
+				return
+			}
+
+			// For now, only test PostgreSQL since that's the only engine with Format support
+			engine := conf.SQL[0].Engine
+			if engine != config.EnginePostgreSQL {
+				return
+			}
 
-					out := ast.Format(stmts[0].Raw)
-					actual, err := postgresql.Fingerprint(out)
+			// Find query files from config
+			var queryFiles []string
+			for _, sql := range conf.SQL {
+				for _, q := range sql.Queries {
+					queryPath := filepath.Join(tc.Path, q)
+					info, err := os.Stat(queryPath)
 					if err != nil {
-						t.Error(err)
+						continue
 					}
-					if expected != actual {
-						debug.Dump(stmts[0].Raw)
-						t.Errorf("- %s", expected)
-						t.Errorf("- %s", string(query))
-						t.Errorf("+ %s", actual)
-						t.Errorf("+ %s", out)
+					if info.IsDir() {
+						// If it's a directory, glob for .sql files
+						matches, err := filepath.Glob(filepath.Join(queryPath, "*.sql"))
+						if err != nil {
+							continue
+						}
+						queryFiles = append(queryFiles, matches...)
+					} else {
+						queryFiles = append(queryFiles, queryPath)
 					}
-				})
+				}
+			}
+
+			if len(queryFiles) == 0 {
+				return
+			}
+
+			parse := postgresql.NewParser()
+
+			for _, queryFile := range queryFiles {
+				if _, err := os.Stat(queryFile); os.IsNotExist(err) {
+					continue
+				}
+
+				contents, err := os.ReadFile(queryFile)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				// Parse the entire file to get proper statement boundaries
+				stmts, err := parse.Parse(bytes.NewReader(contents))
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				for i, stmt := range stmts {
+					stmt := stmt
+					t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+						// Extract the original query text using statement location and length
+						start := stmt.Raw.StmtLocation
+						length := stmt.Raw.StmtLen
+						if length == 0 {
+							// If StmtLen is 0, it means the statement goes to the end of the input
+							length = len(contents) - start
+						}
+						query := strings.TrimSpace(string(contents[start : start+length]))
+
+						expected, err := postgresql.Fingerprint(query)
+						if err != nil {
+							t.Fatal(err)
+						}
+
+						if false {
+							r, err := postgresql.Parse(query)
+							debug.Dump(r, err)
+						}
+
+						out := ast.Format(stmt.Raw)
+						actual, err := postgresql.Fingerprint(out)
+						if err != nil {
+							t.Error(err)
+						}
+						if expected != actual {
+							debug.Dump(stmt.Raw)
+							t.Errorf("- %s", expected)
+							t.Errorf("- %s", query)
+							t.Errorf("+ %s", actual)
+							t.Errorf("+ %s", out)
+						}
+					})
+				}
 			}
 		})
 	}