refactor: use analyzer interface for database-only mode

- Add EnsureConn and GetColumnNames methods to Analyzer interface
- Remove engine-specific pgAnalyzer and sqliteAnalyzer fields from compiler
- Use unified analyzer interface for database connection initialization
- Keep parsing schema files to build catalog, only use database for star expansion

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

Co-Authored-By: Claude <[email protected]>

Author: claude

internal/analyzer/analyzer.go

@@ -110,7 +110,21 @@ func (c *CachedAnalyzer) Close(ctx context.Context) error {
 	return c.a.Close(ctx)
 }
 
+func (c *CachedAnalyzer) EnsureConn(ctx context.Context, migrations []string) error {
+	return c.a.EnsureConn(ctx, migrations)
+}
+
+func (c *CachedAnalyzer) GetColumnNames(ctx context.Context, query string) ([]string, error) {
+	return c.a.GetColumnNames(ctx, query)
+}
+
 type Analyzer interface {
 	Analyze(context.Context, ast.Node, string, []string, *named.ParamSet) (*analysis.Analysis, error)
 	Close(context.Context) error
+	// EnsureConn initializes the database connection with the given migrations.
+	// This is required for database-only mode where we need to connect before analyzing queries.
+	EnsureConn(ctx context.Context, migrations []string) error
+	// GetColumnNames returns the column names for a query by preparing it against the database.
+	// This is used for star expansion in database-only mode.
+	GetColumnNames(ctx context.Context, query string) ([]string, error)
 }

internal/compiler/compile.go

@@ -41,12 +41,6 @@ func (c *Compiler) parseCatalog(schemas []string) error {
 		contents := migrations.RemoveRollbackStatements(string(blob))
 		c.schema = append(c.schema, contents)
 
-		// In database-only mode, we only need to collect schema files for migrations
-		// but don't build the internal catalog from them
-		if c.databaseOnlyMode {
-			continue
-		}
-
 		stmts, err := c.parser.Parse(strings.NewReader(contents))
 		if err != nil {
 			merr.Add(filename, contents, 0, err)
@@ -69,16 +63,9 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 	ctx := context.Background()
 
 	// In database-only mode, initialize the database connection before parsing queries
-	if c.databaseOnlyMode {
-		if c.pgAnalyzer != nil {
-			if err := c.pgAnalyzer.EnsurePool(ctx, c.schema); err != nil {
-				return nil, fmt.Errorf("failed to initialize database connection: %w", err)
-			}
-		}
-		if c.sqliteAnalyzer != nil {
-			if err := c.sqliteAnalyzer.EnsureConn(ctx, c.schema); err != nil {
-				return nil, fmt.Errorf("failed to initialize database connection: %w", err)
-			}
+	if c.databaseOnlyMode && c.analyzer != nil {
+		if err := c.analyzer.EnsureConn(ctx, c.schema); err != nil {
+			return nil, fmt.Errorf("failed to initialize database connection: %w", err)
 		}
 	}
 
@@ -138,28 +125,6 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 		return nil, fmt.Errorf("no queries contained in paths %s", strings.Join(c.conf.Queries, ","))
 	}
 
-	// In database-only mode, build the catalog from the database after parsing all queries
-	if c.databaseOnlyMode {
-		if c.pgAnalyzer != nil {
-			// Default to "public" schema if no specific schemas are specified
-			schemas := []string{"public"}
-			cat, err := c.pgAnalyzer.IntrospectSchema(ctx, schemas)
-			if err != nil {
-				return nil, fmt.Errorf("failed to introspect database schema: %w", err)
-			}
-			c.catalog = cat
-		}
-		if c.sqliteAnalyzer != nil {
-			// SQLite uses "main" as the default schema
-			schemas := []string{"main"}
-			cat, err := c.sqliteAnalyzer.IntrospectSchema(ctx, schemas)
-			if err != nil {
-				return nil, fmt.Errorf("failed to introspect database schema: %w", err)
-			}
-			c.catalog = cat
-		}
-	}
-
 	return &Result{
 		Catalog: c.catalog,
 		Queries: q,

internal/compiler/engine.go

@@ -32,12 +32,6 @@ type Compiler struct {
 	// databaseOnlyMode indicates that the compiler should use database-only analysis
 	// and skip building the internal catalog from schema files (analyzer.database: only)
 	databaseOnlyMode bool
-	// pgAnalyzer is the PostgreSQL-specific analyzer used in database-only mode
-	// for schema introspection
-	pgAnalyzer *pganalyze.Analyzer
-	// sqliteAnalyzer is the SQLite-specific analyzer used in database-only mode
-	// for schema introspection
-	sqliteAnalyzer *sqliteanalyze.Analyzer
 	// expander is used to expand SELECT * and RETURNING * in database-only mode
 	expander *expander.Expander
 }
@@ -70,17 +64,11 @@ func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts
 				return nil, fmt.Errorf("analyzer.database: only requires database.uri or database.managed")
 			}
 			c.databaseOnlyMode = true
-			// Create the SQLite analyzer for schema introspection
-			c.sqliteAnalyzer = sqliteanalyze.New(*conf.Database)
-			// Use the analyzer wrapped with cache for query analysis
-			c.analyzer = analyzer.Cached(
-				c.sqliteAnalyzer,
-				combo.Global,
-				*conf.Database,
-			)
-			// Create the expander using the sqliteAnalyzer as the column getter
-			// The parser implements both Parser and format.Dialect interfaces
-			c.expander = expander.New(c.sqliteAnalyzer, parser, parser)
+			// Create the SQLite analyzer (implements Analyzer interface)
+			sqliteAnalyzer := sqliteanalyze.New(*conf.Database)
+			c.analyzer = analyzer.Cached(sqliteAnalyzer, combo.Global, *conf.Database)
+			// Create the expander using the analyzer as the column getter
+			c.expander = expander.New(c.analyzer, parser, parser)
 		} else if conf.Database != nil {
 			if conf.Analyzer.Database.IsEnabled() {
 				c.analyzer = analyzer.Cached(
@@ -109,17 +97,11 @@ func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts
 				return nil, fmt.Errorf("analyzer.database: only requires database.uri or database.managed")
 			}
 			c.databaseOnlyMode = true
-			// Create the PostgreSQL analyzer for schema introspection
-			c.pgAnalyzer = pganalyze.New(c.client, *conf.Database)
-			// Use the analyzer wrapped with cache for query analysis
-			c.analyzer = analyzer.Cached(
-				c.pgAnalyzer,
-				combo.Global,
-				*conf.Database,
-			)
-			// Create the expander using the pgAnalyzer as the column getter
-			// The parser implements both Parser and format.Dialect interfaces
-			c.expander = expander.New(c.pgAnalyzer, parser, parser)
+			// Create the PostgreSQL analyzer (implements Analyzer interface)
+			pgAnalyzer := pganalyze.New(c.client, *conf.Database)
+			c.analyzer = analyzer.Cached(pgAnalyzer, combo.Global, *conf.Database)
+			// Create the expander using the analyzer as the column getter
+			c.expander = expander.New(c.analyzer, parser, parser)
 		} else if conf.Database != nil {
 			if conf.Analyzer.Database.IsEnabled() {
 				c.analyzer = analyzer.Cached(

internal/engine/postgresql/analyzer/analyze.go

@@ -482,9 +482,9 @@ func (a *Analyzer) IntrospectSchema(ctx context.Context, schemas []string) (*cat
 	return cat, nil
 }
 
-// EnsurePool initializes the database connection pool if not already done.
-// This is useful for accurate mode where we need to connect before analyzing queries.
-func (a *Analyzer) EnsurePool(ctx context.Context, migrations []string) error {
+// EnsureConn initializes the database connection pool if not already done.
+// This is useful for database-only mode where we need to connect before analyzing queries.
+func (a *Analyzer) EnsureConn(ctx context.Context, migrations []string) error {
 	if a.pool != nil {
 		return nil
 	}