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(approval): classify BigQuery statements so sql_type approval rules match (BYT-10131) (#21245)
Vincent Huang2e2bbec8206f
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex ca2e007f27..144e152336 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -19737,6 +19737,7 @@ components:- INSERT- UPDATE- DELETE+ - MERGEdescription: StatementType represents the type of SQL statement.bytebase.v1.StorageConfig:type: objectdiff --git a/backend/common/risk.go b/backend/common/risk.goindex 2509b6d69f..407d897640 100644--- a/backend/common/risk.go+++ b/backend/common/risk.go@@ -17,6 +17,7 @@ var highRiskStatementTypes = map[string]bool{var moderateRiskStatementTypes = map[string]bool{"DELETE": true,"UPDATE": true,+ "MERGE": true,"ALTER_TABLE": true,"DROP_INDEX": true,}diff --git a/backend/common/risk_test.go b/backend/common/risk_test.goindex f0546b665c..d8c5f1e767 100644--- a/backend/common/risk_test.go+++ b/backend/common/risk_test.go@@ -19,6 +19,11 @@ func TestGetRiskLevelFromStatementTypes(t *testing.T) {statementTypes: []string{},want: storepb.RiskLevel_LOW,},+ {+ name: "MERGE is MODERATE",+ statementTypes: []string{"MERGE"},+ want: storepb.RiskLevel_MODERATE,+ },{name: "DROP_TABLE is HIGH",statementTypes: []string{"DROP_TABLE"},diff --git a/backend/component/review/evaluator.go b/backend/component/review/evaluator.goindex 6e886c1a16..6e7f09b8a3 100644--- a/backend/component/review/evaluator.go+++ b/backend/component/review/evaluator.go@@ -703,6 +703,11 @@ func buildCELVariablesForDatabaseChange(ctx context.Context, stores *store.StorestatementSummaryResults = buildStatementSummaryResultMap(planCheckRun.Result.GetResults())}+ // A database group expands one sheet across every target, so classify each+ // (engine, sheet) once. Sheets run to common.MaxSheetCheckSize and this+ // path is synchronous on issue submission.+ statementTypeCache := map[statementTypeKey][]storepb.StatementType{}+var celVarsList []map[string]anyfor _, target := range targets {taskStatement := ""@@ -738,16 +743,21 @@ func buildCELVariablesForDatabaseChange(ctx context.Context, stores *store.StoreDatabaseName: target.database.DatabaseName,SheetSHA256: target.sheetSha256,}]- if !ok {- celVarsList = append(celVarsList, celVars)+ if !ok || result.GetSqlSummaryReport() == nil {+ // Set statement.sql_type wherever the engine can classify:+ // cel-go resolves a declared-but-absent variable to an unknown,+ // which matchRulesForSource drops as a non-match.+ cacheKey := statementTypeKey{engine: target.database.Engine, sheetSHA256: target.sheetSha256}+ statementTypes, cached := statementTypeCache[cacheKey]+ if !cached {+ statementTypes = statementTypesFromParser(target.database.Engine, taskStatement)+ statementTypeCache[cacheKey] = statementTypes+ }+ celVarsList = append(celVarsList, expandCELVars(celVars, statementTypes, nil)...)continue}report := result.GetSqlSummaryReport()- if report == nil {- celVarsList = append(celVarsList, celVars)- continue- }// Calculate table rows from changed resourcesvar tableRows int64@@ -1106,6 +1116,42 @@ func getApprovalSourceFromIssue(ctx context.Context, stores *store.Store, issue}}+// statementTypeKey covers both inputs statementTypesFromParser reads: the+// engine, because an issue's targets can span instances of different engines,+// and the sheet digest, which determines the statement text the caller loaded+// from it.+type statementTypeKey struct {+ engine storepb.Engine+ sheetSHA256 string+}++// statementTypesFromParser classifies a sheet directly, for engines that never+// produce a SQL summary report. Returns nil when the engine has no statement-type+// handler, when the sheet does not parse, or when it is over the size guard,+// which leaves statement.sql_type absent for those engines exactly as before.+//+// The size guard mirrors the statement report check, which skips sheets over+// common.MaxSheetCheckSize; parsing runs on the approval path, so a sheet the+// report check declined to read must not be parsed here either.+func statementTypesFromParser(engine storepb.Engine, statement string) []storepb.StatementType {+ if statement == "" || len(statement) > common.MaxSheetCheckSize {+ return nil+ }+ stmts, err := parserbase.ParseStatements(engine, statement)+ if err != nil {+ return nil+ }+ asts := parserbase.ExtractASTs(stmts)+ if len(asts) == 0 {+ return nil+ }+ statementTypes, err := parserbase.GetStatementTypes(engine, asts)+ if err != nil {+ return nil+ }+ return statementTypes+}+// expandCELVars creates CEL variable maps for each combination of statement types and table names.func expandCELVars(base map[string]any, statementTypes []storepb.StatementType, tableNames []string) []map[string]any {if len(statementTypes) == 0 {@@ -1117,9 +1163,26 @@ func expandCELVars(base map[string]any, statementTypes []storepb.StatementType,tableNames = []string{""}}+ // Both producers return one entry per statement, so a sheet of N statements+ // yields N identical activations for the same type. Rule matching asks+ // whether ANY activation matches, so duplicates cannot change the answer,+ // and every rule is evaluated against every activation: a 2 MiB sheet of+ // short statements is tens of thousands of pointless evaluations per target.+ type activation struct {+ statementType storepb.StatementType+ tableName string+ }+ seen := make(map[activation]bool, len(statementTypes))+var result []map[string]anyfor _, statementType := range statementTypes {for _, tableName := range tableNames {+ key := activation{statementType: statementType, tableName: tableName}+ if seen[key] {+ continue+ }+ seen[key] = true+vars := maps.Clone(base)vars[common.CELAttributeStatementSQLType] = statementType.String()if tableName != "" {diff --git a/backend/component/review/evaluator_test.go b/backend/component/review/evaluator_test.goindex 37a70595fa..7c769131b7 100644--- a/backend/component/review/evaluator_test.go+++ b/backend/component/review/evaluator_test.go@@ -16,6 +16,11 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/migrator"++ // Registers the BigQuery parser handlers the same way backend/server+ // ultimate.go does for the server binary; statementTypesFromParser resolves+ // through that registry.+ _ "github.com/bytebase/bytebase/backend/plugin/parser/bigquery""github.com/bytebase/bytebase/backend/runner/plancheck""github.com/bytebase/bytebase/backend/store")@@ -932,3 +937,103 @@ func setupApprovalDatabaseGroupFixture(ctx context.Context, t *testing.T, s *storequire.NoError(t, err)return allDatabases}++// TestApprovalTemplateMatchesOnEngineWithoutStatementReport is the BYT-10131+// regression. BigQuery is outside common.EngineSupportStatementReport, so no+// SQL summary report exists and statement.sql_type used to be absent from the+// activation; cel-go resolved it to an unknown and the rule was dropped as a+// non-match, so the issue reported "No approval required". Both polarities are+// covered: before the fix the DDL rule wrongly skipped approval, and the DML+// rule would still skip it under a plain "UNKNOWN" default.+func TestApprovalTemplateMatchesOnEngineWithoutStatementReport(t *testing.T) {+ const ddlRule = `!(statement.sql_type in ["INSERT", "UPDATE", "DELETE"]) && resource.environment_id == "prod"`+ const dmlRule = `statement.sql_type in ["INSERT", "UPDATE", "DELETE"] && resource.environment_id == "prod"`+ const mergeRule = `statement.sql_type in ["INSERT", "UPDATE", "DELETE", "MERGE"] && resource.environment_id == "prod"`+ const ddlRuleWithMerge = `!(statement.sql_type in ["INSERT", "UPDATE", "DELETE", "MERGE"]) && resource.environment_id == "prod"`+ const mergeStatement = "MERGE INTO `users` t USING `staging` s ON t.id = s.id WHEN MATCHED THEN UPDATE SET t.name = s.name;"++ tests := []struct {+ name string+ expression string+ statement string+ wantMatch bool+ }{+ {"ddl rule matches ALTER TABLE", ddlRule, "ALTER TABLE `users` ADD COLUMN status STRING;", true},+ {"ddl rule skips INSERT", ddlRule, "INSERT INTO `users` (id) VALUES (1);", false},+ {"dml rule matches INSERT", dmlRule, "INSERT INTO `users` (id) VALUES (1);", true},+ {"dml rule skips ALTER TABLE", dmlRule, "ALTER TABLE `users` ADD COLUMN status STRING;", false},+ // MERGE writes rows, so a DML rule that names it must fire and the+ // DDL rule must not. Only the googlesql engines emit MERGE today.+ {"dml rule matches MERGE when named", mergeRule, mergeStatement, true},+ {"ddl rule skips MERGE when named", ddlRuleWithMerge, mergeStatement, false},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ a := require.New(t)+ statementTypes := statementTypesFromParser(storepb.Engine_BIGQUERY, tt.statement)+ a.NotEmpty(statementTypes, "BigQuery must classify the statement without a summary report")++ celVars := expandCELVars(map[string]any{+ common.CELAttributeResourceEnvironmentID: "prod",+ common.CELAttributeResourceProjectID: "project",+ common.CELAttributeResourceDBEngine: storepb.Engine_BIGQUERY.String(),+ common.CELAttributeStatementText: tt.statement,+ }, statementTypes, nil)++ template, err := getApprovalTemplate(&storepb.WorkspaceApprovalSetting{+ Rules: []*storepb.WorkspaceApprovalSetting_Rule{+ {+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,+ Condition: &expr.Expr{Expression: tt.expression},+ Template: &storepb.ApprovalTemplate{Title: "DDL Prod"},+ },+ },+ }, storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE, celVars)+ a.NoError(err)+ if tt.wantMatch {+ a.NotNil(template)+ a.Equal("DDL Prod", template.Title)+ } else {+ a.Nil(template)+ }+ })+ }+}++// A sheet of N statements yields N type entries, all identical when the sheet+// repeats one statement. Every rule is evaluated against every activation, so+// without deduplication a large sheet costs tens of thousands of pointless+// evaluations per target, multiplied again by a database group's target count.+func TestExpandCELVarsDeduplicatesActivations(t *testing.T) {+ a := require.New(t)+ base := map[string]any{common.CELAttributeResourceProjectID: "project"}++ repeated := make([]storepb.StatementType, 10000)+ for i := range repeated {+ repeated[i] = storepb.StatementType_INSERT+ }+ a.Len(expandCELVars(base, repeated, nil), 1)++ // Distinct types survive, in first-seen order.+ mixed := []storepb.StatementType{+ storepb.StatementType_INSERT,+ storepb.StatementType_ALTER_TABLE,+ storepb.StatementType_INSERT,+ }+ got := expandCELVars(base, mixed, nil)+ a.Len(got, 2)+ a.Equal("INSERT", got[0][common.CELAttributeStatementSQLType])+ a.Equal("ALTER_TABLE", got[1][common.CELAttributeStatementSQLType])++ // Deduplication is over the (type, table) pair, not the type alone.+ pairs := expandCELVars(base, mixed, []string{"users", "users", "orders"})+ a.Len(pairs, 4)++ // UNSPECIFIED collapses like any other value.+ unspecified := []storepb.StatementType{+ storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED,+ storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED,+ }+ a.Len(expandCELVars(base, unspecified, nil), 1)+}diff --git a/backend/generated-go/store/common.pb.go b/backend/generated-go/store/common.pb.goindex 4990307523..daac955d11 100644--- a/backend/generated-go/store/common.pb.go+++ b/backend/generated-go/store/common.pb.go@@ -480,6 +480,7 @@ const (StatementType_INSERT StatementType = 60StatementType_UPDATE StatementType = 61StatementType_DELETE StatementType = 62+ StatementType_MERGE StatementType = 63)// Enum value maps for StatementType.@@ -526,6 +527,7 @@ var (60: "INSERT",61: "UPDATE",62: "DELETE",+ 63: "MERGE",}StatementType_value = map[string]int32{"STATEMENT_TYPE_UNSPECIFIED": 0,@@ -569,6 +571,7 @@ var ("INSERT": 60,"UPDATE": 61,"DELETE": 62,+ "MERGE": 63,})@@ -865,7 +868,7 @@ const file_store_common_proto_rawDesc = "" +"\x06FEISHU\x10\x05\x12\t\n" +"\x05WECOM\x10\x06\x12\b\n" +"\x04LARK\x10\a\x12\x0f\n" +- "\vGOOGLE_CHAT\x10\b*\x83\x06\n" ++ "\vGOOGLE_CHAT\x10\b*\x8e\x06\n" +"\rStatementType\x12\x1e\n" +"\x1aSTATEMENT_TYPE_UNSPECIFIED\x10\x00\x12\x13\n" +"\x0fCREATE_DATABASE\x10\x01\x12\x10\n" +@@ -917,7 +920,8 @@ const file_store_common_proto_rawDesc = "" +"\n" +"\x06UPDATE\x10=\x12\n" +"\n" +- "\x06DELETE\x10>\"\x04\b\r\x10\x13\"\x04\b \x10'\"\x04\b/\x101\"\x04\b8\x10;B\x8e\x01\n" ++ "\x06DELETE\x10>\x12\t\n" ++ "\x05MERGE\x10?\"\x04\b\r\x10\x13\"\x04\b \x10'\"\x04\b/\x101\"\x04\b8\x10;B\x8e\x01\n" +"\x12com.bytebase.storeB\vCommonProtoP\x01Z\x12generated-go/store\xa2\x02\x03BSX\xaa\x02\x0eBytebase.Store\xca\x02\x0eBytebase\\Store\xe2\x02\x1aBytebase\\Store\\GPBMetadata\xea\x02\x0fBytebase::Storeb\x06proto3"var (diff --git a/backend/generated-go/v1/common.pb.go b/backend/generated-go/v1/common.pb.goindex 81e1dc2ffd..c0e3534960 100644--- a/backend/generated-go/v1/common.pb.go+++ b/backend/generated-go/v1/common.pb.go@@ -646,6 +646,7 @@ const (StatementType_INSERT StatementType = 60StatementType_UPDATE StatementType = 61StatementType_DELETE StatementType = 62+ StatementType_MERGE StatementType = 63)// Enum value maps for StatementType.@@ -692,6 +693,7 @@ var (60: "INSERT",61: "UPDATE",62: "DELETE",+ 63: "MERGE",}StatementType_value = map[string]int32{"STATEMENT_TYPE_UNSPECIFIED": 0,@@ -735,6 +737,7 @@ var ("INSERT": 60,"UPDATE": 61,"DELETE": 62,+ "MERGE": 63,})@@ -1055,7 +1058,7 @@ const file_v1_common_proto_rawDesc = "" +"\x06FEISHU\x10\x05\x12\t\n" +"\x05WECOM\x10\x06\x12\b\n" +"\x04LARK\x10\a\x12\x0f\n" +- "\vGOOGLE_CHAT\x10\b*\x83\x06\n" ++ "\vGOOGLE_CHAT\x10\b*\x8e\x06\n" +"\rStatementType\x12\x1e\n" +"\x1aSTATEMENT_TYPE_UNSPECIFIED\x10\x00\x12\x13\n" +"\x0fCREATE_DATABASE\x10\x01\x12\x10\n" +@@ -1107,7 +1110,8 @@ const file_v1_common_proto_rawDesc = "" +"\n" +"\x06UPDATE\x10=\x12\n" +"\n" +- "\x06DELETE\x10>\"\x04\b\r\x10\x13\"\x04\b \x10'\"\x04\b/\x101\"\x04\b8\x10;B\xa1\x01\n" ++ "\x06DELETE\x10>\x12\t\n" ++ "\x05MERGE\x10?\"\x04\b\r\x10\x13\"\x04\b \x10'\"\x04\b/\x101\"\x04\b8\x10;B\xa1\x01\n" +"\x0fcom.bytebase.v1B\vCommonProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.goindex d52d4cf3eb..0b0a74d4f2 100644--- a/backend/plugin/parser/base/interface.go+++ b/backend/plugin/parser/base/interface.go@@ -339,7 +339,7 @@ func GetStatementTypes(engine storepb.Engine, asts []AST) ([]storepb.StatementTyreturn f(asts)}-// IsAllDML checks if all statements are DML (INSERT, UPDATE, DELETE).+// IsAllDML checks if all statements are DML (INSERT, UPDATE, DELETE, MERGE).// Returns false for unsupported engines or parse errors (conservative approach).// Results are cached to avoid repeated parsing of the same statement.// Safe for concurrent calls with the same statement.@@ -382,7 +382,7 @@ func isAllDMLImpl(engine storepb.Engine, statement string) bool {}for _, t := range types {switch t {- case storepb.StatementType_INSERT, storepb.StatementType_UPDATE, storepb.StatementType_DELETE:+ case storepb.StatementType_INSERT, storepb.StatementType_UPDATE, storepb.StatementType_DELETE, storepb.StatementType_MERGE:// DML statement, continuedefault:return falsediff --git a/backend/plugin/parser/bigquery/statement_type_test.go b/backend/plugin/parser/bigquery/statement_type_test.gonew file mode 100644index 0000000000..cc9ed1e078--- /dev/null+++ b/backend/plugin/parser/bigquery/statement_type_test.go@@ -0,0 +1,45 @@+package bigquery++import (+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++// base.IsAllDML resolves through the registry this package populates, and it is+// what computeNeedDump calls to decide whether a BigQuery migration skips the+// schema dump. The googlesql tests cover the type mapping one layer down; these+// pin the predicate the executor actually calls.+func TestIsAllDML(t *testing.T) {+ tests := []struct {+ name string+ statement string+ want bool+ }{+ {"insert", "INSERT INTO users (id) VALUES (1);", true},+ {"update", "UPDATE users SET name = 'b' WHERE id = 1;", true},+ {"delete", "DELETE FROM users WHERE id = 1;", true},+ {+ "merge writes rows, so it must not force a dump",+ "MERGE INTO users t USING staging s ON t.id = s.id WHEN MATCHED THEN UPDATE SET t.name = s.name;",+ true,+ },+ {"ddl", "ALTER TABLE users ADD COLUMN status STRING;", false},+ {"mixed", "ALTER TABLE users ADD COLUMN status STRING;\nINSERT INTO users (id) VALUES (1);", false},+ {+ // The unparsed statement classifies as UNSPECIFIED rather than+ // vanishing, so a sheet whose DDL omni cannot parse still dumps.+ "unparsed statement is not DML",+ "THIS IS NOT SQL;\nINSERT INTO users (id) VALUES (1);",+ false,+ },+ }+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ require.Equal(t, tt.want, base.IsAllDML(storepb.Engine_BIGQUERY, tt.statement))+ })+ }+}diff --git a/backend/plugin/parser/googlesql/register.go b/backend/plugin/parser/googlesql/register.goindex 09c3a7caf9..663fc3473a 100644--- a/backend/plugin/parser/googlesql/register.go+++ b/backend/plugin/parser/googlesql/register.go@@ -16,8 +16,9 @@ type Handlers struct {GetQuerySpan base.GetQuerySpanFunc}-// Register registers the splitter, diagnose, and query-span handlers for one-// GoogleSQL engine with the given dialect configuration.+// Register registers the splitter, diagnose, query-span, statement-parser, and+// statement-type handlers for one GoogleSQL engine with the given dialect+// configuration.func Register(engine storepb.Engine, cfg Config) Handlers {h := Handlers{SplitSQL: func(statement string) ([]base.Statement, error) {@@ -32,5 +33,9 @@ func Register(engine storepb.Engine, cfg Config) Handlers {return Diagnose(statement), nil})base.RegisterGetQuerySpan(engine, h.GetQuerySpan)+ base.RegisterParseStatementsFunc(engine, func(statement string) ([]base.ParsedStatement, error) {+ return ParseStatements(statement, cfg)+ })+ base.RegisterGetStatementTypes(engine, GetStatementTypes)return h}diff --git a/backend/plugin/parser/googlesql/statement_type.go b/backend/plugin/parser/googlesql/statement_type.gonew file mode 100644index 0000000000..49cbe939cc--- /dev/null+++ b/backend/plugin/parser/googlesql/statement_type.go@@ -0,0 +1,199 @@+package googlesql++import (+ "github.com/bytebase/omni/googlesql/ast"+ "github.com/bytebase/omni/googlesql/parser"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++// AST wraps one omni GoogleSQL statement node so it satisfies base.AST. Node is+// nil when omni could not parse the statement.+type AST struct {+ Node ast.Node+ StartPosition *storepb.Position+}++// ASTStartPosition implements base.AST.+func (a *AST) ASTStartPosition() *storepb.Position {+ return a.StartPosition+}++// ParseStatements splits the input with the dialect's splitter and parses each+// statement into an omni AST node.+//+// A statement omni cannot parse carries an AST with a nil Node rather than no+// AST: base.ExtractASTs keeps only non-nil ASTs, so no AST means the statement+// disappears from classification instead of reporting UNSPECIFIED.+func ParseStatements(statement string, cfg Config) ([]base.ParsedStatement, error) {+ stmts, err := SplitSQL(statement, cfg)+ if err != nil {+ return nil, err+ }++ var result []base.ParsedStatement+ for _, stmt := range stmts {+ file, errs := parser.Parse(stmt.Text)+ if len(errs) > 0 || file == nil || len(file.Stmts) == 0 {+ result = append(result, base.ParsedStatement{+ Statement: stmt,+ AST: &AST{StartPosition: stmt.Start},+ })+ continue+ }+ for _, node := range file.Stmts {+ result = append(result, base.ParsedStatement{+ Statement: stmt,+ AST: &AST{Node: node, StartPosition: stmt.Start},+ })+ }+ }+ return result, nil+}++// GetStatementTypes maps each parsed GoogleSQL statement onto the storepb+// statement type that approval rules and risk levels are written against.+func GetStatementTypes(asts []base.AST) ([]storepb.StatementType, error) {+ types := make([]storepb.StatementType, 0, len(asts))+ for _, a := range asts {+ node, ok := a.(*AST)+ if !ok || node.Node == nil {+ types = append(types, storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED)+ continue+ }+ types = append(types, statementType(node.Node))+ }+ return types, nil+}++// statementType maps one omni GoogleSQL node to a storepb.StatementType.+//+// Deferral: every GoogleSQL statement the enum has no value for reports+// UNSPECIFIED, so a rule selecting DML skips it. The gap includes statements+// that do write rows — LOAD DATA INTO, CLONE DATA INTO, scripting bodies+// (BEGIN…END, CALL, FOR, WHILE, each of which parses as one statement), and+// EXECUTE IMMEDIATE, whose text is only known at run time. It also includes+// ALTER SCHEMA, row access policies, generic entities, and the Spanner-only+// DDL set (change streams, roles, GRANT / REVOKE, proto bundles), which do+// not write rows.+//+// A new row-writing statement needs its own enum value before it lands here.+// analysis.ClassifySQL returns Unknown for these too, so it cannot gate the list.+func statementType(node ast.Node) storepb.StatementType {+ switch n := node.(type) {+ case *ast.InsertStmt:+ return storepb.StatementType_INSERT+ case *ast.UpdateStmt:+ return storepb.StatementType_UPDATE+ case *ast.DeleteStmt:+ return storepb.StatementType_DELETE+ case *ast.MergeStmt:+ return storepb.StatementType_MERGE+ case *ast.TruncateStmt:+ return storepb.StatementType_TRUNCATE++ case *ast.CreateTableStmt:+ return storepb.StatementType_CREATE_TABLE+ case *ast.CreateViewStmt:+ return storepb.StatementType_CREATE_VIEW+ case *ast.CreateMaterializedViewStmt:+ return storepb.StatementType_CREATE_VIEW+ case *ast.CreateIndexStmt:+ return storepb.StatementType_CREATE_INDEX+ case *ast.SearchVectorIndexStmt:+ return storepb.StatementType_CREATE_INDEX+ case *ast.CreateSchemaStmt:+ return storepb.StatementType_CREATE_SCHEMA+ case *ast.CreateDatabaseStmt:+ return storepb.StatementType_CREATE_DATABASE+ case *ast.CreateFunctionStmt:+ return storepb.StatementType_CREATE_FUNCTION+ case *ast.CreateProcedureStmt:+ return storepb.StatementType_CREATE_PROCEDURE+ case *ast.CreateSequenceStmt:+ return storepb.StatementType_CREATE_SEQUENCE+ case *ast.CreateSnapshotStmt:+ return storepb.StatementType_CREATE_TABLE++ case *ast.AlterStmt:+ return alterStatementType(n.Object)+ case *ast.DropStmt:+ return dropStatementType(n.Object)+ case *ast.AlterSequenceStmt:+ return storepb.StatementType_ALTER_SEQUENCE+ case *ast.DropSequenceStmt:+ return storepb.StatementType_DROP_SEQUENCE+ case *ast.BQAlterStmt:+ return bqAlterStatementType(n.Object)+ case *ast.BQDropStmt:+ return bqDropStatementType(n.Object)++ case *ast.RenameStmt:+ return storepb.StatementType_RENAME++ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED+ }+}++func alterStatementType(kind ast.AlterObjectKind) storepb.StatementType {+ switch kind {+ case ast.AlterTable:+ return storepb.StatementType_ALTER_TABLE+ case ast.AlterView:+ return storepb.StatementType_ALTER_VIEW+ case ast.AlterIndex, ast.AlterSearchIndex:+ return storepb.StatementType_ALTER_INDEX+ case ast.AlterDatabase:+ return storepb.StatementType_ALTER_DATABASE+ default:+ // ALTER SCHEMA has no enum value; see the deferral on statementType.+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED+ }+}++func dropStatementType(kind ast.DropObjectKind) storepb.StatementType {+ switch kind {+ case ast.DropTable:+ return storepb.StatementType_DROP_TABLE+ case ast.DropView:+ return storepb.StatementType_DROP_VIEW+ case ast.DropIndex:+ return storepb.StatementType_DROP_INDEX+ case ast.DropSchema:+ return storepb.StatementType_DROP_SCHEMA+ case ast.DropDatabase:+ return storepb.StatementType_DROP_DATABASE+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED+ }+}++func bqAlterStatementType(kind ast.BQAlterObjectKind) storepb.StatementType {+ switch kind {+ case ast.BQAlterMaterializedView, ast.BQAlterApproxView:+ return storepb.StatementType_ALTER_VIEW+ case ast.BQAlterVectorIndex:+ return storepb.StatementType_ALTER_INDEX+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED+ }+}++func bqDropStatementType(kind ast.BQDropObjectKind) storepb.StatementType {+ switch kind {+ case ast.BQDropFunction, ast.BQDropTableFunction:+ return storepb.StatementType_DROP_FUNCTION+ case ast.BQDropProcedure:+ return storepb.StatementType_DROP_PROCEDURE+ case ast.BQDropMaterializedView, ast.BQDropApproxView:+ return storepb.StatementType_DROP_VIEW+ case ast.BQDropSnapshotTable:+ return storepb.StatementType_DROP_TABLE+ case ast.BQDropSearchIndex, ast.BQDropVectorIndex:+ return storepb.StatementType_DROP_INDEX+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED+ }+}diff --git a/backend/plugin/parser/googlesql/statement_type_test.go b/backend/plugin/parser/googlesql/statement_type_test.gonew file mode 100644index 0000000000..8aabdd3657--- /dev/null+++ b/backend/plugin/parser/googlesql/statement_type_test.go@@ -0,0 +1,127 @@+package googlesql++import (+ "testing"++ "github.com/bytebase/omni/googlesql/analysis"+ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++var bigQueryConfig = Config{Dialect: analysis.DialectBigQuery, SetStatementIsSelect: true}++func typesOf(t *testing.T, statement string) []storepb.StatementType {+ t.Helper()+ stmts, err := ParseStatements(statement, bigQueryConfig)+ require.NoError(t, err)+ types, err := GetStatementTypes(base.ExtractASTs(stmts))+ require.NoError(t, err)+ return types+}++func TestGetStatementTypes(t *testing.T) {+ tests := []struct {+ statement string+ want storepb.StatementType+ }{+ // DML.+ {"INSERT INTO `users` (id, name) VALUES (1, 'a');", storepb.StatementType_INSERT},+ {"INSERT INTO ds.users SELECT * FROM ds.staging;", storepb.StatementType_INSERT},+ {"UPDATE users SET name = 'b' WHERE id = 1;", storepb.StatementType_UPDATE},+ {"DELETE FROM users WHERE id = 1;", storepb.StatementType_DELETE},+ {"MERGE INTO users t USING staging s ON t.id = s.id WHEN MATCHED THEN UPDATE SET t.name = s.name;", storepb.StatementType_MERGE},+ {"TRUNCATE TABLE users;", storepb.StatementType_TRUNCATE},+ // DDL - create.+ {"CREATE TABLE users (id INT64, name STRING);", storepb.StatementType_CREATE_TABLE},+ {"CREATE OR REPLACE TABLE users (id INT64);", storepb.StatementType_CREATE_TABLE},+ {"CREATE SNAPSHOT TABLE snap CLONE users;", storepb.StatementType_CREATE_TABLE},+ {"CREATE VIEW v AS SELECT 1;", storepb.StatementType_CREATE_VIEW},+ {"CREATE MATERIALIZED VIEW mv AS SELECT 1;", storepb.StatementType_CREATE_VIEW},+ {"CREATE SCHEMA ds;", storepb.StatementType_CREATE_SCHEMA},+ {"CREATE SEARCH INDEX idx ON users(name);", storepb.StatementType_CREATE_INDEX},+ {"CREATE FUNCTION f(x INT64) AS (x + 1);", storepb.StatementType_CREATE_FUNCTION},+ {"CREATE PROCEDURE p() BEGIN SELECT 1; END;", storepb.StatementType_CREATE_PROCEDURE},+ // DDL - alter. The reported case from BYT-10131 is the first one.+ {"ALTER TABLE `users` ADD COLUMN status STRING;", storepb.StatementType_ALTER_TABLE},+ {"ALTER TABLE users SET OPTIONS(description='x');", storepb.StatementType_ALTER_TABLE},+ {"ALTER VIEW v SET OPTIONS(description='x');", storepb.StatementType_ALTER_VIEW},+ {"ALTER MATERIALIZED VIEW mv SET OPTIONS(enable_refresh=true);", storepb.StatementType_ALTER_VIEW},+ // DDL - drop.+ {"DROP TABLE users;", storepb.StatementType_DROP_TABLE},+ {"DROP VIEW v;", storepb.StatementType_DROP_VIEW},+ {"DROP SCHEMA ds;", storepb.StatementType_DROP_SCHEMA},+ {"DROP MATERIALIZED VIEW mv;", storepb.StatementType_DROP_VIEW},+ {"DROP FUNCTION f;", storepb.StatementType_DROP_FUNCTION},+ {"DROP PROCEDURE p;", storepb.StatementType_DROP_PROCEDURE},+ {"DROP SEARCH INDEX idx ON users;", storepb.StatementType_DROP_INDEX},+ // No enum value; see the deferral on statementType.+ {"ALTER SCHEMA ds SET OPTIONS(description='x');", storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED},+ {"DROP ROW ACCESS POLICY rap ON users;", storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED},+ {"SELECT * FROM users;", storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED},+ }+ for _, tt := range tests {+ t.Run(tt.statement, func(t *testing.T) {+ got := typesOf(t, tt.statement)+ require.Len(t, got, 1)+ require.Equal(t, tt.want, got[0])+ })+ }+}++// TestGetStatementTypesAgreesWithClassifier is the acceptance test: omni's+// analysis.ClassifySQL derives DML membership by a different route than the AST+// switch, so a statement it calls DML must map onto a DML enum value. A+// disagreement means an approval rule keyed on statement.sql_type would+// mis-gate that statement, which is the defect BYT-10131 reported.+func TestGetStatementTypesAgreesWithClassifier(t *testing.T) {+ dml := map[storepb.StatementType]bool{+ storepb.StatementType_INSERT: true,+ storepb.StatementType_UPDATE: true,+ storepb.StatementType_DELETE: true,+ storepb.StatementType_MERGE: true,+ storepb.StatementType_TRUNCATE: true,+ }+ statements := []string{+ "INSERT INTO users (id) VALUES (1);",+ "UPDATE users SET name = 'b' WHERE id = 1;",+ "DELETE FROM users WHERE id = 1;",+ "MERGE INTO users t USING staging s ON t.id = s.id WHEN MATCHED THEN UPDATE SET t.name = s.name;",+ "TRUNCATE TABLE users;",+ "CREATE TABLE users (id INT64);",+ "ALTER TABLE users ADD COLUMN status STRING;",+ "DROP TABLE users;",+ "CREATE VIEW v AS SELECT 1;",+ "SELECT * FROM users;",+ }+ for _, statement := range statements {+ t.Run(statement, func(t *testing.T) {+ got := typesOf(t, statement)+ require.Len(t, got, 1)+ classified := analysis.ClassifySQL(statement, analysis.DialectBigQuery)+ require.Equal(t, classified == analysis.DML, dml[got[0]],+ "classifier says %v, mapping says %v", classified, got[0])+ })+ }+}++func TestParseStatementsMultiStatement(t *testing.T) {+ got := typesOf(t, "ALTER TABLE users ADD COLUMN status STRING;\nINSERT INTO users (id) VALUES (1);")+ require.Equal(t, []storepb.StatementType{+ storepb.StatementType_ALTER_TABLE,+ storepb.StatementType_INSERT,+ }, got)+}++// An unparseable statement must survive as UNSPECIFIED rather than vanish.+// base.ExtractASTs drops entries with a nil AST, so dropping it here would hide+// the statement from approval rules entirely and reopen the BYT-10131 skip+// through a parse gap.+func TestParseStatementsReportsAnUnparseableStatement(t *testing.T) {+ got := typesOf(t, "THIS IS NOT SQL;\nINSERT INTO users (id) VALUES (1);")+ require.Equal(t, []storepb.StatementType{+ storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED,+ storepb.StatementType_INSERT,+ }, got)+}diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.goindex f292529d8f..e8bbd09d70 100644--- a/backend/runner/taskrun/database_migrate_executor.go+++ b/backend/runner/taskrun/database_migrate_executor.go@@ -1037,8 +1037,8 @@ func computeNeedDump(taskType storepb.Task_Type, engine storepb.Engine, statemen//exhaustive:enforceswitch taskType {case storepb.Task_DATABASE_MIGRATE:- // For DATABASE_MIGRATE, skip dump if all statements are DML- // (INSERT, UPDATE, DELETE) since they don't change schema.+ // For DATABASE_MIGRATE, skip dump if all statements are DML since they+ // don't change schema. IsAllDML owns the type list.return !parserbase.IsAllDML(engine, statement)case storepb.Task_DATABASE_CREATE:return truediff --git a/frontend/src/modules/cel/types/values.ts b/frontend/src/modules/cel/types/values.tsindex eadbc118f5..ca3f9e382c 100644--- a/frontend/src/modules/cel/types/values.ts+++ b/frontend/src/modules/cel/types/values.ts@@ -45,7 +45,12 @@ const DDL_STATEMENT_TYPES = [StatementType.COMMENT,] as const;-// DML statement types+// DML statement types.+// MERGE is deliberately absent: the picker is engine-agnostic, and only the+// GoogleSQL engines classify a MERGE today. Postgres, SQL Server and Oracle+// still let MergeStmt fall through to STATEMENT_TYPE_UNSPECIFIED, so a rule+// naming MERGE would silently never fire on them and skip the approval the+// author intended. Restore it with BOT-112, which adds those mappings.const DML_STATEMENT_TYPES = [StatementType.INSERT,StatementType.UPDATE,diff --git a/frontend/src/types/proto-es/v1/common_pb.d.ts b/frontend/src/types/proto-es/v1/common_pb.d.tsindex 89eff61a36..ca15d121b0 100644--- a/frontend/src/types/proto-es/v1/common_pb.d.ts+++ b/frontend/src/types/proto-es/v1/common_pb.d.ts@@ -868,6 +868,11 @@ export enum StatementType {* @generated from enum value: DELETE = 62;*/DELETE = 62,++ /**+ * @generated from enum value: MERGE = 63;+ */+ MERGE = 63,}/**diff --git a/frontend/src/types/proto-es/v1/common_pb.js b/frontend/src/types/proto-es/v1/common_pb.jsindex 7b6af42875..6229957860 100644--- a/frontend/src/types/proto-es/v1/common_pb.js+++ b/frontend/src/types/proto-es/v1/common_pb.js@@ -8,7 +8,7 @@ import { enumDesc, fileDesc, messageDesc, tsEnum } from "@bufbuild/protobuf/code* Describes the file v1/common.proto.*/export const file_v1_common = /*@__PURE__*/- fileDesc("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");+ fileDesc("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");/*** Describes the message bytebase.v1.Position.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex b9c418a098..3ffe14cb02 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -30780,6 +30780,7 @@ components:- INSERT- UPDATE- DELETE+ - MERGEdescription: StatementType represents the type of SQL statement.bytebase.v1.StorageConfig:type: objectdiff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex 2a1fbd452d..c0b06608bb 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -636,6 +636,7 @@ StatementType represents the type of SQL statement.| INSERT | 60 | DML statements || UPDATE | 61 | || DELETE | 62 | |+| MERGE | 63 | |diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.htmlindex 606c776694..ad4a12416e 100644--- a/proto/gen/grpc-doc/store/index.html+++ b/proto/gen/grpc-doc/store/index.html@@ -2441,6 +2441,12 @@ Examples:<td><p></p></td></tr>+ <tr>+ <td>MERGE</td>+ <td>63</td>+ <td><p></p></td>+ </tr>+</tbody></table>diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 3644a8635e..0832bc33f1 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -1628,6 +1628,7 @@ StatementType represents the type of SQL statement.| INSERT | 60 | DML statements || UPDATE | 61 | || DELETE | 62 | |+| MERGE | 63 | |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex ce9ea287c2..7caf289fd2 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -5542,6 +5542,12 @@ Examples:<td><p></p></td></tr>+ <tr>+ <td>MERGE</td>+ <td>63</td>+ <td><p></p></td>+ </tr>+</tbody></table>diff --git a/proto/store/store/common.proto b/proto/store/store/common.protoindex dc56a793c7..ed7ac58fc0 100644--- a/proto/store/store/common.proto+++ b/proto/store/store/common.proto@@ -192,4 +192,5 @@ enum StatementType {INSERT = 60;UPDATE = 61;DELETE = 62;+ MERGE = 63;}diff --git a/proto/v1/v1/common.proto b/proto/v1/v1/common.protoindex 8d144b572a..25fbfdb2b6 100644--- a/proto/v1/v1/common.proto+++ b/proto/v1/v1/common.proto@@ -256,6 +256,7 @@ enum StatementType {INSERT = 60;UPDATE = 61;DELETE = 62;+ MERGE = 63;}// PermissionDeniedDetail provides structured information about permission failures.