Preserve column properties on add FOREIGN KEY constraint operation

pkg/migrations/duplicate.go

@@ -42,14 +42,22 @@ func (d *Duplicator) WithType(t string) *Duplicator {
 func (d *Duplicator) Duplicate(ctx context.Context) error {
 	const (
 		cAlterTableSQL    = `ALTER TABLE %s ADD COLUMN %s %s`
+		cSetDefaultSQL    = `ALTER COLUMN %s SET DEFAULT %s`
 		cAddForeignKeySQL = `ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)`
 	)
 
+	// Generate SQL to duplicate the column's name and type
 	sql := fmt.Sprintf(cAlterTableSQL,
 		pq.QuoteIdentifier(d.table.Name),
 		pq.QuoteIdentifier(d.asName),
 		d.withType)
 
+	// Generate SQL to duplicate the column's default value
+	if d.column.Default != nil {
+		sql += fmt.Sprintf(", "+cSetDefaultSQL, d.asName, *d.column.Default)
+	}
+
+	// Generate SQL to duplicate any foreign key constraints on the column
 	for _, fk := range d.table.ForeignKeys {
 		if slices.Contains(fk.Columns, d.column.Name) {
 			sql += fmt.Sprintf(", "+cAddForeignKeySQL,

pkg/migrations/op_change_type_test.go

@@ -222,6 +222,71 @@ func TestChangeColumnType(t *testing.T) {
 				ConstraintMustExist(t, db, "public", "employees", "fk_employee_department")
 			},
 		},
+		{
+			name: "changing column type preserves any defaults on the column",
+			migrations: []migrations.Migration{
+				{
+					Name: "01_add_table",
+					Operations: migrations.Operations{
+						&migrations.OpCreateTable{
+							Name: "users",
+							Columns: []migrations.Column{
+								{
+									Name: "id",
+									Type: "integer",
+									Pk:   true,
+								},
+								{
+									Name:     "username",
+									Type:     "text",
+									Default:  ptr("'alice'"),
+									Nullable: true,
+								},
+							},
+						},
+					},
+				},
+				{
+					Name: "02_change_type",
+					Operations: migrations.Operations{
+						&migrations.OpAlterColumn{
+							Table:  "users",
+							Column: "username",
+							Type:   "varchar(255)",
+							Up:     "username",
+							Down:   "username",
+						},
+					},
+				},
+			},
+			afterStart: func(t *testing.T, db *sql.DB) {
+				// A row can be inserted into the new version of the table.
+				MustInsert(t, db, "public", "02_change_type", "users", map[string]string{
+					"id": "1",
+				})
+
+				// The newly inserted row respects the default value of the column.
+				rows := MustSelect(t, db, "public", "02_change_type", "users")
+				assert.Equal(t, []map[string]any{
+					{"id": 1, "username": "alice"},
+				}, rows)
+			},
+			afterRollback: func(t *testing.T, db *sql.DB) {
+			},
+			afterComplete: func(t *testing.T, db *sql.DB) {
+				// A row can be inserted into the new version of the table.
+				MustInsert(t, db, "public", "02_change_type", "users", map[string]string{
+					"id": "2",
+				})
+
+				// The newly inserted row respects the default value of the column.
+				rows := MustSelect(t, db, "public", "02_change_type", "users")
+				assert.Equal(t, []map[string]any{
+					{"id": 1, "username": "alice"},
+					{"id": 2, "username": "alice"},
+				}, rows)
+			},
+		},
 	})
 }
 

pkg/migrations/op_common_test.go

@@ -496,6 +496,36 @@ func insert(t *testing.T, db *sql.DB, schema, version, table string, record map[
 	return err
 }
 
+func MustDelete(t *testing.T, db *sql.DB, schema, version, table string, record map[string]string) {
+	t.Helper()
+
+	if err := delete(t, db, schema, version, table, record); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func delete(t *testing.T, db *sql.DB, schema, version, table string, record map[string]string) error {
+	t.Helper()
+	versionSchema := roll.VersionedSchemaName(schema, version)
+
+	cols := maps.Keys(record)
+	slices.Sort(cols)
+
+	recordStr := ""
+	for i, c := range cols {
+		if i > 0 {
+			recordStr += " AND "
+		}
+		recordStr += fmt.Sprintf("%s = '%s'", c, record[c])
+	}
+
+	//nolint:gosec // this is a test so we don't care about SQL injection
+	stmt := fmt.Sprintf("DELETE FROM %s.%s WHERE %s", versionSchema, table, recordStr)
+
+	_, err := db.Exec(stmt)
+	return err
+}
+
 func MustSelect(t *testing.T, db *sql.DB, schema, version, table string) []map[string]any {
 	t.Helper()
 	versionSchema := roll.VersionedSchemaName(schema, version)

pkg/migrations/op_set_check.go

@@ -27,7 +27,8 @@ func (o *OpSetCheckConstraint) Start(ctx context.Context, conn *sql.DB, stateSch
 	column := table.GetColumn(o.Column)
 
 	// Create a copy of the column on the underlying table.
-	if err := duplicateColumn(ctx, conn, table, *column); err != nil {
+	d := NewColumnDuplicator(conn, table, column)
+	if err := d.Duplicate(ctx); err != nil {
 		return fmt.Errorf("failed to duplicate column: %w", err)
 	}
 
@@ -112,11 +113,9 @@ func (o *OpSetCheckConstraint) Complete(ctx context.Context, conn *sql.DB, s *sc
 	}
 
 	// Rename the new column to the old column name
-	_, err = conn.ExecContext(ctx, fmt.Sprintf("ALTER TABLE IF EXISTS %s RENAME COLUMN %s TO %s",
-		pq.QuoteIdentifier(o.Table),
-		pq.QuoteIdentifier(TemporaryName(o.Column)),
-		pq.QuoteIdentifier(o.Column)))
-	if err != nil {
+	table := s.GetTable(o.Table)
+	column := table.GetColumn(o.Column)
+	if err := RenameDuplicatedColumn(ctx, conn, table, column); err != nil {
 		return err
 	}