Skip to content

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

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.yaml
index 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
+ - MERGE
description: StatementType represents the type of SQL statement.
bytebase.v1.StorageConfig:
type: object
diff --git a/backend/common/risk.go b/backend/common/risk.go
index 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.go
index 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.go
index 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.Store
statementSummaryResults = 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]any
for _, target := range targets {
taskStatement := ""
@@ -738,16 +743,21 @@ func buildCELVariablesForDatabaseChange(ctx context.Context, stores *store.Store
DatabaseName: 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 resources
var 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]any
for _, 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.go
index 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 *sto
require.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.go
index 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 = 60
StatementType_UPDATE StatementType = 61
StatementType_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.go
index 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 = 60
StatementType_UPDATE StatementType = 61
StatementType_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.go
index 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.StatementTy
return 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, continue
default:
return false
diff --git a/backend/plugin/parser/bigquery/statement_type_test.go b/backend/plugin/parser/bigquery/statement_type_test.go
new file mode 100644
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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:enforce
switch 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 true
diff --git a/frontend/src/modules/cel/types/values.ts b/frontend/src/modules/cel/types/values.ts
index 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.ts
index 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.js
index 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("Cg92MS9jb21tb24ucHJvdG8SC2J5dGViYXNlLnYxIigKCFBvc2l0aW9uEgwKBGxpbmUYASABKAUSDgoGY29sdW1uGAIgASgFIiMKBVJhbmdlEg0KBXN0YXJ0GAEgASgFEgsKA2VuZBgCIAEoBSJZChZQZXJtaXNzaW9uRGVuaWVkRGV0YWlsEg4KBm1ldGhvZBgBIAEoCRIcChRyZXF1aXJlZF9wZXJtaXNzaW9ucxgCIAMoCRIRCglyZXNvdXJjZXMYAyADKAkqNwoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIKCgZBQ1RJVkUQARILCgdERUxFVEVEEAIq6gIKBkVuZ2luZRIWChJFTkdJTkVfVU5TUEVDSUZJRUQQABIOCgpDTElDS0hPVVNFEAESCQoFTVlTUUwQAhIMCghQT1NUR1JFUxADEg0KCVNOT1dGTEFLRRAEEggKBFRJREIQBhILCgdNT05HT0RCEAcSCQoFUkVESVMQCBIKCgZPUkFDTEUQCRILCgdTUEFOTkVSEAoSCQoFTVNTUUwQCxIMCghSRURTSElGVBAMEgsKB01BUklBREIQDRINCglPQ0VBTkJBU0UQDhINCglTVEFSUk9DS1MQDxIJCgVET1JJUxAQEggKBEhJVkUQERIRCg1FTEFTVElDU0VBUkNIEBISDAoIQklHUVVFUlkQExIMCghEWU5BTU9EQhAUEg4KCkRBVEFCUklDS1MQFRIPCgtDT0NLUk9BQ0hEQhAWEgwKCENPU01PU0RCEBcSCQoFVFJJTk8QGBINCglDQVNTQU5EUkEQGSIECAUQBSpcCgdWQ1NUeXBlEhgKFFZDU19UWVBFX1VOU1BFQ0lGSUVEEAASCgoGR0lUSFVCEAESCgoGR0lUTEFCEAISDQoJQklUQlVDS0VUEAMSEAoMQVpVUkVfREVWT1BTEAQqTAoMRXhwb3J0Rm9ybWF0EhYKEkZPUk1BVF9VTlNQRUNJRklFRBAAEgcKA0NTVhABEggKBEpTT04QAhIHCgNTUUwQAxIICgRYTFNYEAQqdQoOQXBwcm92YWxTdGF0dXMSHwobQVBQUk9WQUxfU1RBVFVTX1VOU1BFQ0lGSUVEEAASDAoIQ0hFQ0tJTkcQARILCgdQRU5ESU5HEAISDAoIQVBQUk9WRUQQAxIMCghSRUpFQ1RFRBAEEgsKB1NLSVBQRUQQBSpNCgtJc3N1ZVN0YXR1cxIcChhJU1NVRV9TVEFUVVNfVU5TUEVDSUZJRUQQABIICgRPUEVOEAESCAoERE9ORRACEgwKCENBTkNFTEVEEAMqSAoJUmlza0xldmVsEhoKFlJJU0tfTEVWRUxfVU5TUEVDSUZJRUQQABIHCgNMT1cQARIMCghNT0RFUkFURRACEggKBEhJR0gQAyqOAQoLV2ViaG9va1R5cGUSHAoYV0VCSE9PS19UWVBFX1VOU1BFQ0lGSUVEEAASCQoFU0xBQ0sQARILCgdESVNDT1JEEAISCQoFVEVBTVMQAxIMCghESU5HVEFMSxAEEgoKBkZFSVNIVRAFEgkKBVdFQ09NEAYSCAoETEFSSxAHEg8KC0dPT0dMRV9DSEFUEAgqgwYKDVN0YXRlbWVudFR5cGUSHgoaU1RBVEVNRU5UX1RZUEVfVU5TUEVDSUZJRUQQABITCg9DUkVBVEVfREFUQUJBU0UQARIQCgxDUkVBVEVfVEFCTEUQAhIPCgtDUkVBVEVfVklFVxADEhAKDENSRUFURV9JTkRFWBAEEhMKD0NSRUFURV9TRVFVRU5DRRAFEhEKDUNSRUFURV9TQ0hFTUEQBhITCg9DUkVBVEVfRlVOQ1RJT04QBxISCg5DUkVBVEVfVFJJR0dFUhAIEhQKEENSRUFURV9QUk9DRURVUkUQCRIQCgxDUkVBVEVfRVZFTlQQChIUChBDUkVBVEVfRVhURU5TSU9OEAsSDwoLQ1JFQVRFX1RZUEUQDBIRCg1EUk9QX0RBVEFCQVNFEBQSDgoKRFJPUF9UQUJMRRAVEg0KCURST1BfVklFVxAWEg4KCkRST1BfSU5ERVgQFxIRCg1EUk9QX1NFUVVFTkNFEBgSDwoLRFJPUF9TQ0hFTUEQGRIRCg1EUk9QX0ZVTkNUSU9OEBoSEAoMRFJPUF9UUklHR0VSEBsSEgoORFJPUF9QUk9DRURVUkUQHBIOCgpEUk9QX0VWRU5UEB0SEgoORFJPUF9FWFRFTlNJT04QHhINCglEUk9QX1RZUEUQHxISCg5BTFRFUl9EQVRBQkFTRRAoEg8KC0FMVEVSX1RBQkxFECkSDgoKQUxURVJfVklFVxAqEhIKDkFMVEVSX1NFUVVFTkNFECsSDwoLQUxURVJfRVZFTlQQLBIOCgpBTFRFUl9UWVBFEC0SDwoLQUxURVJfSU5ERVgQLhIMCghUUlVOQ0FURRAyEgoKBlJFTkFNRRAzEhAKDFJFTkFNRV9JTkRFWBA0EhEKDVJFTkFNRV9TQ0hFTUEQNRITCg9SRU5BTUVfU0VRVUVOQ0UQNhILCgdDT01NRU5UEDcSCgoGSU5TRVJUEDwSCgoGVVBEQVRFED0SCgoGREVMRVRFED4iBAgNEBMiBAggECciBAgvEDEiBAg4EDtCoQEKD2NvbS5ieXRlYmFzZS52MUILQ29tbW9uUHJvdG9QAVo0Z2l0aHViLmNvbS9ieXRlYmFzZS9ieXRlYmFzZS9iYWNrZW5kL2dlbmVyYXRlZC1nby92MaICA0JYWKoCC0J5dGViYXNlLlYxygILQnl0ZWJhc2VcVjHiAhdCeXRlYmFzZVxWMVxHUEJNZXRhZGF0YeoCDEJ5dGViYXNlOjpWMWIGcHJvdG8z");
+ 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.yaml
index 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
+ - MERGE
description: StatementType represents the type of SQL statement.
bytebase.v1.StorageConfig:
type: object
diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.md
index 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.html
index 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.md
index 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.html
index 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.proto
index 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.proto
index 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.