Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: consolidate release schema change type handling (#18756)
Danny Xue2eaf9e742fb
diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.goindex 6f77180f74..2251beb4e1 100644--- a/backend/runner/taskrun/database_migrate_executor.go+++ b/backend/runner/taskrun/database_migrate_executor.go@@ -55,7 +55,30 @@ type DatabaseMigrateExecutor struct {func (exec *DatabaseMigrateExecutor) RunOnce(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int) (bool, *storepb.TaskRunResult, error) {// Check if this is a release-based taskif releaseName := task.Payload.GetRelease(); releaseName != "" {- return exec.runReleaseTask(ctx, driverCtx, task, taskRunUID, releaseName)+ // Parse release name to get project ID and release UID+ _, releaseUID, err := common.GetProjectReleaseUID(releaseName)+ if err != nil {+ return true, nil, errors.Wrapf(err, "failed to parse release name %q", releaseName)+ }++ // Fetch the release+ release, err := exec.store.GetReleaseByUID(ctx, releaseUID)+ if err != nil {+ return true, nil, errors.Wrapf(err, "failed to get release %d", releaseUID)+ }+ if release == nil {+ return true, nil, errors.Errorf("release %d not found", releaseUID)+ }++ // Switch based on release type+ switch release.Payload.Type {+ case storepb.SchemaChangeType_VERSIONED:+ return exec.runVersionedRelease(ctx, driverCtx, task, taskRunUID, release)+ case storepb.SchemaChangeType_DECLARATIVE:+ return exec.runDeclarativeRelease(ctx, driverCtx, task, taskRunUID, release)+ default:+ return true, nil, errors.Errorf("unsupported release type %q", release.Payload.Type)+ }}if task.Payload.GetEnableGhost() {@@ -239,22 +262,7 @@ func (exec *DatabaseMigrateExecutor) runGhostMigration(ctx context.Context, drivreturn runMigrationWithFunc(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_SCHEMA_CHANGE_TYPE_UNSPECIFIED, execFunc)}-func (exec *DatabaseMigrateExecutor) runReleaseTask(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, releaseName string) (bool, *storepb.TaskRunResult, error) {- // Parse release name to get project ID and release UID- _, releaseUID, err := common.GetProjectReleaseUID(releaseName)- if err != nil {- return true, nil, errors.Wrapf(err, "failed to parse release name %q", releaseName)- }-- // Fetch the release- release, err := exec.store.GetReleaseByUID(ctx, releaseUID)- if err != nil {- return true, nil, errors.Wrapf(err, "failed to get release %d", releaseUID)- }- if release == nil {- return true, nil, errors.Errorf("release %d not found", releaseUID)- }-+func (exec *DatabaseMigrateExecutor) runVersionedRelease(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, release *store.ReleaseMessage) (bool, *storepb.TaskRunResult, error) {// Get existing revisions for this databaserevisions, err := exec.store.ListRevisions(ctx, &store.FindRevisionMessage{InstanceID: &task.InstanceID,@@ -264,146 +272,131 @@ func (exec *DatabaseMigrateExecutor) runReleaseTask(ctx context.Context, driverCreturn true, nil, errors.Wrapf(err, "failed to list revisions for database %q", *task.DatabaseName)}- // Extract release type to determine execution strategy- releaseType := release.Payload.Type-- switch releaseType {- case storepb.SchemaChangeType_VERSIONED:- // For VERSIONED releases, apply each unapplied migration file in order- // Build map of applied versions- appliedVersions := make(map[string]bool)- for _, revision := range revisions {- if revision.Payload.Type == storepb.SchemaChangeType_VERSIONED {- appliedVersions[revision.Version] = true- }+ // Build map of applied versions+ appliedVersions := make(map[string]bool)+ for _, revision := range revisions {+ if revision.Payload.Type == storepb.SchemaChangeType_VERSIONED {+ appliedVersions[revision.Version] = true}+ }- // Execute unapplied files in order- for _, file := range release.Payload.Files {- // Skip if already applied- if appliedVersions[file.Version] {- slog.Info("skipping already applied version",- slog.String("version", file.Version),- slog.String("database", *task.DatabaseName))- continue- }-- // Fetch and execute this file- sheet, err := exec.store.GetSheetFull(ctx, file.SheetSha256)- if err != nil {- return true, nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)- }- if sheet == nil {- return true, nil, errors.Errorf("sheet not found: %s", file.SheetSha256)- }-- slog.Info("executing release file",+ // Execute unapplied files in order+ for _, file := range release.Payload.Files {+ // Skip if already applied+ if appliedVersions[file.Version] {+ slog.Info("skipping already applied version",slog.String("version", file.Version),- slog.String("database", *task.DatabaseName),- slog.String("file", file.Path))-- // Log release file execution- exec.store.CreateTaskRunLogS(ctx, taskRunUID, time.Now(), exec.profile.DeployID, &storepb.TaskRunLog{- Type: storepb.TaskRunLog_RELEASE_FILE_EXECUTE,- ReleaseFileExecute: &storepb.TaskRunLog_ReleaseFileExecute{- Version: file.Version,- FilePath: file.Path,- },- })-- // Execute migration for this file- _, _, err = runMigration(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, file.Version, releaseType)- if err != nil {- return true, nil, errors.Wrapf(err, "failed to execute release file %s (version %s)", file.Path, file.Version)- }+ slog.String("database", *task.DatabaseName))+ continue}- case storepb.SchemaChangeType_DECLARATIVE:- // For DECLARATIVE releases, apply only the latest schema state- // Find the latest file version in the release (declarative releases should have only one file)- var latestFile *storepb.ReleasePayload_File- var latestVersion *model.Version- for _, file := range release.Payload.Files {- v, err := model.NewVersion(file.Version)- if err != nil {- return true, nil, errors.Wrapf(err, "failed to parse file version %q", file.Version)- }- if latestVersion == nil || latestVersion.LessThan(v) {- latestVersion = v- latestFile = file- }- }-- if latestFile == nil {- return true, nil, errors.Errorf("no files found in declarative release")- }-- // Fetch the schema file- sheet, err := exec.store.GetSheetFull(ctx, latestFile.SheetSha256)+ // Fetch and execute this file+ sheet, err := exec.store.GetSheetFull(ctx, file.SheetSha256)if err != nil {- return true, nil, errors.Wrapf(err, "failed to get sheet %s for version %s", latestFile.SheetSha256, latestFile.Version)+ return true, nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)}if sheet == nil {- return true, nil, errors.Errorf("sheet not found: %s", latestFile.SheetSha256)+ return true, nil, errors.Errorf("sheet not found: %s", file.SheetSha256)}- slog.Info("executing declarative release",- slog.String("version", latestFile.Version),+ slog.Info("executing release file",+ slog.String("version", file.Version),slog.String("database", *task.DatabaseName),- slog.String("file", latestFile.Path))+ slog.String("file", file.Path))// Log release file executionexec.store.CreateTaskRunLogS(ctx, taskRunUID, time.Now(), exec.profile.DeployID, &storepb.TaskRunLog{Type: storepb.TaskRunLog_RELEASE_FILE_EXECUTE,ReleaseFileExecute: &storepb.TaskRunLog_ReleaseFileExecute{- Version: latestFile.Version,- FilePath: latestFile.Path,+ Version: file.Version,+ FilePath: file.Path,},})- // Get instance and database for SDL diff- instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})+ // Execute migration for this file+ _, _, err = runMigration(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, file.Version, storepb.SchemaChangeType_VERSIONED)if err != nil {- return true, nil, errors.Wrapf(err, "failed to get instance %s", task.InstanceID)- }- database, err := exec.store.GetDatabase(ctx, &store.FindDatabaseMessage{InstanceID: &task.InstanceID, DatabaseName: task.DatabaseName})- if err != nil {- return true, nil, errors.Wrapf(err, "failed to get database %s", *task.DatabaseName)+ return true, nil, errors.Wrapf(err, "failed to execute release file %s (version %s)", file.Path, file.Version)}+ }- // Create execFunc that uses SDL diff logic (same as old SchemaDeclareExecutor)- execFunc := func(ctx context.Context, execStatement string, driver db.Driver, opts db.ExecuteOptions) error {- opts.LogComputeDiffStart()- migrationSQL, err := diff(ctx, exec.store, instance, database, execStatement)- if err != nil {- opts.LogComputeDiffEnd(err.Error())- return errors.Wrapf(err, "failed to diff database schema")- }- opts.LogComputeDiffEnd("")+ return true, &storepb.TaskRunResult{+ Detail: "Versioned release executed successfully",+ }, nil+}- // Log statement string.- opts.LogCommandStatement = true- if _, err := driver.Execute(ctx, migrationSQL, opts); err != nil {- return err- }- return nil- }+func (exec *DatabaseMigrateExecutor) runDeclarativeRelease(ctx context.Context, driverCtx context.Context, task *store.TaskMessage, taskRunUID int, release *store.ReleaseMessage) (bool, *storepb.TaskRunResult, error) {+ // Declarative releases should have exactly one file+ if len(release.Payload.Files) == 0 {+ return true, nil, errors.Errorf("no files found in declarative release")+ }+ if len(release.Payload.Files) > 1 {+ return true, nil, errors.Errorf("declarative release should have exactly one file, found %d", len(release.Payload.Files))+ }- // Execute SDL migration using the diff logic- // For DECLARATIVE releases, pass empty string for version (revisions are not version-tracked)- // runMigrationWithFunc will handle version checking for DECLARATIVE releases (see executor.go:332-357)- _, _, err = runMigrationWithFunc(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", releaseType, execFunc)+ file := release.Payload.Files[0]++ // Fetch the schema file+ sheet, err := exec.store.GetSheetFull(ctx, file.SheetSha256)+ if err != nil {+ return true, nil, errors.Wrapf(err, "failed to get sheet %s for version %s", file.SheetSha256, file.Version)+ }+ if sheet == nil {+ return true, nil, errors.Errorf("sheet not found: %s", file.SheetSha256)+ }++ slog.Info("executing declarative release",+ slog.String("version", file.Version),+ slog.String("database", *task.DatabaseName),+ slog.String("file", file.Path))++ // Log release file execution+ exec.store.CreateTaskRunLogS(ctx, taskRunUID, time.Now(), exec.profile.DeployID, &storepb.TaskRunLog{+ Type: storepb.TaskRunLog_RELEASE_FILE_EXECUTE,+ ReleaseFileExecute: &storepb.TaskRunLog_ReleaseFileExecute{+ Version: file.Version,+ // FilePath is omitted because it's artificial for declarative releases+ },+ })++ // Get instance and database for SDL diff+ instance, err := exec.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &task.InstanceID})+ if err != nil {+ return true, nil, errors.Wrapf(err, "failed to get instance %s", task.InstanceID)+ }+ database, err := exec.store.GetDatabase(ctx, &store.FindDatabaseMessage{InstanceID: &task.InstanceID, DatabaseName: task.DatabaseName})+ if err != nil {+ return true, nil, errors.Wrapf(err, "failed to get database %s", *task.DatabaseName)+ }++ // Create execFunc that uses SDL diff logic (same as old SchemaDeclareExecutor)+ execFunc := func(ctx context.Context, execStatement string, driver db.Driver, opts db.ExecuteOptions) error {+ opts.LogComputeDiffStart()+ migrationSQL, err := diff(ctx, exec.store, instance, database, execStatement)if err != nil {- return true, nil, errors.Wrapf(err, "failed to execute declarative release (version %s)", latestFile.Version)+ opts.LogComputeDiffEnd(err.Error())+ return errors.Wrapf(err, "failed to diff database schema")+ }+ opts.LogComputeDiffEnd("")++ // Log statement string.+ opts.LogCommandStatement = true+ if _, err := driver.Execute(ctx, migrationSQL, opts); err != nil {+ return err}+ return nil+ }- default:- return true, nil, errors.Errorf("unsupported release type %q", releaseType)+ // Execute SDL migration using the diff logic+ // For DECLARATIVE releases, pass empty string for version (revisions are not version-tracked)+ // runMigrationWithFunc will handle version checking for DECLARATIVE releases (see executor.go:332-357)+ _, _, err = runMigrationWithFunc(ctx, driverCtx, exec.store, exec.dbFactory, exec.schemaSyncer, exec.profile, task, taskRunUID, sheet, "", storepb.SchemaChangeType_DECLARATIVE, execFunc)+ if err != nil {+ return true, nil, errors.Wrapf(err, "failed to execute declarative release (version %s)", file.Version)}- // All files executed successfullyreturn true, &storepb.TaskRunResult{- Detail: "Release executed successfully",+ Detail: "Declarative release executed successfully",}, nil}