Skip to content

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

feat(pg): add metadata schema diff migration (#20098)

rebelice596acb6d603e
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.go
index 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[v
return 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[v
return 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[v
return 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.go
index 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 string
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.go
index 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 sequences
for 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.Advice
type 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.DatabaseMe
return 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 {