Skip to content

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

refactor: consolidate plan service converters and remove unused code (#18595)

Danny Xu7e544e12bdf2
diff --git a/backend/api/v1/database_group_service_validation_test.go b/backend/api/v1/database_group_service_validation_test.go
deleted file mode 100644
index 1977b7ca3d..0000000000
--- a/backend/api/v1/database_group_service_validation_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package v1
-
-import (
- "strings"
- "testing"
-
- "buf.build/go/protovalidate"
- "github.com/stretchr/testify/require"
-
- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
-)
-
-func TestDatabaseGroupTitleValidation(t *testing.T) {
- validator, err := protovalidate.New()
- require.NoError(t, err)
-
- tests := []struct {
- name string
- title string
- wantError bool
- errMsg string
- }{
- {
- name: "valid title",
- title: "Valid Group Title",
- wantError: false,
- },
- {
- name: "title at max length (200 chars)",
- title: strings.Repeat("a", 200),
- wantError: false,
- },
- {
- name: "title exceeding max length (201 chars)",
- title: strings.Repeat("a", 201),
- wantError: true,
- errMsg: "title",
- },
- {
- name: "single character title (valid)",
- title: "A",
- wantError: false,
- },
- }
-
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- databaseGroup := &v1pb.DatabaseGroup{
- Title: tt.title,
- }
-
- err := validator.Validate(databaseGroup)
- if tt.wantError {
- require.Error(t, err, "Expected validation error for title: %q", tt.title)
- if tt.errMsg != "" {
- require.Contains(t, err.Error(), tt.errMsg)
- }
- } else {
- require.NoError(t, err, "Expected no validation error for title: %q", tt.title)
- }
- })
- }
-}
diff --git a/backend/api/v1/database_metadata_check.go b/backend/api/v1/database_metadata_check.go
deleted file mode 100644
index e52769d029..0000000000
--- a/backend/api/v1/database_metadata_check.go
+++ /dev/null
@@ -1,71 +0,0 @@
-package v1
-
-import (
- "github.com/pkg/errors"
-
- storepb "github.com/bytebase/bytebase/backend/generated-go/store"
-)
-
-func checkDatabaseMetadata(engine storepb.Engine, metadata *storepb.DatabaseSchemaMetadata) error {
- switch engine {
- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_POSTGRES, storepb.Engine_ORACLE:
- default:
- return errors.Errorf("unsupported engine for check database metadata: %v", engine)
- }
-
- schemaMap := make(map[string]bool)
- for _, schema := range metadata.GetSchemas() {
- if (engine == storepb.Engine_MYSQL || engine == storepb.Engine_TIDB) && schema.GetName() != "" {
- return errors.Errorf("schema name should be empty for MySQL and TiDB")
- }
- if _, ok := schemaMap[schema.GetName()]; ok {
- return errors.Errorf("duplicate schema name %s", schema.GetName())
- }
- schemaMap[schema.GetName()] = true
-
- tableNameMap := make(map[string]bool)
- for _, table := range schema.GetTables() {
- if table.GetName() == "" {
- return errors.Errorf("table name should not be empty")
- }
- if _, ok := tableNameMap[table.GetName()]; ok {
- return errors.Errorf("duplicate table name %s", table.GetName())
- }
- tableNameMap[table.GetName()] = true
-
- columnNameMap := make(map[string]bool)
- for _, column := range table.GetColumns() {
- if column.GetName() == "" {
- return errors.Errorf("column name should not be empty in table %s", table.GetName())
- }
- if _, ok := columnNameMap[column.GetName()]; ok {
- return errors.Errorf("duplicate column name %s in table %s", column.GetName(), table.GetName())
- }
- columnNameMap[column.GetName()] = true
-
- if column.GetType() == "" {
- return errors.Errorf("column %s type should not be empty in table %s", column.GetName(), table.GetName())
- }
- }
-
- indexNameMap := make(map[string]bool)
- for _, index := range table.GetIndexes() {
- if index.GetName() == "" {
- return errors.Errorf("index name should not be empty in table %s", table.GetName())
- }
- if _, ok := indexNameMap[index.GetName()]; ok {
- return errors.Errorf("duplicate index name %s in table %s", index.GetName(), table.GetName())
- }
- indexNameMap[index.GetName()] = true
- if index.Primary {
- for _, key := range index.GetExpressions() {
- if _, ok := columnNameMap[key]; !ok {
- return errors.Errorf("primary key column %s not found in table %s", key, table.GetName())
- }
- }
- }
- }
- }
- }
- return nil
-}
diff --git a/backend/api/v1/database_metadata_check_test.go b/backend/api/v1/database_metadata_check_test.go
deleted file mode 100644
index 48774c2767..0000000000
--- a/backend/api/v1/database_metadata_check_test.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package v1
-
-import (
- "io"
- "os"
- "testing"
-
- "github.com/stretchr/testify/require"
- "gopkg.in/yaml.v3"
-
- "github.com/bytebase/bytebase/backend/common"
- storepb "github.com/bytebase/bytebase/backend/generated-go/store"
-)
-
-type checkTest struct {
- Engine storepb.Engine
- Metadata string
- Err string
-}
-
-func TestCheckDatabaseMetadata(t *testing.T) {
- const (
- record = false
- )
- var (
- filepath = "testdata/check.yaml"
- )
-
- a := require.New(t)
- yamlFile, err := os.Open(filepath)
- a.NoError(err)
-
- tests := []checkTest{}
- byteValue, err := io.ReadAll(yamlFile)
- a.NoError(yamlFile.Close())
- a.NoError(err)
- a.NoError(yaml.Unmarshal(byteValue, &tests))
-
- for i, t := range tests {
- meta := &storepb.DatabaseSchemaMetadata{}
- a.NoError(common.ProtojsonUnmarshaler.Unmarshal([]byte(t.Metadata), meta))
- err := checkDatabaseMetadata(t.Engine, meta)
- if record {
- if err != nil {
- tests[i].Err = err.Error()
- } else {
- tests[i].Err = ""
- }
- } else {
- if t.Err == "" {
- a.NoError(err)
- } else {
- a.NotNil(err, t.Err)
- a.Equal(t.Err, err.Error())
- }
- }
- }
-
- if record {
- byteValue, err := yaml.Marshal(tests)
- a.NoError(err)
- err = os.WriteFile(filepath, byteValue, 0644)
- a.NoError(err)
- }
-}
diff --git a/backend/api/v1/plan_service.go b/backend/api/v1/plan_service.go
index a80da7defd..84485aafc3 100644
--- a/backend/api/v1/plan_service.go
+++ b/backend/api/v1/plan_service.go
@@ -10,6 +10,7 @@ import (
celast "github.com/google/cel-go/common/ast"
celoperators "github.com/google/cel-go/common/operators"
"github.com/pkg/errors"
+ "google.golang.org/protobuf/types/known/timestamppb"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
@@ -591,36 +592,6 @@ func (*PlanService) parsePlanCheckRunFilter(filter string, find *store.FindPlanC
return parseFilter(ast.NativeRep().Expr())
}
-// convertToStorePlanCheckRunStatus converts v1pb.PlanCheckRun_Status to store.PlanCheckRunStatus.
-func convertToStorePlanCheckRunStatus(status v1pb.PlanCheckRun_Status) store.PlanCheckRunStatus {
- switch status {
- case v1pb.PlanCheckRun_CANCELED:
- return store.PlanCheckRunStatusCanceled
- case v1pb.PlanCheckRun_DONE:
- return store.PlanCheckRunStatusDone
- case v1pb.PlanCheckRun_FAILED:
- return store.PlanCheckRunStatusFailed
- case v1pb.PlanCheckRun_RUNNING:
- return store.PlanCheckRunStatusRunning
- default:
- return store.PlanCheckRunStatusRunning
- }
-}
-
-// convertToStoreResultStatus converts v1pb.Advice_Status to storepb.Advice_Status.
-func convertToStoreResultStatus(status v1pb.Advice_Level) storepb.Advice_Status {
- switch status {
- case v1pb.Advice_ERROR:
- return storepb.Advice_ERROR
- case v1pb.Advice_WARNING:
- return storepb.Advice_WARNING
- case v1pb.Advice_SUCCESS:
- return storepb.Advice_SUCCESS
- default:
- return storepb.Advice_STATUS_UNSPECIFIED
- }
-}
-
// RunPlanChecks runs plan checks for a plan.
func (s *PlanService) RunPlanChecks(ctx context.Context, request *connect.Request[v1pb.RunPlanChecksRequest]) (*connect.Response[v1pb.RunPlanChecksResponse], error) {
req := request.Msg
@@ -949,3 +920,485 @@ func storePlanConfigHasRelease(plan *storepb.PlanConfig) bool {
}
return false
}
+
+// Converters section - ordered with callers before callees.
+
+// getPlanCheckRunFromPlan returns a single consolidated plan check run for a plan.
+func getPlanCheckRunFromPlan(project *store.ProjectMessage, plan *store.PlanMessage, databaseGroup *v1pb.DatabaseGroup) (*store.PlanCheckRunMessage, error) {
+ var targets []*storepb.PlanCheckRunConfig_CheckTarget
+
+ for _, spec := range plan.Config.Specs {
+ switch config := spec.Config.(type) {
+ case *storepb.PlanConfig_Spec_CreateDatabaseConfig:
+ // No checks for create database.
+ case *storepb.PlanConfig_Spec_ExportDataConfig:
+ // No checks for export data.
+ case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:
+ // Skip plan checks for releases.
+ if config.ChangeDatabaseConfig.Release != "" {
+ continue
+ }
+
+ var databases []string
+ if len(config.ChangeDatabaseConfig.Targets) == 1 && databaseGroup != nil && config.ChangeDatabaseConfig.Targets[0] == databaseGroup.Name {
+ for _, m := range databaseGroup.MatchedDatabases {
+ databases = append(databases, m.Name)
+ }
+ } else {
+ databases = config.ChangeDatabaseConfig.Targets
+ }
+
+ // Apply sampling upfront
+ if samplingSize := project.Setting.GetCiSamplingSize(); samplingSize > 0 {
+ if len(databases) > int(samplingSize) {
+ databases = databases[:samplingSize]
+ }
+ }
+
+ enableSDL := config.ChangeDatabaseConfig.Type == storepb.PlanConfig_ChangeDatabaseConfig_SDL
+ enableGhost := config.ChangeDatabaseConfig.Type == storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE && config.ChangeDatabaseConfig.EnableGhost
+
+ for _, target := range databases {
+ types := []storepb.PlanCheckType{
+ storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_ADVISE,
+ storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_SUMMARY_REPORT,
+ }
+ if enableGhost {
+ types = append(types, storepb.PlanCheckType_PLAN_CHECK_TYPE_GHOST_SYNC)
+ }
+
+ targets = append(targets, &storepb.PlanCheckRunConfig_CheckTarget{
+ Target: target,
+ SheetSha256: config.ChangeDatabaseConfig.SheetSha256,
+ EnablePriorBackup: config.ChangeDatabaseConfig.EnablePriorBackup,
+ EnableGhost: config.ChangeDatabaseConfig.EnableGhost,
+ EnableSdl: enableSDL,
+ GhostFlags: config.ChangeDatabaseConfig.GhostFlags,
+ Types: types,
+ })
+ }
+ default:
+ return nil, errors.Errorf("unknown spec config type %T", config)
+ }
+ }
+
+ if len(targets) == 0 {
+ return nil, nil
+ }
+
+ return &store.PlanCheckRunMessage{
+ PlanUID: plan.UID,
+ Status: store.PlanCheckRunStatusRunning,
+ Config: &storepb.PlanCheckRunConfig{Targets: targets},
+ }, nil
+}
+
+func convertToPlans(ctx context.Context, s *store.Store, plans []*store.PlanMessage) ([]*v1pb.Plan, error) {
+ v1Plans := make([]*v1pb.Plan, len(plans))
+ for i := range plans {
+ p, err := convertToPlan(ctx, s, plans[i])
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to convert plan")
+ }
+ v1Plans[i] = p
+ }
+ return v1Plans, nil
+}
+
+func convertToPlan(ctx context.Context, s *store.Store, plan *store.PlanMessage) (*v1pb.Plan, error) {
+ p := &v1pb.Plan{
+ Name: common.FormatPlan(plan.ProjectID, plan.UID),
+ Title: plan.Name,
+ Description: plan.Description,
+ Creator: common.FormatUserEmail(plan.Creator),
+ Specs: convertToPlanSpecs(plan.ProjectID, plan.Config.Specs), // Use specs field for output
+ CreateTime: timestamppb.New(plan.CreatedAt),
+ UpdateTime: timestamppb.New(plan.UpdatedAt),
+ State: convertDeletedToState(plan.Deleted),
+ PlanCheckRunStatusCount: map[string]int32{},
+ }
+
+ issue, err := s.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &plan.UID})
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get issue by plan uid %d", plan.UID)
+ }
+ if issue != nil {
+ p.Issue = common.FormatIssue(issue.Project.ResourceID, issue.UID)
+ }
+ if plan.PipelineUID != nil {
+ p.Rollout = common.FormatRollout(plan.ProjectID, *plan.PipelineUID)
+ }
+ planCheckRuns, err := s.ListPlanCheckRuns(ctx, &store.FindPlanCheckRunMessage{
+ PlanUID: &plan.UID,
+ })
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to list plan check runs for plan uid %d", plan.UID)
+ }
+ for _, run := range planCheckRuns {
+ p.PlanCheckRunStatusCount[string(run.Status)]++
+ for _, result := range run.Result.Results {
+ p.PlanCheckRunStatusCount[storepb.Advice_Status_name[int32(result.Status)]]++
+ }
+ }
+ return p, nil
+}
+
+func convertPlan(plan *v1pb.Plan) *storepb.PlanConfig {
+ if plan == nil {
+ return nil
+ }
+
+ // At this point, plan.Specs should always be populated
+ // (either originally or converted from steps at API entry point)
+ return &storepb.PlanConfig{
+ Specs: convertPlanSpecs(plan.Specs),
+ }
+}
+
+func convertToPlanCheckRuns(projectID string, planUID int64, runs []*store.PlanCheckRunMessage) []*v1pb.PlanCheckRun {
+ var planCheckRuns []*v1pb.PlanCheckRun
+ for _, run := range runs {
+ // Expand consolidated run into virtual records for backward compatibility
+ expanded := expandPlanCheckRun(projectID, planUID, run)
+ planCheckRuns = append(planCheckRuns, expanded...)
+ }
+ return planCheckRuns
+}
+
+func convertToPlanSpecs(projectID string, specs []*storepb.PlanConfig_Spec) []*v1pb.Plan_Spec {
+ v1Specs := make([]*v1pb.Plan_Spec, len(specs))
+ for i := range specs {
+ v1Specs[i] = convertToPlanSpec(projectID, specs[i])
+ }
+ return v1Specs
+}
+
+func convertToPlanSpec(projectID string, spec *storepb.PlanConfig_Spec) *v1pb.Plan_Spec {
+ v1Spec := &v1pb.Plan_Spec{
+ Id: spec.Id,
+ }
+
+ switch v := spec.Config.(type) {
+ case *storepb.PlanConfig_Spec_CreateDatabaseConfig:
+ v1Spec.Config = convertToPlanSpecCreateDatabaseConfig(v)
+ case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:
+ v1Spec.Config = convertToPlanSpecChangeDatabaseConfig(projectID, v)
+ case *storepb.PlanConfig_Spec_ExportDataConfig:
+ v1Spec.Config = convertToPlanSpecExportDataConfig(projectID, v)
+ }
+
+ return v1Spec
+}
+
+func convertToPlanSpecCreateDatabaseConfig(config *storepb.PlanConfig_Spec_CreateDatabaseConfig) *v1pb.Plan_Spec_CreateDatabaseConfig {
+ c := config.CreateDatabaseConfig
+ return &v1pb.Plan_Spec_CreateDatabaseConfig{
+ CreateDatabaseConfig: &v1pb.Plan_CreateDatabaseConfig{
+ Target: c.Target,
+ Database: c.Database,
+ Table: c.Table,
+ CharacterSet: c.CharacterSet,
+ Collation: c.Collation,
+ Cluster: c.Cluster,
+ Owner: c.Owner,
+ Environment: c.Environment,
+ },
+ }
+}
+
+func convertToPlanSpecChangeDatabaseConfig(projectID string, config *storepb.PlanConfig_Spec_ChangeDatabaseConfig) *v1pb.Plan_Spec_ChangeDatabaseConfig {
+ c := config.ChangeDatabaseConfig
+ return &v1pb.Plan_Spec_ChangeDatabaseConfig{
+ ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
+ Targets: c.Targets,
+ Sheet: common.FormatSheet(projectID, c.SheetSha256),
+ Release: c.Release,
+ Type: convertToPlanSpecChangeDatabaseConfigType(c.Type),
+ GhostFlags: c.GhostFlags,
+ EnablePriorBackup: c.EnablePriorBackup,
+ EnableGhost: c.EnableGhost,
+ },
+ }
+}
+
+func convertToPlanSpecChangeDatabaseConfigType(t storepb.PlanConfig_ChangeDatabaseConfig_Type) v1pb.DatabaseChangeType {
+ switch t {
+ case storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED:
+ return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED
+ case storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE:
+ return v1pb.DatabaseChangeType_MIGRATE
+ case storepb.PlanConfig_ChangeDatabaseConfig_SDL:
+ return v1pb.DatabaseChangeType_SDL
+ default:
+ return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED
+ }
+}
+
+func convertToPlanSpecExportDataConfig(projectID string, config *storepb.PlanConfig_Spec_ExportDataConfig) *v1pb.Plan_Spec_ExportDataConfig {
+ c := config.ExportDataConfig
+ return &v1pb.Plan_Spec_ExportDataConfig{
+ ExportDataConfig: &v1pb.Plan_ExportDataConfig{
+ Targets: c.Targets,
+ Sheet: common.FormatSheet(projectID, c.SheetSha256),
+ Format: convertExportFormat(c.Format),
+ Password: c.Password,
+ },
+ }
+}
+
+func convertPlanSpecs(specs []*v1pb.Plan_Spec) []*storepb.PlanConfig_Spec {
+ storeSpecs := make([]*storepb.PlanConfig_Spec, len(specs))
+ for i := range specs {
+ storeSpecs[i] = convertPlanSpec(specs[i])
+ }
+ return storeSpecs
+}
+
+func convertPlanSpec(spec *v1pb.Plan_Spec) *storepb.PlanConfig_Spec {
+ storeSpec := &storepb.PlanConfig_Spec{
+ Id: spec.Id,
+ }
+
+ switch v := spec.Config.(type) {
+ case *v1pb.Plan_Spec_CreateDatabaseConfig:
+ storeSpec.Config = convertPlanSpecCreateDatabaseConfig(v)
+ case *v1pb.Plan_Spec_ChangeDatabaseConfig:
+ storeSpec.Config = convertPlanSpecChangeDatabaseConfig(v)
+ case *v1pb.Plan_Spec_ExportDataConfig:
+ storeSpec.Config = convertPlanSpecExportDataConfig(v)
+ }
+ return storeSpec
+}
+
+func convertPlanSpecCreateDatabaseConfig(config *v1pb.Plan_Spec_CreateDatabaseConfig) *storepb.PlanConfig_Spec_CreateDatabaseConfig {
+ c := config.CreateDatabaseConfig
+ return &storepb.PlanConfig_Spec_CreateDatabaseConfig{
+ CreateDatabaseConfig: convertPlanConfigCreateDatabaseConfig(c),
+ }
+}
+
+func convertPlanConfigCreateDatabaseConfig(c *v1pb.Plan_CreateDatabaseConfig) *storepb.PlanConfig_CreateDatabaseConfig {
+ return &storepb.PlanConfig_CreateDatabaseConfig{
+ Target: c.Target,
+ Database: c.Database,
+ Table: c.Table,
+ CharacterSet: c.CharacterSet,
+ Collation: c.Collation,
+ Cluster: c.Cluster,
+ Owner: c.Owner,
+ Environment: c.Environment,
+ }
+}
+
+func convertPlanSpecChangeDatabaseConfig(config *v1pb.Plan_Spec_ChangeDatabaseConfig) *storepb.PlanConfig_Spec_ChangeDatabaseConfig {
+ c := config.ChangeDatabaseConfig
+
+ // Convert v1 DatabaseChangeType to store Type
+ var storeType storepb.PlanConfig_ChangeDatabaseConfig_Type
+ switch c.Type {
+ case v1pb.DatabaseChangeType_MIGRATE:
+ storeType = storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE
+ case v1pb.DatabaseChangeType_SDL:
+ storeType = storepb.PlanConfig_ChangeDatabaseConfig_SDL
+ default:
+ storeType = storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED
+ }
+
+ // Sheet can be empty when using Release-based workflow (SQL comes from release files).
+ // Plans can use either Sheet-based or Release-based approach, but not both.
+ var sheetSha256 string
+ if c.Sheet != "" {
+ _, sha256, err := common.GetProjectResourceIDSheetSha256(c.Sheet)
+ if err != nil {
+ return nil
+ }
+ sheetSha256 = sha256
+ }
+ return &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
+ ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
+ Targets: c.Targets,
+ SheetSha256: sheetSha256,
+ Release: c.Release,
+ Type: storeType,
+ GhostFlags: c.GhostFlags,
+ EnablePriorBackup: c.EnablePriorBackup,
+ EnableGhost: c.EnableGhost,
+ },
+ }
+}
+
+func convertPlanSpecExportDataConfig(config *v1pb.Plan_Spec_ExportDataConfig) *storepb.PlanConfig_Spec_ExportDataConfig {
+ c := config.ExportDataConfig
+ // Sheet can be empty if not yet attached to the export data config.
+ var sheetSha256 string
+ if c.Sheet != "" {
+ _, sha256, err := common.GetProjectResourceIDSheetSha256(c.Sheet)
+ if err != nil {
+ return nil
+ }
+ sheetSha256 = sha256
+ }
+ return &storepb.PlanConfig_Spec_ExportDataConfig{
+ ExportDataConfig: &storepb.PlanConfig_ExportDataConfig{
+ Targets: c.Targets,
+ SheetSha256: sheetSha256,
+ Format: convertToExportFormat(c.Format),
+ Password: c.Password,
+ },
+ }
+}
+
+// expandPlanCheckRun expands a consolidated plan check run into multiple virtual
+// records for API backward compatibility. Each target/type combination becomes
+// a separate API response record.
+func expandPlanCheckRun(projectID string, planUID int64, run *store.PlanCheckRunMessage) []*v1pb.PlanCheckRun {
+ var runs []*v1pb.PlanCheckRun
+
+ // Group results by target and type
+ type key struct {
+ target string
+ checkType storepb.PlanCheckType
+ }
+ resultsByKey := make(map[key][]*storepb.PlanCheckRunResult_Result)
+ for _, result := range run.Result.GetResults() {
+ k := key{
+ target: result.Target,
+ checkType: result.Type,
+ }
+ resultsByKey[k] = append(resultsByKey[k], result)
+ }
+
+ // Build virtual records from targets
+ virtualID := 0
+ for _, target := range run.Config.GetTargets() {
+ for _, checkType := range target.Types {
+ virtualID++
+ k := key{
+ target: target.Target,
+ checkType: checkType,
+ }
+ results := resultsByKey[k]
+
+ runs = append(runs, &v1pb.PlanCheckRun{
+ Name: common.FormatPlanCheckRun(projectID, planUID, int64(run.UID)*1000+int64(virtualID)),
+ CreateTime: timestamppb.New(run.CreatedAt),
+ Type: convertPlanCheckType(checkType),
+ Status: convertToPlanCheckRunStatus(run.Status),
+ Target: target.Target,
+ Sheet: common.FormatSheet(projectID, target.SheetSha256),
+ Results: convertToPlanCheckRunResults(results),
+ Error: run.Result.Error,
+ })
+ }
+ }
+
+ return runs
+}
+
+func convertPlanCheckType(t storepb.PlanCheckType) v1pb.PlanCheckRun_Type {
+ switch t {
+ case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_ADVISE:
+ return v1pb.PlanCheckRun_DATABASE_STATEMENT_ADVISE
+ case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_SUMMARY_REPORT:
+ return v1pb.PlanCheckRun_DATABASE_STATEMENT_SUMMARY_REPORT
+ case storepb.PlanCheckType_PLAN_CHECK_TYPE_GHOST_SYNC:
+ return v1pb.PlanCheckRun_DATABASE_GHOST_SYNC
+ default:
+ return v1pb.PlanCheckRun_TYPE_UNSPECIFIED
+ }
+}
+
+func convertToPlanCheckRunStatus(status store.PlanCheckRunStatus) v1pb.PlanCheckRun_Status {
+ switch status {
+ case store.PlanCheckRunStatusCanceled:
+ return v1pb.PlanCheckRun_CANCELED
+ case store.PlanCheckRunStatusDone:
+ return v1pb.PlanCheckRun_DONE
+ case store.PlanCheckRunStatusFailed:
+ return v1pb.PlanCheckRun_FAILED
+ case store.PlanCheckRunStatusRunning:
+ return v1pb.PlanCheckRun_RUNNING
+ default:
+ return v1pb.PlanCheckRun_STATUS_UNSPECIFIED
+ }
+}
+
+func convertToPlanCheckRunResults(results []*storepb.PlanCheckRunResult_Result) []*v1pb.PlanCheckRun_Result {
+ var resultsV1 []*v1pb.PlanCheckRun_Result
+ for _, result := range results {
+ resultsV1 = append(resultsV1, convertToPlanCheckRunResult(result))
+ }
+ return resultsV1
+}
+
+func convertToPlanCheckRunResult(result *storepb.PlanCheckRunResult_Result) *v1pb.PlanCheckRun_Result {
+ resultV1 := &v1pb.PlanCheckRun_Result{
+ Status: convertToPlanCheckRunResultStatus(result.Status),
+ Title: result.Title,
+ Content: result.Content,
+ Code: result.Code,
+ Report: nil,
+ }
+ switch report := result.Report.(type) {
+ case *storepb.PlanCheckRunResult_Result_SqlSummaryReport_:
+ resultV1.Report = &v1pb.PlanCheckRun_Result_SqlSummaryReport_{
+ SqlSummaryReport: &v1pb.PlanCheckRun_Result_SqlSummaryReport{
+ StatementTypes: report.SqlSummaryReport.StatementTypes,
+ AffectedRows: report.SqlSummaryReport.AffectedRows,
+ },
+ }
+ case *storepb.PlanCheckRunResult_Result_SqlReviewReport_:
+ resultV1.Report = &v1pb.PlanCheckRun_Result_SqlReviewReport_{
+ SqlReviewReport: &v1pb.PlanCheckRun_Result_SqlReviewReport{
+ StartPosition: convertToPosition(report.SqlReviewReport.StartPosition),
+ EndPosition: convertToPosition(report.SqlReviewReport.EndPosition),
+ },
+ }
+ }
+ return resultV1
+}
+
+func convertToPlanCheckRunResultStatus(status storepb.Advice_Status) v1pb.Advice_Level {
+ switch status {
+ case storepb.Advice_STATUS_UNSPECIFIED:
+ return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED
+ case storepb.Advice_SUCCESS:
+ return v1pb.Advice_SUCCESS
+ case storepb.Advice_WARNING:
+ return v1pb.Advice_WARNING
+ case storepb.Advice_ERROR:
+ return v1pb.Advice_ERROR
+ default:
+ return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED
+ }
+}
+
+// convertToStorePlanCheckRunStatus converts v1pb.PlanCheckRun_Status to store.PlanCheckRunStatus.
+func convertToStorePlanCheckRunStatus(status v1pb.PlanCheckRun_Status) store.PlanCheckRunStatus {
+ switch status {
+ case v1pb.PlanCheckRun_CANCELED:
+ return store.PlanCheckRunStatusCanceled
+ case v1pb.PlanCheckRun_DONE:
+ return store.PlanCheckRunStatusDone
+ case v1pb.PlanCheckRun_FAILED:
+ return store.PlanCheckRunStatusFailed
+ case v1pb.PlanCheckRun_RUNNING:
+ return store.PlanCheckRunStatusRunning
+ default:
+ return store.PlanCheckRunStatusRunning
+ }
+}
+
+// convertToStoreResultStatus converts v1pb.Advice_Status to storepb.Advice_Status.
+func convertToStoreResultStatus(status v1pb.Advice_Level) storepb.Advice_Status {
+ switch status {
+ case v1pb.Advice_ERROR:
+ return storepb.Advice_ERROR
+ case v1pb.Advice_WARNING:
+ return storepb.Advice_WARNING
+ case v1pb.Advice_SUCCESS:
+ return storepb.Advice_SUCCESS
+ default:
+ return storepb.Advice_STATUS_UNSPECIFIED
+ }
+}
diff --git a/backend/api/v1/plan_service_converter.go b/backend/api/v1/plan_service_converter.go
deleted file mode 100644
index 507c566137..0000000000
--- a/backend/api/v1/plan_service_converter.go
+++ /dev/null
@@ -1,393 +0,0 @@
-package v1
-
-import (
- "context"
-
- "github.com/pkg/errors"
- "google.golang.org/protobuf/types/known/timestamppb"
-
- "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 convertToPlans(ctx context.Context, s *store.Store, plans []*store.PlanMessage) ([]*v1pb.Plan, error) {
- v1Plans := make([]*v1pb.Plan, len(plans))
- for i := range plans {
- p, err := convertToPlan(ctx, s, plans[i])
- if err != nil {
- return nil, errors.Wrapf(err, "failed to convert plan")
- }
- v1Plans[i] = p
- }
- return v1Plans, nil
-}
-
-func convertToPlan(ctx context.Context, s *store.Store, plan *store.PlanMessage) (*v1pb.Plan, error) {
- p := &v1pb.Plan{
- Name: common.FormatPlan(plan.ProjectID, plan.UID),
- Title: plan.Name,
- Description: plan.Description,
- Creator: common.FormatUserEmail(plan.Creator),
- Specs: convertToPlanSpecs(plan.ProjectID, plan.Config.Specs), // Use specs field for output
- CreateTime: timestamppb.New(plan.CreatedAt),
- UpdateTime: timestamppb.New(plan.UpdatedAt),
- State: convertDeletedToState(plan.Deleted),
- PlanCheckRunStatusCount: map[string]int32{},
- }
-
- issue, err := s.GetIssue(ctx, &store.FindIssueMessage{PlanUID: &plan.UID})
- if err != nil {
- return nil, errors.Wrapf(err, "failed to get issue by plan uid %d", plan.UID)
- }
- if issue != nil {
- p.Issue = common.FormatIssue(issue.Project.ResourceID, issue.UID)
- }
- if plan.PipelineUID != nil {
- p.Rollout = common.FormatRollout(plan.ProjectID, *plan.PipelineUID)
- }
- planCheckRuns, err := s.ListPlanCheckRuns(ctx, &store.FindPlanCheckRunMessage{
- PlanUID: &plan.UID,
- })
- if err != nil {
- return nil, errors.Wrapf(err, "failed to list plan check runs for plan uid %d", plan.UID)
- }
- for _, run := range planCheckRuns {
- p.PlanCheckRunStatusCount[string(run.Status)]++
- for _, result := range run.Result.Results {
- p.PlanCheckRunStatusCount[storepb.Advice_Status_name[int32(result.Status)]]++
- }
- }
- return p, nil
-}
-
-func convertToPlanSpecs(projectID string, specs []*storepb.PlanConfig_Spec) []*v1pb.Plan_Spec {
- v1Specs := make([]*v1pb.Plan_Spec, len(specs))
- for i := range specs {
- v1Specs[i] = convertToPlanSpec(projectID, specs[i])
- }
- return v1Specs
-}
-
-func convertToPlanSpec(projectID string, spec *storepb.PlanConfig_Spec) *v1pb.Plan_Spec {
- v1Spec := &v1pb.Plan_Spec{
- Id: spec.Id,
- }
-
- switch v := spec.Config.(type) {
- case *storepb.PlanConfig_Spec_CreateDatabaseConfig:
- v1Spec.Config = convertToPlanSpecCreateDatabaseConfig(v)
- case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:
- v1Spec.Config = convertToPlanSpecChangeDatabaseConfig(projectID, v)
- case *storepb.PlanConfig_Spec_ExportDataConfig:
- v1Spec.Config = convertToPlanSpecExportDataConfig(projectID, v)
- }
-
- return v1Spec
-}
-
-func convertToPlanSpecCreateDatabaseConfig(config *storepb.PlanConfig_Spec_CreateDatabaseConfig) *v1pb.Plan_Spec_CreateDatabaseConfig {
- c := config.CreateDatabaseConfig
- return &v1pb.Plan_Spec_CreateDatabaseConfig{
- CreateDatabaseConfig: &v1pb.Plan_CreateDatabaseConfig{
- Target: c.Target,
- Database: c.Database,
- Table: c.Table,
- CharacterSet: c.CharacterSet,
- Collation: c.Collation,
- Cluster: c.Cluster,
- Owner: c.Owner,
- Environment: c.Environment,
- },
- }
-}
-
-func convertToPlanSpecChangeDatabaseConfig(projectID string, config *storepb.PlanConfig_Spec_ChangeDatabaseConfig) *v1pb.Plan_Spec_ChangeDatabaseConfig {
- c := config.ChangeDatabaseConfig
- return &v1pb.Plan_Spec_ChangeDatabaseConfig{
- ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
- Targets: c.Targets,
- Sheet: common.FormatSheet(projectID, c.SheetSha256),
- Release: c.Release,
- Type: convertToPlanSpecChangeDatabaseConfigType(c.Type),
- GhostFlags: c.GhostFlags,
- EnablePriorBackup: c.EnablePriorBackup,
- EnableGhost: c.EnableGhost,
- },
- }
-}
-
-func convertToPlanSpecChangeDatabaseConfigType(t storepb.PlanConfig_ChangeDatabaseConfig_Type) v1pb.DatabaseChangeType {
- switch t {
- case storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED:
- return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED
- case storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE:
- return v1pb.DatabaseChangeType_MIGRATE
- case storepb.PlanConfig_ChangeDatabaseConfig_SDL:
- return v1pb.DatabaseChangeType_SDL
- default:
- return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED
- }
-}
-
-func convertToPlanSpecExportDataConfig(projectID string, config *storepb.PlanConfig_Spec_ExportDataConfig) *v1pb.Plan_Spec_ExportDataConfig {
- c := config.ExportDataConfig
- return &v1pb.Plan_Spec_ExportDataConfig{
- ExportDataConfig: &v1pb.Plan_ExportDataConfig{
- Targets: c.Targets,
- Sheet: common.FormatSheet(projectID, c.SheetSha256),
- Format: convertExportFormat(c.Format),
- Password: c.Password,
- },
- }
-}
-
-func convertPlan(plan *v1pb.Plan) *storepb.PlanConfig {
- if plan == nil {
- return nil
- }
-
- // At this point, plan.Specs should always be populated
- // (either originally or converted from steps at API entry point)
- return &storepb.PlanConfig{
- Specs: convertPlanSpecs(plan.Specs),
- }
-}
-
-func convertPlanSpecs(specs []*v1pb.Plan_Spec) []*storepb.PlanConfig_Spec {
- storeSpecs := make([]*storepb.PlanConfig_Spec, len(specs))
- for i := range specs {
- storeSpecs[i] = convertPlanSpec(specs[i])
- }
- return storeSpecs
-}
-
-func convertPlanSpec(spec *v1pb.Plan_Spec) *storepb.PlanConfig_Spec {
- storeSpec := &storepb.PlanConfig_Spec{
- Id: spec.Id,
- }
-
- switch v := spec.Config.(type) {
- case *v1pb.Plan_Spec_CreateDatabaseConfig:
- storeSpec.Config = convertPlanSpecCreateDatabaseConfig(v)
- case *v1pb.Plan_Spec_ChangeDatabaseConfig:
- storeSpec.Config = convertPlanSpecChangeDatabaseConfig(v)
- case *v1pb.Plan_Spec_ExportDataConfig:
- storeSpec.Config = convertPlanSpecExportDataConfig(v)
- }
- return storeSpec
-}
-
-func convertPlanSpecCreateDatabaseConfig(config *v1pb.Plan_Spec_CreateDatabaseConfig) *storepb.PlanConfig_Spec_CreateDatabaseConfig {
- c := config.CreateDatabaseConfig
- return &storepb.PlanConfig_Spec_CreateDatabaseConfig{
- CreateDatabaseConfig: convertPlanConfigCreateDatabaseConfig(c),
- }
-}
-
-func convertPlanConfigCreateDatabaseConfig(c *v1pb.Plan_CreateDatabaseConfig) *storepb.PlanConfig_CreateDatabaseConfig {
- return &storepb.PlanConfig_CreateDatabaseConfig{
- Target: c.Target,
- Database: c.Database,
- Table: c.Table,
- CharacterSet: c.CharacterSet,
- Collation: c.Collation,
- Cluster: c.Cluster,
- Owner: c.Owner,
- Environment: c.Environment,
- }
-}
-
-func convertPlanSpecChangeDatabaseConfig(config *v1pb.Plan_Spec_ChangeDatabaseConfig) *storepb.PlanConfig_Spec_ChangeDatabaseConfig {
- c := config.ChangeDatabaseConfig
-
- // Convert v1 DatabaseChangeType to store Type
- var storeType storepb.PlanConfig_ChangeDatabaseConfig_Type
- switch c.Type {
- case v1pb.DatabaseChangeType_MIGRATE:
- storeType = storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE
- case v1pb.DatabaseChangeType_SDL:
- storeType = storepb.PlanConfig_ChangeDatabaseConfig_SDL
- default:
- storeType = storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED
- }
-
- // Sheet can be empty when using Release-based workflow (SQL comes from release files).
- // Plans can use either Sheet-based or Release-based approach, but not both.
- var sheetSha256 string
- if c.Sheet != "" {
- _, sha256, err := common.GetProjectResourceIDSheetSha256(c.Sheet)
- if err != nil {
- return nil
- }
- sheetSha256 = sha256
- }
- return &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
- ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
- Targets: c.Targets,
- SheetSha256: sheetSha256,
- Release: c.Release,
- Type: storeType,
- GhostFlags: c.GhostFlags,
- EnablePriorBackup: c.EnablePriorBackup,
- EnableGhost: c.EnableGhost,
- },
- }
-}
-
-func convertPlanSpecExportDataConfig(config *v1pb.Plan_Spec_ExportDataConfig) *storepb.PlanConfig_Spec_ExportDataConfig {
- c := config.ExportDataConfig
- // Sheet can be empty if not yet attached to the export data config.
- var sheetSha256 string
- if c.Sheet != "" {
- _, sha256, err := common.GetProjectResourceIDSheetSha256(c.Sheet)
- if err != nil {
- return nil
- }
- sheetSha256 = sha256
- }
- return &storepb.PlanConfig_Spec_ExportDataConfig{
- ExportDataConfig: &storepb.PlanConfig_ExportDataConfig{
- Targets: c.Targets,
- SheetSha256: sheetSha256,
- Format: convertToExportFormat(c.Format),
- Password: c.Password,
- },
- }
-}
-
-func convertToPlanCheckRuns(projectID string, planUID int64, runs []*store.PlanCheckRunMessage) []*v1pb.PlanCheckRun {
- var planCheckRuns []*v1pb.PlanCheckRun
- for _, run := range runs {
- // Expand consolidated run into virtual records for backward compatibility
- expanded := expandPlanCheckRun(projectID, planUID, run)
- planCheckRuns = append(planCheckRuns, expanded...)
- }
- return planCheckRuns
-}
-
-// expandPlanCheckRun expands a consolidated plan check run into multiple virtual
-// records for API backward compatibility. Each target/type combination becomes
-// a separate API response record.
-func expandPlanCheckRun(projectID string, planUID int64, run *store.PlanCheckRunMessage) []*v1pb.PlanCheckRun {
- var runs []*v1pb.PlanCheckRun
-
- // Group results by target and type
- type key struct {
- target string
- checkType storepb.PlanCheckType
- }
- resultsByKey := make(map[key][]*storepb.PlanCheckRunResult_Result)
- for _, result := range run.Result.GetResults() {
- k := key{
- target: result.Target,
- checkType: result.Type,
- }
- resultsByKey[k] = append(resultsByKey[k], result)
- }
-
- // Build virtual records from targets
- virtualID := 0
- for _, target := range run.Config.GetTargets() {
- for _, checkType := range target.Types {
- virtualID++
- k := key{
- target: target.Target,
- checkType: checkType,
- }
- results := resultsByKey[k]
-
- runs = append(runs, &v1pb.PlanCheckRun{
- Name: common.FormatPlanCheckRun(projectID, planUID, int64(run.UID)*1000+int64(virtualID)),
- CreateTime: timestamppb.New(run.CreatedAt),
- Type: convertPlanCheckType(checkType),
- Status: convertToPlanCheckRunStatus(run.Status),
- Target: target.Target,
- Sheet: common.FormatSheet(projectID, target.SheetSha256),
- Results: convertToPlanCheckRunResults(results),
- Error: run.Result.Error,
- })
- }
- }
-
- return runs
-}
-
-func convertPlanCheckType(t storepb.PlanCheckType) v1pb.PlanCheckRun_Type {
- switch t {
- case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_ADVISE:
- return v1pb.PlanCheckRun_DATABASE_STATEMENT_ADVISE
- case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_SUMMARY_REPORT:
- return v1pb.PlanCheckRun_DATABASE_STATEMENT_SUMMARY_REPORT
- case storepb.PlanCheckType_PLAN_CHECK_TYPE_GHOST_SYNC:
- return v1pb.PlanCheckRun_DATABASE_GHOST_SYNC
- default:
- return v1pb.PlanCheckRun_TYPE_UNSPECIFIED
- }
-}
-
-func convertToPlanCheckRunStatus(status store.PlanCheckRunStatus) v1pb.PlanCheckRun_Status {
- switch status {
- case store.PlanCheckRunStatusCanceled:
- return v1pb.PlanCheckRun_CANCELED
- case store.PlanCheckRunStatusDone:
- return v1pb.PlanCheckRun_DONE
- case store.PlanCheckRunStatusFailed:
- return v1pb.PlanCheckRun_FAILED
- case store.PlanCheckRunStatusRunning:
- return v1pb.PlanCheckRun_RUNNING
- default:
- return v1pb.PlanCheckRun_STATUS_UNSPECIFIED
- }
-}
-
-func convertToPlanCheckRunResults(results []*storepb.PlanCheckRunResult_Result) []*v1pb.PlanCheckRun_Result {
- var resultsV1 []*v1pb.PlanCheckRun_Result
- for _, result := range results {
- resultsV1 = append(resultsV1, convertToPlanCheckRunResult(result))
- }
- return resultsV1
-}
-
-func convertToPlanCheckRunResult(result *storepb.PlanCheckRunResult_Result) *v1pb.PlanCheckRun_Result {
- resultV1 := &v1pb.PlanCheckRun_Result{
- Status: convertToPlanCheckRunResultStatus(result.Status),
- Title: result.Title,
- Content: result.Content,
- Code: result.Code,
- Report: nil,
- }
- switch report := result.Report.(type) {
- case *storepb.PlanCheckRunResult_Result_SqlSummaryReport_:
- resultV1.Report = &v1pb.PlanCheckRun_Result_SqlSummaryReport_{
- SqlSummaryReport: &v1pb.PlanCheckRun_Result_SqlSummaryReport{
- StatementTypes: report.SqlSummaryReport.StatementTypes,
- AffectedRows: report.SqlSummaryReport.AffectedRows,
- },
- }
- case *storepb.PlanCheckRunResult_Result_SqlReviewReport_:
- resultV1.Report = &v1pb.PlanCheckRun_Result_SqlReviewReport_{
- SqlReviewReport: &v1pb.PlanCheckRun_Result_SqlReviewReport{
- StartPosition: convertToPosition(report.SqlReviewReport.StartPosition),
- EndPosition: convertToPosition(report.SqlReviewReport.EndPosition),
- },
- }
- }
- return resultV1
-}
-
-func convertToPlanCheckRunResultStatus(status storepb.Advice_Status) v1pb.Advice_Level {
- switch status {
- case storepb.Advice_STATUS_UNSPECIFIED:
- return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED
- case storepb.Advice_SUCCESS:
- return v1pb.Advice_SUCCESS
- case storepb.Advice_WARNING:
- return v1pb.Advice_WARNING
- case storepb.Advice_ERROR:
- return v1pb.Advice_ERROR
- default:
- return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED
- }
-}
diff --git a/backend/api/v1/plan_service_plan_check.go b/backend/api/v1/plan_service_plan_check.go
deleted file mode 100644
index 3394f29e35..0000000000
--- a/backend/api/v1/plan_service_plan_check.go
+++ /dev/null
@@ -1,79 +0,0 @@
-package v1
-
-import (
- "github.com/pkg/errors"
-
- storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
- "github.com/bytebase/bytebase/backend/store"
-)
-
-// getPlanCheckRunFromPlan returns a single consolidated plan check run for a plan.
-func getPlanCheckRunFromPlan(project *store.ProjectMessage, plan *store.PlanMessage, databaseGroup *v1pb.DatabaseGroup) (*store.PlanCheckRunMessage, error) {
- var targets []*storepb.PlanCheckRunConfig_CheckTarget
-
- for _, spec := range plan.Config.Specs {
- switch config := spec.Config.(type) {
- case *storepb.PlanConfig_Spec_CreateDatabaseConfig:
- // No checks for create database.
- case *storepb.PlanConfig_Spec_ExportDataConfig:
- // No checks for export data.
- case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:
- // Skip plan checks for releases.
- if config.ChangeDatabaseConfig.Release != "" {
- continue
- }
-
- var databases []string
- if len(config.ChangeDatabaseConfig.Targets) == 1 && databaseGroup != nil && config.ChangeDatabaseConfig.Targets[0] == databaseGroup.Name {
- for _, m := range databaseGroup.MatchedDatabases {
- databases = append(databases, m.Name)
- }
- } else {
- databases = config.ChangeDatabaseConfig.Targets
- }
-
- // Apply sampling upfront
- if samplingSize := project.Setting.GetCiSamplingSize(); samplingSize > 0 {
- if len(databases) > int(samplingSize) {
- databases = databases[:samplingSize]
- }
- }
-
- enableSDL := config.ChangeDatabaseConfig.Type == storepb.PlanConfig_ChangeDatabaseConfig_SDL
- enableGhost := config.ChangeDatabaseConfig.Type == storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE && config.ChangeDatabaseConfig.EnableGhost
-
- for _, target := range databases {
- types := []storepb.PlanCheckType{
- storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_ADVISE,
- storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_SUMMARY_REPORT,
- }
- if enableGhost {
- types = append(types, storepb.PlanCheckType_PLAN_CHECK_TYPE_GHOST_SYNC)
- }
-
- targets = append(targets, &storepb.PlanCheckRunConfig_CheckTarget{
- Target: target,
- SheetSha256: config.ChangeDatabaseConfig.SheetSha256,
- EnablePriorBackup: config.ChangeDatabaseConfig.EnablePriorBackup,
- EnableGhost: config.ChangeDatabaseConfig.EnableGhost,
- EnableSdl: enableSDL,
- GhostFlags: config.ChangeDatabaseConfig.GhostFlags,
- Types: types,
- })
- }
- default:
- return nil, errors.Errorf("unknown spec config type %T", config)
- }
- }
-
- if len(targets) == 0 {
- return nil, nil
- }
-
- return &store.PlanCheckRunMessage{
- PlanUID: plan.UID,
- Status: store.PlanCheckRunStatusRunning,
- Config: &storepb.PlanCheckRunConfig{Targets: targets},
- }, nil
-}
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.go
index 1034f3f24e..745bd32d16 100644
--- a/backend/api/v1/sql_service.go
+++ b/backend/api/v1/sql_service.go
@@ -1714,10 +1714,6 @@ func (*SQLService) DiffMetadata(_ context.Context, req *connect.Request[v1pb.Dif
storeSourceMetadata := convertV1DatabaseMetadata(request.SourceMetadata)
storeTargetMetadata := convertV1DatabaseMetadata(request.TargetMetadata)
- if err := checkDatabaseMetadata(storepb.Engine(request.Engine), storeTargetMetadata); err != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrap(err, "invalid target metadata"))
- }
-
// Convert metadata to model.DatabaseMetadata for diffing
isObjectCaseSensitive := true
sourceDBSchema := model.NewDatabaseMetadata(storeSourceMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)
diff --git a/go.mod b/go.mod
index b3483c4df0..844eaed634 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,6 @@ godebug x509negativeserial=1
require (
buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.10-20250912141014-52f32327d4b0.1
- buf.build/go/protovalidate v1.0.1
cloud.google.com/go/bigquery v1.72.0
cloud.google.com/go/cloudsqlconn v1.19.0
cloud.google.com/go/secretmanager v1.16.0
@@ -109,6 +108,7 @@ require (
)
require (
+ buf.build/go/protovalidate v1.0.1 // indirect
cel.dev/expr v0.24.0 // indirect
cloud.google.com/go/auth v0.17.0 // indirect
cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect