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(pg): add metadata schema diff migration (#20098)
rebelice596acb6d603e
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.goindex 772bce0dfd..8592642d67 100644--- a/backend/api/v1/database_service.go+++ b/backend/api/v1/database_service.go@@ -684,8 +684,9 @@ func (s *DatabaseService) DiffSchema(ctx context.Context, req *connect.Request[vreturn nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get parser engine"))}- // PG/CockroachDB: use omni SDL diff path.- if engine == storepb.Engine_POSTGRES || engine == storepb.Engine_COCKROACHDB {+ // PG/CockroachDB raw schema text still needs the omni SDL diff path. Metadata+ // targets such as changelogs use schema.DiffMigration's metadata path.+ if shouldDiffSchemaViaSDL(engine, req.Msg) {migrationSQL, err := s.diffSchemaViaSDL(ctx, req.Msg, engine)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to compute schema diff"))@@ -693,7 +694,9 @@ func (s *DatabaseService) DiffSchema(ctx context.Context, req *connect.Request[vreturn connect.NewResponse(&v1pb.DiffSchemaResponse{Diff: migrationSQL}), nil}- // Other engines: legacy metadata diff path.+ // Metadata-backed diff path. PostgreSQL/CockroachDB changelog targets use+ // their registered metadata migration here, while other engines keep the+ // existing metadata parser/generator behavior.sourceDBSchema, err := s.getSourceDBMetadata(ctx, req.Msg)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get source schema"))@@ -709,6 +712,14 @@ func (s *DatabaseService) DiffSchema(ctx context.Context, req *connect.Request[vreturn connect.NewResponse(&v1pb.DiffSchemaResponse{Diff: migrationSQL}), nil}+func shouldDiffSchemaViaSDL(engine storepb.Engine, req *v1pb.DiffSchemaRequest) bool {+ if engine != storepb.Engine_POSTGRES && engine != storepb.Engine_COCKROACHDB {+ return false+ }+ _, ok := req.GetTarget().(*v1pb.DiffSchemaRequest_Schema)+ return ok+}+// diffSchemaViaSDL handles PG/CockroachDB DiffSchema using omni SDL diff.func (s *DatabaseService) diffSchemaViaSDL(ctx context.Context, req *v1pb.DiffSchemaRequest, engine storepb.Engine) (string, error) {sourceMetadata, err := s.getSourceDBMetadata(ctx, req)diff --git a/backend/api/v1/database_service_test.go b/backend/api/v1/database_service_test.goindex cfc95a5ea5..0fb7e4ec85 100644--- a/backend/api/v1/database_service_test.go+++ b/backend/api/v1/database_service_test.go@@ -8,10 +8,67 @@ import ("github.com/stretchr/testify/require""github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/store")+func TestShouldDiffSchemaViaSDL(t *testing.T) {+ tests := []struct {+ name string+ engine storepb.Engine+ req *v1pb.DiffSchemaRequest+ want bool+ }{+ {+ name: "postgres raw schema text uses SDL",+ engine: storepb.Engine_POSTGRES,+ req: &v1pb.DiffSchemaRequest{+ Target: &v1pb.DiffSchemaRequest_Schema{Schema: "CREATE TABLE t(id int);"},+ },+ want: true,+ },+ {+ name: "postgres empty raw schema text uses SDL",+ engine: storepb.Engine_POSTGRES,+ req: &v1pb.DiffSchemaRequest{+ Target: &v1pb.DiffSchemaRequest_Schema{Schema: ""},+ },+ want: true,+ },+ {+ name: "postgres changelog target uses metadata diff",+ engine: storepb.Engine_POSTGRES,+ req: &v1pb.DiffSchemaRequest{+ Target: &v1pb.DiffSchemaRequest_Changelog{Changelog: "instances/prod/databases/app/changelogs/123"},+ },+ want: false,+ },+ {+ name: "cockroach raw schema text uses SDL",+ engine: storepb.Engine_COCKROACHDB,+ req: &v1pb.DiffSchemaRequest{+ Target: &v1pb.DiffSchemaRequest_Schema{Schema: "CREATE TABLE t(id int);"},+ },+ want: true,+ },+ {+ name: "mysql raw schema text uses metadata parser",+ engine: storepb.Engine_MYSQL,+ req: &v1pb.DiffSchemaRequest{+ Target: &v1pb.DiffSchemaRequest_Schema{Schema: "CREATE TABLE t(id int);"},+ },+ want: false,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ require.Equal(t, tt.want, shouldDiffSchemaViaSDL(tt.engine, tt.req))+ })+ }+}+func TestListDatabaseFilter(t *testing.T) {testCases := []struct {input stringdiff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.goindex cf6961befa..c9e7447f7a 100644--- a/backend/plugin/schema/differ.go+++ b/backend/plugin/schema/differ.go@@ -1873,19 +1873,40 @@ func compareSequences(diff *MetadataDiff, schemaName string, oldSchema, newSchem}}- // Check for new sequences+ // Check for new and modified sequencesfor seqName, newSeq := range newSeqMap {- if _, exists := oldSeqMap[seqName]; !exists {+ if oldSeq, exists := oldSeqMap[seqName]; !exists {diff.SequenceChanges = append(diff.SequenceChanges, &SequenceDiff{Action: MetadataDiffActionCreate,SchemaName: schemaName,SequenceName: seqName,NewSequence: newSeq,})+ } else if !sequencesEqual(oldSeq, newSeq) {+ diff.SequenceChanges = append(diff.SequenceChanges, &SequenceDiff{+ Action: MetadataDiffActionAlter,+ SchemaName: schemaName,+ SequenceName: seqName,+ OldSequence: oldSeq,+ NewSequence: newSeq,+ })}}}+func sequencesEqual(oldSeq, newSeq *storepb.SequenceMetadata) bool {+ return oldSeq.DataType == newSeq.DataType &&+ oldSeq.Start == newSeq.Start &&+ oldSeq.MinValue == newSeq.MinValue &&+ oldSeq.MaxValue == newSeq.MaxValue &&+ oldSeq.Increment == newSeq.Increment &&+ oldSeq.Cycle == newSeq.Cycle &&+ oldSeq.CacheSize == newSeq.CacheSize &&+ oldSeq.OwnerTable == newSeq.OwnerTable &&+ oldSeq.OwnerColumn == newSeq.OwnerColumn &&+ oldSeq.Comment == newSeq.Comment+}+// compareEnumTypes compares enum types between two schemas.func compareEnumTypes(diff *MetadataDiff, schemaName string, oldSchema, newSchema *model.SchemaMetadata) {oldSchemaProto := oldSchema.GetProto()diff --git a/backend/plugin/schema/pg/metadata_migration.go b/backend/plugin/schema/pg/metadata_migration.gonew file mode 100644index 0000000000..1bfb3f23dc--- /dev/null+++ b/backend/plugin/schema/pg/metadata_migration.go@@ -0,0 +1,1950 @@+package pg++import (+ "fmt"+ "io"+ "slices"+ "strconv"+ "strings"++ "github.com/pkg/errors"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/store/model"+)++const (+ pgTypeCharacterVarying = "character varying"+ pgTypeDoublePrecision = "double precision"+ viewCommentObjectFormat = "VIEW \"%s\".\"%s\""+)++func pgDiffMetadataMigration(oldSchema, newSchema *model.DatabaseMetadata) (string, error) {+ return pgDiffMetadataMigrationForEngine(storepb.Engine_POSTGRES, oldSchema, newSchema)+}++func pgDiffCockroachMetadataMigration(oldSchema, newSchema *model.DatabaseMetadata) (string, error) {+ return pgDiffMetadataMigrationForEngine(storepb.Engine_COCKROACHDB, oldSchema, newSchema)+}++func pgDiffMetadataMigrationForEngine(engine storepb.Engine, oldSchema, newSchema *model.DatabaseMetadata) (string, error) {+ diff, err := schema.GetDatabaseSchemaDiff(engine, oldSchema, newSchema)+ if err != nil {+ return "", err+ }+ augmentMetadataDiffForMigration(diff, oldSchema, newSchema)+ if metadataDiffEmpty(diff) {+ return "", nil+ }+ return pgGenerateMetadataMigration(diff)+}++func metadataDiffEmpty(diff *schema.MetadataDiff) bool {+ return diff == nil ||+ len(diff.SchemaChanges) == 0 &&+ len(diff.TableChanges) == 0 &&+ len(diff.ViewChanges) == 0 &&+ len(diff.MaterializedViewChanges) == 0 &&+ len(diff.FunctionChanges) == 0 &&+ len(diff.ProcedureChanges) == 0 &&+ len(diff.SequenceChanges) == 0 &&+ len(diff.EnumTypeChanges) == 0 &&+ len(diff.ExtensionChanges) == 0 &&+ len(diff.EventTriggerChanges) == 0 &&+ len(diff.EventChanges) == 0 &&+ len(diff.CommentChanges) == 0+}++type affectedTableColumns struct {+ columns map[string]bool+}++func augmentMetadataDiffForMigration(diff *schema.MetadataDiff, oldSchema, newSchema *model.DatabaseMetadata) {+ if diff == nil || oldSchema == nil || newSchema == nil {+ return+ }+ affectedTables := collectDependencySensitiveTableColumns(diff)+ if len(affectedTables) == 0 {+ return+ }+ addUnchangedDependentViews(diff, oldSchema, newSchema, affectedTables)+ addUnchangedDependentMaterializedViews(diff, oldSchema, newSchema, affectedTables)+}++func collectDependencySensitiveTableColumns(diff *schema.MetadataDiff) map[string]affectedTableColumns {+ affectedTables := make(map[string]affectedTableColumns)+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action != schema.MetadataDiffActionAlter {+ continue+ }+ for _, columnDiff := range tableDiff.ColumnChanges {+ columnName := dependentObjectBlockingColumnName(columnDiff)+ if columnName == "" {+ continue+ }+ tableID := getMigrationObjectID(tableDiff.SchemaName, tableDiff.TableName)+ affected := affectedTables[tableID]+ if affected.columns == nil {+ affected.columns = make(map[string]bool)+ }+ affected.columns[columnName] = true+ affectedTables[tableID] = affected+ }+ }+ return affectedTables+}++func dependentObjectBlockingColumnName(columnDiff *schema.ColumnDiff) string {+ switch columnDiff.Action {+ case schema.MetadataDiffActionDrop:+ return columnDiff.OldColumn.GetName()+ case schema.MetadataDiffActionAlter:+ if columnDiff.OldColumn.GetType() != columnDiff.NewColumn.GetType() {+ return columnDiff.OldColumn.GetName()+ }+ return ""+ default:+ return ""+ }+}++func addUnchangedDependentViews(diff *schema.MetadataDiff, oldSchema, newSchema *model.DatabaseMetadata, affectedTables map[string]affectedTableColumns) {+ changedViews := make(map[string]bool)+ for _, viewDiff := range diff.ViewChanges {+ changedViews[getMigrationObjectID(viewDiff.SchemaName, viewDiff.ViewName)] = true+ }+ for _, schemaMeta := range newSchema.GetProto().GetSchemas() {+ oldSchemaMeta := oldSchema.GetSchemaMetadata(schemaMeta.GetName())+ if oldSchemaMeta == nil {+ continue+ }+ for _, newView := range schemaMeta.GetViews() {+ viewID := getMigrationObjectID(schemaMeta.GetName(), newView.GetName())+ if changedViews[viewID] || newView.GetSkipDump() {+ continue+ }+ oldView := oldSchemaMeta.GetView(newView.GetName())+ if oldView == nil || oldView.GetSkipDump() {+ continue+ }+ if !dependencyColumnsReferenceAffectedTable(oldView.GetDependencyColumns(), affectedTables) && !dependencyColumnsReferenceAffectedTable(newView.GetDependencyColumns(), affectedTables) {+ continue+ }+ diff.ViewChanges = append(diff.ViewChanges, &schema.ViewDiff{+ Action: schema.MetadataDiffActionAlter,+ SchemaName: schemaMeta.GetName(),+ ViewName: newView.GetName(),+ OldView: oldView,+ NewView: newView,+ })+ changedViews[viewID] = true+ }+ }+}++func addUnchangedDependentMaterializedViews(diff *schema.MetadataDiff, oldSchema, newSchema *model.DatabaseMetadata, affectedTables map[string]affectedTableColumns) {+ changedViews := make(map[string]bool)+ for _, viewDiff := range diff.MaterializedViewChanges {+ changedViews[getMigrationObjectID(viewDiff.SchemaName, viewDiff.MaterializedViewName)] = true+ }+ for _, schemaMeta := range newSchema.GetProto().GetSchemas() {+ oldSchemaMeta := oldSchema.GetSchemaMetadata(schemaMeta.GetName())+ if oldSchemaMeta == nil {+ continue+ }+ for _, newView := range schemaMeta.GetMaterializedViews() {+ viewID := getMigrationObjectID(schemaMeta.GetName(), newView.GetName())+ if changedViews[viewID] || newView.GetSkipDump() {+ continue+ }+ oldView := oldSchemaMeta.GetMaterializedView(newView.GetName())+ if oldView == nil || oldView.GetSkipDump() {+ continue+ }+ if !dependencyColumnsReferenceAffectedTable(oldView.GetDependencyColumns(), affectedTables) && !dependencyColumnsReferenceAffectedTable(newView.GetDependencyColumns(), affectedTables) {+ continue+ }+ diff.MaterializedViewChanges = append(diff.MaterializedViewChanges, &schema.MaterializedViewDiff{+ Action: schema.MetadataDiffActionAlter,+ SchemaName: schemaMeta.GetName(),+ MaterializedViewName: newView.GetName(),+ OldMaterializedView: oldView,+ NewMaterializedView: newView,+ })+ changedViews[viewID] = true+ }+ }+}++func dependencyColumnsReferenceAffectedTable(dependencies []*storepb.DependencyColumn, affectedTables map[string]affectedTableColumns) bool {+ for _, dep := range dependencies {+ affected, ok := affectedTables[getMigrationObjectID(dep.GetSchema(), dep.GetTable())]+ if !ok {+ continue+ }+ if dep.GetColumn() == "" || affected.columns[dep.GetColumn()] {+ return true+ }+ }+ return false+}++func pgGenerateMetadataMigration(diff *schema.MetadataDiff) (string, error) {+ if err := validateSupportedMetadataDiff(diff); err != nil {+ return "", err+ }++ var buf strings.Builder+ if err := writeDropPhase(&buf, diff); err != nil {+ return "", err+ }+ if err := writeCreateOrAlterPhase(&buf, diff); err != nil {+ return "", err+ }+ return buf.String(), nil+}++func writeDropPhase(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, eventTriggerDiff := range diff.EventTriggerChanges {+ if eventTriggerDiff.Action == schema.MetadataDiffActionDrop || eventTriggerDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeEventTriggerDiff(out, eventTriggerDiff); err != nil {+ return err+ }+ }+ }++ if err := writeDropTableTriggers(out, diff); err != nil {+ return err+ }+ if err := writeDropAlterTableForeignKeys(out, diff); err != nil {+ return err+ }+ if err := writeDropTableForeignKeysForTableDrops(out, diff); err != nil {+ return err+ }+ if err := writeDropSequenceOwnershipBeforeTableDrops(out, diff); err != nil {+ return err+ }+ if err := writeDropDependentObjects(out, diff); err != nil {+ return err+ }+ if err := writeDropAlterTableObjects(out, diff); err != nil {+ return err+ }++ for _, sequenceDiff := range diff.SequenceChanges {+ if sequenceDiff.Action == schema.MetadataDiffActionDrop {+ if isSequenceOwnedByDroppedTable(diff, sequenceDiff.SchemaName, sequenceDiff.OldSequence) {+ continue+ }+ if err := writeSequenceDiff(out, sequenceDiff); err != nil {+ return err+ }+ }+ }+ for _, enumDiff := range diff.EnumTypeChanges {+ if enumDiff.Action == schema.MetadataDiffActionDrop {+ if err := writeEnumTypeDiff(out, enumDiff); err != nil {+ return err+ }+ }+ }+ for _, extensionDiff := range diff.ExtensionChanges {+ if extensionDiff.Action == schema.MetadataDiffActionDrop {+ if err := writeExtensionDiff(out, extensionDiff); err != nil {+ return err+ }+ }+ }+ for _, schemaDiff := range diff.SchemaChanges {+ if schemaDiff.Action == schema.MetadataDiffActionDrop {+ if err := writeSchemaDiff(out, schemaDiff); err != nil {+ return err+ }+ }+ }+ return nil+}++func writeCreateOrAlterPhase(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, schemaDiff := range diff.SchemaChanges {+ if schemaDiff.Action == schema.MetadataDiffActionCreate {+ if err := writeSchemaDiff(out, schemaDiff); err != nil {+ return err+ }+ }+ }+ for _, extensionDiff := range diff.ExtensionChanges {+ if extensionDiff.Action == schema.MetadataDiffActionCreate {+ if err := writeExtensionDiff(out, extensionDiff); err != nil {+ return err+ }+ }+ }+ for _, enumDiff := range diff.EnumTypeChanges {+ if enumDiff.Action == schema.MetadataDiffActionCreate || enumDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeEnumTypeDiff(out, enumDiff); err != nil {+ return err+ }+ }+ }+ for _, sequenceDiff := range diff.SequenceChanges {+ if sequenceDiff.Action == schema.MetadataDiffActionCreate || sequenceDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeSequenceDiff(out, sequenceDiff); err != nil {+ return err+ }+ }+ }++ if err := writeCreateTables(out, diff); err != nil {+ return err+ }+ if err := writeAlterTables(out, diff); err != nil {+ return err+ }+ if err := writeSequenceOwnershipAfterTables(out, diff); err != nil {+ return err+ }+ if err := writeCreateRoutinesViewsAndMaterializedViews(out, diff); err != nil {+ return err+ }+ if err := writeCreateTableForeignKeys(out, diff); err != nil {+ return err+ }+ if err := writeCreateTableTriggers(out, diff); err != nil {+ return err+ }+ if err := writeCommentChanges(out, diff); err != nil {+ return err+ }+ for _, eventTriggerDiff := range diff.EventTriggerChanges {+ if eventTriggerDiff.Action == schema.MetadataDiffActionCreate || eventTriggerDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeEventTriggerDiff(out, eventTriggerDiff); err != nil {+ return err+ }+ }+ }+ return nil+}++func validateSupportedMetadataDiff(diff *schema.MetadataDiff) error {+ if len(diff.EventChanges) > 0 {+ return errors.New("unsupported PostgreSQL metadata diff: event")+ }+ return nil+}++type metadataObjectMaps struct {+ tables map[string]*schema.TableDiff+ views map[string]*schema.ViewDiff+ materializedViews map[string]*schema.MaterializedViewDiff+ functions map[string]*schema.FunctionDiff+ procedures map[string]*schema.ProcedureDiff+}++func newMetadataObjectMaps() *metadataObjectMaps {+ return &metadataObjectMaps{+ tables: make(map[string]*schema.TableDiff),+ views: make(map[string]*schema.ViewDiff),+ materializedViews: make(map[string]*schema.MaterializedViewDiff),+ functions: make(map[string]*schema.FunctionDiff),+ procedures: make(map[string]*schema.ProcedureDiff),+ }+}++func getMigrationObjectID(schemaName, objectName string) string {+ return fmt.Sprintf("%s.%s", schemaName, objectName)+}++func buildDropObjectMaps(diff *schema.MetadataDiff) *metadataObjectMaps {+ maps := newMetadataObjectMaps()+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionDrop {+ maps.tables[getMigrationObjectID(tableDiff.SchemaName, tableDiff.TableName)] = tableDiff+ }+ }+ for _, viewDiff := range diff.ViewChanges {+ if viewDiff.Action == schema.MetadataDiffActionDrop || alteredViewDependsOnTableDDL(viewDiff, diff) {+ maps.views[getMigrationObjectID(viewDiff.SchemaName, viewDiff.ViewName)] = viewDiff+ }+ }+ for _, materializedViewDiff := range diff.MaterializedViewChanges {+ if materializedViewDiff.Action == schema.MetadataDiffActionDrop || materializedViewDiff.Action == schema.MetadataDiffActionAlter {+ maps.materializedViews[getMigrationObjectID(materializedViewDiff.SchemaName, materializedViewDiff.MaterializedViewName)] = materializedViewDiff+ }+ }+ for _, functionDiff := range diff.FunctionChanges {+ if functionDiff.Action == schema.MetadataDiffActionDrop {+ maps.functions[getMigrationObjectID(functionDiff.SchemaName, functionDiff.FunctionName)] = functionDiff+ }+ }+ for _, procedureDiff := range diff.ProcedureChanges {+ if procedureDiff.Action == schema.MetadataDiffActionDrop {+ maps.procedures[getMigrationObjectID(procedureDiff.SchemaName, procedureDiff.ProcedureName)] = procedureDiff+ }+ }+ return maps+}++func alteredViewDependsOnTableDDL(viewDiff *schema.ViewDiff, diff *schema.MetadataDiff) bool {+ if viewDiff.Action != schema.MetadataDiffActionAlter {+ return false+ }+ tableDDLTargets := make(map[string]bool)+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionDrop || tableDiff.Action == schema.MetadataDiffActionAlter {+ tableDDLTargets[getMigrationObjectID(tableDiff.SchemaName, tableDiff.TableName)] = true+ }+ }+ for _, dep := range viewDiff.OldView.GetDependencyColumns() {+ if tableDDLTargets[getMigrationObjectID(dep.GetSchema(), dep.GetTable())] {+ return true+ }+ }+ return false+}++func buildCreateObjectMaps(diff *schema.MetadataDiff) *metadataObjectMaps {+ maps := newMetadataObjectMaps()+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionCreate {+ maps.tables[getMigrationObjectID(tableDiff.SchemaName, tableDiff.TableName)] = tableDiff+ }+ }+ for _, viewDiff := range diff.ViewChanges {+ if viewDiff.Action == schema.MetadataDiffActionCreate || viewDiff.Action == schema.MetadataDiffActionAlter {+ maps.views[getMigrationObjectID(viewDiff.SchemaName, viewDiff.ViewName)] = viewDiff+ }+ }+ for _, materializedViewDiff := range diff.MaterializedViewChanges {+ if materializedViewDiff.Action == schema.MetadataDiffActionCreate || materializedViewDiff.Action == schema.MetadataDiffActionAlter {+ maps.materializedViews[getMigrationObjectID(materializedViewDiff.SchemaName, materializedViewDiff.MaterializedViewName)] = materializedViewDiff+ }+ }+ for _, functionDiff := range diff.FunctionChanges {+ if functionDiff.Action == schema.MetadataDiffActionCreate || functionDiff.Action == schema.MetadataDiffActionAlter {+ maps.functions[getMigrationObjectID(functionDiff.SchemaName, functionDiff.FunctionName)] = functionDiff+ }+ }+ for _, procedureDiff := range diff.ProcedureChanges {+ if procedureDiff.Action == schema.MetadataDiffActionCreate || procedureDiff.Action == schema.MetadataDiffActionAlter {+ maps.procedures[getMigrationObjectID(procedureDiff.SchemaName, procedureDiff.ProcedureName)] = procedureDiff+ }+ }+ return maps+}++func sortedMapKeys[T any](items map[string]T) []string {+ keys := make([]string, 0, len(items))+ for key := range items {+ keys = append(keys, key)+ }+ slices.Sort(keys)+ return keys+}++func writeDropTableTriggers(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ switch tableDiff.Action {+ case schema.MetadataDiffActionDrop:+ for _, trigger := range tableDiff.OldTable.GetTriggers() {+ if err := writeDropTrigger(out, tableDiff.SchemaName, tableDiff.TableName, trigger.Name); err != nil {+ return err+ }+ }+ case schema.MetadataDiffActionAlter:+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionDrop || triggerDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropTrigger(out, tableDiff.SchemaName, tableDiff.TableName, triggerDiff.TriggerName); err != nil {+ return err+ }+ }+ }+ default:+ }+ }+ return nil+}++func writeDropAlterTableForeignKeys(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action != schema.MetadataDiffActionAlter {+ continue+ }+ for _, fkDiff := range tableDiff.ForeignKeyChanges {+ if fkDiff.Action == schema.MetadataDiffActionDrop || fkDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropForeignKey(out, tableDiff.SchemaName, tableDiff.TableName, fkDiff.OldForeignKey.GetName()); err != nil {+ return err+ }+ }+ }+ }+ return nil+}++func writeDropTableForeignKeysForTableDrops(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action != schema.MetadataDiffActionDrop {+ continue+ }+ for _, fk := range tableDiff.OldTable.GetForeignKeys() {+ if err := writeDropForeignKey(out, tableDiff.SchemaName, tableDiff.TableName, fk.GetName()); err != nil {+ return err+ }+ }+ }+ return nil+}++func isSequenceOwnedByDroppedTable(diff *schema.MetadataDiff, schemaName string, sequence *storepb.SequenceMetadata) bool {+ if sequence.GetOwnerTable() == "" || sequence.GetOwnerColumn() == "" {+ return false+ }+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionDrop &&+ tableDiff.SchemaName == schemaName &&+ tableDiff.TableName == sequence.GetOwnerTable() {+ return true+ }+ }+ return false+}++func writeDropDependentObjects(out *strings.Builder, diff *schema.MetadataDiff) error {+ maps := buildDropObjectMaps(diff)+ graph := base.NewGraph()+ for _, id := range sortedMapKeys(maps.tables) {+ graph.AddNode(id)+ }+ for _, id := range sortedMapKeys(maps.views) {+ graph.AddNode(id)+ }+ for _, id := range sortedMapKeys(maps.materializedViews) {+ graph.AddNode(id)+ }+ for _, id := range sortedMapKeys(maps.functions) {+ graph.AddNode(id)+ }+ for _, id := range sortedMapKeys(maps.procedures) {+ graph.AddNode(id)+ }+ for _, tableID := range sortedMapKeys(maps.tables) {+ for _, id := range sortedMapKeys(maps.views) {+ graph.AddEdge(id, tableID)+ }+ for _, id := range sortedMapKeys(maps.materializedViews) {+ graph.AddEdge(id, tableID)+ }+ for _, id := range sortedMapKeys(maps.procedures) {+ graph.AddEdge(id, tableID)+ }+ for _, id := range sortedMapKeys(maps.functions) {+ graph.AddEdge(id, tableID)+ }+ }++ hasNode := func(id string) bool {+ _, ok := graph.NodeMap[id]+ return ok+ }+ for viewID, viewDiff := range maps.views {+ for _, dep := range viewDiff.OldView.GetDependencyColumns() {+ depID := getMigrationObjectID(dep.GetSchema(), dep.GetTable())+ if hasNode(depID) {+ graph.AddEdge(viewID, depID)+ }+ }+ }+ for viewID, viewDiff := range maps.materializedViews {+ for _, dep := range viewDiff.OldMaterializedView.GetDependencyColumns() {+ depID := getMigrationObjectID(dep.GetSchema(), dep.GetTable())+ if hasNode(depID) {+ graph.AddEdge(viewID, depID)+ }+ }+ }+ for functionID, functionDiff := range maps.functions {+ for _, dep := range functionDiff.OldFunction.GetDependencyTables() {+ depID := getMigrationObjectID(dep.GetSchema(), dep.GetTable())+ if hasNode(depID) {+ graph.AddEdge(functionID, depID)+ }+ }+ }+ for tableID, tableDiff := range maps.tables {+ for _, fk := range tableDiff.OldTable.GetForeignKeys() {+ depID := getMigrationObjectID(fk.GetReferencedSchema(), fk.GetReferencedTable())+ if hasNode(depID) {+ graph.AddEdge(tableID, depID)+ }+ }+ }++ orderedIDs, err := graph.TopologicalSort()+ if err != nil {+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.views)...)+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.materializedViews)...)+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.procedures)...)+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.functions)...)+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.tables)...)+ }+ for _, id := range orderedIDs {+ switch {+ case maps.views[id] != nil:+ if err := writeDropView(out, maps.views[id].SchemaName, maps.views[id].ViewName); err != nil {+ return err+ }+ case maps.materializedViews[id] != nil:+ if err := writeDropMaterializedView(out, maps.materializedViews[id].SchemaName, maps.materializedViews[id].MaterializedViewName); err != nil {+ return err+ }+ case maps.procedures[id] != nil:+ if err := writeProcedureDiff(out, maps.procedures[id]); err != nil {+ return err+ }+ case maps.functions[id] != nil:+ if err := writeFunctionDiff(out, maps.functions[id]); err != nil {+ return err+ }+ case maps.tables[id] != nil:+ if err := writeTableDiff(out, maps.tables[id]); err != nil {+ return err+ }+ default:+ }+ }+ return nil+}++func writeDropAlterTableObjects(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action != schema.MetadataDiffActionAlter {+ continue+ }+ for _, partitionDiff := range tableDiff.PartitionChanges {+ if partitionDiff.Action == schema.MetadataDiffActionDrop {+ if err := writeDropPartition(out, tableDiff.SchemaName, partitionDiff.OldPartition); err != nil {+ return err+ }+ }+ }+ for _, primaryKeyDiff := range tableDiff.PrimaryKeyChanges {+ if primaryKeyDiff.Action == schema.MetadataDiffActionDrop || primaryKeyDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropTableConstraint(out, tableDiff.SchemaName, tableDiff.TableName, primaryKeyDiff.OldPrimaryKey.GetName()); err != nil {+ return err+ }+ }+ }+ for _, uniqueConstraintDiff := range tableDiff.UniqueConstraintChanges {+ if uniqueConstraintDiff.Action == schema.MetadataDiffActionDrop || uniqueConstraintDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropTableConstraint(out, tableDiff.SchemaName, tableDiff.TableName, uniqueConstraintDiff.OldUniqueConstraint.GetName()); err != nil {+ return err+ }+ }+ }+ for _, checkDiff := range tableDiff.CheckConstraintChanges {+ if checkDiff.Action == schema.MetadataDiffActionDrop || checkDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropTableConstraint(out, tableDiff.SchemaName, tableDiff.TableName, checkDiff.OldCheckConstraint.GetName()); err != nil {+ return err+ }+ }+ }+ for _, excludeDiff := range tableDiff.ExcludeConstraintChanges {+ if excludeDiff.Action == schema.MetadataDiffActionDrop || excludeDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropTableConstraint(out, tableDiff.SchemaName, tableDiff.TableName, excludeDiff.OldExcludeConstraint.GetName()); err != nil {+ return err+ }+ }+ }+ for _, indexDiff := range tableDiff.IndexChanges {+ if indexDiff.Action == schema.MetadataDiffActionDrop || indexDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeDropIndexDiff(out, tableDiff.SchemaName, tableDiff.TableName, indexDiff.OldIndex); err != nil {+ return err+ }+ }+ }+ for _, columnDiff := range tableDiff.ColumnChanges {+ if columnDiff.Action == schema.MetadataDiffActionDrop {+ if err := writeColumnDiff(out, tableDiff.SchemaName, tableDiff.TableName, columnDiff); err != nil {+ return err+ }+ }+ }+ }+ return nil+}++func writeCreateTables(out *strings.Builder, diff *schema.MetadataDiff) error {+ maps := buildCreateObjectMaps(diff)+ graph := base.NewGraph()+ for _, id := range sortedMapKeys(maps.tables) {+ graph.AddNode(id)+ }+ for tableID, tableDiff := range maps.tables {+ for _, fk := range tableDiff.NewTable.GetForeignKeys() {+ depID := getMigrationObjectID(fk.GetReferencedSchema(), fk.GetReferencedTable())+ if _, ok := maps.tables[depID]; ok {+ graph.AddEdge(depID, tableID)+ }+ }+ }++ orderedIDs, err := graph.TopologicalSort()+ if err != nil {+ orderedIDs = sortedMapKeys(maps.tables)+ }+ for _, id := range orderedIDs {+ if err := writeTableDiff(out, maps.tables[id]); err != nil {+ return err+ }+ }+ return nil+}++func writeAlterTables(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeAlterTableDiff(out, tableDiff); err != nil {+ return err+ }+ }+ }+ return nil+}++func writeDropSequenceOwnershipBeforeTableDrops(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, sequenceDiff := range diff.SequenceChanges {+ if sequenceDiff.Action != schema.MetadataDiffActionAlter || !sequenceOwnershipChanged(sequenceDiff.OldSequence, sequenceDiff.NewSequence) {+ continue+ }+ if sequenceDiff.OldSequence.GetOwnerTable() == "" || sequenceDiff.OldSequence.GetOwnerColumn() == "" {+ continue+ }+ if !tableIsDropped(diff, sequenceDiff.SchemaName, sequenceDiff.OldSequence.GetOwnerTable()) {+ continue+ }+ if err := writeAlterSequenceOwnedByNone(out, sequenceDiff.SchemaName, sequenceDiff.SequenceName); err != nil {+ return err+ }+ }+ return nil+}++func writeSequenceOwnershipAfterTables(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, sequenceDiff := range diff.SequenceChanges {+ switch sequenceDiff.Action {+ case schema.MetadataDiffActionCreate:+ if sequenceDiff.NewSequence.GetOwnerTable() != "" && sequenceDiff.NewSequence.GetOwnerColumn() != "" {+ if err := writeAlterSequenceOwnedBy(out, sequenceDiff.SchemaName, sequenceDiff.NewSequence); err != nil {+ return err+ }+ }+ case schema.MetadataDiffActionAlter:+ if !sequenceOwnershipChanged(sequenceDiff.OldSequence, sequenceDiff.NewSequence) {+ continue+ }+ if sequenceDiff.NewSequence.GetOwnerTable() != "" && sequenceDiff.NewSequence.GetOwnerColumn() != "" {+ if err := writeAlterSequenceOwnedBy(out, sequenceDiff.SchemaName, sequenceDiff.NewSequence); err != nil {+ return err+ }+ } else if !tableIsDropped(diff, sequenceDiff.SchemaName, sequenceDiff.OldSequence.GetOwnerTable()) {+ if err := writeAlterSequenceOwnedByNone(out, sequenceDiff.SchemaName, sequenceDiff.SequenceName); err != nil {+ return err+ }+ }+ default:+ }+ }+ return nil+}++func sequenceOwnershipChanged(oldSequence, newSequence *storepb.SequenceMetadata) bool {+ return oldSequence.GetOwnerTable() != newSequence.GetOwnerTable() || oldSequence.GetOwnerColumn() != newSequence.GetOwnerColumn()+}++func tableIsDropped(diff *schema.MetadataDiff, schemaName, tableName string) bool {+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionDrop && tableDiff.SchemaName == schemaName && tableDiff.TableName == tableName {+ return true+ }+ }+ return false+}++func writeCreateRoutinesViewsAndMaterializedViews(out *strings.Builder, diff *schema.MetadataDiff) error {+ maps := buildCreateObjectMaps(diff)+ dependentFunctions := functionsDependingOnCreatedViewsOrMaterializedViews(maps)+ for _, id := range sortedMapKeys(maps.functions) {+ if dependentFunctions[id] {+ continue+ }+ if err := writeFunctionDiff(out, maps.functions[id]); err != nil {+ return err+ }+ }+ for _, id := range sortedMapKeys(maps.procedures) {+ if err := writeProcedureDiff(out, maps.procedures[id]); err != nil {+ return err+ }+ }++ graph := base.NewGraph()+ for _, id := range sortedMapKeys(maps.views) {+ graph.AddNode(id)+ }+ for _, id := range sortedMapKeys(maps.materializedViews) {+ graph.AddNode(id)+ }+ for _, id := range sortedMapKeys(dependentFunctions) {+ graph.AddNode(id)+ }+ hasNode := func(id string) bool {+ _, ok := graph.NodeMap[id]+ return ok+ }+ for viewID, viewDiff := range maps.views {+ for _, dep := range viewDiff.NewView.GetDependencyColumns() {+ depID := getMigrationObjectID(dep.GetSchema(), dep.GetTable())+ if hasNode(depID) {+ graph.AddEdge(depID, viewID)+ }+ }+ }+ for viewID, viewDiff := range maps.materializedViews {+ for _, dep := range viewDiff.NewMaterializedView.GetDependencyColumns() {+ depID := getMigrationObjectID(dep.GetSchema(), dep.GetTable())+ if hasNode(depID) {+ graph.AddEdge(depID, viewID)+ }+ }+ }+ for functionID := range dependentFunctions {+ for _, dep := range maps.functions[functionID].NewFunction.GetDependencyTables() {+ depID := getMigrationObjectID(dep.GetSchema(), dep.GetTable())+ if hasNode(depID) {+ graph.AddEdge(depID, functionID)+ }+ }+ }+ orderedIDs, err := graph.TopologicalSort()+ if err != nil {+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.views)...)+ orderedIDs = append(orderedIDs, sortedMapKeys(maps.materializedViews)...)+ orderedIDs = append(orderedIDs, sortedMapKeys(dependentFunctions)...)+ }+ for _, id := range orderedIDs {+ switch {+ case maps.views[id] != nil:+ if err := writeViewDiff(out, maps.views[id]); err != nil {+ return err+ }+ case maps.materializedViews[id] != nil:+ if err := writeCreateMaterializedViewDiff(out, maps.materializedViews[id]); err != nil {+ return err+ }+ case maps.functions[id] != nil:+ if err := writeFunctionDiff(out, maps.functions[id]); err != nil {+ return err+ }+ default:+ }+ }+ return nil+}++func functionsDependingOnCreatedViewsOrMaterializedViews(maps *metadataObjectMaps) map[string]bool {+ viewIDs := make(map[string]bool)+ for id := range maps.views {+ viewIDs[id] = true+ }+ for id := range maps.materializedViews {+ viewIDs[id] = true+ }+ dependentFunctions := make(map[string]bool)+ for functionID, functionDiff := range maps.functions {+ for _, dep := range functionDiff.NewFunction.GetDependencyTables() {+ if viewIDs[getMigrationObjectID(dep.GetSchema(), dep.GetTable())] {+ dependentFunctions[functionID] = true+ break+ }+ }+ }+ return dependentFunctions+}++func writeCreateTableForeignKeys(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ switch tableDiff.Action {+ case schema.MetadataDiffActionCreate:+ for _, fk := range tableDiff.NewTable.GetForeignKeys() {+ if err := writeForeignKey(out, tableDiff.SchemaName, tableDiff.TableName, fk); err != nil {+ return err+ }+ }+ case schema.MetadataDiffActionAlter:+ for _, fkDiff := range tableDiff.ForeignKeyChanges {+ if fkDiff.Action == schema.MetadataDiffActionCreate || fkDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeForeignKey(out, tableDiff.SchemaName, tableDiff.TableName, fkDiff.NewForeignKey); err != nil {+ return err+ }+ }+ }+ default:+ }+ }+ return nil+}++func writeCreateTableTriggers(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, tableDiff := range diff.TableChanges {+ switch tableDiff.Action {+ case schema.MetadataDiffActionCreate:+ for _, trigger := range tableDiff.NewTable.GetTriggers() {+ if err := writeTrigger(out, tableDiff.SchemaName, tableDiff.TableName, trigger); err != nil {+ return err+ }+ }+ case schema.MetadataDiffActionAlter:+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionCreate || triggerDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeTrigger(out, tableDiff.SchemaName, tableDiff.TableName, triggerDiff.NewTrigger); err != nil {+ return err+ }+ }+ }+ default:+ }+ }+ return nil+}++func writeCommentChanges(out *strings.Builder, diff *schema.MetadataDiff) error {+ for _, commentDiff := range diff.CommentChanges {+ if err := writeCommentDiff(out, commentDiff); err != nil {+ return err+ }+ }+ return nil+}++func writeTableDiff(out *strings.Builder, tableDiff *schema.TableDiff) error {+ switch tableDiff.Action {+ case schema.MetadataDiffActionCreate:+ return writeTableForMetadataMigration(out, tableDiff.SchemaName, tableDiff.NewTable)+ case schema.MetadataDiffActionDrop:+ _, err := fmt.Fprintf(out, "DROP TABLE \"%s\".\"%s\";\n\n", tableDiff.SchemaName, tableDiff.TableName)+ return err+ case schema.MetadataDiffActionAlter:+ return writeAlterTableDiff(out, tableDiff)+ default:+ return nil+ }+}++func writeTableForMetadataMigration(out *strings.Builder, schemaName string, table *storepb.TableMetadata) error {+ if err := writeCreateTableForMetadataMigration(out, schemaName, table); err != nil {+ return err+ }+ if len(table.Partitions) > 0 {+ if err := writePartitionClause(out, table.Partitions[0]); err != nil {+ return err+ }+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ if table.GetComment() != "" {+ if err := writeTableComment(out, schemaName, table); err != nil {+ return err+ }+ }+ for _, column := range table.GetColumns() {+ if column.GetComment() != "" {+ if err := writeColumnComment(out, schemaName, table.GetName(), column); err != nil {+ return err+ }+ }+ }+ for _, partition := range table.GetPartitions() {+ if err := writePartitionTable(out, schemaName, table.GetColumns(), partition); err != nil {+ return err+ }+ }+ for _, partition := range table.GetPartitions() {+ if err := writeAttachPartition(out, schemaName, table.GetName(), partition); err != nil {+ return err+ }+ }+ for _, index := range table.GetIndexes() {+ if index.GetPrimary() {+ if err := writePrimaryKey(out, schemaName, table.GetName(), index); err != nil {+ return err+ }+ }+ }+ for _, partition := range table.GetPartitions() {+ if err := writePartitionPrimaryKey(out, schemaName, partition); err != nil {+ return err+ }+ }+ for _, index := range table.GetIndexes() {+ if index.GetUnique() && !index.GetPrimary() && index.GetIsConstraint() {+ if err := writeUniqueKey(out, schemaName, table.GetName(), index); err != nil {+ return err+ }+ }+ }+ for _, partition := range table.GetPartitions() {+ if err := writePartitionUniqueKey(out, schemaName, partition); err != nil {+ return err+ }+ }+ for _, index := range table.GetIndexes() {+ if !index.GetPrimary() && !index.GetIsConstraint() {+ if err := writeCreateRegularIndex(out, schemaName, table.GetName(), index, len(table.GetPartitions()) > 0); err != nil {+ return err+ }+ }+ }+ for _, partition := range table.GetPartitions() {+ if err := writePartitionIndexForMetadataMigration(out, schemaName, partition); err != nil {+ return err+ }+ }+ for _, partition := range table.GetPartitions() {+ if err := writeAttachPartitionIndex(out, schemaName, partition); err != nil {+ return err+ }+ }+ return nil+}++func writeCreateTableForMetadataMigration(out *strings.Builder, schemaName string, table *storepb.TableMetadata) error {+ if _, err := fmt.Fprintf(out, "CREATE TABLE \"%s\".\"%s\" (", schemaName, table.GetName()); err != nil {+ return err+ }+ for i, column := range table.GetColumns() {+ if i > 0 {+ if _, err := out.WriteString(","); err != nil {+ return err+ }+ }+ if _, err := out.WriteString("\n "); err != nil {+ return err+ }+ if err := writeColumnDefinition(out, column); err != nil {+ return err+ }+ }+ for _, check := range table.GetCheckConstraints() {+ if _, err := out.WriteString(",\n "); err != nil {+ return err+ }+ if _, err := fmt.Fprintf(out, "CONSTRAINT \"%s\" CHECK %s", check.GetName(), check.GetExpression()); err != nil {+ return err+ }+ }+ for _, exclude := range table.GetExcludeConstraints() {+ if _, err := out.WriteString(",\n "); err != nil {+ return err+ }+ if _, err := fmt.Fprintf(out, "CONSTRAINT \"%s\" %s", exclude.GetName(), exclude.GetExpression()); err != nil {+ return err+ }+ }+ _, err := out.WriteString("\n)")+ return err+}++func writeDropPartition(out *strings.Builder, schemaName string, partition *storepb.TablePartitionMetadata) error {+ if partition == nil {+ return nil+ }+ for _, subpartition := range partition.GetSubpartitions() {+ if err := writeDropPartition(out, schemaName, subpartition); err != nil {+ return err+ }+ }+ _, err := fmt.Fprintf(out, "DROP TABLE \"%s\".\"%s\";\n\n", schemaName, partition.GetName())+ return err+}++func writeCreatePartitionDiff(out *strings.Builder, schemaName, tableName string, columns []*storepb.ColumnMetadata, partition *storepb.TablePartitionMetadata) error {+ if partition == nil {+ return nil+ }+ if err := writePartitionTable(out, schemaName, columns, partition); err != nil {+ return err+ }+ if err := writeAttachPartition(out, schemaName, tableName, partition); err != nil {+ return err+ }+ if err := writePartitionPrimaryKey(out, schemaName, partition); err != nil {+ return err+ }+ if err := writePartitionUniqueKey(out, schemaName, partition); err != nil {+ return err+ }+ if err := writePartitionIndexForMetadataMigration(out, schemaName, partition); err != nil {+ return err+ }+ return writeAttachPartitionIndex(out, schemaName, partition)+}++func writePartitionIndexForMetadataMigration(out *strings.Builder, schemaName string, partition *storepb.TablePartitionMetadata) error {+ for _, index := range partition.GetIndexes() {+ if !index.GetIsConstraint() && !index.GetPrimary() {+ if err := writeCreateRegularIndex(out, schemaName, partition.GetName(), index, len(partition.GetSubpartitions()) > 0); err != nil {+ return err+ }+ }+ }+ for _, subpartition := range partition.GetSubpartitions() {+ if err := writePartitionIndexForMetadataMigration(out, schemaName, subpartition); err != nil {+ return err+ }+ }+ return nil+}++func writeAlterTableDiff(out *strings.Builder, tableDiff *schema.TableDiff) error {+ for _, columnDiff := range tableDiff.ColumnChanges {+ if columnDiff.Action == schema.MetadataDiffActionDrop {+ continue+ }+ if err := writeColumnDiff(out, tableDiff.SchemaName, tableDiff.TableName, columnDiff); err != nil {+ return err+ }+ }+ for _, partitionDiff := range tableDiff.PartitionChanges {+ if partitionDiff.Action == schema.MetadataDiffActionCreate {+ if err := writeCreatePartitionDiff(out, tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable.GetColumns(), partitionDiff.NewPartition); err != nil {+ return err+ }+ }+ }+ for _, primaryKeyDiff := range tableDiff.PrimaryKeyChanges {+ if primaryKeyDiff.Action == schema.MetadataDiffActionCreate || primaryKeyDiff.Action == schema.MetadataDiffActionAlter {+ if err := writePrimaryKey(out, tableDiff.SchemaName, tableDiff.TableName, primaryKeyDiff.NewPrimaryKey); err != nil {+ return err+ }+ }+ }+ for _, uniqueConstraintDiff := range tableDiff.UniqueConstraintChanges {+ if uniqueConstraintDiff.Action == schema.MetadataDiffActionCreate || uniqueConstraintDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeUniqueKey(out, tableDiff.SchemaName, tableDiff.TableName, uniqueConstraintDiff.NewUniqueConstraint); err != nil {+ return err+ }+ }+ }+ for _, checkDiff := range tableDiff.CheckConstraintChanges {+ if checkDiff.Action == schema.MetadataDiffActionCreate || checkDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeAddCheckConstraint(out, tableDiff.SchemaName, tableDiff.TableName, checkDiff.NewCheckConstraint); err != nil {+ return err+ }+ }+ }+ for _, excludeDiff := range tableDiff.ExcludeConstraintChanges {+ if excludeDiff.Action == schema.MetadataDiffActionCreate || excludeDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeAddExcludeConstraint(out, tableDiff.SchemaName, tableDiff.TableName, excludeDiff.NewExcludeConstraint); err != nil {+ return err+ }+ }+ }+ for _, indexDiff := range tableDiff.IndexChanges {+ if indexDiff.Action == schema.MetadataDiffActionCreate || indexDiff.Action == schema.MetadataDiffActionAlter {+ if err := writeCreateIndexDiff(out, tableDiff.SchemaName, tableDiff.TableName, indexDiff.NewIndex); err != nil {+ return err+ }+ }+ }+ return writeTableCommentDiff(out, tableDiff.SchemaName, tableDiff.TableName, tableDiff.OldTable.GetComment(), tableDiff.NewTable.GetComment())+}++func writeColumnDiff(out *strings.Builder, schemaName, tableName string, columnDiff *schema.ColumnDiff) error {+ switch columnDiff.Action {+ case schema.MetadataDiffActionCreate:+ if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ADD COLUMN ", schemaName, tableName); err != nil {+ return err+ }+ if err := writeColumnDefinition(out, columnDiff.NewColumn); err != nil {+ return err+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ if columnDiff.NewColumn.GetComment() != "" {+ return writeColumnComment(out, schemaName, tableName, columnDiff.NewColumn)+ }+ return nil+ case schema.MetadataDiffActionDrop:+ _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" DROP COLUMN \"%s\";\n\n", schemaName, tableName, columnDiff.OldColumn.Name)+ return err+ case schema.MetadataDiffActionAlter:+ return writeAlterColumnDiff(out, schemaName, tableName, columnDiff)+ default:+ return nil+ }+}++func writeAlterColumnDiff(out *strings.Builder, schemaName, tableName string, columnDiff *schema.ColumnDiff) error {+ oldColumn := columnDiff.OldColumn+ newColumn := columnDiff.NewColumn+ if oldColumn.Type != newColumn.Type {+ if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ALTER COLUMN \"%s\" TYPE %s", schemaName, tableName, newColumn.Name, newColumn.Type); err != nil {+ return err+ }+ if requiresExplicitCasting(oldColumn.Type, newColumn.Type) {+ if _, err := fmt.Fprintf(out, " USING \"%s\"::%s", newColumn.Name, newColumn.Type); err != nil {+ return err+ }+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ }+ if oldColumn.Default != newColumn.Default {+ if newColumn.Default == "" {+ if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ALTER COLUMN \"%s\" DROP DEFAULT;\n\n", schemaName, tableName, newColumn.Name); err != nil {+ return err+ }+ } else if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ALTER COLUMN \"%s\" SET DEFAULT %s;\n\n", schemaName, tableName, newColumn.Name, newColumn.Default); err != nil {+ return err+ }+ }+ if oldColumn.Nullable != newColumn.Nullable {+ nullability := "DROP NOT NULL"+ if !newColumn.Nullable {+ nullability = "SET NOT NULL"+ }+ if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ALTER COLUMN \"%s\" %s;\n\n", schemaName, tableName, newColumn.Name, nullability); err != nil {+ return err+ }+ }+ if oldColumn.GetComment() != newColumn.GetComment() {+ if err := writeColumnCommentDiff(out, schemaName, tableName, newColumn.Name, newColumn.GetComment()); err != nil {+ return err+ }+ }+ return nil+}++func requiresExplicitCasting(oldType, newType string) bool {+ oldBaseType := extractBaseType(oldType)+ newBaseType := extractBaseType(newType)+ if oldBaseType == newBaseType {+ return requiresUsingForSameType(oldType, newType)+ }+ incompatibleConversions := map[string][]string{+ "text": {"integer", "numeric", "real", pgTypeDoublePrecision, "smallint", "bigint", "boolean"},+ pgTypeCharacterVarying: {"integer", "numeric", "real", pgTypeDoublePrecision, "smallint", "bigint", "boolean"},+ "character": {"integer", "numeric", "real", pgTypeDoublePrecision, "smallint", "bigint", "boolean"},+ "jsonb": {"text", pgTypeCharacterVarying, "character"},+ "json": {"text", pgTypeCharacterVarying, "character"},+ "integer[]": {"text", pgTypeCharacterVarying, "character"},+ "text[]": {"text", pgTypeCharacterVarying, "character"},+ "bigint": {"smallint", "integer"},+ pgTypeDoublePrecision: {"real"},+ "timestamp with time zone": {"date"},+ "timestamp without time zone": {"date"},+ "numeric": {"integer", "smallint", "bigint", "real", pgTypeDoublePrecision},+ }+ for _, target := range incompatibleConversions[oldBaseType] {+ if target == newBaseType {+ return true+ }+ }+ return false+}++func extractBaseType(typeName string) string {+ if idx := strings.Index(typeName, "("); idx >= 0 {+ return strings.TrimSpace(typeName[:idx])+ }+ return typeName+}++func requiresUsingForSameType(oldType, newType string) bool {+ oldBaseType := extractBaseType(oldType)+ newBaseType := extractBaseType(newType)+ if oldBaseType != newBaseType {+ return false+ }+ if strings.Contains(oldType, pgTypeCharacterVarying) {+ oldLen := extractLength(oldType)+ newLen := extractLength(newType)+ return oldLen > 0 && newLen > 0 && oldLen > newLen*2+ }+ return false+}++func extractLength(typeName string) int {+ start := strings.Index(typeName, "(")+ end := strings.Index(typeName, ")")+ if start < 0 || end < 0 || end <= start {+ return 0+ }+ length, err := strconv.Atoi(strings.TrimSpace(typeName[start+1 : end]))+ if err != nil {+ return 0+ }+ return length+}++func writeColumnDefinition(out *strings.Builder, column *storepb.ColumnMetadata) error {+ if _, err := fmt.Fprintf(out, "\"%s\" %s", column.Name, column.Type); err != nil {+ return err+ }+ if column.Default != "" {+ if _, err := fmt.Fprintf(out, " DEFAULT %s", column.Default); err != nil {+ return err+ }+ }+ switch column.GetIdentityGeneration() {+ case storepb.ColumnMetadata_ALWAYS:+ if _, err := out.WriteString(" GENERATED ALWAYS AS IDENTITY"); err != nil {+ return err+ }+ case storepb.ColumnMetadata_BY_DEFAULT:+ if _, err := out.WriteString(" GENERATED BY DEFAULT AS IDENTITY"); err != nil {+ return err+ }+ default:+ }+ if generation := column.GetGeneration(); generation != nil && generation.GetExpression() != "" {+ generationType := "STORED"+ if generation.GetType() == storepb.GenerationMetadata_TYPE_VIRTUAL {+ generationType = "VIRTUAL"+ }+ if _, err := fmt.Fprintf(out, " GENERATED ALWAYS AS (%s) %s", generation.GetExpression(), generationType); err != nil {+ return err+ }+ }+ if !column.Nullable {+ if _, err := out.WriteString(" NOT NULL"); err != nil {+ return err+ }+ }+ return nil+}++func writeDropTrigger(out *strings.Builder, schemaName, tableName, triggerName string) error {+ _, err := fmt.Fprintf(out, "DROP TRIGGER \"%s\" ON \"%s\".\"%s\";\n\n", triggerName, schemaName, tableName)+ return err+}++func writeDropForeignKey(out *strings.Builder, schemaName, tableName, fkName string) error {+ return writeDropTableConstraint(out, schemaName, tableName, fkName)+}++func writeDropTableConstraint(out *strings.Builder, schemaName, tableName, constraintName string) error {+ if constraintName == "" {+ return nil+ }+ _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" DROP CONSTRAINT \"%s\";\n\n", schemaName, tableName, constraintName)+ return err+}++func writeDropIndexDiff(out *strings.Builder, schemaName, tableName string, index *storepb.IndexMetadata) error {+ if index.GetIsConstraint() {+ return writeDropTableConstraint(out, schemaName, tableName, index.GetName())+ }+ if index.GetName() == "" {+ return nil+ }+ _, err := fmt.Fprintf(out, "DROP INDEX \"%s\".\"%s\";\n\n", schemaName, index.GetName())+ return err+}++func writeAddCheckConstraint(out *strings.Builder, schemaName, tableName string, check *storepb.CheckConstraintMetadata) error {+ if check == nil {+ return nil+ }+ if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ADD CONSTRAINT \"%s\" CHECK %s;\n\n", schemaName, tableName, check.GetName(), check.GetExpression()); err != nil {+ return err+ }+ return nil+}++func writeAddExcludeConstraint(out *strings.Builder, schemaName, tableName string, exclude *storepb.ExcludeConstraintMetadata) error {+ if exclude == nil {+ return nil+ }+ if _, err := fmt.Fprintf(out, "ALTER TABLE \"%s\".\"%s\" ADD CONSTRAINT \"%s\" %s;\n\n", schemaName, tableName, exclude.GetName(), exclude.GetExpression()); err != nil {+ return err+ }+ return nil+}++func writeCreateIndexDiff(out *strings.Builder, schemaName, tableName string, index *storepb.IndexMetadata) error {+ if index == nil {+ return nil+ }+ switch {+ case index.GetPrimary():+ return writePrimaryKey(out, schemaName, tableName, index)+ case index.GetUnique() && index.GetIsConstraint():+ return writeUniqueKey(out, schemaName, tableName, index)+ default:+ return writeCreateRegularIndex(out, schemaName, tableName, index, false)+ }+}++func writeCreateRegularIndex(out *strings.Builder, schemaName, tableName string, index *storepb.IndexMetadata, useOnlyClause bool) error {+ if index.GetDefinition() != "" {+ if err := writeDefinitionStatement(out, index.GetDefinition()); err != nil {+ return err+ }+ if index.GetComment() != "" {+ return writeIndexComment(out, schemaName, index)+ }+ return nil+ }+ return writeIndex(out, schemaName, tableName, index, useOnlyClause)+}++func writeTableCommentDiff(out *strings.Builder, schemaName, tableName, oldComment, newComment string) error {+ if oldComment == newComment {+ return nil+ }+ return writeComment(out, fmt.Sprintf("TABLE \"%s\".\"%s\"", schemaName, tableName), newComment)+}++func writeColumnCommentDiff(out *strings.Builder, schemaName, tableName, columnName, comment string) error {+ return writeComment(out, fmt.Sprintf("COLUMN \"%s\".\"%s\".\"%s\"", schemaName, tableName, columnName), comment)+}++func writeCommentDiff(out *strings.Builder, commentDiff *schema.CommentDiff) error {+ switch commentDiff.ObjectType {+ case schema.CommentObjectTypeSchema:+ return writeComment(out, fmt.Sprintf("SCHEMA \"%s\"", commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeTable:+ return writeComment(out, fmt.Sprintf("TABLE \"%s\".\"%s\"", commentDiff.SchemaName, commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeColumn:+ return writeComment(out, fmt.Sprintf("COLUMN \"%s\".\"%s\".\"%s\"", commentDiff.SchemaName, commentDiff.ObjectName, commentDiff.ColumnName), commentDiff.NewComment)+ case schema.CommentObjectTypeView:+ return writeComment(out, fmt.Sprintf(viewCommentObjectFormat, commentDiff.SchemaName, commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeMaterializedView:+ return writeComment(out, fmt.Sprintf("MATERIALIZED VIEW \"%s\".\"%s\"", commentDiff.SchemaName, commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeFunction:+ return writeComment(out, fmt.Sprintf("FUNCTION %s", formatQualifiedRoutineSignature(commentDiff.SchemaName, commentDiff.ObjectName)), commentDiff.NewComment)+ case schema.CommentObjectTypeSequence:+ return writeComment(out, fmt.Sprintf("SEQUENCE \"%s\".\"%s\"", commentDiff.SchemaName, commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeIndex:+ indexName := commentDiff.IndexName+ if indexName == "" {+ indexName = commentDiff.ObjectName+ }+ return writeComment(out, fmt.Sprintf("INDEX \"%s\".\"%s\"", commentDiff.SchemaName, indexName), commentDiff.NewComment)+ case schema.CommentObjectTypeTrigger:+ return writeComment(out, fmt.Sprintf("TRIGGER \"%s\" ON \"%s\".\"%s\"", commentDiff.ObjectName, commentDiff.SchemaName, commentDiff.TableName), commentDiff.NewComment)+ case schema.CommentObjectTypeType:+ return writeComment(out, fmt.Sprintf("TYPE \"%s\".\"%s\"", commentDiff.SchemaName, commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeExtension:+ return writeComment(out, fmt.Sprintf("EXTENSION \"%s\"", commentDiff.ObjectName), commentDiff.NewComment)+ case schema.CommentObjectTypeEventTrigger:+ return writeComment(out, fmt.Sprintf("EVENT TRIGGER \"%s\"", commentDiff.ObjectName), commentDiff.NewComment)+ default:+ return nil+ }+}++func writeComment(out io.Writer, object, comment string) error {+ if comment == "" {+ _, err := fmt.Fprintf(out, "COMMENT ON %s IS NULL;\n\n", object)+ return err+ }+ _, err := fmt.Fprintf(out, "COMMENT ON %s IS '%s';\n\n", object, escapeSingleQuote(comment))+ return err+}++func writeSchemaDiff(out *strings.Builder, schemaDiff *schema.SchemaDiff) error {+ switch schemaDiff.Action {+ case schema.MetadataDiffActionCreate:+ if skipPostgresSchemaDDL(schemaDiff.SchemaName) {+ return nil+ }+ return writeSchema(out, schemaDiff.NewSchema)+ case schema.MetadataDiffActionDrop:+ if skipPostgresSchemaDDL(schemaDiff.SchemaName) {+ return nil+ }+ if err := writeDropSchemaObjects(out, schemaDiff.SchemaName, schemaDiff.OldSchema); err != nil {+ return err+ }+ _, err := fmt.Fprintf(out, "DROP SCHEMA IF EXISTS \"%s\";\n\n", schemaDiff.SchemaName)+ return err+ default:+ return nil+ }+}++func skipPostgresSchemaDDL(schemaName string) bool {+ return schemaName == "pg_catalog" || schemaName == "public"+}++func writeDropSchemaObjects(out *strings.Builder, schemaName string, schemaMeta *storepb.SchemaMetadata) error {+ if schemaMeta == nil {+ return nil+ }+ diff := buildDropSchemaObjectsDiff(schemaName, schemaMeta)+ if err := writeDropTableTriggers(out, diff); err != nil {+ return err+ }+ if err := writeDropTableForeignKeysForTableDrops(out, diff); err != nil {+ return err+ }+ if err := writeDropDependentObjects(out, diff); err != nil {+ return err+ }+ for _, sequenceDiff := range diff.SequenceChanges {+ if isSequenceOwnedByDroppedTable(diff, sequenceDiff.SchemaName, sequenceDiff.OldSequence) {+ continue+ }+ if err := writeSequenceDiff(out, sequenceDiff); err != nil {+ return err+ }+ }+ for _, enumDiff := range diff.EnumTypeChanges {+ if err := writeEnumTypeDiff(out, enumDiff); err != nil {+ return err+ }+ }+ return nil+}++func buildDropSchemaObjectsDiff(schemaName string, schemaMeta *storepb.SchemaMetadata) *schema.MetadataDiff {+ diff := &schema.MetadataDiff{}+ for _, table := range schemaMeta.GetTables() {+ if table.GetSkipDump() {+ continue+ }+ diff.TableChanges = append(diff.TableChanges, &schema.TableDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ TableName: table.GetName(),+ OldTable: table,+ })+ }+ for _, view := range schemaMeta.GetViews() {+ if view.GetSkipDump() {+ continue+ }+ diff.ViewChanges = append(diff.ViewChanges, &schema.ViewDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ ViewName: view.GetName(),+ OldView: view,+ })+ }+ for _, materializedView := range schemaMeta.GetMaterializedViews() {+ if materializedView.GetSkipDump() {+ continue+ }+ diff.MaterializedViewChanges = append(diff.MaterializedViewChanges, &schema.MaterializedViewDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ MaterializedViewName: materializedView.GetName(),+ OldMaterializedView: materializedView,+ })+ }+ for _, function := range schemaMeta.GetFunctions() {+ if function.GetSkipDump() {+ continue+ }+ functionName := function.GetSignature()+ if functionName == "" {+ functionName = function.GetName()+ }+ diff.FunctionChanges = append(diff.FunctionChanges, &schema.FunctionDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ FunctionName: functionName,+ OldFunction: function,+ })+ }+ for _, procedure := range schemaMeta.GetProcedures() {+ if procedure.GetSkipDump() {+ continue+ }+ procedureName := procedure.GetSignature()+ if procedureName == "" {+ procedureName = procedure.GetName()+ }+ diff.ProcedureChanges = append(diff.ProcedureChanges, &schema.ProcedureDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ ProcedureName: procedureName,+ OldProcedure: procedure,+ })+ }+ for _, sequence := range schemaMeta.GetSequences() {+ if sequence.GetSkipDump() {+ continue+ }+ diff.SequenceChanges = append(diff.SequenceChanges, &schema.SequenceDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ SequenceName: sequence.GetName(),+ OldSequence: sequence,+ })+ }+ for _, enumType := range schemaMeta.GetEnumTypes() {+ if enumType.GetSkipDump() {+ continue+ }+ diff.EnumTypeChanges = append(diff.EnumTypeChanges, &schema.EnumTypeDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ EnumTypeName: enumType.GetName(),+ OldEnumType: enumType,+ })+ }+ return diff+}++func writeExtensionDiff(out *strings.Builder, extensionDiff *schema.ExtensionDiff) error {+ switch extensionDiff.Action {+ case schema.MetadataDiffActionCreate:+ return writeExtension(out, extensionDiff.NewExtension)+ case schema.MetadataDiffActionDrop:+ _, err := fmt.Fprintf(out, "DROP EXTENSION \"%s\";\n\n", extensionDiff.ExtensionName)+ return err+ default:+ return nil+ }+}++func writeEventTriggerDiff(out *strings.Builder, eventTriggerDiff *schema.EventTriggerDiff) error {+ switch eventTriggerDiff.Action {+ case schema.MetadataDiffActionCreate, schema.MetadataDiffActionAlter:+ return writeEventTrigger(out, eventTriggerDiff.NewEventTrigger)+ case schema.MetadataDiffActionDrop:+ _, err := fmt.Fprintf(out, "DROP EVENT TRIGGER \"%s\";\n\n", eventTriggerDiff.EventTriggerName)+ return err+ default:+ return nil+ }+}++func writeSequenceDiff(out *strings.Builder, sequenceDiff *schema.SequenceDiff) error {+ switch sequenceDiff.Action {+ case schema.MetadataDiffActionCreate:+ return writeCreateSequence(out, sequenceDiff.SchemaName, sequenceDiff.NewSequence)+ case schema.MetadataDiffActionDrop:+ _, err := fmt.Fprintf(out, "DROP SEQUENCE \"%s\".\"%s\";\n\n", sequenceDiff.SchemaName, sequenceDiff.SequenceName)+ return err+ case schema.MetadataDiffActionAlter:+ return writeAlterSequence(out, sequenceDiff.SchemaName, sequenceDiff.OldSequence, sequenceDiff.NewSequence)+ default:+ return nil+ }+}++func writeAlterSequence(out *strings.Builder, schemaName string, oldSequence *storepb.SequenceMetadata, sequence *storepb.SequenceMetadata) error {+ if _, err := fmt.Fprintf(out, "ALTER SEQUENCE \"%s\".\"%s\"", schemaName, sequence.Name); err != nil {+ return err+ }+ if sequence.DataType != "" {+ if _, err := fmt.Fprintf(out, "\n AS %s", sequence.DataType); err != nil {+ return err+ }+ }+ if sequence.Start != "" {+ if _, err := fmt.Fprintf(out, "\n START WITH %s", sequence.Start); err != nil {+ return err+ }+ }+ if sequence.Increment != "" {+ if _, err := fmt.Fprintf(out, "\n INCREMENT BY %s", sequence.Increment); err != nil {+ return err+ }+ }+ if sequence.MinValue != "" {+ if _, err := fmt.Fprintf(out, "\n MINVALUE %s", sequence.MinValue); err != nil {+ return err+ }+ }+ if sequence.MaxValue != "" {+ if _, err := fmt.Fprintf(out, "\n MAXVALUE %s", sequence.MaxValue); err != nil {+ return err+ }+ }+ if sequence.CacheSize != "" {+ if _, err := fmt.Fprintf(out, "\n CACHE %s", sequence.CacheSize); err != nil {+ return err+ }+ }+ if sequence.Cycle {+ if _, err := out.WriteString("\n CYCLE"); err != nil {+ return err+ }+ } else if _, err := out.WriteString("\n NO CYCLE"); err != nil {+ return err+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ if oldSequence.GetComment() != sequence.GetComment() {+ return writeComment(out, fmt.Sprintf("SEQUENCE \"%s\".\"%s\"", schemaName, sequence.Name), sequence.GetComment())+ }+ return nil+}++func writeAlterSequenceOwnedByNone(out *strings.Builder, schemaName, sequenceName string) error {+ _, err := fmt.Fprintf(out, "ALTER SEQUENCE \"%s\".\"%s\" OWNED BY NONE;\n\n", schemaName, sequenceName)+ return err+}++func writeFunctionDiff(out *strings.Builder, functionDiff *schema.FunctionDiff) error {+ switch functionDiff.Action {+ case schema.MetadataDiffActionCreate:+ return writeFunctionStatement(out, functionDiff.SchemaName, functionDiff.NewFunction, false)+ case schema.MetadataDiffActionAlter:+ return writeFunctionStatement(out, functionDiff.SchemaName, functionDiff.NewFunction, true)+ case schema.MetadataDiffActionDrop:+ signature := functionDiff.FunctionName+ if functionDiff.OldFunction.GetSignature() != "" {+ signature = functionDiff.OldFunction.GetSignature()+ }+ return writeDropRoutine(out, "FUNCTION", functionDiff.SchemaName, signature)+ default:+ return nil+ }+}++func writeFunctionStatement(out *strings.Builder, schemaName string, function *storepb.FunctionMetadata, replace bool) error {+ definition := function.GetDefinition()+ if replace {+ definition = convertCreateFunctionToCreateOrReplace(definition)+ }+ if err := writeDefinitionStatement(out, definition); err != nil {+ return err+ }+ if function.GetComment() != "" {+ return writeFunctionComment(out, schemaName, function)+ }+ return nil+}++func convertCreateFunctionToCreateOrReplace(definition string) string {+ trimmedLeft := strings.TrimLeft(definition, " \t\r\n")+ prefixLen := len(definition) - len(trimmedLeft)+ upper := strings.ToUpper(trimmedLeft)+ if strings.HasPrefix(upper, "CREATE OR REPLACE FUNCTION") {+ return definition+ }+ if strings.HasPrefix(upper, "CREATE FUNCTION") {+ return definition[:prefixLen] + "CREATE OR REPLACE FUNCTION" + trimmedLeft[len("CREATE FUNCTION"):]+ }+ return definition+}++func writeProcedureDiff(out *strings.Builder, procedureDiff *schema.ProcedureDiff) error {+ switch procedureDiff.Action {+ case schema.MetadataDiffActionCreate:+ return writeProcedure(out, procedureDiff.SchemaName, procedureDiff.NewProcedure)+ case schema.MetadataDiffActionDrop:+ signature := procedureDiff.ProcedureName+ if procedureDiff.OldProcedure.GetSignature() != "" {+ signature = procedureDiff.OldProcedure.GetSignature()+ }+ return writeDropRoutine(out, "PROCEDURE", procedureDiff.SchemaName, signature)+ case schema.MetadataDiffActionAlter:+ signature := procedureDiff.ProcedureName+ if procedureDiff.OldProcedure.GetSignature() != "" {+ signature = procedureDiff.OldProcedure.GetSignature()+ }+ if err := writeDropRoutine(out, "PROCEDURE", procedureDiff.SchemaName, signature); err != nil {+ return err+ }+ return writeProcedure(out, procedureDiff.SchemaName, procedureDiff.NewProcedure)+ default:+ return nil+ }+}++func writeProcedure(out *strings.Builder, schemaName string, procedure *storepb.ProcedureMetadata) error {+ if err := writeDefinitionStatement(out, procedure.Definition); err != nil {+ return err+ }+ if procedure.Comment != "" {+ return writeRoutineComment(out, "PROCEDURE", schemaName, procedure.Signature, procedure.Name, procedure.Comment)+ }+ return nil+}++func writeDefinitionStatement(out *strings.Builder, definition string) error {+ definition = strings.TrimSpace(definition)+ if _, err := out.WriteString(definition); err != nil {+ return err+ }+ if !strings.HasSuffix(definition, ";") {+ if _, err := out.WriteString(";"); err != nil {+ return err+ }+ }+ _, err := out.WriteString("\n\n")+ return err+}++func writeDropRoutine(out *strings.Builder, routineType, schemaName, signature string) error {+ _, err := fmt.Fprintf(out, "DROP %s %s;\n\n", routineType, formatQualifiedRoutineSignature(schemaName, signature))+ return err+}++func formatQualifiedRoutineSignature(schemaName, signature string) string {+ signature = strings.TrimSpace(signature)+ openParen := strings.Index(signature, "(")+ if openParen < 0 {+ return fmt.Sprintf("\"%s\".\"%s\"()", schemaName, strings.Trim(signature, `"`))+ }+ name := strings.TrimSpace(signature[:openParen])+ if lastDot := strings.LastIndex(name, "."); lastDot >= 0 {+ name = name[lastDot+1:]+ }+ name = strings.Trim(name, `"`)+ return fmt.Sprintf("\"%s\".\"%s\"%s", schemaName, name, signature[openParen:])+}++func writeRoutineComment(out *strings.Builder, routineType, schemaName, signature, name, comment string) error {+ if signature == "" {+ signature = name + "()"+ }+ if _, err := fmt.Fprintf(out, "COMMENT ON %s %s IS '%s';\n\n", routineType, formatQualifiedRoutineSignature(schemaName, signature), escapeSingleQuote(comment)); err != nil {+ return err+ }+ return nil+}++func writeEnumTypeDiff(out *strings.Builder, enumDiff *schema.EnumTypeDiff) error {+ switch enumDiff.Action {+ case schema.MetadataDiffActionCreate:+ if err := writeEnum(out, enumDiff.SchemaName, enumDiff.NewEnumType); err != nil {+ return err+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ if enumDiff.NewEnumType.Comment != "" {+ return writeEnumComment(out, enumDiff.SchemaName, enumDiff.NewEnumType)+ }+ return nil+ case schema.MetadataDiffActionDrop:+ _, err := fmt.Fprintf(out, "DROP TYPE \"%s\".\"%s\";\n\n", enumDiff.SchemaName, enumDiff.EnumTypeName)+ return err+ case schema.MetadataDiffActionAlter:+ return writeAlterEnumTypeAddValues(out, enumDiff.SchemaName, enumDiff.OldEnumType, enumDiff.NewEnumType)+ default:+ return nil+ }+}++func writeAlterEnumTypeAddValues(out *strings.Builder, schemaName string, oldEnum *storepb.EnumTypeMetadata, newEnum *storepb.EnumTypeMetadata) error {+ oldValueSet := make(map[string]bool)+ for _, value := range oldEnum.GetValues() {+ oldValueSet[value] = true+ }+ newValueSet := make(map[string]bool)+ for _, value := range newEnum.GetValues() {+ newValueSet[value] = true+ }++ var removedValues []string+ for _, value := range oldEnum.GetValues() {+ if !newValueSet[value] {+ removedValues = append(removedValues, value)+ }+ }+ if len(removedValues) > 0 {+ if _, err := fmt.Fprintf(out, "-- WARNING: PostgreSQL does not support removing enum values from \"%s\".\"%s\": ", schemaName, newEnum.GetName()); err != nil {+ return err+ }+ for i, value := range removedValues {+ if i > 0 {+ if _, err := out.WriteString(", "); err != nil {+ return err+ }+ }+ if _, err := fmt.Fprintf(out, "'%s'", escapeSingleQuote(value)); err != nil {+ return err+ }+ }+ if _, err := out.WriteString("\n\n"); err != nil {+ return err+ }+ }++ for i, newValue := range newEnum.GetValues() {+ if oldValueSet[newValue] {+ continue+ }+ if _, err := fmt.Fprintf(out, "ALTER TYPE \"%s\".\"%s\" ADD VALUE '%s'", schemaName, newEnum.GetName(), escapeSingleQuote(newValue)); err != nil {+ return err+ }+ for j := i + 1; j < len(newEnum.GetValues()); j++ {+ nextValue := newEnum.GetValues()[j]+ if oldValueSet[nextValue] {+ if _, err := fmt.Fprintf(out, " BEFORE '%s'", escapeSingleQuote(nextValue)); err != nil {+ return err+ }+ break+ }+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ }+ if oldEnum.GetComment() != newEnum.GetComment() {+ return writeComment(out, fmt.Sprintf("TYPE \"%s\".\"%s\"", schemaName, newEnum.GetName()), newEnum.GetComment())+ }+ return nil+}++func writeViewDiff(out *strings.Builder, viewDiff *schema.ViewDiff) error {+ switch viewDiff.Action {+ case schema.MetadataDiffActionCreate:+ if err := writeViewSDL(out, viewDiff.SchemaName, viewDiff.NewView); err != nil {+ return err+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ if viewDiff.NewView.GetComment() != "" {+ return writeComment(out, fmt.Sprintf(viewCommentObjectFormat, viewDiff.SchemaName, viewDiff.ViewName), viewDiff.NewView.GetComment())+ }+ return nil+ case schema.MetadataDiffActionAlter:+ definition := strings.TrimSuffix(strings.TrimSpace(viewDiff.NewView.Definition), ";")+ if _, err := fmt.Fprintf(out, "CREATE OR REPLACE VIEW \"%s\".\"%s\" AS %s", viewDiff.SchemaName, viewDiff.ViewName, definition); err != nil {+ return err+ }+ if _, err := out.WriteString(";\n\n"); err != nil {+ return err+ }+ if viewDiff.NewView.GetComment() != "" {+ return writeComment(out, fmt.Sprintf(viewCommentObjectFormat, viewDiff.SchemaName, viewDiff.ViewName), viewDiff.NewView.GetComment())+ }+ return nil+ case schema.MetadataDiffActionDrop:+ return writeDropView(out, viewDiff.SchemaName, viewDiff.ViewName)+ default:+ return nil+ }+}++func writeDropView(out *strings.Builder, schemaName, viewName string) error {+ _, err := fmt.Fprintf(out, "DROP VIEW \"%s\".\"%s\";\n\n", schemaName, viewName)+ return err+}++func writeCreateMaterializedViewDiff(out *strings.Builder, viewDiff *schema.MaterializedViewDiff) error {+ return writeMaterializedView(out, viewDiff.SchemaName, viewDiff.NewMaterializedView)+}++func writeDropMaterializedView(out *strings.Builder, schemaName, viewName string) error {+ _, err := fmt.Fprintf(out, "DROP MATERIALIZED VIEW \"%s\".\"%s\";\n\n", schemaName, viewName)+ return err+}diff --git a/backend/plugin/schema/pg/metadata_migration_test.go b/backend/plugin/schema/pg/metadata_migration_test.gonew file mode 100644index 0000000000..0fdcb4d3e8--- /dev/null+++ b/backend/plugin/schema/pg/metadata_migration_test.go@@ -0,0 +1,1615 @@+package pg++import (+ "strings"+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/store/model"+)++func TestPGMetadataDiffIdenticalRawViewDoesNotLoadSDL(t *testing.T) {+ source := newPGDatabaseMetadataWithView("SELECT @@@omni_unsupported@@@")+ target := newPGDatabaseMetadataWithView("SELECT @@@omni_unsupported@@@")++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Empty(t, sql)+}++func TestPGMetadataDiffRawViewAlterUsesMetadataDefinition(t *testing.T) {+ source := newPGDatabaseMetadataWithView("SELECT @@@old_definition@@@")+ target := newPGDatabaseMetadataWithView("SELECT @@@new_definition@@@")++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `CREATE OR REPLACE VIEW "public"."v" AS`)+ require.Contains(t, sql, "SELECT @@@new_definition@@@")+}++func TestCockroachMetadataDiffIdenticalRawViewDoesNotLoadSDL(t *testing.T) {+ source := newDatabaseMetadataWithEngine(storepb.Engine_COCKROACHDB, nil, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT @@@omni_unsupported@@@",+ },+ })+ target := newDatabaseMetadataWithEngine(storepb.Engine_COCKROACHDB, nil, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT @@@omni_unsupported@@@",+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_COCKROACHDB, source, target)++ require.NoError(t, err)+ require.Empty(t, sql)+}++func TestCockroachMetadataDiffUsesCockroachFunctionComparer(t *testing.T) {+ schema.RegisterFunctionComparer(storepb.Engine_COCKROACHDB, &alwaysEqualFunctionComparer{})+ t.Cleanup(func() {+ schema.RegisterFunctionComparer(storepb.Engine_COCKROACHDB, &schema.DefaultFunctionComparer{})+ })+ source := newCockroachDatabaseMetadataWithFunctions([]*storepb.FunctionMetadata{+ newPGFunctionMetadata("SELECT 1"),+ })+ target := newCockroachDatabaseMetadataWithFunctions([]*storepb.FunctionMetadata{+ newPGFunctionMetadata("SELECT 2"),+ })++ sql, err := schema.DiffMigration(storepb.Engine_COCKROACHDB, source, target)++ require.NoError(t, err)+ require.Empty(t, sql)+}++func TestPGMetadataDiffCreateTableFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata(nil, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ {+ Name: "name",+ Type: "text",+ Nullable: true,+ },+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `CREATE TABLE "public"."users"`)+ require.Contains(t, sql, `"id" integer NOT NULL`)+ require.Contains(t, sql, `"name" text`)+}++func TestPGMetadataDiffCreateTableWithGeneratedAndIdentityColumnsFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata(nil, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "bigint",+ Nullable: false,+ IdentityGeneration: storepb.ColumnMetadata_BY_DEFAULT,+ },+ {+ Name: "name",+ Type: "text",+ Nullable: false,+ },+ {+ Name: "name_key",+ Type: "text",+ Nullable: false,+ Generation: &storepb.GenerationMetadata{+ Type: storepb.GenerationMetadata_TYPE_STORED,+ Expression: "lower(name)",+ },+ },+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `"id" bigint GENERATED BY DEFAULT AS IDENTITY NOT NULL`)+ require.Contains(t, sql, `"name_key" text GENERATED ALWAYS AS (lower(name)) STORED NOT NULL`)+}++func TestPGMetadataDiffAlterTableAddColumnFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ },+ },+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ {+ Name: "name",+ Type: "text",+ Nullable: true,+ },+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `ALTER TABLE "public"."users" ADD COLUMN "name" text`)+}++func TestPGMetadataDiffAlterTableAddGeneratedAndIdentityColumnsFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "name", Type: "text", Nullable: false},+ },+ },+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "name", Type: "text", Nullable: false},+ {+ Name: "id",+ Type: "bigint",+ Nullable: false,+ IdentityGeneration: storepb.ColumnMetadata_ALWAYS,+ },+ {+ Name: "name_key",+ Type: "text",+ Nullable: false,+ Generation: &storepb.GenerationMetadata{+ Type: storepb.GenerationMetadata_TYPE_STORED,+ Expression: "lower(name)",+ },+ },+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `ADD COLUMN "id" bigint GENERATED ALWAYS AS IDENTITY NOT NULL`)+ require.Contains(t, sql, `ADD COLUMN "name_key" text GENERATED ALWAYS AS (lower(name)) STORED NOT NULL`)+}++func TestPGMetadataDiffAlterColumnTypeUsesUsingForIncompatibleCast(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "events",+ Columns: []*storepb.ColumnMetadata{+ {Name: "payload", Type: "text", Nullable: true},+ },+ },+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "events",+ Columns: []*storepb.ColumnMetadata{+ {Name: "payload", Type: "integer", Nullable: true},+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `ALTER COLUMN "payload" TYPE integer USING "payload"::integer`)+}++func TestPGMetadataDiffAlterTableDropsColumnOnce(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "legacy", Type: "text", Nullable: true},+ },+ },+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Equal(t, 1, strings.Count(sql, `DROP COLUMN "legacy"`))+}++func TestPGMetadataDiffAlterTableObjectsFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "accounts",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ },+ },+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ {+ Name: "account_id",+ Type: "integer",+ Nullable: false,+ },+ {+ Name: "email",+ Type: "text",+ Nullable: false,+ },+ },+ },+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "accounts",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ },+ },+ {+ Name: "users",+ Comment: "Application users",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "integer",+ Nullable: false,+ },+ {+ Name: "account_id",+ Type: "integer",+ Nullable: false,+ },+ {+ Name: "email",+ Type: "text",+ Nullable: false,+ Comment: "Login email",+ },+ },+ Indexes: []*storepb.IndexMetadata{+ {+ Name: "users_pkey",+ Expressions: []string{"id"},+ Primary: true,+ Unique: true,+ IsConstraint: true,+ },+ {+ Name: "users_email_key",+ Expressions: []string{"email"},+ Unique: true,+ IsConstraint: true,+ },+ {+ Name: "idx_users_account_id",+ Expressions: []string{"account_id"},+ Type: "btree",+ },+ },+ ForeignKeys: []*storepb.ForeignKeyMetadata{+ {+ Name: "users_account_id_fkey",+ Columns: []string{"account_id"},+ ReferencedSchema: "public",+ ReferencedTable: "accounts",+ ReferencedColumns: []string{"id"},+ OnDelete: "CASCADE",+ },+ },+ CheckConstraints: []*storepb.CheckConstraintMetadata{+ {+ Name: "users_email_check",+ Expression: "(email <> '')",+ },+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "users_touch_updated_at",+ Body: "CREATE TRIGGER users_touch_updated_at BEFORE UPDATE ON public.users " ++ "FOR EACH ROW EXECUTE FUNCTION public.touch_updated_at()",+ Comment: "maintain updated_at",+ },+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `ALTER TABLE ONLY "public"."users" ADD CONSTRAINT "users_pkey" PRIMARY KEY (id)`)+ require.Contains(t, sql, `ALTER TABLE ONLY "public"."users" ADD CONSTRAINT "users_email_key" UNIQUE (email)`)+ require.Contains(t, sql, `ALTER TABLE "public"."users" ADD CONSTRAINT "users_email_check" CHECK (email <> '')`)+ require.Contains(t, sql, `CREATE INDEX "idx_users_account_id" ON "public"."users" (account_id)`)+ require.Contains(t, sql, `ADD CONSTRAINT "users_account_id_fkey" FOREIGN KEY ("account_id")`)+ require.Contains(t, sql, `ON DELETE CASCADE`)+ require.Contains(t, sql, `CREATE TRIGGER users_touch_updated_at BEFORE UPDATE ON public.users`)+ require.Contains(t, sql, `COMMENT ON TRIGGER "users_touch_updated_at" ON "public"."users" IS 'maintain updated_at'`)+ require.Contains(t, sql, `COMMENT ON TABLE "public"."users" IS 'Application users'`)+ require.Contains(t, sql, `COMMENT ON COLUMN "public"."users"."email" IS 'Login email'`)+}++func TestPGMetadataDiffCreateIndexUsesFullDefinitionFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "email", Type: "text", Nullable: false},+ },+ },+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "email", Type: "text", Nullable: false},+ },+ Indexes: []*storepb.IndexMetadata{+ {+ Name: "idx_users_email",+ Expressions: []string{"email"},+ Type: "btree",+ Definition: `CREATE INDEX idx_users_email ON public.users USING btree (email DESC NULLS LAST) WITH (fillfactor='70')`,+ },+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `CREATE INDEX idx_users_email ON public.users USING btree (email DESC NULLS LAST) WITH (fillfactor='70');`)+}++func TestPGMetadataDiffCreateTableForeignKeysAfterAllTables(t *testing.T) {+ source := newPGDatabaseMetadata(nil, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "child",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "parent_id", Type: "integer", Nullable: false},+ },+ ForeignKeys: []*storepb.ForeignKeyMetadata{+ {+ Name: "child_parent_id_fkey",+ Columns: []string{"parent_id"},+ ReferencedSchema: "public",+ ReferencedTable: "parent",+ ReferencedColumns: []string{"id"},+ },+ },+ },+ {+ Name: "parent",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ parentIdx := strings.Index(sql, `CREATE TABLE "public"."parent"`)+ childIdx := strings.Index(sql, `CREATE TABLE "public"."child"`)+ fkIdx := strings.Index(sql, `ADD CONSTRAINT "child_parent_id_fkey"`)+ require.NotEqual(t, -1, parentIdx)+ require.NotEqual(t, -1, childIdx)+ require.NotEqual(t, -1, fkIdx)+ require.Less(t, parentIdx, childIdx)+ require.Less(t, childIdx, fkIdx)+}++func TestPGMetadataDiffDropTablesInForeignKeyDependencyOrder(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "parent",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ {+ Name: "child",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "parent_id", Type: "integer", Nullable: false},+ },+ ForeignKeys: []*storepb.ForeignKeyMetadata{+ {+ Name: "child_parent_id_fkey",+ Columns: []string{"parent_id"},+ ReferencedSchema: "public",+ ReferencedTable: "parent",+ ReferencedColumns: []string{"id"},+ },+ },+ },+ }, nil)+ target := newPGDatabaseMetadata(nil, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ childIdx := strings.Index(sql, `DROP TABLE "public"."child"`)+ parentIdx := strings.Index(sql, `DROP TABLE "public"."parent"`)+ require.NotEqual(t, -1, childIdx)+ require.NotEqual(t, -1, parentIdx)+ require.Less(t, childIdx, parentIdx)+}++func TestPGMetadataDiffDropTableSkipsOwnedSequenceDrop(t *testing.T) {+ source := newPGDatabaseMetadataWithTablesAndSequences([]*storepb.TableMetadata{+ {+ Name: "orders",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ }, []*storepb.SequenceMetadata{+ {+ Name: "orders_id_seq",+ DataType: "bigint",+ Start: "1",+ Increment: "1",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "1",+ OwnerTable: "orders",+ OwnerColumn: "id",+ },+ })+ target := newPGDatabaseMetadataWithTablesAndSequences(nil, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `DROP TABLE "public"."orders"`)+ require.NotContains(t, sql, `DROP SEQUENCE "public"."orders_id_seq"`)+}++func TestPGMetadataDiffDropCyclicForeignKeyTablesDropsForeignKeysFirst(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "a",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "b_id", Type: "integer", Nullable: false},+ },+ ForeignKeys: []*storepb.ForeignKeyMetadata{+ {+ Name: "a_b_id_fkey",+ Columns: []string{"b_id"},+ ReferencedSchema: "public",+ ReferencedTable: "b",+ ReferencedColumns: []string{"id"},+ },+ },+ },+ {+ Name: "b",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "a_id", Type: "integer", Nullable: false},+ },+ ForeignKeys: []*storepb.ForeignKeyMetadata{+ {+ Name: "b_a_id_fkey",+ Columns: []string{"a_id"},+ ReferencedSchema: "public",+ ReferencedTable: "a",+ ReferencedColumns: []string{"id"},+ },+ },+ },+ }, nil)+ target := newPGDatabaseMetadata(nil, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `ALTER TABLE "public"."a" DROP CONSTRAINT "a_b_id_fkey"`)+ require.Contains(t, sql, `ALTER TABLE "public"."b" DROP CONSTRAINT "b_a_id_fkey"`)+ firstDropConstraintIdx := strings.Index(sql, `DROP CONSTRAINT`)+ firstDropTableIdx := strings.Index(sql, `DROP TABLE`)+ require.NotEqual(t, -1, firstDropConstraintIdx)+ require.NotEqual(t, -1, firstDropTableIdx)+ require.Less(t, firstDropConstraintIdx, firstDropTableIdx)+}++func TestPGMetadataDiffDropSchemaDropsViewsBeforeTablesWithoutDependencyMetadata(t *testing.T) {+ source := newPGDatabaseMetadataWithSchemas([]*storepb.SchemaMetadata{+ {+ Name: "analytics",+ Tables: []*storepb.TableMetadata{+ {Name: "a", Columns: []*storepb.ColumnMetadata{{Name: "id", Type: "integer", Nullable: false}}},+ },+ Views: []*storepb.ViewMetadata{+ {Name: "z", Definition: "SELECT id FROM analytics.a"},+ },+ },+ })+ target := newPGDatabaseMetadataWithSchemas(nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ viewIdx := strings.Index(sql, `DROP VIEW "analytics"."z"`)+ tableIdx := strings.Index(sql, `DROP TABLE "analytics"."a"`)+ require.NotEqual(t, -1, viewIdx)+ require.NotEqual(t, -1, tableIdx)+ require.Less(t, viewIdx, tableIdx)+}++func TestPGMetadataDiffDropAlteredViewBeforeDependentTableAlter(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ }, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT id FROM public.users",+ Comment: "user ids",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "users"},+ },+ },+ })+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "bigint", Nullable: false},+ },+ },+ }, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT id::bigint AS id FROM public.users",+ Comment: "user ids",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "users"},+ },+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ dropViewIdx := strings.Index(sql, `DROP VIEW "public"."v"`)+ alterTableIdx := strings.Index(sql, `ALTER TABLE "public"."users" ALTER COLUMN "id" TYPE bigint`)+ createViewIdx := strings.Index(sql, `CREATE OR REPLACE VIEW "public"."v"`)+ commentIdx := strings.Index(sql, `COMMENT ON VIEW "public"."v" IS 'user ids'`)+ require.NotEqual(t, -1, dropViewIdx)+ require.NotEqual(t, -1, alterTableIdx)+ require.NotEqual(t, -1, createViewIdx)+ require.NotEqual(t, -1, commentIdx)+ require.Less(t, dropViewIdx, alterTableIdx)+ require.Less(t, alterTableIdx, createViewIdx)+ require.Less(t, createViewIdx, commentIdx)+}++func TestPGMetadataDiffDropUnchangedDependentViewBeforeTableAlter(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "name", Type: "text", Nullable: false},+ },+ },+ }, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT id FROM public.users",+ Comment: "user ids",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "users", Column: "id"},+ },+ },+ })+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "bigint", Nullable: false},+ {Name: "name", Type: "text", Nullable: false},+ },+ },+ }, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT id FROM public.users",+ Comment: "user ids",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "users", Column: "id"},+ },+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ dropViewIdx := strings.Index(sql, `DROP VIEW "public"."v"`)+ alterTableIdx := strings.Index(sql, `ALTER TABLE "public"."users" ALTER COLUMN "id" TYPE bigint`)+ createViewIdx := strings.Index(sql, `CREATE OR REPLACE VIEW "public"."v"`)+ commentIdx := strings.Index(sql, `COMMENT ON VIEW "public"."v" IS 'user ids'`)+ require.NotEqual(t, -1, dropViewIdx)+ require.NotEqual(t, -1, alterTableIdx)+ require.NotEqual(t, -1, createViewIdx)+ require.NotEqual(t, -1, commentIdx)+ require.Less(t, dropViewIdx, alterTableIdx)+ require.Less(t, alterTableIdx, createViewIdx)+ require.Less(t, createViewIdx, commentIdx)+}++func TestPGMetadataDiffDropAlteredViewBeforeDroppedReferencedTable(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "legacy_users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ }, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT id FROM public.legacy_users",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "legacy_users", Column: "id"},+ },+ },+ })+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ },+ },+ }, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: "SELECT id FROM public.users",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "users", Column: "id"},+ },+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ dropViewIdx := strings.Index(sql, `DROP VIEW "public"."v"`)+ dropTableIdx := strings.Index(sql, `DROP TABLE "public"."legacy_users"`)+ createViewIdx := strings.Index(sql, `CREATE OR REPLACE VIEW "public"."v"`)+ require.NotEqual(t, -1, dropViewIdx)+ require.NotEqual(t, -1, dropTableIdx)+ require.NotEqual(t, -1, createViewIdx)+ require.Less(t, dropViewIdx, dropTableIdx)+ require.Less(t, dropTableIdx, createViewIdx)+}++func TestPGMetadataDiffAlterTablePartitionChangesFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadata([]*storepb.TableMetadata{+ newPGPartitionedOrdersTable([]*storepb.TablePartitionMetadata{+ newPGOrdersPartition("orders_2023", "FOR VALUES FROM ('2023-01-01') TO ('2024-01-01')"),+ newPGOrdersPartition("orders_2024", "FOR VALUES FROM ('2024-01-01') TO ('2025-01-01')"),+ }),+ }, nil)+ target := newPGDatabaseMetadata([]*storepb.TableMetadata{+ newPGPartitionedOrdersTable([]*storepb.TablePartitionMetadata{+ newPGOrdersPartition("orders_2024", "FOR VALUES FROM ('2024-01-01') TO ('2025-01-01')"),+ newPGOrdersPartition("orders_2025", "FOR VALUES FROM ('2025-01-01') TO ('2026-01-01')"),+ }),+ }, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ dropPartitionIdx := strings.Index(sql, `DROP TABLE "public"."orders_2023"`)+ createPartitionIdx := strings.Index(sql, `CREATE TABLE "public"."orders_2025"`)+ attachPartitionIdx := strings.Index(sql, `ATTACH PARTITION "public"."orders_2025" FOR VALUES FROM ('2025-01-01') TO ('2026-01-01')`)+ require.NotEqual(t, -1, dropPartitionIdx)+ require.NotEqual(t, -1, createPartitionIdx)+ require.NotEqual(t, -1, attachPartitionIdx)+ require.Less(t, dropPartitionIdx, createPartitionIdx)+ require.Less(t, createPartitionIdx, attachPartitionIdx)+}++func TestPGMetadataDiffCreateViewsInDependencyOrder(t *testing.T) {+ source := newPGDatabaseMetadata(nil, nil)+ target := newPGDatabaseMetadata(nil, []*storepb.ViewMetadata{+ {+ Name: "b",+ Definition: "SELECT * FROM a",+ DependencyColumns: []*storepb.DependencyColumn{+ {Schema: "public", Table: "a"},+ },+ },+ {+ Name: "a",+ Definition: "SELECT 1",+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ viewAIdx := strings.Index(sql, `CREATE VIEW "public"."a"`)+ viewBIdx := strings.Index(sql, `CREATE VIEW "public"."b"`)+ require.NotEqual(t, -1, viewAIdx)+ require.NotEqual(t, -1, viewBIdx)+ require.Less(t, viewAIdx, viewBIdx)+}++func TestPGMetadataDiffCreateFunctionAfterNewDependencyView(t *testing.T) {+ source := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{{Name: "public"}},+ }, nil, nil, storepb.Engine_POSTGRES, true)+ target := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Views: []*storepb.ViewMetadata{+ {+ Name: "active_users",+ Definition: "SELECT 1 AS id",+ },+ },+ Functions: []*storepb.FunctionMetadata{+ {+ Name: "get_active_users",+ Signature: "get_active_users()",+ Definition: "CREATE FUNCTION public.get_active_users() RETURNS SETOF public.active_users LANGUAGE sql AS $$ " ++ "SELECT * FROM public.active_users $$",+ DependencyTables: []*storepb.DependencyTable{+ {Schema: "public", Table: "active_users"},+ },+ },+ },+ },+ },+ }, nil, nil, storepb.Engine_POSTGRES, true)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ viewIdx := strings.Index(sql, `CREATE VIEW "public"."active_users"`)+ functionIdx := strings.Index(sql, "CREATE FUNCTION public.get_active_users()")+ require.NotEqual(t, -1, viewIdx)+ require.NotEqual(t, -1, functionIdx)+ require.Less(t, viewIdx, functionIdx)+}++func TestPGMetadataDiffEnumObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.EnumTypeMetadata+ target []*storepb.EnumTypeMetadata+ contains []string+ }{+ {+ name: "create enum",+ source: nil,+ target: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active", "archived"},+ },+ },+ contains: []string{`CREATE TYPE "public"."status" AS ENUM`, `'active'`, `'archived'`},+ },+ {+ name: "drop enum",+ source: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active"},+ },+ },+ target: nil,+ contains: []string{`DROP TYPE "public"."status"`},+ },+ {+ name: "append enum value",+ source: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active"},+ },+ },+ target: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active", "archived"},+ },+ },+ contains: []string{`ALTER TYPE "public"."status" ADD VALUE 'archived'`},+ },+ {+ name: "insert enum value before existing value",+ source: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active", "archived"},+ },+ },+ target: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active", "pending", "archived"},+ },+ },+ contains: []string{`ALTER TYPE "public"."status" ADD VALUE 'pending' BEFORE 'archived'`},+ },+ {+ name: "removed enum value emits warning",+ source: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active", "archived"},+ },+ },+ target: []*storepb.EnumTypeMetadata{+ {+ Name: "status",+ Values: []string{"active"},+ },+ },+ contains: []string{`-- WARNING: PostgreSQL does not support removing enum values from "public"."status": 'archived'`},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithEnum(tt.source)+ target := newPGDatabaseMetadataWithEnum(tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func TestPGMetadataDiffSequenceObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.SequenceMetadata+ target []*storepb.SequenceMetadata+ contains []string+ }{+ {+ name: "create sequence",+ source: nil,+ target: []*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ },+ contains: []string{`CREATE SEQUENCE "public"."order_seq"`, "START WITH 1", "INCREMENT BY 1"},+ },+ {+ name: "drop sequence",+ source: []*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ },+ target: nil,+ contains: []string{`DROP SEQUENCE "public"."order_seq"`},+ },+ {+ name: "alter sequence",+ source: []*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ },+ target: []*storepb.SequenceMetadata{+ {+ Name: "order_seq",+ DataType: "bigint",+ Start: "10",+ Increment: "2",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "5",+ },+ },+ contains: []string{`ALTER SEQUENCE "public"."order_seq"`, "START WITH 10", "INCREMENT BY 2", "CACHE 5"},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithSequences(tt.source)+ target := newPGDatabaseMetadataWithSequences(tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func TestPGMetadataDiffAlterSequenceDropsOwnershipFromMetadata(t *testing.T) {+ source := newPGDatabaseMetadataWithSequences([]*storepb.SequenceMetadata{+ {+ Name: "order_seq",+ DataType: "bigint",+ Start: "1",+ Increment: "1",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "1",+ OwnerTable: "orders",+ OwnerColumn: "id",+ },+ })+ target := newPGDatabaseMetadataWithSequences([]*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ require.Contains(t, sql, `ALTER SEQUENCE "public"."order_seq" OWNED BY NONE`)+}++func TestPGMetadataDiffAlterSequenceAttachesOwnershipAfterCreateTable(t *testing.T) {+ source := newPGDatabaseMetadataWithTablesAndSequences(nil, []*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ })+ target := newPGDatabaseMetadataWithTablesAndSequences([]*storepb.TableMetadata{+ {+ Name: "orders",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "bigint", Nullable: false},+ },+ },+ }, []*storepb.SequenceMetadata{+ {+ Name: "order_seq",+ DataType: "bigint",+ Start: "1",+ Increment: "1",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "1",+ OwnerTable: "orders",+ OwnerColumn: "id",+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ createTableIdx := strings.Index(sql, `CREATE TABLE "public"."orders"`)+ ownedByIdx := strings.Index(sql, `ALTER SEQUENCE "public"."order_seq" OWNED BY "public"."orders"."id"`)+ require.NotEqual(t, -1, createTableIdx)+ require.NotEqual(t, -1, ownedByIdx)+ require.Less(t, createTableIdx, ownedByIdx)+}++func TestPGMetadataDiffAlterSequenceAttachesOwnershipAfterAddColumn(t *testing.T) {+ source := newPGDatabaseMetadataWithTablesAndSequences([]*storepb.TableMetadata{+ {+ Name: "orders",+ Columns: []*storepb.ColumnMetadata{+ {Name: "name", Type: "text", Nullable: false},+ },+ },+ }, []*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ })+ target := newPGDatabaseMetadataWithTablesAndSequences([]*storepb.TableMetadata{+ {+ Name: "orders",+ Columns: []*storepb.ColumnMetadata{+ {Name: "name", Type: "text", Nullable: false},+ {Name: "id", Type: "bigint", Nullable: false},+ },+ },+ }, []*storepb.SequenceMetadata{+ {+ Name: "order_seq",+ DataType: "bigint",+ Start: "1",+ Increment: "1",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "1",+ OwnerTable: "orders",+ OwnerColumn: "id",+ },+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ addColumnIdx := strings.Index(sql, `ALTER TABLE "public"."orders" ADD COLUMN "id" bigint NOT NULL`)+ ownedByIdx := strings.Index(sql, `ALTER SEQUENCE "public"."order_seq" OWNED BY "public"."orders"."id"`)+ require.NotEqual(t, -1, addColumnIdx)+ require.NotEqual(t, -1, ownedByIdx)+ require.Less(t, addColumnIdx, ownedByIdx)+}++func TestPGMetadataDiffAlterSequenceDetachesOwnershipBeforeOwnerTableDrop(t *testing.T) {+ source := newPGDatabaseMetadataWithTablesAndSequences([]*storepb.TableMetadata{+ {+ Name: "orders",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "bigint", Nullable: false},+ },+ },+ }, []*storepb.SequenceMetadata{+ {+ Name: "order_seq",+ DataType: "bigint",+ Start: "1",+ Increment: "1",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "1",+ OwnerTable: "orders",+ OwnerColumn: "id",+ },+ })+ target := newPGDatabaseMetadataWithTablesAndSequences(nil, []*storepb.SequenceMetadata{+ newPGSequenceMetadata(),+ })++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ detachIdx := strings.Index(sql, `ALTER SEQUENCE "public"."order_seq" OWNED BY NONE`)+ dropTableIdx := strings.Index(sql, `DROP TABLE "public"."orders"`)+ require.NotEqual(t, -1, detachIdx)+ require.NotEqual(t, -1, dropTableIdx)+ require.Less(t, detachIdx, dropTableIdx)+}++func TestPGMetadataDiffMaterializedViewObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.MaterializedViewMetadata+ target []*storepb.MaterializedViewMetadata+ contains []string+ }{+ {+ name: "create materialized view",+ source: nil,+ target: []*storepb.MaterializedViewMetadata{+ {Name: "active_users_mv", Definition: "SELECT @@@active_users@@@"},+ },+ contains: []string{`CREATE MATERIALIZED VIEW "public"."active_users_mv" AS`, "SELECT @@@active_users@@@"},+ },+ {+ name: "drop materialized view",+ source: []*storepb.MaterializedViewMetadata{+ {Name: "active_users_mv", Definition: "SELECT @@@active_users@@@"},+ },+ target: nil,+ contains: []string{`DROP MATERIALIZED VIEW "public"."active_users_mv"`},+ },+ {+ name: "alter materialized view",+ source: []*storepb.MaterializedViewMetadata{+ {Name: "active_users_mv", Definition: "SELECT @@@old_active_users@@@"},+ },+ target: []*storepb.MaterializedViewMetadata{+ {Name: "active_users_mv", Definition: "SELECT @@@new_active_users@@@"},+ },+ contains: []string{+ `DROP MATERIALIZED VIEW "public"."active_users_mv"`,+ `CREATE MATERIALIZED VIEW "public"."active_users_mv" AS`,+ "SELECT @@@new_active_users@@@",+ },+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithMaterializedViews(tt.source)+ target := newPGDatabaseMetadataWithMaterializedViews(tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func TestPGMetadataDiffFunctionObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.FunctionMetadata+ target []*storepb.FunctionMetadata+ contains []string+ }{+ {+ name: "create function",+ source: nil,+ target: []*storepb.FunctionMetadata{newPGFunctionMetadata("SELECT 1")},+ contains: []string{"CREATE FUNCTION public.calculate_area()", "SELECT 1"},+ },+ {+ name: "drop function",+ source: []*storepb.FunctionMetadata{newPGFunctionMetadata("SELECT 1")},+ target: nil,+ contains: []string{`DROP FUNCTION "public"."calculate_area"()`},+ },+ {+ name: "alter function",+ source: []*storepb.FunctionMetadata{newPGFunctionMetadata("SELECT 1")},+ target: []*storepb.FunctionMetadata{newPGFunctionMetadata("SELECT 2")},+ contains: []string{`DROP FUNCTION "public"."calculate_area"()`, "CREATE FUNCTION public.calculate_area()", "SELECT 2"},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithRoutines(tt.source, nil)+ target := newPGDatabaseMetadataWithRoutines(tt.target, nil)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func TestPGMetadataDiffProcedureObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.ProcedureMetadata+ target []*storepb.ProcedureMetadata+ contains []string+ }{+ {+ name: "create procedure",+ source: nil,+ target: []*storepb.ProcedureMetadata{newPGProcedureMetadata("NULL")},+ contains: []string{"CREATE PROCEDURE public.refresh_stats()", "NULL"},+ },+ {+ name: "drop procedure",+ source: []*storepb.ProcedureMetadata{newPGProcedureMetadata("NULL")},+ target: nil,+ contains: []string{`DROP PROCEDURE "public"."refresh_stats"()`},+ },+ {+ name: "alter procedure",+ source: []*storepb.ProcedureMetadata{newPGProcedureMetadata("NULL")},+ target: []*storepb.ProcedureMetadata{newPGProcedureMetadata("RAISE NOTICE 'refresh'")},+ contains: []string{`DROP PROCEDURE "public"."refresh_stats"()`, "CREATE PROCEDURE public.refresh_stats()", "RAISE NOTICE 'refresh'"},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithRoutines(nil, tt.source)+ target := newPGDatabaseMetadataWithRoutines(nil, tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func TestPGMetadataDiffSchemaObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.SchemaMetadata+ target []*storepb.SchemaMetadata+ contains []string+ }{+ {+ name: "create schema",+ source: []*storepb.SchemaMetadata{{Name: "public"}},+ target: []*storepb.SchemaMetadata{{Name: "public"}, {Name: "analytics"}},+ contains: []string{+ `CREATE SCHEMA IF NOT EXISTS "analytics"`,+ },+ },+ {+ name: "drop schema",+ source: []*storepb.SchemaMetadata{+ {Name: "public"},+ {+ Name: "analytics",+ Tables: []*storepb.TableMetadata{+ {Name: "events", Columns: []*storepb.ColumnMetadata{{Name: "id", Type: "integer", Nullable: false}}},+ },+ Views: []*storepb.ViewMetadata{+ {Name: "event_ids", Definition: "SELECT id FROM analytics.events"},+ },+ Sequences: []*storepb.SequenceMetadata{+ {Name: "event_id_seq", DataType: "bigint"},+ },+ EnumTypes: []*storepb.EnumTypeMetadata{+ {Name: "event_status", Values: []string{"active"}},+ },+ },+ },+ target: []*storepb.SchemaMetadata{{Name: "public"}},+ contains: []string{+ `DROP VIEW "analytics"."event_ids"`,+ `DROP TABLE "analytics"."events"`,+ `DROP SEQUENCE "analytics"."event_id_seq"`,+ `DROP TYPE "analytics"."event_status"`,+ `DROP SCHEMA IF EXISTS "analytics"`,+ },+ },+ {+ name: "drop public schema is ignored",+ source: []*storepb.SchemaMetadata{{Name: "public"}},+ target: nil,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithSchemas(tt.source)+ target := newPGDatabaseMetadataWithSchemas(tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ require.NotContains(t, sql, "CASCADE")+ require.NotContains(t, sql, `DROP SCHEMA "public"`)+ })+ }+}++func TestPGMetadataDiffExtensionObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.ExtensionMetadata+ target []*storepb.ExtensionMetadata+ contains []string+ }{+ {+ name: "create extension",+ source: nil,+ target: []*storepb.ExtensionMetadata{{Name: "pg_trgm", Schema: "public", Version: "1.6"}},+ contains: []string{`CREATE EXTENSION IF NOT EXISTS "pg_trgm"`},+ },+ {+ name: "drop extension",+ source: []*storepb.ExtensionMetadata{{Name: "pg_trgm", Schema: "public", Version: "1.6"}},+ target: nil,+ contains: []string{`DROP EXTENSION "pg_trgm"`},+ },+ {+ name: "recreate changed extension",+ source: []*storepb.ExtensionMetadata{{Name: "pg_trgm", Schema: "public", Version: "1.5"}},+ target: []*storepb.ExtensionMetadata{{Name: "pg_trgm", Schema: "public", Version: "1.6"}},+ contains: []string{`DROP EXTENSION "pg_trgm"`, `CREATE EXTENSION IF NOT EXISTS "pg_trgm"`},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithExtensions(tt.source)+ target := newPGDatabaseMetadataWithExtensions(tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func TestPGMetadataDiffEventTriggerObjectChanges(t *testing.T) {+ tests := []struct {+ name string+ source []*storepb.EventTriggerMetadata+ target []*storepb.EventTriggerMetadata+ contains []string+ }{+ {+ name: "create event trigger",+ source: nil,+ target: []*storepb.EventTriggerMetadata{+ newPGEventTriggerMetadata("ddl_command_end"),+ },+ contains: []string{`CREATE EVENT TRIGGER "audit_ddl" ON ddl_command_end`},+ },+ {+ name: "drop event trigger",+ source: []*storepb.EventTriggerMetadata{+ newPGEventTriggerMetadata("ddl_command_end"),+ },+ target: nil,+ contains: []string{`DROP EVENT TRIGGER "audit_ddl"`},+ },+ {+ name: "recreate changed event trigger",+ source: []*storepb.EventTriggerMetadata{+ newPGEventTriggerMetadata("ddl_command_start"),+ },+ target: []*storepb.EventTriggerMetadata{+ newPGEventTriggerMetadata("ddl_command_end"),+ },+ contains: []string{`DROP EVENT TRIGGER "audit_ddl"`, `CREATE EVENT TRIGGER "audit_ddl" ON ddl_command_end`},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ source := newPGDatabaseMetadataWithEventTriggers(tt.source)+ target := newPGDatabaseMetadataWithEventTriggers(tt.target)++ sql, err := schema.DiffMigration(storepb.Engine_POSTGRES, source, target)++ require.NoError(t, err)+ for _, want := range tt.contains {+ require.Contains(t, sql, want)+ }+ })+ }+}++func newPGDatabaseMetadataWithView(definition string) *model.DatabaseMetadata {+ return newPGDatabaseMetadata(nil, []*storepb.ViewMetadata{+ {+ Name: "v",+ Definition: definition,+ },+ })+}++func newPGDatabaseMetadataWithEnum(enumTypes []*storepb.EnumTypeMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ EnumTypes: enumTypes,+ },+ },+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGDatabaseMetadataWithSchemas(schemas []*storepb.SchemaMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: schemas,+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGDatabaseMetadataWithExtensions(extensions []*storepb.ExtensionMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{{Name: "public"}},+ Extensions: extensions,+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGDatabaseMetadataWithEventTriggers(eventTriggers []*storepb.EventTriggerMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{{Name: "public"}},+ EventTriggers: eventTriggers,+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGEventTriggerMetadata(event string) *storepb.EventTriggerMetadata {+ return &storepb.EventTriggerMetadata{+ Name: "audit_ddl",+ Event: event,+ FunctionSchema: "public",+ FunctionName: "audit_ddl",+ Enabled: true,+ }+}++func newPGDatabaseMetadataWithRoutines(functions []*storepb.FunctionMetadata, procedures []*storepb.ProcedureMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Functions: functions,+ Procedures: procedures,+ },+ },+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGFunctionMetadata(body string) *storepb.FunctionMetadata {+ return &storepb.FunctionMetadata{+ Name: "calculate_area",+ Signature: "calculate_area()",+ Definition: "CREATE FUNCTION public.calculate_area() RETURNS integer LANGUAGE sql AS $$ " ++ body + " $$",+ }+}++func newPGProcedureMetadata(body string) *storepb.ProcedureMetadata {+ return &storepb.ProcedureMetadata{+ Name: "refresh_stats",+ Signature: "refresh_stats()",+ Definition: "CREATE PROCEDURE public.refresh_stats() LANGUAGE plpgsql AS $$ BEGIN " ++ body + "; END $$",+ }+}++func newCockroachDatabaseMetadataWithFunctions(functions []*storepb.FunctionMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Functions: functions,+ },+ },+ }, nil, nil, storepb.Engine_COCKROACHDB, true)+}++type alwaysEqualFunctionComparer struct{}++func (*alwaysEqualFunctionComparer) Equal(*storepb.FunctionMetadata, *storepb.FunctionMetadata) bool {+ return true+}++func (*alwaysEqualFunctionComparer) CompareDetailed(*storepb.FunctionMetadata, *storepb.FunctionMetadata) (*schema.FunctionComparisonResult, error) {+ return nil, nil+}++func newPGDatabaseMetadataWithMaterializedViews(views []*storepb.MaterializedViewMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ MaterializedViews: views,+ },+ },+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGDatabaseMetadataWithSequences(sequences []*storepb.SequenceMetadata) *model.DatabaseMetadata {+ return newPGDatabaseMetadataWithTablesAndSequences(nil, sequences)+}++func newPGDatabaseMetadataWithTablesAndSequences(tables []*storepb.TableMetadata, sequences []*storepb.SequenceMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: tables,+ Sequences: sequences,+ },+ },+ }, nil, nil, storepb.Engine_POSTGRES, true)+}++func newPGSequenceMetadata() *storepb.SequenceMetadata {+ return &storepb.SequenceMetadata{+ Name: "order_seq",+ DataType: "bigint",+ Start: "1",+ Increment: "1",+ MinValue: "1",+ MaxValue: "9223372036854775807",+ CacheSize: "1",+ }+}++func newPGPartitionedOrdersTable(partitions []*storepb.TablePartitionMetadata) *storepb.TableMetadata {+ return &storepb.TableMetadata{+ Name: "orders",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer", Nullable: false},+ {Name: "created_at", Type: "date", Nullable: false},+ },+ Partitions: partitions,+ }+}++func newPGOrdersPartition(name string, value string) *storepb.TablePartitionMetadata {+ return &storepb.TablePartitionMetadata{+ Name: name,+ Type: storepb.TablePartitionMetadata_RANGE,+ Expression: "RANGE (created_at)",+ Value: value,+ }+}++func newPGDatabaseMetadata(tables []*storepb.TableMetadata, views []*storepb.ViewMetadata) *model.DatabaseMetadata {+ return newDatabaseMetadataWithEngine(storepb.Engine_POSTGRES, tables, views)+}++func newDatabaseMetadataWithEngine(engine storepb.Engine, tables []*storepb.TableMetadata, views []*storepb.ViewMetadata) *model.DatabaseMetadata {+ return model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: tables,+ Views: views,+ },+ },+ }, nil, nil, engine, true)+}diff --git a/backend/plugin/schema/pg/sdl_migration_omni.go b/backend/plugin/schema/pg/sdl_migration_omni.goindex b6cadeab9e..8156b4ff38 100644--- a/backend/plugin/schema/pg/sdl_migration_omni.go+++ b/backend/plugin/schema/pg/sdl_migration_omni.go@@ -16,6 +16,8 @@ import (func init() {schema.RegisterDiffSDLMigration(storepb.Engine_POSTGRES, pgDiffSDLMigration)schema.RegisterDiffSDLMigration(storepb.Engine_COCKROACHDB, pgDiffSDLMigration)+ schema.RegisterDiffMetadataMigration(storepb.Engine_POSTGRES, pgDiffMetadataMigration)+ schema.RegisterDiffMetadataMigration(storepb.Engine_COCKROACHDB, pgDiffCockroachMetadataMigration)schema.RegisterSDLDropAdvices(storepb.Engine_POSTGRES, pgSDLDropAdvices)schema.RegisterSDLDropAdvices(storepb.Engine_COCKROACHDB, pgSDLDropAdvices)}diff --git a/backend/plugin/schema/schema.go b/backend/plugin/schema/schema.goindex 5bf9a030a0..f3ebab47e7 100644--- a/backend/plugin/schema/schema.go+++ b/backend/plugin/schema/schema.go@@ -26,6 +26,7 @@ var (getSDLDiffs = make(map[storepb.Engine]getSDLDiff)sdlDropAdvicesFns = make(map[storepb.Engine]sdlDropAdvices)diffSDLMigrations = make(map[storepb.Engine]diffSDLMigration)+ diffMetadataMigrations = make(map[storepb.Engine]diffMetadataMigration)getMultiFileDatabaseDefinitions = make(map[storepb.Engine]getMultiFileDatabaseDefinition)walkThroughs = make(map[storepb.Engine]walkThrough)walkThroughsWithContext = make(map[storepb.Engine]walkThroughWithContext)@@ -45,6 +46,7 @@ type generateMigration func(*MetadataDiff) (string, error)type getSDLDiff func(currentSDLText, previousUserSDLText string, currentSchema *model.DatabaseMetadata) (*MetadataDiff, error)type sdlDropAdvices func(userSDLText string, currentSchema *model.DatabaseMetadata) ([]*storepb.Advice, error)type diffSDLMigration func(sourceSDL, targetSDL string) (string, error)+type diffMetadataMigration func(oldSchema, newSchema *model.DatabaseMetadata) (string, error)type walkThrough func(*model.DatabaseMetadata, []base.AST) *storepb.Advicetype walkThroughWithContext func(WalkThroughContext, *model.DatabaseMetadata, []base.AST) *storepb.Advice@@ -296,9 +298,14 @@ func SDLDropAdvices(engine storepb.Engine, userSDLText string, currentSchema *mo}// DiffMigration computes the migration SQL between two database metadata states.-// For engines with DiffSDLMigration registered, converts both sides to SDL and diffs.-// Falls back to the legacy GetDatabaseSchemaDiff + GenerateMigration path otherwise.+// Engines may register a metadata migration to avoid round-tripping synced+// metadata through SDL text. Otherwise, engines with DiffSDLMigration registered+// convert both sides to SDL and diff. The legacy MetadataDiff + GenerateMigration+// path remains the fallback for engines that haven't migrated yet.func DiffMigration(engine storepb.Engine, oldSchema, newSchema *model.DatabaseMetadata) (string, error) {+ if f, ok := diffMetadataMigrations[engine]; ok {+ return f(oldSchema, newSchema)+ }if _, ok := diffSDLMigrations[engine]; ok {sourceSDL, err := MetadataToSDL(engine, oldSchema)if err != nil {@@ -318,6 +325,15 @@ func DiffMigration(engine storepb.Engine, oldSchema, newSchema *model.DatabaseMereturn GenerateMigration(engine, diff)}+func RegisterDiffMetadataMigration(engine storepb.Engine, f diffMetadataMigration) {+ mux.Lock()+ defer mux.Unlock()+ if _, dup := diffMetadataMigrations[engine]; dup {+ panic(fmt.Sprintf("Register called twice %s", engine))+ }+ diffMetadataMigrations[engine] = f+}+// MetadataToSDL converts database metadata to SDL text using the registered GetDatabaseDefinition.func MetadataToSDL(engine storepb.Engine, meta *model.DatabaseMetadata) (string, error) {if meta == nil {