fix(sqlite): allow to use overrides for columns which were created using "alter table .. add column"

This fixes the failing test which was added in the previous commit.

Normalize sqlite `ALTER TABLE` column identifiers and preserve analyzer
origin metadata when merging query analysis. This allows exact column
overrides such as `chat_messages.updated_at` to match columns added via
`ALTER TABLE .. ADD COLUMN`.

Using the sqlc config:

    overrides:
      - column: "*.*_at"
        go_type:
          import: "time"
          type: "Time"

and the SQL schema:

    CREATE TABLE chat_messages (
      id TEXT PRIMARY KEY NOT NULL,
      body TEXT NOT NULL,
      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
    ) STRICT;

    ALTER TABLE chat_messages ADD COLUMN "updated_at" TEXT NOT NULL DEFAULT '';

sqlc would previously generate the following code:

    type ChatMessage struct {
    	ID        string
    	Body      string
    	CreatedAt time.Time
    	UpdatedAt string    // Bug: This should be a time.Time!
    }

_With_ this fix, the following code is generated:

    type ChatMessage struct {
    	ID        string
    	Body      string
    	CreatedAt time.Time
    	UpdatedAt time.Time // Fixed, now a time.Time, even for retroactively added columns
    }

Author: leonklingele

internal/compiler/analyze.go

@@ -65,6 +65,36 @@ func convertColumn(c *analyzer.Column) *Column {
 	}
 }
 
+func mergeColumnOrigin(dst, src *Column) {
+	if dst == nil || src == nil {
+		return
+	}
+
+	// Column overrides in the Go generator depend on the column's original
+	// table identity. For SQLite, the database analyzer is often the most
+	// accurate source for this information, especially for columns added by
+	// ALTER TABLE ... ADD COLUMN.
+	//
+	// Keep the catalog-inferred name/type/nullability unless the existing
+	// combine logic below decides to override the type. Only merge origin
+	// metadata here.
+	if src.OriginalName != "" {
+		dst.OriginalName = src.OriginalName
+	}
+	if src.Table != nil {
+		dst.Table = src.Table
+	}
+	if src.TableAlias != "" {
+		dst.TableAlias = src.TableAlias
+	}
+	if src.Scope != "" {
+		dst.Scope = src.Scope
+	}
+	if src.EmbedTable != nil {
+		dst.EmbedTable = src.EmbedTable
+	}
+}
+
 func combineAnalysis(prev *analysis, a *analyzer.Analysis) *analysis {
 	var cols []*Column
 	for _, c := range a.Columns {
@@ -79,6 +109,7 @@ func combineAnalysis(prev *analysis, a *analyzer.Analysis) *analysis {
 	}
 	if len(prev.Columns) == len(cols) {
 		for i := range prev.Columns {
+			mergeColumnOrigin(prev.Columns[i], cols[i])
 			// 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" {

internal/engine/sqlite/convert.go

@@ -67,14 +67,18 @@ func (c *cc) convertAlter_table_stmtContext(n *parser.Alter_table_stmtContext) a
 				Table: parseTableName(n),
 				Cmds:  &ast.List{},
 			}
-			name := def.Column_name().GetText()
+			name := identifier(def.Column_name().GetText())
+			typeName := "any"
+			if def.Type_name() != nil {
+				typeName = def.Type_name().GetText()
+			}
 			stmt.Cmds.Items = append(stmt.Cmds.Items, &ast.AlterTableCmd{
 				Name:    &name,
 				Subtype: ast.AT_AddColumn,
 				Def: &ast.ColumnDef{
 					Colname: name,
 					TypeName: &ast.TypeName{
-						Name: def.Type_name().GetText(),
+						Name: typeName,
 					},
 					IsNotNull: hasNotNullConstraint(def.AllColumn_constraint()),
 				},
@@ -88,7 +92,7 @@ func (c *cc) convertAlter_table_stmtContext(n *parser.Alter_table_stmtContext) a
 			Table: parseTableName(n),
 			Cmds:  &ast.List{},
 		}
-		name := n.Column_name(0).GetText()
+		name := identifier(n.Column_name(0).GetText())
 		stmt.Cmds.Items = append(stmt.Cmds.Items, &ast.AlterTableCmd{
 			Name:    &name,
 			Subtype: ast.AT_DropColumn,
@@ -826,7 +830,7 @@ func (c *cc) convertUnaryExpr(n *parser.Expr_unaryContext) ast.Node {
 		if opCtx.MINUS() != nil {
 			// Negative number: -expr
 			return &ast.A_Expr{
-				Name: &ast.List{Items: []ast.Node{&ast.String{Str: "-"}}},
+				Name:  &ast.List{Items: []ast.Node{&ast.String{Str: "-"}}},
 				Rexpr: expr,
 			}
 		}
@@ -837,7 +841,7 @@ func (c *cc) convertUnaryExpr(n *parser.Expr_unaryContext) ast.Node {
 		if opCtx.TILDE() != nil {
 			// Bitwise NOT: ~expr
 			return &ast.A_Expr{
-				Name: &ast.List{Items: []ast.Node{&ast.String{Str: "~"}}},
+				Name:  &ast.List{Items: []ast.Node{&ast.String{Str: "~"}}},
 				Rexpr: expr,
 			}
 		}