Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.goindex 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 typesfor 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.goindex 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 generatedfunc 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.goindex 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) errorif 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}