Skip to content

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

fix(review): derive review targets without the CI sampling limit

rebelice4d86903c3933
diff --git a/backend/api/v1/issue_service_review_run.go b/backend/api/v1/issue_service_review_run.go
index 98db11b5fb..bee8f36210 100644
--- a/backend/api/v1/issue_service_review_run.go
+++ b/backend/api/v1/issue_service_review_run.go
@@ -75,7 +75,7 @@ func (s *IssueService) RunReview(ctx context.Context, req *connect.Request[v1pb.
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database group for plan"))
}
- targets, err := plancheck.DeriveCheckTargets(ctx, s.store, project, plan, databaseGroup)
+ targets, err := plancheck.DeriveReviewTargets(ctx, s.store, project, plan, databaseGroup)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to derive review targets"))
}
diff --git a/backend/runner/plancheck/derive.go b/backend/runner/plancheck/derive.go
index c316631539..a7b02547f2 100644
--- a/backend/runner/plancheck/derive.go
+++ b/backend/runner/plancheck/derive.go
@@ -11,9 +11,22 @@ import (
"github.com/bytebase/bytebase/backend/store"
)
-// DeriveCheckTargets derives check targets from a plan and optional database group.
+// DeriveCheckTargets derives check targets from a plan and optional database
+// group, applying the project's CI sampling limit: plan checks are CI
+// validation, and sampling bounds their cost.
// This replaces the stored config by computing targets at runtime.
func DeriveCheckTargets(ctx context.Context, s *store.Store, project *store.ProjectMessage, plan *store.PlanMessage, databaseGroup *v1pb.DatabaseGroup) ([]*CheckTarget, error) {
+ return deriveTargets(ctx, s, project, plan, databaseGroup, true)
+}
+
+// DeriveReviewTargets derives the same targets without CI sampling: a review
+// run's DONE means every (spec, target) unit was evaluated, so review must
+// see the full target set.
+func DeriveReviewTargets(ctx context.Context, s *store.Store, project *store.ProjectMessage, plan *store.PlanMessage, databaseGroup *v1pb.DatabaseGroup) ([]*CheckTarget, error) {
+ return deriveTargets(ctx, s, project, plan, databaseGroup, false)
+}
+
+func deriveTargets(ctx context.Context, s *store.Store, project *store.ProjectMessage, plan *store.PlanMessage, databaseGroup *v1pb.DatabaseGroup, applySampling bool) ([]*CheckTarget, error) {
var targets []*CheckTarget
for _, spec := range plan.Config.Specs {
@@ -36,8 +49,8 @@ func DeriveCheckTargets(ctx context.Context, s *store.Store, project *store.Proj
}
// Apply sampling upfront
- if samplingSize := project.Setting.GetCiSamplingSize(); samplingSize > 0 {
- if len(databases) > int(samplingSize) {
+ if applySampling {
+ if samplingSize := project.Setting.GetCiSamplingSize(); samplingSize > 0 && len(databases) > int(samplingSize) {
databases = databases[:samplingSize]
}
}
diff --git a/backend/runner/plancheck/derive_test.go b/backend/runner/plancheck/derive_test.go
new file mode 100644
index 0000000000..60230d3629
--- /dev/null
+++ b/backend/runner/plancheck/derive_test.go
@@ -0,0 +1,45 @@
+package plancheck
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+// Plan checks are CI validation and honor the project's CI sampling limit;
+// a review run's DONE means every (spec, target) unit was evaluated, so
+// review derivation must not sample.
+func TestDeriveReviewTargetsSkipsCISampling(t *testing.T) {
+ ctx := context.Background()
+ project := &store.ProjectMessage{
+ ResourceID: "p",
+ Setting: &storepb.Project{CiSamplingSize: 1},
+ }
+ plan := &store.PlanMessage{
+ Config: &storepb.PlanConfig{
+ Specs: []*storepb.PlanConfig_Spec{{
+ Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
+ ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
+ Targets: []string{
+ "instances/i/databases/a",
+ "instances/i/databases/b",
+ "instances/i/databases/c",
+ },
+ },
+ },
+ }},
+ },
+ }
+
+ sampled, err := DeriveCheckTargets(ctx, nil, project, plan, nil)
+ require.NoError(t, err)
+ require.Len(t, sampled, 1, "plan checks apply the CI sampling limit")
+
+ full, err := DeriveReviewTargets(ctx, nil, project, plan, nil)
+ require.NoError(t, err)
+ require.Len(t, full, 3, "review must evaluate every target regardless of CI sampling")
+}
diff --git a/backend/runner/reviewrun/rule_executor.go b/backend/runner/reviewrun/rule_executor.go
index 0686dc4e58..38685b1806 100644
--- a/backend/runner/reviewrun/rule_executor.go
+++ b/backend/runner/reviewrun/rule_executor.go
@@ -67,7 +67,9 @@ func (e *RuleExecutor) RunOnce(ctx context.Context, projectID string, issueUID i
if err != nil {
return errors.Wrapf(err, "failed to get database group for plan")
}
- targets, err := plancheck.DeriveCheckTargets(ctx, e.store, project, plan, databaseGroup)
+ // DeriveReviewTargets, not DeriveCheckTargets: review must evaluate every
+ // (spec, target) unit, so the CI sampling limit does not apply.
+ targets, err := plancheck.DeriveReviewTargets(ctx, e.store, project, plan, databaseGroup)
if err != nil {
return errors.Wrapf(err, "failed to derive review targets")
}