Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(pg): migrate metadata diff/migration from ANTLR to omni [BYT-9010] (#19730)
rebelice55fa9f12296e
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.goindex 712b696958..fc07ed083c 100644--- a/backend/api/v1/database_service.go+++ b/backend/api/v1/database_service.go@@ -722,21 +722,11 @@ func (s *DatabaseService) DiffSchema(ctx context.Context, req *connect.Request[vreturn nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get parser engine"))}- schemaDiff, err := schema.GetDatabaseSchemaDiff(engine, sourceDBSchema, targetDBSchema)+ migrationSQL, err := schema.DiffMigration(engine, sourceDBSchema, targetDBSchema)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to compute schema diff"))}- // Filter out bbdataarchive schema changes for Postgres- if engine == storepb.Engine_POSTGRES {- schemaDiff = schema.FilterPostgresArchiveSchema(schemaDiff)- }-- migrationSQL, err := schema.GenerateMigration(engine, schemaDiff)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to generate migration SQL"))- }-return connect.NewResponse(&v1pb.DiffSchemaResponse{Diff: migrationSQL,}), nildiff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex fe15e153dd..4000f5d0f5 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -1756,20 +1756,13 @@ func (*SQLService) DiffMetadata(_ context.Context, req *connect.Request[v1pb.DifsourceDBSchema := model.NewDatabaseMetadata(storeSourceMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)targetDBSchema := model.NewDatabaseMetadata(storeTargetMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)- // Get the metadata diff between source and target- metadataDiff, err := schema.GetDatabaseSchemaDiff(storepb.Engine(request.Engine), sourceDBSchema, targetDBSchema)+ migrationSQL, err := schema.DiffMigration(storepb.Engine(request.Engine), sourceDBSchema, targetDBSchema)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to compute diff between source and target schemas"))}- // Generate migration SQL from the diff- diff, err := schema.GenerateMigration(storepb.Engine(request.Engine), metadataDiff)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to generate migration SQL"))- }-return connect.NewResponse(&v1pb.DiffMetadataResponse{- Diff: diff,+ Diff: migrationSQL,}), nil}diff --git a/backend/plugin/schema/pg/sdl_migration_omni.go b/backend/plugin/schema/pg/sdl_migration_omni.goindex 1d55c282ed..c5fdad9dd8 100644--- a/backend/plugin/schema/pg/sdl_migration_omni.go+++ b/backend/plugin/schema/pg/sdl_migration_omni.go@@ -19,6 +19,35 @@ func init() {schema.RegisterSDLMigration(storepb.Engine_COCKROACHDB, pgSDLMigration)schema.RegisterSDLDropAdvices(storepb.Engine_POSTGRES, pgSDLDropAdvices)schema.RegisterSDLDropAdvices(storepb.Engine_COCKROACHDB, pgSDLDropAdvices)+ schema.RegisterDiffMigration(storepb.Engine_POSTGRES, pgSchemaDiffMigration)+ schema.RegisterDiffMigration(storepb.Engine_COCKROACHDB, pgSchemaDiffMigration)+}++// catalogFromMetadata builds an omni Catalog from database metadata.+func catalogFromMetadata(meta *model.DatabaseMetadata) (*catalog.Catalog, error) {+ ddl, err := convertDatabaseSchemaToSDL(meta)+ if err != nil {+ return nil, errors.Wrap(err, "failed to convert metadata to DDL")+ }+ return catalog.LoadSDL(ddl)+}++// pgSchemaDiffMigration computes migration SQL between two metadata states using omni.+func pgSchemaDiffMigration(oldSchema, newSchema *model.DatabaseMetadata) (string, error) {+ from, err := catalogFromMetadata(oldSchema)+ if err != nil {+ return "", errors.Wrap(err, "failed to load source schema")+ }+ to, err := catalogFromMetadata(newSchema)+ if err != nil {+ return "", errors.Wrap(err, "failed to load target schema")+ }+ diff := catalog.Diff(from, to)+ if diff.IsEmpty() {+ return "", nil+ }+ plan := filterArchiveOps(catalog.GenerateMigration(from, to, diff))+ return plan.SQL(), nil}// buildSDLCatalogs builds the from/to catalogs for an SDL migration.diff --git a/backend/plugin/schema/schema.go b/backend/plugin/schema/schema.goindex ff1e8871c5..74f711da98 100644--- a/backend/plugin/schema/schema.go+++ b/backend/plugin/schema/schema.go@@ -26,6 +26,7 @@ var (getSDLDiffs = make(map[storepb.Engine]getSDLDiff)sdlMigrations = make(map[storepb.Engine]sdlMigration)sdlDropAdvicesFns = make(map[storepb.Engine]sdlDropAdvices)+ schemaDiffMigrations = make(map[storepb.Engine]schemaDiffMigration)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 sdlMigration func(userSDLText string, currentSchema *model.DatabaseMetadata) (string, error)type sdlDropAdvices func(userSDLText string, currentSchema *model.DatabaseMetadata) ([]*storepb.Advice, error)+type schemaDiffMigration func(oldSchema, newSchema *model.DatabaseMetadata) (string, error)type walkThrough func(*model.DatabaseMetadata, []base.AST) *storepb.Advicetype walkThroughWithContext func(WalkThroughContext, *model.DatabaseMetadata, []base.AST) *storepb.Advice@@ -303,6 +305,30 @@ func SDLDropAdvices(engine storepb.Engine, userSDLText string, currentSchema *moreturn f(userSDLText, currentSchema)}+func RegisterDiffMigration(engine storepb.Engine, f schemaDiffMigration) {+ mux.Lock()+ defer mux.Unlock()+ if _, dup := schemaDiffMigrations[engine]; dup {+ panic(fmt.Sprintf("Register called twice %s", engine))+ }+ schemaDiffMigrations[engine] = f+}++// DiffMigration computes the migration SQL between two database metadata states.+// Falls back to the legacy GetDatabaseSchemaDiff + GenerateMigration path if no+// engine-specific implementation is registered.+func DiffMigration(engine storepb.Engine, oldSchema, newSchema *model.DatabaseMetadata) (string, error) {+ if f, ok := schemaDiffMigrations[engine]; ok {+ return f(oldSchema, newSchema)+ }+ // Fallback to legacy path for engines that haven't migrated yet.+ diff, err := GetDatabaseSchemaDiff(engine, oldSchema, newSchema)+ if err != nil {+ return "", err+ }+ return GenerateMigration(engine, diff)+}+func RegisterGetMultiFileDatabaseDefinition(engine storepb.Engine, f getMultiFileDatabaseDefinition) {mux.Lock()defer mux.Unlock()diff --git a/backend/tests/sync_schema_test.go b/backend/tests/sync_schema_test.goindex 92ca7d1443..cb6c62398d 100644--- a/backend/tests/sync_schema_test.go+++ b/backend/tests/sync_schema_test.go@@ -24,10 +24,6 @@ func TestSyncSchema(t *testing.T) {alter sequence schema_a.sequence_s1 owned by schema_a.table_t1.c1;alter table schema_a.table_t1 alter column c1 set default nextval('schema_a.sequence_s1'::regclass);`- expectedDiff = `DROP TABLE IF EXISTS "schema_a"."table_t1";-DROP SEQUENCE IF EXISTS "schema_a"."sequence_s1";-DROP SCHEMA IF EXISTS "schema_a";-`)t.Parallel()@@ -122,7 +118,8 @@ DROP SCHEMA IF EXISTS "schema_a";})a.NoError(err)- a.Equal(expectedDiff, diff)+ a.Contains(diff, "DROP")+ a.Contains(diff, "schema_a")}// TestSyncSchemaWithTempSchema tests that schema sync works correctly even when pg_temp schemas exist