feat: add SQLite support for database-only mode (analyzer.database: only)

This extends the database-only analyzer mode to support SQLite in addition
to PostgreSQL:

1. Add EnsureConn, GetColumnNames, and IntrospectSchema methods to the
   SQLite analyzer for database-only mode functionality

2. Update compiler to handle SQLite database-only mode:
   - Add sqliteAnalyzer field to Compiler struct
   - Initialize SQLite analyzer when database-only mode is enabled
   - Build catalog from SQLite database via PRAGMA table_info

3. Add SQLite end-to-end test case for database-only mode

The SQLite database-only mode uses PRAGMA table_info to introspect
tables and columns, and prepares queries to get column names for
star expansion.

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

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

Author: claude

internal/compiler/compile.go

@@ -68,10 +68,17 @@ func (c *Compiler) parseCatalog(schemas []string) error {
 func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 	ctx := context.Background()
 
-	// In database-only mode, initialize the database connection pool before parsing queries
-	if c.databaseOnlyMode && c.pgAnalyzer != nil {
-		if err := c.pgAnalyzer.EnsurePool(ctx, c.schema); err != nil {
-			return nil, fmt.Errorf("failed to initialize database connection: %w", err)
+	// 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)
+			}
 		}
 	}
 
@@ -132,14 +139,25 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 	}
 
 	// In database-only mode, build the catalog from the database after parsing all queries
-	if c.databaseOnlyMode && 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)
+	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
 		}
-		c.catalog = cat
 	}
 
 	return &Result{

internal/compiler/engine.go

@@ -35,6 +35,9 @@ type Compiler struct {
 	// 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
 }
@@ -53,10 +56,32 @@ func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts
 
 	switch conf.Engine {
 	case config.EngineSQLite:
-		c.parser = sqlite.NewParser()
+		parser := sqlite.NewParser()
+		c.parser = parser
 		c.catalog = sqlite.NewCatalog()
 		c.selector = newSQLiteSelector()
-		if conf.Database != nil {
+
+		if databaseOnlyMode {
+			// Database-only mode requires a database connection
+			if conf.Database == nil {
+				return nil, fmt.Errorf("analyzer.database: only requires database configuration")
+			}
+			if conf.Database.URI == "" && !conf.Database.Managed {
+				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)
+		} else if conf.Database != nil {
 			if conf.Analyzer.Database.IsEnabled() {
 				c.analyzer = analyzer.Cached(
 					sqliteanalyze.New(*conf.Database),

internal/endtoend/testdata/accurate_sqlite/sqlite/stdlib/exec.json

@@ -0,0 +1,6 @@
+{
+  "contexts": ["managed-db"],
+  "env": {
+    "SQLCEXPERIMENT": "analyzerv2"
+  }
+}

internal/endtoend/testdata/accurate_sqlite/sqlite/stdlib/go/db.go

@@ -0,0 +1,8 @@
+-- name: GetAuthor :one
+SELECT * FROM authors WHERE id = ?;
+
+-- name: ListAuthors :many
+SELECT * FROM authors;
+
+-- name: CreateAuthor :one
+INSERT INTO authors (name, bio) VALUES (?, ?) RETURNING *;

internal/endtoend/testdata/accurate_sqlite/sqlite/stdlib/go/models.go

@@ -0,0 +1,5 @@
+CREATE TABLE authors (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    bio TEXT
+);

internal/endtoend/testdata/accurate_sqlite/sqlite/stdlib/go/query.sql.go

@@ -0,0 +1,13 @@
+version: "2"
+sql:
+  - engine: sqlite
+    schema: "schema.sql"
+    queries: "query.sql"
+    database:
+      managed: true
+    analyzer:
+      database: "only"
+    gen:
+      go:
+        package: "querytest"
+        out: "go"