Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

feat(schema): support ALTER TYPE ADD VALUE for PostgreSQL enum sync (#18879)

rebelicee6c25f629d75
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.go
index 90077fe316..349d5e6177 100644
--- a/backend/plugin/schema/differ.go
+++ b/backend/plugin/schema/differ.go
@@ -1971,19 +1971,39 @@ func compareEnumTypes(diff *MetadataDiff, schemaName string, oldSchema, newSchem
}
}
- // Check for new enum types
+ // Check for new and modified enum types
for enumName, newEnum := range newEnumMap {
- if _, exists := oldEnumMap[enumName]; !exists {
+ if oldEnum, exists := oldEnumMap[enumName]; !exists {
diff.EnumTypeChanges = append(diff.EnumTypeChanges, &EnumTypeDiff{
Action: MetadataDiffActionCreate,
SchemaName: schemaName,
EnumTypeName: enumName,
NewEnumType: newEnum,
})
+ } else if !enumValuesEqual(oldEnum.Values, newEnum.Values) {
+ // Enum values changed - generate ALTER diff
+ diff.EnumTypeChanges = append(diff.EnumTypeChanges, &EnumTypeDiff{
+ Action: MetadataDiffActionAlter,
+ SchemaName: schemaName,
+ EnumTypeName: enumName,
+ OldEnumType: oldEnum,
+ NewEnumType: newEnum,
+ })
+ }
+ }
+}
+
+// enumValuesEqual checks if two enum value slices are equal.
+func enumValuesEqual(oldValues, newValues []string) bool {
+ if len(oldValues) != len(newValues) {
+ return false
+ }
+ for i, v := range oldValues {
+ if v != newValues[i] {
+ return false
}
- // Note: We don't support ALTER enum types yet
- // PostgreSQL doesn't allow modifying enum values easily
}
+ return true
}
// compareExtensions compares extensions between old and new database metadata.
diff --git a/backend/plugin/schema/pg/enum_type_test.go b/backend/plugin/schema/pg/enum_type_test.go
index 0adabb48be..c2a94be025 100644
--- a/backend/plugin/schema/pg/enum_type_test.go
+++ b/backend/plugin/schema/pg/enum_type_test.go
@@ -393,6 +393,260 @@ CREATE TABLE "public"."users" (
})
}
+// TestEnumTypeAlterAddValue tests that ALTER TYPE ADD VALUE is generated for new enum values
+func TestEnumTypeAlterAddValue(t *testing.T) {
+ t.Run("Add single value at end", func(t *testing.T) {
+ oldMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "orderstatus_enum",
+ Values: []string{"active", "inactive"},
+ },
+ },
+ },
+ },
+ }
+
+ newMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "orderstatus_enum",
+ Values: []string{"active", "inactive", "archived"},
+ },
+ },
+ },
+ },
+ }
+
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
+ require.NoError(t, err)
+
+ // Should have one ALTER enum change
+ require.Equal(t, 1, len(diff.EnumTypeChanges), "Should have 1 enum type change")
+ enumDiff := diff.EnumTypeChanges[0]
+ require.Equal(t, schema.MetadataDiffActionAlter, enumDiff.Action)
+ require.Equal(t, "public", enumDiff.SchemaName)
+ require.Equal(t, "orderstatus_enum", enumDiff.EnumTypeName)
+
+ migration, err := schema.GenerateMigration(storepb.Engine_POSTGRES, diff)
+ require.NoError(t, err)
+ t.Logf("Generated migration:\n%s", migration)
+
+ require.Contains(t, migration, "ALTER TYPE")
+ require.Contains(t, migration, "ADD VALUE")
+ require.Contains(t, migration, "'archived'")
+ // Should not contain DROP TYPE since we're using ALTER
+ require.NotContains(t, migration, "DROP TYPE")
+ })
+
+ t.Run("Add multiple values", func(t *testing.T) {
+ oldMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "priority_enum",
+ Values: []string{"low", "high"},
+ },
+ },
+ },
+ },
+ }
+
+ newMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "priority_enum",
+ Values: []string{"low", "medium", "high", "urgent"},
+ },
+ },
+ },
+ },
+ }
+
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
+ require.NoError(t, err)
+
+ migration, err := schema.GenerateMigration(storepb.Engine_POSTGRES, diff)
+ require.NoError(t, err)
+ t.Logf("Generated migration:\n%s", migration)
+
+ // Should have ALTER TYPE ADD VALUE for 'medium' and 'urgent'
+ require.Contains(t, migration, "ALTER TYPE")
+ require.Contains(t, migration, "'medium'")
+ require.Contains(t, migration, "'urgent'")
+ // 'medium' should be added BEFORE 'high'
+ require.Contains(t, migration, "BEFORE 'high'")
+ })
+
+ t.Run("Add value in the middle with BEFORE clause", func(t *testing.T) {
+ oldMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "status_enum",
+ Values: []string{"draft", "published"},
+ },
+ },
+ },
+ },
+ }
+
+ newMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "status_enum",
+ Values: []string{"draft", "pending", "published"},
+ },
+ },
+ },
+ },
+ }
+
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
+ require.NoError(t, err)
+
+ migration, err := schema.GenerateMigration(storepb.Engine_POSTGRES, diff)
+ require.NoError(t, err)
+ t.Logf("Generated migration:\n%s", migration)
+
+ // 'pending' should be added BEFORE 'published'
+ require.Contains(t, migration, "'pending'")
+ require.Contains(t, migration, "BEFORE 'published'")
+ })
+
+ t.Run("Remove enum value - generates warning comment", func(t *testing.T) {
+ // PostgreSQL does NOT support ALTER TYPE ... DROP VALUE
+ // When enum values are removed, we generate a warning comment with instructions
+
+ oldMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "status_enum",
+ Values: []string{"active", "inactive", "archived"},
+ },
+ },
+ },
+ },
+ }
+
+ newMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "status_enum",
+ Values: []string{"active", "inactive"}, // 'archived' removed
+ },
+ },
+ },
+ },
+ }
+
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
+ require.NoError(t, err)
+
+ // Should detect the change
+ require.Equal(t, 1, len(diff.EnumTypeChanges), "Should have 1 enum type change")
+ enumDiff := diff.EnumTypeChanges[0]
+ require.Equal(t, schema.MetadataDiffActionAlter, enumDiff.Action)
+
+ migration, err := schema.GenerateMigration(storepb.Engine_POSTGRES, diff)
+ require.NoError(t, err)
+ t.Logf("Generated migration for enum value removal:\n%s", migration)
+
+ // Should generate warning comment about removed values
+ require.Contains(t, migration, "WARNING")
+ require.Contains(t, migration, "does not support removing enum values")
+ require.Contains(t, migration, "'archived'")
+ require.Contains(t, migration, "RENAME TO")
+ })
+
+ t.Run("Rename enum value - generates warning and adds new value", func(t *testing.T) {
+ // When enum values appear to be renamed (one removed, one added at same position),
+ // we generate a warning for the removed value and ADD VALUE for the new one
+
+ oldMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "priority_enum",
+ Values: []string{"low", "medium", "high"},
+ },
+ },
+ },
+ },
+ }
+
+ newMetadata := &storepb.DatabaseSchemaMetadata{
+ Schemas: []*storepb.SchemaMetadata{
+ {
+ Name: "public",
+ EnumTypes: []*storepb.EnumTypeMetadata{
+ {
+ Name: "priority_enum",
+ Values: []string{"low", "normal", "high"}, // 'medium' renamed to 'normal'
+ },
+ },
+ },
+ },
+ }
+
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
+ require.NoError(t, err)
+
+ // Should detect the change
+ require.Equal(t, 1, len(diff.EnumTypeChanges), "Should have 1 enum type change")
+ enumDiff := diff.EnumTypeChanges[0]
+ require.Equal(t, schema.MetadataDiffActionAlter, enumDiff.Action)
+
+ migration, err := schema.GenerateMigration(storepb.Engine_POSTGRES, diff)
+ require.NoError(t, err)
+ t.Logf("Generated migration for enum value rename:\n%s", migration)
+
+ // Should generate warning for removed 'medium' and ADD VALUE for 'normal'
+ require.Contains(t, migration, "WARNING")
+ require.Contains(t, migration, "'medium'")
+ require.Contains(t, migration, "ADD VALUE 'normal'")
+ })
+}
+
// TestEnumTypeCommentChanges tests that enum type comment changes are properly detected and generated
func TestEnumTypeCommentChanges(t *testing.T) {
// Previous SDL (enum without comment)
diff --git a/backend/plugin/schema/pg/generate_migration.go b/backend/plugin/schema/pg/generate_migration.go
index 0f14c7e4ec..f89ab045b3 100644
--- a/backend/plugin/schema/pg/generate_migration.go
+++ b/backend/plugin/schema/pg/generate_migration.go
@@ -732,6 +732,126 @@ func createEnumTypes(diff *schema.MetadataDiff, buf *strings.Builder) error {
return nil
}
+// alterEnumTypes generates ALTER TYPE ADD VALUE statements for enum value additions.
+func alterEnumTypes(diff *schema.MetadataDiff, buf *strings.Builder) error {
+ for _, enumDiff := range diff.EnumTypeChanges {
+ if enumDiff.Action == schema.MetadataDiffActionAlter {
+ if enumDiff.OldEnumType != nil && enumDiff.NewEnumType != nil {
+ if err := writeAlterEnumTypeAddValues(buf, enumDiff.SchemaName, enumDiff.OldEnumType, enumDiff.NewEnumType); err != nil {
+ return err
+ }
+ }
+ }
+ }
+ return nil
+}
+
+// writeAlterEnumTypeAddValues generates ALTER TYPE ADD VALUE statements for new enum values.
+// PostgreSQL supports adding enum values with ALTER TYPE ... ADD VALUE.
+// New values can be added at the end, before an existing value, or after an existing value.
+// For removed values, a warning comment is generated since PostgreSQL doesn't support DROP VALUE.
+func writeAlterEnumTypeAddValues(out *strings.Builder, schemaName string, oldEnum, newEnum *storepb.EnumTypeMetadata) error {
+ // Build sets for comparison
+ oldValueSet := make(map[string]bool)
+ for _, v := range oldEnum.Values {
+ oldValueSet[v] = true
+ }
+
+ newValueSet := make(map[string]bool)
+ for _, v := range newEnum.Values {
+ newValueSet[v] = true
+ }
+
+ // Find removed values (exist in old but not in new)
+ var removedValues []string
+ for _, v := range oldEnum.Values {
+ if !newValueSet[v] {
+ removedValues = append(removedValues, v)
+ }
+ }
+
+ // Generate warning comment for removed values
+ if len(removedValues) > 0 {
+ _, _ = out.WriteString(`-- WARNING: PostgreSQL does not support removing enum values.`)
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- The following enum values were removed from "`)
+ _, _ = out.WriteString(schemaName)
+ _, _ = out.WriteString(`"."`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`": `)
+ for i, v := range removedValues {
+ if i > 0 {
+ _, _ = out.WriteString(", ")
+ }
+ _, _ = out.WriteString("'")
+ _, _ = out.WriteString(v)
+ _, _ = out.WriteString("'")
+ }
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- To remove enum values, you must recreate the type:`)
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- 1. Update existing data that uses the removed values`)
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- 2. ALTER TYPE "`)
+ _, _ = out.WriteString(schemaName)
+ _, _ = out.WriteString(`"."`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`" RENAME TO "`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`_old";`)
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- 3. CREATE TYPE "`)
+ _, _ = out.WriteString(schemaName)
+ _, _ = out.WriteString(`"."`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`" AS ENUM (...);`)
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- 4. ALTER TABLE ... ALTER COLUMN ... TYPE "`)
+ _, _ = out.WriteString(schemaName)
+ _, _ = out.WriteString(`"."`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`" USING ...;`)
+ _, _ = out.WriteString("\n")
+ _, _ = out.WriteString(`-- 5. DROP TYPE "`)
+ _, _ = out.WriteString(schemaName)
+ _, _ = out.WriteString(`"."`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`_old";`)
+ _, _ = out.WriteString("\n")
+ }
+
+ // Find new values and their positions
+ for i, newValue := range newEnum.Values {
+ if !oldValueSet[newValue] {
+ // This is a new value, generate ALTER TYPE ADD VALUE
+ _, _ = out.WriteString(`ALTER TYPE "`)
+ _, _ = out.WriteString(schemaName)
+ _, _ = out.WriteString(`"."`)
+ _, _ = out.WriteString(newEnum.Name)
+ _, _ = out.WriteString(`" ADD VALUE '`)
+ _, _ = out.WriteString(newValue)
+ _, _ = out.WriteString(`'`)
+
+ // Determine position: if not the last value, add BEFORE clause
+ if i < len(newEnum.Values)-1 {
+ // Find the next value that exists in oldEnum to use as reference
+ for j := i + 1; j < len(newEnum.Values); j++ {
+ if oldValueSet[newEnum.Values[j]] {
+ _, _ = out.WriteString(` BEFORE '`)
+ _, _ = out.WriteString(newEnum.Values[j])
+ _, _ = out.WriteString(`'`)
+ break
+ }
+ }
+ }
+
+ _, _ = out.WriteString(`;`)
+ _, _ = out.WriteString("\n")
+ }
+ }
+ return nil
+}
+
// createSequences creates all new sequences.
func createSequences(diff *schema.MetadataDiff, buf *strings.Builder) error {
for _, seqDiff := range diff.SequenceChanges {
@@ -1122,6 +1242,9 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error
if err := createEnumTypes(diff, buf); err != nil {
return err
}
+ if err := alterEnumTypes(diff, buf); err != nil {
+ return err
+ }
if err := createSequences(diff, buf); err != nil {
return err
}