fix(sqlite): Handle in-memory databases and preserve inferred types

- Apply migrations for in-memory SQLite databases in both the analyzer
  and vet command, since they start empty and need schema setup
- Preserve catalog-inferred column/parameter types when the database
  analyzer returns "any" (SQLite doesn't provide type info for parameters)
- Change driver name from "sqlite" to "sqlite3" for ncruces/go-sqlite3

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

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

Author: kyleconroy

internal/cmd/vet.go

@@ -391,6 +391,19 @@ type checker struct {
 	Replacer      *shfmt.Replacer
 }
 
+// isInMemorySQLite checks if a SQLite URI refers to an in-memory database
+func isInMemorySQLite(uri string) bool {
+	if uri == ":memory:" || uri == "" {
+		return true
+	}
+	// Check for file URI with mode=memory parameter
+	// e.g., "file:test?mode=memory&cache=shared"
+	if strings.Contains(uri, "mode=memory") {
+		return true
+	}
+	return false
+}
+
 func (c *checker) fetchDatabaseUri(ctx context.Context, s config.SQL) (string, func() error, error) {
 	cleanup := func() error {
 		return nil
@@ -517,14 +530,31 @@ func (c *checker) checkSQL(ctx context.Context, s config.SQL) error {
 			prep = &dbPreparer{db}
 			expl = &mysqlExplainer{db}
 		case config.EngineSQLite:
-			db, err := sql.Open("sqlite", dburl)
+			db, err := sql.Open("sqlite3", dburl)
 			if err != nil {
 				return fmt.Errorf("database: connection error: %s", err)
 			}
 			if err := db.PingContext(ctx); err != nil {
 				return fmt.Errorf("database: connection error: %s", err)
 			}
 			defer db.Close()
+			// For in-memory SQLite databases, apply migrations
+			if isInMemorySQLite(dburl) {
+				files, err := sqlpath.Glob(s.Schema)
+				if err != nil {
+					return fmt.Errorf("schema: %w", err)
+				}
+				for _, schema := range files {
+					contents, err := os.ReadFile(schema)
+					if err != nil {
+						return fmt.Errorf("read schema file: %w", err)
+					}
+					ddl := migrations.RemoveRollbackStatements(string(contents))
+					if _, err := db.ExecContext(ctx, ddl); err != nil {
+						return fmt.Errorf("apply schema %s: %w", schema, err)
+					}
+				}
+			}
 			prep = &dbPreparer{db}
 			// SQLite really doesn't want us to depend on the output of EXPLAIN
 			// QUERY PLAN: https://www.sqlite.org/eqp.html

internal/compiler/analyze.go

@@ -79,9 +79,13 @@ func combineAnalysis(prev *analysis, a *analyzer.Analysis) *analysis {
 	}
 	if len(prev.Columns) == len(cols) {
 		for i := range prev.Columns {
-			prev.Columns[i].DataType = cols[i].DataType
-			prev.Columns[i].IsArray = cols[i].IsArray
-			prev.Columns[i].ArrayDims = cols[i].ArrayDims
+			// Only override column types if the analyzer provides a specific type
+			// (not "any"), since the catalog-based inference may have better info
+			if cols[i].DataType != "any" {
+				prev.Columns[i].DataType = cols[i].DataType
+				prev.Columns[i].IsArray = cols[i].IsArray
+				prev.Columns[i].ArrayDims = cols[i].ArrayDims
+			}
 		}
 	} else {
 		embedding := false
@@ -96,9 +100,13 @@ func combineAnalysis(prev *analysis, a *analyzer.Analysis) *analysis {
 	}
 	if len(prev.Parameters) == len(params) {
 		for i := range prev.Parameters {
-			prev.Parameters[i].Column.DataType = params[i].Column.DataType
-			prev.Parameters[i].Column.IsArray = params[i].Column.IsArray
-			prev.Parameters[i].Column.ArrayDims = params[i].Column.ArrayDims
+			// Only override parameter types if the analyzer provides a specific type
+			// (not "any"), since the catalog-based inference may have better info
+			if params[i].Column.DataType != "any" {
+				prev.Parameters[i].Column.DataType = params[i].Column.DataType
+				prev.Parameters[i].Column.IsArray = params[i].Column.IsArray
+				prev.Parameters[i].Column.ArrayDims = params[i].Column.ArrayDims
+			}
 		}
 	} else {
 		prev.Parameters = params

internal/engine/sqlite/analyzer/analyze.go

@@ -40,13 +40,18 @@ func (a *Analyzer) Analyze(ctx context.Context, n ast.Node, query string, migrat
 
 	if a.conn == nil {
 		var uri string
+		applyMigrations := a.db.Managed
 		if a.db.Managed {
 			// For managed databases, create an in-memory database
 			uri = ":memory:"
 		} else if a.dbg.OnlyManagedDatabases {
 			return nil, fmt.Errorf("database: connections disabled via SQLCDEBUG=databases=managed")
 		} else {
 			uri = a.replacer.Replace(a.db.URI)
+			// For in-memory databases, we need to apply migrations since the database starts empty
+			if isInMemoryDatabase(uri) {
+				applyMigrations = true
+			}
 		}
 
 		conn, err := sqlite3.Open(uri)
@@ -55,8 +60,8 @@ func (a *Analyzer) Analyze(ctx context.Context, n ast.Node, query string, migrat
 		}
 		a.conn = conn
 
-		// Apply migrations for managed databases
-		if a.db.Managed {
+		// Apply migrations for managed or in-memory databases
+		if applyMigrations {
 			for _, m := range migrations {
 				if len(strings.TrimSpace(m)) == 0 {
 					continue
@@ -177,6 +182,19 @@ func (a *Analyzer) Close(_ context.Context) error {
 	return nil
 }
 
+// isInMemoryDatabase checks if a SQLite URI refers to an in-memory database
+func isInMemoryDatabase(uri string) bool {
+	if uri == ":memory:" || uri == "" {
+		return true
+	}
+	// Check for file URI with mode=memory parameter
+	// e.g., "file:test?mode=memory&cache=shared"
+	if strings.Contains(uri, "mode=memory") {
+		return true
+	}
+	return false
+}
+
 // normalizeType converts SQLite type declarations to standard type names
 func normalizeType(declType string) string {
 	if declType == "" {