Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.goindex 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.goindex 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.goindex 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, sheetManagerasts := parserbase.ExtractASTs(stmts)var explainCalculator getAffectedRowsFromExplain- var sqlTypes []storepb.StatementTypevar defaultSchema stringproject, 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, sheetManagerreturn 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, sheetManagerreturn 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, sheetManagerreturn 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, sheetManagerreturn 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, sheetManagerreturn nil, errors.Errorf("invalid oracle driver type")}explainCalculator = od.CountAffectedRows-- sqlTypes, err = plsql.GetStatementTypes(asts)- if err != nil {- return nil, err- }defaultSchema = database.DatabaseNamecase storepb.Engine_MSSQL:md, ok := driver.(*mssqldriver.Driver)@@ -240,17 +201,17 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManagerreturn 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.gonew file mode 100644index 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)+}