Skip to content

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

fix(plancheck): classify OceanBase statements so sql_type approval rules match (BYT-10136) (#21441)

zchpeter1a0c84b9ffa7
diff --git a/backend/component/review/evaluator_test.go b/backend/component/review/evaluator_test.go
index 10b22a6cae..ca3b632537 100644
--- a/backend/component/review/evaluator_test.go
+++ b/backend/component/review/evaluator_test.go
@@ -19,6 +19,7 @@ import (
// Registers the BigQuery parser handlers the same way backend/server
// ultimate.go does for the server binary; statementTypesFromParser resolves
// through that registry.
+ parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"
_ "github.com/bytebase/bytebase/backend/plugin/parser/bigquery"
"github.com/bytebase/bytebase/backend/runner/plancheck"
"github.com/bytebase/bytebase/backend/store"
@@ -1025,3 +1026,84 @@ func TestExpandCELVarsDeduplicatesActivations(t *testing.T) {
}
a.Len(expandCELVars(base, unspecified, nil), 1)
}
+
+// OceanBase runs the statement report, so its statement.sql_type comes from the
+// report's StatementTypes that plancheck.SummaryStatementTypes produces
+// (BYT-10136). Cells cover both rule polarities, fail-closed handling of an
+// unclassified statement, first-matching-rule order on a mixed sheet, and the
+// risk level derived from the same list.
+func TestApprovalRuleMatchesOceanBaseSummaryReport(t *testing.T) {
+ const ddlRule = `!(statement.sql_type in ["INSERT", "UPDATE", "DELETE"]) && resource.db_engine == "OCEANBASE"`
+ const dmlRule = `statement.sql_type in ["INSERT", "UPDATE", "DELETE"] && resource.db_engine == "OCEANBASE"`
+ const (
+ insertStmt = "INSERT INTO t1 (id, c1) VALUES (1, 'a');"
+ updateStmt = "UPDATE t1 SET c1 = 'x' WHERE id = 1;"
+ alterStmt = "ALTER TABLE t1 ADD COLUMN c2 INT;"
+ dropStmt = "DROP TABLE t1;"
+ setSessionStmt = "SET SESSION ob_query_timeout = 10000000;"
+ )
+ ddl := &storepb.WorkspaceApprovalSetting_Rule{
+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
+ Condition: &expr.Expr{Expression: ddlRule},
+ Template: &storepb.ApprovalTemplate{Title: "DDL"},
+ }
+ dml := &storepb.WorkspaceApprovalSetting_Rule{
+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
+ Condition: &expr.Expr{Expression: dmlRule},
+ Template: &storepb.ApprovalTemplate{Title: "DML"},
+ }
+
+ tests := []struct {
+ name string
+ statement string
+ rules []*storepb.WorkspaceApprovalSetting_Rule
+ wantTitle string
+ wantRisk storepb.RiskLevel
+ }{
+ {"dml rule matches UPDATE", updateStmt, []*storepb.WorkspaceApprovalSetting_Rule{dml}, "DML", storepb.RiskLevel_MODERATE},
+ {"ddl rule matches ALTER TABLE", alterStmt, []*storepb.WorkspaceApprovalSetting_Rule{ddl}, "DDL", storepb.RiskLevel_MODERATE},
+ {"dml rule skips ALTER TABLE", alterStmt, []*storepb.WorkspaceApprovalSetting_Rule{dml}, "", storepb.RiskLevel_MODERATE},
+ {"ddl rule skips UPDATE", updateStmt, []*storepb.WorkspaceApprovalSetting_Rule{ddl}, "", storepb.RiskLevel_MODERATE},
+ {"INSERT is DML and low risk", insertStmt, []*storepb.WorkspaceApprovalSetting_Rule{dml}, "DML", storepb.RiskLevel_LOW},
+ {"DROP TABLE is DDL and high risk", dropStmt, []*storepb.WorkspaceApprovalSetting_Rule{ddl}, "DDL", storepb.RiskLevel_HIGH},
+ // The MySQL-family classifier keeps UNSPECIFIED, which is outside the DML
+ // list, so the negated DML rule catches it.
+ {"unclassified SET SESSION fails closed to the ddl rule", setSessionStmt, []*storepb.WorkspaceApprovalSetting_Rule{ddl}, "DDL", storepb.RiskLevel_LOW},
+ {"unclassified SET SESSION does not pass as DML", setSessionStmt, []*storepb.WorkspaceApprovalSetting_Rule{dml}, "", storepb.RiskLevel_LOW},
+ // Rules iterate outer, activations inner: the first rule any statement of
+ // the sheet satisfies wins. Listing the DDL rule first protects a mixed
+ // sheet; listing the DML no-approval rule first lets the DDL ride along.
+ {"mixed sheet takes the DDL rule when it is listed first", updateStmt + "\n" + alterStmt, []*storepb.WorkspaceApprovalSetting_Rule{ddl, dml}, "DDL", storepb.RiskLevel_MODERATE},
+ {"mixed sheet takes the DML rule when it is listed first", updateStmt + "\n" + alterStmt, []*storepb.WorkspaceApprovalSetting_Rule{dml, ddl}, "DML", storepb.RiskLevel_MODERATE},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ a := require.New(t)
+ stmts, err := parserbase.ParseStatements(storepb.Engine_OCEANBASE, tt.statement)
+ a.NoError(err)
+ statementTypes, err := plancheck.SummaryStatementTypes(storepb.Engine_OCEANBASE, parserbase.ExtractASTs(stmts))
+ a.NoError(err)
+ a.NotEmpty(statementTypes, "the OceanBase summary report must carry statement types")
+
+ report := &storepb.PlanCheckRunResult_Result_SqlSummaryReport{StatementTypes: statementTypes}
+ celVars := expandCELVars(map[string]any{
+ common.CELAttributeResourceEnvironmentID: "test",
+ common.CELAttributeResourceProjectID: "project",
+ common.CELAttributeResourceDBEngine: storepb.Engine_OCEANBASE.String(),
+ common.CELAttributeStatementText: tt.statement,
+ }, report.StatementTypes, nil)
+
+ a.Equal(tt.wantRisk, calculateRiskLevelFromCELVars(celVars))
+
+ template, err := getApprovalTemplate(&storepb.WorkspaceApprovalSetting{Rules: tt.rules}, storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE, celVars)
+ a.NoError(err)
+ if tt.wantTitle == "" {
+ a.Nil(template)
+ return
+ }
+ a.NotNil(template)
+ a.Equal(tt.wantTitle, template.Title)
+ })
+ }
+}
diff --git a/backend/plugin/parser/mysql/statement_type_test.go b/backend/plugin/parser/mysql/statement_type_test.go
index 1716cb10a8..094221fe89 100644
--- a/backend/plugin/parser/mysql/statement_type_test.go
+++ b/backend/plugin/parser/mysql/statement_type_test.go
@@ -18,6 +18,9 @@ type statementTypeTest struct {
Want []string
}
+// TestGetStatementType runs the fixture under every engine this package
+// registers the classifier for, so MariaDB and OceanBase cannot silently
+// diverge from MySQL (BYT-10136).
func TestGetStatementType(t *testing.T) {
tests := []statementTypeTest{}
@@ -38,25 +41,36 @@ func TestGetStatementType(t *testing.T) {
a.NoError(err)
a.NoError(yaml.Unmarshal(byteValue, &tests))
- for i, test := range tests {
- stmts, err := base.ParseStatements(storepb.Engine_MYSQL, test.Statement)
- a.NoError(err)
- asts := base.ExtractASTs(stmts)
+ engines := []storepb.Engine{
+ storepb.Engine_MYSQL,
+ storepb.Engine_MARIADB,
+ storepb.Engine_OCEANBASE,
+ }
+ for _, engine := range engines {
+ t.Run(engine.String(), func(t *testing.T) {
+ a := require.New(t)
+ for i, test := range tests {
+ stmts, err := base.ParseStatements(engine, test.Statement)
+ a.NoError(err)
+ asts := base.ExtractASTs(stmts)
- sqlType, err := GetStatementTypes(asts)
- a.NoError(err)
+ sqlType, err := GetStatementTypes(asts)
+ a.NoError(err)
- // Convert enum to string for comparison
- sqlTypeStrings := make([]string, len(sqlType))
- for j, t := range sqlType {
- sqlTypeStrings[j] = t.String()
- }
+ // Convert enum to string for comparison
+ sqlTypeStrings := make([]string, len(sqlType))
+ for j, t := range sqlType {
+ sqlTypeStrings[j] = t.String()
+ }
- if record {
- tests[i].Want = sqlTypeStrings
- } else {
- a.Equal(test.Want, sqlTypeStrings)
- }
+ // Record from the MySQL run only; the other engines must match it.
+ if record && engine == storepb.Engine_MYSQL {
+ tests[i].Want = sqlTypeStrings
+ } else {
+ a.Equal(test.Want, sqlTypeStrings)
+ }
+ }
+ })
}
if record {
diff --git a/backend/runner/plancheck/statement_report_executor.go b/backend/runner/plancheck/statement_report_executor.go
index 69035e36f1..2d66c6f731 100644
--- a/backend/runner/plancheck/statement_report_executor.go
+++ b/backend/runner/plancheck/statement_report_executor.go
@@ -19,14 +19,8 @@ import (
redshiftdriver "github.com/bytebase/bytebase/backend/plugin/db/redshift"
tidbdriver "github.com/bytebase/bytebase/backend/plugin/db/tidb"
parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"
- mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
- tidbparser "github.com/bytebase/bytebase/backend/plugin/parser/tidb"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/plugin/parser/pg"
- "github.com/bytebase/bytebase/backend/plugin/parser/plsql"
- redshiftparser "github.com/bytebase/bytebase/backend/plugin/parser/redshift"
- "github.com/bytebase/bytebase/backend/plugin/parser/tsql"
"github.com/bytebase/bytebase/backend/store"
)
@@ -150,7 +144,6 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
asts := parserbase.ExtractASTs(stmts)
var explainCalculator getAffectedRowsFromExplain
- var sqlTypes []storepb.StatementType
var defaultSchema string
project, err := stores.GetProject(ctx, &store.FindProjectMessage{Workspace: instance.Workspace, ResourceID: &database.ProjectID})
if err != nil {
@@ -171,15 +164,6 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("invalid pg driver type")
}
explainCalculator = pd.CountAffectedRows
-
- stmtsWithPos, err := pg.GetStatementTypes(asts)
- if err != nil {
- return nil, err
- }
- sqlTypes = make([]storepb.StatementType, len(stmtsWithPos))
- for i, stmt := range stmtsWithPos {
- sqlTypes[i] = stmt.Type
- }
// Empty so pg's extractChangedResources falls back to the database's actual
// default search_path (Change-1 makes a non-empty value force [currentSchema]).
defaultSchema = ""
@@ -189,12 +173,6 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("invalid redshift driver type")
}
explainCalculator = rd.CountAffectedRows
-
- // Use Redshift parser for statement types
- sqlTypes, err = redshiftparser.GetStatementTypes(asts)
- if err != nil {
- return nil, err
- }
defaultSchema = "public"
case storepb.Engine_MYSQL, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:
md, ok := driver.(*mysqldriver.Driver)
@@ -202,13 +180,6 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("invalid mysql driver type")
}
explainCalculator = md.CountAffectedRows
-
- if instance.Metadata.GetEngine() != storepb.Engine_OCEANBASE {
- sqlTypes, err = mysqlparser.GetStatementTypes(asts)
- if err != nil {
- return nil, err
- }
- }
defaultSchema = ""
case storepb.Engine_TIDB:
md, ok := driver.(*tidbdriver.Driver)
@@ -216,11 +187,6 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("invalid tidb driver type")
}
explainCalculator = md.CountAffectedRows
-
- sqlTypes, err = tidbparser.GetStatementTypes(asts)
- if err != nil {
- slog.Error("failed to get statement types", log.BBError(err))
- }
defaultSchema = ""
case storepb.Engine_ORACLE:
od, ok := driver.(*oracledriver.Driver)
@@ -228,11 +194,6 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("invalid oracle driver type")
}
explainCalculator = od.CountAffectedRows
-
- sqlTypes, err = plsql.GetStatementTypes(asts)
- if err != nil {
- return nil, err
- }
defaultSchema = database.DatabaseName
case storepb.Engine_MSSQL:
md, ok := driver.(*mssqldriver.Driver)
@@ -240,17 +201,17 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
return nil, errors.Errorf("invalid mssql driver type")
}
explainCalculator = md.CountAffectedRows
-
- sqlTypes, err = tsql.GetStatementTypes(asts)
- if err != nil {
- slog.Error("failed to get statement types", log.BBError(err))
- }
defaultSchema = "dbo"
default:
// Already checked in the Run().
return nil, nil
}
+ sqlTypes, err := SummaryStatementTypes(instance.Metadata.GetEngine(), asts)
+ if err != nil {
+ return nil, err
+ }
+
// Database secrets feature has been removed
// To avoid leaking the rendered statement, the error message should use the original statement and not the rendered statement.
// Database secrets feature removed - using original statement directly
@@ -267,6 +228,20 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManager
}, nil
}
+// SummaryStatementTypes classifies a summary report's statements through the
+// parser registry, the single classifier per engine that the approval
+// evaluator's parser fallback also uses. An engine without a registered
+// classifier is an error rather than an empty list, because an empty list
+// silently drops every statement.sql_type approval rule; classifier errors
+// propagate for the same reason.
+func SummaryStatementTypes(engine storepb.Engine, asts []parserbase.AST) ([]storepb.StatementType, error) {
+ sqlTypes, err := parserbase.GetStatementTypes(engine, asts)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get statement types for %s", engine)
+ }
+ return sqlTypes, nil
+}
+
type getAffectedRowsFromExplain func(context.Context, string) (int64, error)
func calculateAffectedRows(ctx context.Context, changeSummary *parserbase.ChangeSummary, explainCalculator getAffectedRowsFromExplain) int64 {
diff --git a/backend/runner/plancheck/statement_report_executor_test.go b/backend/runner/plancheck/statement_report_executor_test.go
new file mode 100644
index 0000000000..fac96fe4c5
--- /dev/null
+++ b/backend/runner/plancheck/statement_report_executor_test.go
@@ -0,0 +1,129 @@
+package plancheck
+
+import (
+ "slices"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+// reportEngines derives the list from common.EngineSupportStatementReport so a
+// newly admitted engine is covered without editing this test.
+func reportEngines() []storepb.Engine {
+ values := make([]int32, 0, len(storepb.Engine_name))
+ for v := range storepb.Engine_name {
+ values = append(values, v)
+ }
+ slices.Sort(values)
+
+ var engines []storepb.Engine
+ for _, v := range values {
+ if engine := storepb.Engine(v); common.EngineSupportStatementReport(engine) {
+ engines = append(engines, engine)
+ }
+ }
+ return engines
+}
+
+func dedupeStatementTypes(types []storepb.StatementType) []storepb.StatementType {
+ seen := make(map[storepb.StatementType]bool, len(types))
+ var out []storepb.StatementType
+ for _, t := range types {
+ if seen[t] {
+ continue
+ }
+ seen[t] = true
+ out = append(out, t)
+ }
+ return out
+}
+
+// The approval evaluator reads statement.sql_type from the report, so every
+// report engine must classify the sheet (BYT-10136).
+func TestSummaryStatementTypesCoverEveryReportEngine(t *testing.T) {
+ const sheet = "CREATE TABLE t (id INT);\nUPDATE t SET id = 1 WHERE id = 2;\nDROP TABLE t;"
+ want := []storepb.StatementType{
+ storepb.StatementType_CREATE_TABLE,
+ storepb.StatementType_UPDATE,
+ storepb.StatementType_DROP_TABLE,
+ }
+
+ engines := reportEngines()
+ require.Contains(t, engines, storepb.Engine_OCEANBASE, "OceanBase must be a report engine for this test to guard it")
+
+ for _, engine := range engines {
+ t.Run(engine.String(), func(t *testing.T) {
+ stmts, err := parserbase.ParseStatements(engine, sheet)
+ require.NoError(t, err)
+
+ got, err := SummaryStatementTypes(engine, parserbase.ExtractASTs(stmts))
+ require.NoError(t, err)
+ require.ElementsMatch(t, want, dedupeStatementTypes(got))
+ })
+ }
+}
+
+// The MySQL-family classifier keeps STATEMENT_TYPE_UNSPECIFIED, so a DDL rule
+// written as the negation of a DML list fails closed on an unclassified
+// OceanBase statement.
+func TestSummaryStatementTypesOceanBase(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []storepb.StatementType
+ }{
+ {"insert", "INSERT INTO t1 VALUES (1, 'a');", []storepb.StatementType{storepb.StatementType_INSERT}},
+ {"insert with parallel hint", "INSERT /*+ PARALLEL(4) */ INTO t1 SELECT * FROM t2;", []storepb.StatementType{storepb.StatementType_INSERT}},
+ {"update", "UPDATE t1 SET c1 = 'x' WHERE id = 1;", []storepb.StatementType{storepb.StatementType_UPDATE}},
+ {"delete", "DELETE FROM t1 WHERE id = 1;", []storepb.StatementType{storepb.StatementType_DELETE}},
+ {
+ "create subpartitioned table",
+ "CREATE TABLE t4 (id INT PRIMARY KEY, c1 INT) PARTITION BY RANGE(id) SUBPARTITION BY HASH(c1) SUBPARTITIONS 4 (PARTITION p0 VALUES LESS THAN (100), PARTITION p1 VALUES LESS THAN MAXVALUE);",
+ []storepb.StatementType{storepb.StatementType_CREATE_TABLE},
+ },
+ {
+ "create range columns partitioned table",
+ "CREATE TABLE t6 (id INT, dt DATE) PARTITION BY RANGE COLUMNS(dt) (PARTITION p0 VALUES LESS THAN ('2020-01-01'));",
+ []storepb.StatementType{storepb.StatementType_CREATE_TABLE},
+ },
+ {"alter table add column", "ALTER TABLE t1 ADD COLUMN c2 INT;", []storepb.StatementType{storepb.StatementType_ALTER_TABLE}},
+ {"alter table modify column", "ALTER TABLE t1 MODIFY COLUMN c1 VARCHAR(20);", []storepb.StatementType{storepb.StatementType_ALTER_TABLE}},
+ {"alter table add partition", "ALTER TABLE t1 ADD PARTITION (PARTITION p2 VALUES LESS THAN (200));", []storepb.StatementType{storepb.StatementType_ALTER_TABLE}},
+ {"create index", "CREATE INDEX idx ON t1 (c1);", []storepb.StatementType{storepb.StatementType_CREATE_INDEX}},
+ {"drop index", "DROP INDEX idx ON t1;", []storepb.StatementType{storepb.StatementType_DROP_INDEX}},
+ {"truncate", "TRUNCATE TABLE t1;", []storepb.StatementType{storepb.StatementType_TRUNCATE}},
+ {"drop table", "DROP TABLE t1;", []storepb.StatementType{storepb.StatementType_DROP_TABLE}},
+ {
+ "session variable is unclassified, not dropped",
+ "SET SESSION ob_query_timeout = 10000000;",
+ []storepb.StatementType{storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED},
+ },
+ {
+ "mixed sheet keeps every type",
+ "UPDATE t1 SET c1 = 'x' WHERE id = 1;\nALTER TABLE t1 ADD COLUMN c2 INT;",
+ []storepb.StatementType{storepb.StatementType_UPDATE, storepb.StatementType_ALTER_TABLE},
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ stmts, err := parserbase.ParseStatements(storepb.Engine_OCEANBASE, tt.statement)
+ require.NoError(t, err)
+
+ got, err := SummaryStatementTypes(storepb.Engine_OCEANBASE, parserbase.ExtractASTs(stmts))
+ require.NoError(t, err)
+ require.ElementsMatch(t, tt.want, dedupeStatementTypes(got))
+ })
+ }
+}
+
+// An engine without a registered classifier must error rather than yield an
+// empty list, which would silently drop every statement.sql_type rule.
+func TestSummaryStatementTypesRejectsEngineWithoutClassifier(t *testing.T) {
+ _, err := SummaryStatementTypes(storepb.Engine_SNOWFLAKE, nil)
+ require.Error(t, err)
+}