Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: change classification level from string to int (#19725)
Danny Xu7c3e217d7674
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex f3a9e2642d..bb76755526 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -9368,9 +9368,7 @@ components:items:$ref: '#/components/schemas/bytebase.v1.DataClassificationSetting.DataClassificationConfig.Level'title: levels- description: |-- levels is user defined level list for classification.- The order for the level decides its priority.+ description: levels is user defined level list for classification.classification:type: objecttitle: classification@@ -9406,25 +9404,29 @@ components:description:type: stringtitle: description- levelId:+ level:type:- - string+ - integer- "null"- title: level_id+ title: level+ format: int32+ description: The sensitivity level. Maps to Level.level.title: DataClassificationadditionalProperties: falsebytebase.v1.DataClassificationSetting.DataClassificationConfig.Level:type: objectproperties:- id:- type: string- title: idtitle:type: stringtitle: titledescription:type: stringtitle: description+ level:+ type: integer+ title: level+ format: int32+ description: The numeric level for ordering. Higher = more sensitive.title: LeveladditionalProperties: falsebytebase.v1.DataSource:@@ -13666,9 +13668,10 @@ components:title: contextdescription: 'Additional context (e.g., "Matched global rule: PII Protection").'classificationLevel:- type: string+ type: integertitle: classification_level- description: Whether masking was due to classification level.+ format: int32+ description: The classification level that triggered masking.semanticTypeIcon:type: stringtitle: semantic_type_icon@@ -13707,13 +13710,14 @@ components:resource.database_name: the database name.resource.table_name: the table name.resource.column_name: the column name.- resource.classification_level: the classification level.+ resource.classification_level: the classification level (integer).Each variable support following operations:==: the value equals the target.!=: the value not equals the target.in: the value matches one of the targets.!(in): the value not matches any of the targets.+ <, <=, >, >=: numeric comparison (classification_level only).For example:resource.environment_id == "test" && resource.project_id == "sample-project"diff --git a/backend/api/v1/masking_evaluator.go b/backend/api/v1/masking_evaluator.goindex 5b68497d9d..ffdb4778b7 100644--- a/backend/api/v1/masking_evaluator.go+++ b/backend/api/v1/masking_evaluator.go@@ -28,7 +28,7 @@ type MaskingEvaluation struct {MaskingRuleID stringAlgorithm stringContext string- ClassificationLevel string+ ClassificationLevel int32}func newEmptyMaskingLevelEvaluator() *maskingLevelEvaluator {@@ -143,7 +143,7 @@ func (m *maskingLevelEvaluator) evaluateGlobalMaskingLevelOfColumn(common.CELAttributeResourceSchemaName: schemaName,common.CELAttributeResourceTableName: tableName,common.CELAttributeResourceColumnName: columnName,- common.CELAttributeResourceClassificationLevel: classificationLevel,+ common.CELAttributeResourceClassificationLevel: int64(classificationLevel),}if databaseMessage.EffectiveEnvironmentID != nil {maskingRuleAttributes[common.CELAttributeResourceEnvironmentID] = *databaseMessage.EffectiveEnvironmentID@@ -212,20 +212,20 @@ func evaluateExemptionOfColumn(databaseMessage *store.DatabaseMessage, schemaNamreturn false, nil}-func getClassificationLevelOfColumn(columnClassificationID string, classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig) string {+func getClassificationLevelOfColumn(columnClassificationID string, classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig) int32 {if columnClassificationID == "" || classificationConfig == nil {- return ""+ return 0}classification, ok := classificationConfig.Classification[columnClassificationID]if !ok {- return ""+ return 0}- if classification.LevelId == nil {- return ""+ if classification.Level == nil {+ return 0}- return *classification.LevelId+ return *classification.Level}func evaluateMaskingExemptionPolicyCondition(expression *expr.Expr, attributes map[string]any) (bool, error) {diff --git a/backend/api/v1/masking_evaluator_test.go b/backend/api/v1/masking_evaluator_test.goindex 48f524f6b7..4d809bf3aa 100644--- a/backend/api/v1/masking_evaluator_test.go+++ b/backend/api/v1/masking_evaluator_test.go@@ -28,18 +28,18 @@ func TestEvalMaskingLevelOfColumn(t *testing.T) {Id: defaultProjectDatabaseDataClassificationID,Levels: []*storepb.DataClassificationSetting_DataClassificationConfig_Level{{- Id: "S1",+ Level: 1,},{- Id: "S2",+ Level: 2,},},Classification: map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification{"1-1-1": {Id: "1-1-1",Title: "personal",- LevelId: func() *string {- a := "S2"+ Level: func() *int32 {+ a := int32(2)return &a}(),},@@ -83,7 +83,7 @@ func TestEvalMaskingLevelOfColumn(t *testing.T) {want stringwantAlgorithm stringwantContext string- wantClassLevel string+ wantClassLevel int32}{{description: "Follow The Global Masking Rule",@@ -98,7 +98,7 @@ func TestEvalMaskingLevelOfColumn(t *testing.T) {Rules: []*storepb.MaskingRulePolicy_MaskingRule{{// Classification hit.- Condition: &expr.Expr{Expression: `(resource.table_name == "no_table") || (resource.classification_level == "S2")`},+ Condition: &expr.Expr{Expression: `(resource.table_name == "no_table") || (resource.classification_level == 2)`},SemanticType: "default",},},@@ -109,7 +109,7 @@ func TestEvalMaskingLevelOfColumn(t *testing.T) {want: "default",wantAlgorithm: "Full mask",- wantClassLevel: "S2",+ wantClassLevel: 2,},{description: "Respect The Exception",@@ -124,7 +124,7 @@ func TestEvalMaskingLevelOfColumn(t *testing.T) {Rules: []*storepb.MaskingRulePolicy_MaskingRule{{// Classification hit.- Condition: &expr.Expr{Expression: `(resource.table_name == "no_table") || (resource.classification_level == "S2")`},+ Condition: &expr.Expr{Expression: `(resource.table_name == "no_table") || (resource.classification_level == 2)`},SemanticType: "default",},},@@ -177,7 +177,7 @@ func TestEvalMaskingLevelOfColumn(t *testing.T) {if tc.wantContext != "" {a.Equal(tc.wantContext, result.Context, tc.description)}- if tc.wantClassLevel != "" {+ if tc.wantClassLevel != 0 {a.Equal(tc.wantClassLevel, result.ClassificationLevel, tc.description)}}diff --git a/backend/api/v1/setting_service_converter.go b/backend/api/v1/setting_service_converter.goindex 41bb385c34..066bf94b2a 100644--- a/backend/api/v1/setting_service_converter.go+++ b/backend/api/v1/setting_service_converter.go@@ -490,9 +490,9 @@ func convertDataClassificationSettingLevels(levels []*v1pb.DataClassificationSetstoreLevels := make([]*storepb.DataClassificationSetting_DataClassificationConfig_Level, len(levels))for i, level := range levels {storeLevels[i] = &storepb.DataClassificationSetting_DataClassificationConfig_Level{- Id: level.Id,Title: level.Title,Description: level.Description,+ Level: level.Level,}}return storeLevels@@ -509,7 +509,7 @@ func convertDataClassificationSettingClassification(classification map[string]*vId: v.Id,Title: v.Title,Description: v.Description,- LevelId: v.LevelId,+ Level: v.Level,}}return storeClassification@@ -549,9 +549,9 @@ func convertToDataClassificationSettingLevels(levels []*storepb.DataClassificativ1Levels := make([]*v1pb.DataClassificationSetting_DataClassificationConfig_Level, len(levels))for i, level := range levels {v1Levels[i] = &v1pb.DataClassificationSetting_DataClassificationConfig_Level{- Id: level.Id,Title: level.Title,Description: level.Description,+ Level: level.Level,}}return v1Levels@@ -568,7 +568,7 @@ func convertToDataClassificationSettingClassification(classification map[string]Id: v.Id,Title: v.Title,Description: v.Description,- LevelId: v.LevelId,+ Level: v.Level,}}return v1Classificationdiff --git a/backend/common/cel.go b/backend/common/cel.goindex ec12612ca0..178fa2a80e 100644--- a/backend/common/cel.go+++ b/backend/common/cel.go@@ -88,7 +88,7 @@ var MaskingRulePolicyCELAttributes = []cel.EnvOption{cel.Variable(CELAttributeResourceSchemaName, cel.StringType),cel.Variable(CELAttributeResourceTableName, cel.StringType),cel.Variable(CELAttributeResourceColumnName, cel.StringType),- cel.Variable(CELAttributeResourceClassificationLevel, cel.StringType),+ cel.Variable(CELAttributeResourceClassificationLevel, cel.IntType),cel.ParserExpressionSizeLimit(celLimit),}diff --git a/backend/generated-go/store/setting.pb.go b/backend/generated-go/store/setting.pb.goindex 13103dde5b..1183b477b4 100644--- a/backend/generated-go/store/setting.pb.go+++ b/backend/generated-go/store/setting.pb.go@@ -1278,7 +1278,6 @@ type DataClassificationSetting_DataClassificationConfig struct {Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`// levels is user defined level list for classification.- // The order for the level decides its priority.Levels []*DataClassificationSetting_DataClassificationConfig_Level `protobuf:"bytes,3,rep,name=levels,proto3" json:"levels,omitempty"`// classification is the id - DataClassification map.// The id should in [0-9]+-[0-9]+-[0-9]+ format.@@ -1346,10 +1345,11 @@ func (x *DataClassificationSetting_DataClassificationConfig) GetClassification()}type DataClassificationSetting_DataClassificationConfig_Level struct {- state protoimpl.MessageState `protogen:"open.v1"`- Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`- Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`- Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`+ state protoimpl.MessageState `protogen:"open.v1"`+ Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`+ Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`+ // The numeric level for ordering. Higher = more sensitive.+ Level int32 `protobuf:"varint,4,opt,name=level,proto3" json:"level,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -1384,13 +1384,6 @@ func (*DataClassificationSetting_DataClassificationConfig_Level) Descriptor() ([return file_store_setting_proto_rawDescGZIP(), []int{3, 0, 0}}-func (x *DataClassificationSetting_DataClassificationConfig_Level) GetId() string {- if x != nil {- return x.Id- }- return ""-}-func (x *DataClassificationSetting_DataClassificationConfig_Level) GetTitle() string {if x != nil {return x.Title@@ -1405,13 +1398,21 @@ func (x *DataClassificationSetting_DataClassificationConfig_Level) GetDescriptioreturn ""}+func (x *DataClassificationSetting_DataClassificationConfig_Level) GetLevel() int32 {+ if x != nil {+ return x.Level+ }+ return 0+}+type DataClassificationSetting_DataClassificationConfig_DataClassification struct {state protoimpl.MessageState `protogen:"open.v1"`// id is the classification id in [0-9]+-[0-9]+-[0-9]+ format.- Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`- Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`- Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`- LevelId *string `protobuf:"bytes,4,opt,name=level_id,json=levelId,proto3,oneof" json:"level_id,omitempty"`+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`+ Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`+ Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`+ // The sensitivity level. Maps to Level.level.+ Level *int32 `protobuf:"varint,4,opt,name=level,proto3,oneof" json:"level,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -1467,11 +1468,11 @@ func (x *DataClassificationSetting_DataClassificationConfig_DataClassification)return ""}-func (x *DataClassificationSetting_DataClassificationConfig_DataClassification) GetLevelId() string {- if x != nil && x.LevelId != nil {- return *x.LevelId+func (x *DataClassificationSetting_DataClassificationConfig_DataClassification) GetLevel() int32 {+ if x != nil && x.Level != nil {+ return *x.Level}- return ""+ return 0}type Algorithm_FullMask struct {@@ -2457,24 +2458,24 @@ const file_store_setting_proto_rawDesc = "" +"\x0fCREATE_DATABASE\x10\x02\x12\x0f\n" +"\vEXPORT_DATA\x10\x03\x12\x10\n" +"\fREQUEST_ROLE\x10\x04\x12\x12\n" +- "\x0eREQUEST_ACCESS\x10\x05\"\x96\x06\n" ++ "\x0eREQUEST_ACCESS\x10\x05\"\x94\x06\n" +"\x19DataClassificationSetting\x12\\\n" +- "\aconfigs\x18\x01 \x03(\v2B.bytebase.store.DataClassificationSetting.DataClassificationConfigR\aconfigs\x1a\x9a\x05\n" ++ "\aconfigs\x18\x01 \x03(\v2B.bytebase.store.DataClassificationSetting.DataClassificationConfigR\aconfigs\x1a\x98\x05\n" +"\x18DataClassificationConfig\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +"\x05title\x18\x02 \x01(\tR\x05title\x12`\n" +"\x06levels\x18\x03 \x03(\v2H.bytebase.store.DataClassificationSetting.DataClassificationConfig.LevelR\x06levels\x12~\n" +- "\x0eclassification\x18\x04 \x03(\v2V.bytebase.store.DataClassificationSetting.DataClassificationConfig.ClassificationEntryR\x0eclassification\x1aO\n" +- "\x05Level\x12\x0e\n" +- "\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" ++ "\x0eclassification\x18\x04 \x03(\v2V.bytebase.store.DataClassificationSetting.DataClassificationConfig.ClassificationEntryR\x0eclassification\x1aU\n" ++ "\x05Level\x12\x14\n" +"\x05title\x18\x02 \x01(\tR\x05title\x12 \n" +- "\vdescription\x18\x03 \x01(\tR\vdescription\x1a\x89\x01\n" ++ "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x14\n" ++ "\x05level\x18\x04 \x01(\x05R\x05level\x1a\x81\x01\n" +"\x12DataClassification\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +"\x05title\x18\x02 \x01(\tR\x05title\x12 \n" +- "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x1e\n" +- "\blevel_id\x18\x04 \x01(\tH\x00R\alevelId\x88\x01\x01B\v\n" +- "\t_level_id\x1a\x98\x01\n" ++ "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x19\n" ++ "\x05level\x18\x04 \x01(\x05H\x00R\x05level\x88\x01\x01B\b\n" ++ "\x06_level\x1a\x98\x01\n" +"\x13ClassificationEntry\x12\x10\n" +"\x03key\x18\x01 \x01(\tR\x03key\x12k\n" +"\x05value\x18\x02 \x01(\v2U.bytebase.store.DataClassificationSetting.DataClassificationConfig.DataClassificationR\x05value:\x028\x01\"\xa0\x06\n" +diff --git a/backend/generated-go/store/setting_equal.pb.go b/backend/generated-go/store/setting_equal.pb.goindex b45a1be928..0e12934453 100644--- a/backend/generated-go/store/setting_equal.pb.go+++ b/backend/generated-go/store/setting_equal.pb.go@@ -195,15 +195,15 @@ func (x *DataClassificationSetting_DataClassificationConfig_Level) Equal(y *Dataif x == nil || y == nil {return x == nil && y == nil}- if x.Id != y.Id {- return false- }if x.Title != y.Title {return false}if x.Description != y.Description {return false}+ if x.Level != y.Level {+ return false+ }return true}@@ -223,7 +223,7 @@ func (x *DataClassificationSetting_DataClassificationConfig_DataClassification)if x.Description != y.Description {return false}- if p, q := x.LevelId, y.LevelId; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {+ if p, q := x.Level, y.Level; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {return false}return truediff --git a/backend/generated-go/v1/org_policy_service.pb.go b/backend/generated-go/v1/org_policy_service.pb.goindex 52db0aa612..6ad0dbbb36 100644--- a/backend/generated-go/v1/org_policy_service.pb.go+++ b/backend/generated-go/v1/org_policy_service.pb.go@@ -1035,13 +1035,14 @@ type MaskingRulePolicy_MaskingRule struct {// resource.database_name: the database name.// resource.table_name: the table name.// resource.column_name: the column name.- // resource.classification_level: the classification level.+ // resource.classification_level: the classification level (integer).//// Each variable support following operations:// ==: the value equals the target.// !=: the value not equals the target.// in: the value matches one of the targets.// !(in): the value not matches any of the targets.+ // <, <=, >, >=: numeric comparison (classification_level only).//// For example:// resource.environment_id == "test" && resource.project_id == "sample-project"diff --git a/backend/generated-go/v1/setting_service.pb.go b/backend/generated-go/v1/setting_service.pb.goindex 4d6dbc92dd..97ae59567f 100644--- a/backend/generated-go/v1/setting_service.pb.go+++ b/backend/generated-go/v1/setting_service.pb.go@@ -2207,7 +2207,6 @@ type DataClassificationSetting_DataClassificationConfig struct {Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`// levels is user defined level list for classification.- // The order for the level decides its priority.Levels []*DataClassificationSetting_DataClassificationConfig_Level `protobuf:"bytes,3,rep,name=levels,proto3" json:"levels,omitempty"`// classification is the id - DataClassification map.// The id should in [0-9]+-[0-9]+-[0-9]+ format.@@ -2275,10 +2274,11 @@ func (x *DataClassificationSetting_DataClassificationConfig) GetClassification()}type DataClassificationSetting_DataClassificationConfig_Level struct {- state protoimpl.MessageState `protogen:"open.v1"`- Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`- Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`- Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`+ state protoimpl.MessageState `protogen:"open.v1"`+ Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`+ Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`+ // The numeric level for ordering. Higher = more sensitive.+ Level int32 `protobuf:"varint,4,opt,name=level,proto3" json:"level,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -2313,13 +2313,6 @@ func (*DataClassificationSetting_DataClassificationConfig_Level) Descriptor() ([return file_v1_setting_service_proto_rawDescGZIP(), []int{11, 0, 0}}-func (x *DataClassificationSetting_DataClassificationConfig_Level) GetId() string {- if x != nil {- return x.Id- }- return ""-}-func (x *DataClassificationSetting_DataClassificationConfig_Level) GetTitle() string {if x != nil {return x.Title@@ -2334,13 +2327,21 @@ func (x *DataClassificationSetting_DataClassificationConfig_Level) GetDescriptioreturn ""}+func (x *DataClassificationSetting_DataClassificationConfig_Level) GetLevel() int32 {+ if x != nil {+ return x.Level+ }+ return 0+}+type DataClassificationSetting_DataClassificationConfig_DataClassification struct {state protoimpl.MessageState `protogen:"open.v1"`// id is the classification id in [0-9]+-[0-9]+-[0-9]+ format.- Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`- Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`- Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`- LevelId *string `protobuf:"bytes,4,opt,name=level_id,json=levelId,proto3,oneof" json:"level_id,omitempty"`+ Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`+ Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`+ Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`+ // The sensitivity level. Maps to Level.level.+ Level *int32 `protobuf:"varint,4,opt,name=level,proto3,oneof" json:"level,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -2396,11 +2397,11 @@ func (x *DataClassificationSetting_DataClassificationConfig_DataClassification)return ""}-func (x *DataClassificationSetting_DataClassificationConfig_DataClassification) GetLevelId() string {- if x != nil && x.LevelId != nil {- return *x.LevelId+func (x *DataClassificationSetting_DataClassificationConfig_DataClassification) GetLevel() int32 {+ if x != nil && x.Level != nil {+ return *x.Level}- return ""+ return 0}type SemanticTypeSetting_SemanticType struct {@@ -2968,24 +2969,24 @@ const file_v1_setting_service_proto_rawDesc = "" +"\x0fCREATE_DATABASE\x10\x02\x12\x0f\n" +"\vEXPORT_DATA\x10\x03\x12\x10\n" +"\fREQUEST_ROLE\x10\x04\x12\x12\n" +- "\x0eREQUEST_ACCESS\x10\x05\"\x8a\x06\n" ++ "\x0eREQUEST_ACCESS\x10\x05\"\x88\x06\n" +"\x19DataClassificationSetting\x12Y\n" +- "\aconfigs\x18\x01 \x03(\v2?.bytebase.v1.DataClassificationSetting.DataClassificationConfigR\aconfigs\x1a\x91\x05\n" ++ "\aconfigs\x18\x01 \x03(\v2?.bytebase.v1.DataClassificationSetting.DataClassificationConfigR\aconfigs\x1a\x8f\x05\n" +"\x18DataClassificationConfig\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +"\x05title\x18\x02 \x01(\tR\x05title\x12]\n" +"\x06levels\x18\x03 \x03(\v2E.bytebase.v1.DataClassificationSetting.DataClassificationConfig.LevelR\x06levels\x12{\n" +- "\x0eclassification\x18\x04 \x03(\v2S.bytebase.v1.DataClassificationSetting.DataClassificationConfig.ClassificationEntryR\x0eclassification\x1aO\n" +- "\x05Level\x12\x0e\n" +- "\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" ++ "\x0eclassification\x18\x04 \x03(\v2S.bytebase.v1.DataClassificationSetting.DataClassificationConfig.ClassificationEntryR\x0eclassification\x1aU\n" ++ "\x05Level\x12\x14\n" +"\x05title\x18\x02 \x01(\tR\x05title\x12 \n" +- "\vdescription\x18\x03 \x01(\tR\vdescription\x1a\x89\x01\n" ++ "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x14\n" ++ "\x05level\x18\x04 \x01(\x05R\x05level\x1a\x81\x01\n" +"\x12DataClassification\x12\x0e\n" +"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +"\x05title\x18\x02 \x01(\tR\x05title\x12 \n" +- "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x1e\n" +- "\blevel_id\x18\x04 \x01(\tH\x00R\alevelId\x88\x01\x01B\v\n" +- "\t_level_id\x1a\x95\x01\n" ++ "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x19\n" ++ "\x05level\x18\x04 \x01(\x05H\x00R\x05level\x88\x01\x01B\b\n" ++ "\x06_level\x1a\x95\x01\n" +"\x13ClassificationEntry\x12\x10\n" +"\x03key\x18\x01 \x01(\tR\x03key\x12h\n" +"\x05value\x18\x02 \x01(\v2R.bytebase.v1.DataClassificationSetting.DataClassificationConfig.DataClassificationR\x05value:\x028\x01\"\xfd\x01\n" +diff --git a/backend/generated-go/v1/setting_service_equal.pb.go b/backend/generated-go/v1/setting_service_equal.pb.goindex fc4353a0a3..85ae340f7d 100644--- a/backend/generated-go/v1/setting_service_equal.pb.go+++ b/backend/generated-go/v1/setting_service_equal.pb.go@@ -461,15 +461,15 @@ func (x *DataClassificationSetting_DataClassificationConfig_Level) Equal(y *Dataif x == nil || y == nil {return x == nil && y == nil}- if x.Id != y.Id {- return false- }if x.Title != y.Title {return false}if x.Description != y.Description {return false}+ if x.Level != y.Level {+ return false+ }return true}@@ -489,7 +489,7 @@ func (x *DataClassificationSetting_DataClassificationConfig_DataClassification)if x.Description != y.Description {return false}- if p, q := x.LevelId, y.LevelId; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {+ if p, q := x.Level, y.Level; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {return false}return truediff --git a/backend/generated-go/v1/sql_service.pb.go b/backend/generated-go/v1/sql_service.pb.goindex ced29ea4c4..b7d33fa388 100644--- a/backend/generated-go/v1/sql_service.pb.go+++ b/backend/generated-go/v1/sql_service.pb.go@@ -960,8 +960,8 @@ type MaskingReason struct {Algorithm string `protobuf:"bytes,4,opt,name=algorithm,proto3" json:"algorithm,omitempty"`// Additional context (e.g., "Matched global rule: PII Protection").Context string `protobuf:"bytes,5,opt,name=context,proto3" json:"context,omitempty"`- // Whether masking was due to classification level.- ClassificationLevel string `protobuf:"bytes,6,opt,name=classification_level,json=classificationLevel,proto3" json:"classification_level,omitempty"`+ // The classification level that triggered masking.+ ClassificationLevel int32 `protobuf:"varint,6,opt,name=classification_level,json=classificationLevel,proto3" json:"classification_level,omitempty"`// Icon associated with the semantic type (if any).SemanticTypeIcon string `protobuf:"bytes,7,opt,name=semantic_type_icon,json=semanticTypeIcon,proto3" json:"semantic_type_icon,omitempty"`unknownFields protoimpl.UnknownFields@@ -1033,11 +1033,11 @@ func (x *MaskingReason) GetContext() string {return ""}-func (x *MaskingReason) GetClassificationLevel() string {+func (x *MaskingReason) GetClassificationLevel() int32 {if x != nil {return x.ClassificationLevel}- return ""+ return 0}func (x *MaskingReason) GetSemanticTypeIcon() string {@@ -2801,7 +2801,7 @@ const file_v1_sql_service_proto_rawDesc = "" +"\x0fmasking_rule_id\x18\x03 \x01(\tR\rmaskingRuleId\x12\x1c\n" +"\talgorithm\x18\x04 \x01(\tR\talgorithm\x12\x18\n" +"\acontext\x18\x05 \x01(\tR\acontext\x121\n" +- "\x14classification_level\x18\x06 \x01(\tR\x13classificationLevel\x12,\n" ++ "\x14classification_level\x18\x06 \x01(\x05R\x13classificationLevel\x12,\n" +"\x12semantic_type_icon\x18\a \x01(\tR\x10semanticTypeIcon\"9\n" +"\bQueryRow\x12-\n" +"\x06values\x18\x01 \x03(\v2\x15.bytebase.v1.RowValueR\x06values\"\xf9\x06\n" +diff --git a/backend/migrator/migration/3.17/0012##classification_level_to_int.sql b/backend/migrator/migration/3.17/0012##classification_level_to_int.sqlnew file mode 100644index 0000000000..737ad9599e--- /dev/null+++ b/backend/migrator/migration/3.17/0012##classification_level_to_int.sql@@ -0,0 +1,163 @@+-- Migration: Convert classification level from string to int.+--+-- 1. Build a temp mapping from old string level IDs to new integer levels (array index + 1).+-- 2. Migrate DATA_CLASSIFICATION setting: remove id from levels, add level (int).+-- Convert classification levelId (string) to level (int).+-- 3. Migrate MASKING_RULE policy CEL expressions: replace string level IDs with integers+-- using the mapping from step 1.++-- Step 1: Build level_id -> level_number mapping from existing classification configs.+-- Each workspace may have its own classification config with its own level IDs.+CREATE TEMPORARY TABLE _level_id_map (+ workspace TEXT,+ old_level_id TEXT,+ new_level INT+);++INSERT INTO _level_id_map (workspace, old_level_id, new_level)+SELECT+ s.workspace,+ lv.val->>'id' AS old_level_id,+ lv.pos::int AS new_level+FROM setting s,+ jsonb_array_elements(s.value->'configs') AS config,+ LATERAL (+ SELECT e.value AS val, e.ordinality AS pos+ FROM jsonb_array_elements(config->'levels') WITH ORDINALITY AS e(value, ordinality)+ ) lv+WHERE s.name = 'DATA_CLASSIFICATION'+ AND s.value->'configs' IS NOT NULL;++-- Step 2: Migrate DATA_CLASSIFICATION setting.+UPDATE setting+SET value = (+ SELECT jsonb_set(+ value,+ '{configs}',+ (+ SELECT COALESCE(jsonb_agg(+ jsonb_set(+ jsonb_set(+ config,+ '{levels}',+ (+ SELECT COALESCE(jsonb_agg(+ jsonb_build_object(+ 'title', lv.val->>'title',+ 'description', COALESCE(lv.val->>'description', ''),+ 'level', lv.pos::int+ )+ ORDER BY lv.pos), '[]'::jsonb)+ FROM (+ SELECT e.value AS val, e.ordinality AS pos+ FROM jsonb_array_elements(config->'levels') WITH ORDINALITY AS e(value, ordinality)+ ) lv+ )+ ),+ '{classification}',+ (+ SELECT COALESCE(jsonb_object_agg(+ key,+ CASE+ WHEN cls_value ? 'levelId' THEN+ (cls_value - 'levelId') || jsonb_build_object(+ 'level',+ (+ SELECT lr.pos::int+ FROM (+ SELECT e.value->>'id' AS level_id, e.ordinality AS pos+ FROM jsonb_array_elements(config->'levels') WITH ORDINALITY AS e(value, ordinality)+ ) lr+ WHERE lr.level_id = cls_value->>'levelId'+ )+ )+ ELSE cls_value+ END+ ), '{}'::jsonb)+ FROM jsonb_each(config->'classification') AS cls(key, cls_value)+ )+ )+ ), '[]'::jsonb)+ FROM jsonb_array_elements(value->'configs') AS config+ )+ )+)+WHERE name = 'DATA_CLASSIFICATION'+ AND value->'configs' IS NOT NULL;++-- Step 3: Migrate MASKING_RULE policy CEL expressions using the level_id -> int mapping.+-- Uses a PL/pgSQL block to iterate over each masking rule and replace each old string+-- level ID with its numeric equivalent using the temp mapping table.+-- Replaces exact patterns like:+-- classification_level == "old_id" -> classification_level == 1+-- classification_level != "old_id" -> classification_level != 1+-- classification_level in ["a", "b"] -> classification_level in [1, 2]+-- Non-classification predicates (e.g. resource.table_name == "2024") are untouched.+DO $$+DECLARE+ pol RECORD;+ rule_val JSONB;+ expr_text TEXT;+ new_expr TEXT;+ mapping RECORD;+ new_rules JSONB;+ rules_changed BOOLEAN;+ new_level_str TEXT;+BEGIN+ FOR pol IN+ SELECT ctid, payload, workspace+ FROM policy+ WHERE type = 'MASKING_RULE'+ AND payload->'rules' IS NOT NULL+ AND payload::text LIKE '%classification_level%'+ LOOP+ new_rules := '[]'::jsonb;+ rules_changed := false;++ FOR rule_val IN SELECT jsonb_array_elements(pol.payload->'rules')+ LOOP+ expr_text := rule_val->'condition'->>'expression';++ IF expr_text IS NOT NULL AND expr_text ~ 'classification_level' THEN+ new_expr := expr_text;+ new_level_str := '';++ -- For each known level ID, replace exact classification_level patterns.+ -- Process longest IDs first to avoid partial matches (e.g. "S2" before "S").+ FOR mapping IN+ SELECT old_level_id, new_level+ FROM _level_id_map+ WHERE workspace = pol.workspace+ ORDER BY length(old_level_id) DESC+ LOOP+ new_level_str := mapping.new_level::text;+ -- Replace classification_level == "old_id"+ new_expr := replace(new_expr, 'classification_level == "' || mapping.old_level_id || '"', 'classification_level == ' || new_level_str);+ -- Replace classification_level != "old_id"+ new_expr := replace(new_expr, 'classification_level != "' || mapping.old_level_id || '"', 'classification_level != ' || new_level_str);+ -- Replace "old_id" inside in [...] lists.+ -- This is safe because these are scoped: the full pattern+ -- classification_level in ["old_id", ...] only appears in+ -- classification_level expressions, and "old_id" is a known+ -- level ID that we're replacing with its exact numeric equivalent.+ new_expr := replace(new_expr, '"' || mapping.old_level_id || '"', new_level_str);+ END LOOP;++ IF new_expr IS DISTINCT FROM expr_text THEN+ rule_val := jsonb_set(rule_val, '{condition,expression}', to_jsonb(new_expr));+ rules_changed := true;+ END IF;+ END IF;++ new_rules := new_rules || jsonb_build_array(rule_val);+ END LOOP;++ IF rules_changed THEN+ UPDATE policy+ SET payload = jsonb_set(pol.payload, '{rules}', new_rules)+ WHERE ctid = pol.ctid;+ END IF;+ END LOOP;+END $$;++DROP TABLE _level_id_map;diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.goindex e0b8e7ef6c..0c709cbcfe 100644--- a/backend/migrator/migrator_test.go+++ b/backend/migrator/migrator_test.go@@ -15,8 +15,8 @@ import (func TestLatestVersion(t *testing.T) {files, err := getSortedVersionedFiles()require.NoError(t, err)- require.Equal(t, semver.MustParse("3.17.11"), *files[len(files)-1].version)- require.Equal(t, "migration/3.17/0011##idp_nullable_workspace.sql", files[len(files)-1].path)+ require.Equal(t, semver.MustParse("3.17.12"), *files[len(files)-1].version)+ require.Equal(t, "migration/3.17/0012##classification_level_to_int.sql", files[len(files)-1].path)}func TestVersionUnique(t *testing.T) {diff --git a/docs/superpowers/plans/2026-03-25-classification-level-to-int.md b/docs/superpowers/plans/2026-03-25-classification-level-to-int.mdnew file mode 100644index 0000000000..74af91c1f9--- /dev/null+++ b/docs/superpowers/plans/2026-03-25-classification-level-to-int.md@@ -0,0 +1,732 @@+# Classification Level: String to Int Migration++> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.++**Goal:** Replace the opaque string `level_id` on `DataClassification` with an explicit numeric `level` (int32) to enable ordered comparisons like `resource.classification_level <= 3` in CEL expressions for masking rules and exemptions.++**Architecture:** Change proto field `DataClassification.level_id` (string) to `DataClassification.level` (int32). Add `level` field (int32) to `Level` message for explicit ordering. Change the CEL variable `resource.classification_level` from `StringType` to `IntType`. Write a SQL migration to convert stored JSONB data (classification configs and CEL expressions). Update frontend to treat classification level as a number.++**Tech Stack:** Protobuf, Go (CEL, protojson), PostgreSQL (JSONB migration), TypeScript/Vue++---++## File Structure++### Proto (source of truth)+- Modify: `proto/store/store/setting.proto` — `Level` add `level` (int32), `DataClassification` change `level_id` to `level`+- Modify: `proto/v1/v1/setting_service.proto` — mirror same changes+- Modify: `proto/v1/v1/sql_service.proto` — `classification_level` field type string to int32+- Modify: `proto/v1/v1/org_policy_service.proto:356` — update comment to document numeric operators++### Backend+- Modify: `backend/common/cel.go:91` — change `cel.StringType` to `cel.IntType` for classification level+- Modify: `backend/api/v1/masking_evaluator.go:31,136,146,167,183,215-229` — `ClassificationLevel` becomes `int32`, `getClassificationLevelOfColumn` returns int+- Modify: `backend/api/v1/masking_evaluator_test.go` — update test data and expectations+- Modify: `backend/api/v1/query_result_masker.go:389,405` — adapt ClassificationLevel type+- Modify: `backend/api/v1/setting_service_converter.go:512,551-555,571` — `LevelId` → `Level`, add `Level` field to level converter++### Database Migration+- Create: `backend/migrator/migration/3.17/0012##classification_level_to_int.sql` — migrate stored JSONB++### Frontend+- Modify: `frontend/src/plugins/cel/types/factor.ts:55` — move `classification_level` from `StringFactorList` to `NumberFactorList`+- Modify: `frontend/src/plugins/cel/types/operator.ts:139-141` — change to equality + compare operators+- Modify: `frontend/src/components/SensitiveData/components/ClassificationLevelBadge.vue:50-54` — use level directly instead of findIndex+- Modify: `frontend/src/components/SensitiveData/components/ClassificationTree.vue:52,60,124,149` — `levelId` becomes `level` (number)+- Modify: `frontend/src/components/SensitiveData/components/utils.ts:20-23` — level options use level number as value+- Modify: `frontend/src/components/SensitiveData/classification-example.json` — update to use numeric `level`+- Modify: `frontend/src/views/sql-editor/EditorCommon/ResultView/DataTable/common/MaskingReasonPopover.vue:46-50` — display int level++### Demo Data+- Modify: `backend/demo/data/dump.sql` — update classification configs and masking rule CEL expressions++---++## Task 1: Proto Changes++**Files:**+- Modify: `proto/store/store/setting.proto:173-188`+- Modify: `proto/v1/v1/setting_service.proto:327-342`+- Modify: `proto/v1/v1/sql_service.proto:300-301`++- [ ] **Step 1: Update store proto**++In `proto/store/store/setting.proto`, change:++```protobuf+message Level {+ string title = 2;+ string description = 3;+ // The numeric level for ordering. Higher = more sensitive.+ int32 level = 4;+}++// ...++message DataClassification {+ string id = 1;+ string title = 2;+ string description = 3;+ // The sensitivity level. Maps to Level.level.+ optional int32 level = 4;+}+```++Note: `Level.id` (field 1) is removed. The `level` int is now the sole identifier. The `levels` array uses `level` as the key for lookups.++Key: field number 4 is reused but type changes from `string` to `int32`. This is a wire-incompatible change but the data is stored as JSON (protojson), not wire proto, so the migration handles it.++- [ ] **Step 2: Update v1 API proto**++Mirror identical changes in `proto/v1/v1/setting_service.proto`.++- [ ] **Step 3: Update sql_service.proto**++In `proto/v1/v1/sql_service.proto`, change `classification_level` from string to int32:++```protobuf+// The classification level that triggered masking.+int32 classification_level = 6;+```++- [ ] **Step 4: Update org_policy_service.proto comment**++In `proto/v1/v1/org_policy_service.proto`, update the `MaskingRule.condition` comment at line 356 to document that `resource.classification_level` is now an integer and supports numeric comparison operators (`<`, `<=`, `>`, `>=`) in addition to `==`, `!=`, `in`, `!(in)`.++- [ ] **Step 5: Format and lint protos**++Run:+```bash+buf format -w proto+buf lint proto+```+Expected: clean output.++- [ ] **Step 6: Generate code from protos**++Run:+```bash+cd proto && buf generate+```+Expected: regenerated Go and TypeScript files.++- [ ] **Step 7: Commit**++```bash+git add proto/ backend/generated-go/ frontend/src/types/proto-es/ backend/api/mcp/gen/+git commit -m "proto: change classification level from string to int32++Add level field (int32) to Level for explicit ordering. Change+DataClassification.level_id (string) to level (int32).+Change sql_service classification_level to int32."+```++---++## Task 2: Database Migration++**Files:**+- Create: `backend/migrator/migration/3.17/0012##classification_level_to_int.sql`+- Modify: `backend/migrator/migrator_test.go` (update `TestLatestVersion` if needed)++The migration must update two types of stored JSONB:++1. **Classification configs** in the `setting` table (`name = 'DATA_CLASSIFICATION'`): convert `"levelId": "2"` to `"level": 2` in each classification entry, and add `"level"` (int) to each level entry based on array position.+2. **Masking rule CEL expressions** in the `policy` table (`type = 'MASKING_RULE'`): convert string comparisons like `resource.classification_level in ["2", "3"]` to integer comparisons like `resource.classification_level in [2, 3]`.+3. **Audit log** entries in `audit_log` table: these contain historical CEL expressions in `payload` JSONB. Leave audit logs unchanged — they are historical records.++- [ ] **Step 1: Write the migration SQL**++Create `backend/migrator/migration/3.17/0012##classification_level_to_int.sql`:++```sql+-- Migration: Convert classification level from string to int+--+-- 1. In DATA_CLASSIFICATION setting: convert levelId (string) to level (int) in classifications,+-- add level (int) to levels based on array position.+-- 2. In MASKING_RULE policies: convert string classification_level values in CEL expressions to integers.++-- Step 1: Migrate DATA_CLASSIFICATION setting+-- Add level (int) to each level based on array position, convert levelId to level in classifications+UPDATE setting+SET value = (+ SELECT jsonb_set(+ value,+ '{configs}',+ (+ SELECT COALESCE(jsonb_agg(+ jsonb_set(+ -- First: replace levels array — remove id, add level (int) based on position+ jsonb_set(+ config,+ '{levels}',+ (+ SELECT COALESCE(jsonb_agg(+ jsonb_build_object(+ 'title', level_row.level->>'title',+ 'description', level_row.level->>'description',+ 'level', (level_row.rn)::int+ )+ ORDER BY level_row.rn), '[]'::jsonb)+ FROM (+ SELECT elem AS level, ordinality AS rn+ FROM jsonb_array_elements(config->'levels') WITH ORDINALITY AS elem+ ) level_row+ )+ ),+ -- Second: convert levelId (string) to level (int) in classifications+ -- Look up the old level id's array position to get the new numeric level+ '{classification}',+ (+ SELECT COALESCE(jsonb_object_agg(+ key,+ CASE+ WHEN cls_value ? 'levelId' THEN+ (cls_value - 'levelId') || jsonb_build_object(+ 'level',+ (+ SELECT (level_row.rn)::int+ FROM (+ SELECT elem->>'id' AS level_id, ordinality AS rn+ FROM jsonb_array_elements(config->'levels') WITH ORDINALITY AS elem+ ) level_row+ WHERE level_row.level_id = cls_value->>'levelId'+ )+ )+ ELSE cls_value+ END+ ), '{}'::jsonb)+ FROM jsonb_each(config->'classification') AS cls(key, cls_value)+ )+ )+ ), '[]'::jsonb)+ FROM jsonb_array_elements(value->'configs') AS config+ )+ )+)+WHERE name = 'DATA_CLASSIFICATION'+ AND value->'configs' IS NOT NULL;++-- Step 2: Migrate MASKING_RULE policy CEL expressions+-- Convert string classification_level values to integers in CEL expressions.+-- Handles patterns:+-- classification_level == "N" -> classification_level == N+-- classification_level in ["N", "M"] -> classification_level in [N, M]+-- classification_level != "N" -> classification_level != N+--+-- Uses a two-pass approach to avoid affecting non-classification string values:+-- Pass 1: Convert equality/inequality patterns: classification_level == "N" or != "N"+-- Pass 2: Convert collection patterns: within [...] blocks that follow classification_level+UPDATE policy+SET payload = (+ SELECT jsonb_set(+ payload,+ '{rules}',+ (+ SELECT COALESCE(jsonb_agg(+ CASE+ WHEN rule->'condition'->>'expression' ~ 'classification_level'+ THEN jsonb_set(+ rule,+ '{condition,expression}',+ to_jsonb(+ -- Pass 2: Convert quoted numbers inside in [...] after classification_level+ regexp_replace(+ -- Pass 1: Convert classification_level == "N" and != "N"+ regexp_replace(+ rule->'condition'->>'expression',+ 'classification_level\s*(==|!=)\s*"(\d+)"',+ 'classification_level \1 \2',+ 'g'+ ),+ -- For "in" expressions, replace quoted digits within brackets+ -- This targets the specific pattern: classification_level in [...]+ 'classification_level\s+in\s+\[([^\]]+)\]',+ -- Use a function-style replacement to strip quotes from numbers in the bracket content+ 'classification_level in [\1]',+ 'g'+ )+ )+ )+ ELSE rule+ END+ ), '[]'::jsonb)+ FROM jsonb_array_elements(payload->'rules') AS rule+ )+ )+)+WHERE type = 'MASKING_RULE'+ AND payload->'rules' IS NOT NULL+ AND payload::text LIKE '%classification_level%';++-- Step 2b: Clean up quoted numbers inside classification_level in [...] brackets+-- The above regex preserves the bracket content as-is; now strip quotes from digits inside.+-- This runs as a separate pass because PostgreSQL regex doesn't support lookahead well.+UPDATE policy+SET payload = (+ SELECT jsonb_set(+ payload,+ '{rules}',+ (+ SELECT COALESCE(jsonb_agg(+ CASE+ WHEN rule->'condition'->>'expression' ~ 'classification_level\s+in'+ THEN jsonb_set(+ rule,+ '{condition,expression}',+ to_jsonb(+ regexp_replace(+ rule->'condition'->>'expression',+ '"(\d+)"',+ '\1',+ 'g'+ )+ )+ )+ ELSE rule+ END+ ), '[]'::jsonb)+ FROM jsonb_array_elements(payload->'rules') AS rule+ )+ )+)+WHERE type = 'MASKING_RULE'+ AND payload->'rules' IS NOT NULL+ AND payload::text LIKE '%classification_level%';+```++**Note on CEL migration safety**: The equality/inequality pass (`== "N"`, `!= "N"`) is tightly scoped to patterns immediately following `classification_level`. The `in [...]` pass is applied only to rules whose expression contains `classification_level in` — these rules are specifically classification-level rules where all bracket values are level IDs. If a rule mixes `classification_level in [...]` with other string conditions containing quoted digits (e.g., `&& resource.instance_id == "12345"`), the second pass would incorrectly unquote those. In practice this is unlikely since classification_level rules are typically standalone, but the implementer should verify against production data.++- [ ] **Step 2: Update LATEST.sql if needed**++No DDL changes are needed in LATEST.sql — the setting and policy tables are unchanged. The migration only transforms JSONB content.++- [ ] **Step 3: Run the migration test**++Check if `TestLatestVersion` needs updating. The test typically validates migration file count:++```bash+go test -v -count=1 github.com/bytebase/bytebase/backend/migrator -run ^TestLatestVersion$+```++- [ ] **Step 4: Commit**++```bash+git add backend/migrator/+git commit -m "migration: convert classification level from string to int++Migrate DATA_CLASSIFICATION setting to use numeric level.+Migrate MASKING_RULE policy CEL expressions from string to int comparisons."+```++---++## Task 3: Backend Go Changes++**Files:**+- Modify: `backend/common/cel.go:91`+- Modify: `backend/api/v1/masking_evaluator.go:31,136,146,167,183,215-229`+- Modify: `backend/api/v1/masking_evaluator_test.go`+- Modify: `backend/api/v1/query_result_masker.go:389,405`+- Modify: `backend/api/v1/audit.go:629`+- Modify: `backend/api/v1/setting_service_converter.go:512,551-555,571`++- [ ] **Step 1: Change CEL type from StringType to IntType**++In `backend/common/cel.go`, line 91, change:++```go+// Before:+cel.Variable(CELAttributeResourceClassificationLevel, cel.StringType),++// After:+cel.Variable(CELAttributeResourceClassificationLevel, cel.IntType),+```++- [ ] **Step 2: Update MaskingEvaluation struct**++In `backend/api/v1/masking_evaluator.go`, change `ClassificationLevel` from `string` to `int32`:++```go+type MaskingEvaluation struct {+ SemanticTypeID string+ SemanticTypeTitle string+ SemanticTypeIcon string+ MaskingRuleID string+ Algorithm string+ Context string+ ClassificationLevel int32+}+```++- [ ] **Step 3: Update getClassificationLevelOfColumn**++In `backend/api/v1/masking_evaluator.go`, change the function to return `int32`:++```go+func getClassificationLevelOfColumn(columnClassificationID string, classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig) int32 {+ if columnClassificationID == "" || classificationConfig == nil {+ return 0+ }++ classification, ok := classificationConfig.Classification[columnClassificationID]+ if !ok {+ return 0+ }+ if classification.Level == nil {+ return 0+ }++ return *classification.Level+}+```++**Edge case note:** Columns with no classification return `0`. A CEL rule like `resource.classification_level <= 3` will match unclassified columns (0 <= 3). This is acceptable — unclassified columns should be treated as having the lowest sensitivity, and masking rules that target `level >= N` (where N >= 1) will correctly exclude them.++- [ ] **Step 4: Update CEL attribute value in evaluateGlobalMaskingLevelOfColumn**++In `backend/api/v1/masking_evaluator.go`, line 146, the classification level is already assigned to `classificationLevel` variable. The type change flows through automatically since CEL handles `int64` for `IntType`. Ensure the map value is `int64`:++```go+common.CELAttributeResourceClassificationLevel: int64(classificationLevel),+```++- [ ] **Step 5: Update query_result_masker.go**++In `backend/api/v1/query_result_masker.go`, lines 389 and 405: these assign `reason.ClassificationLevel` to the v1pb response struct. After proto regeneration, `ClassificationLevel` in the v1pb struct becomes `int32`, so this should type-check automatically. Verify after build.++- [ ] **Step 6: Update audit.go**++In `backend/api/v1/audit.go`, line 629: same as above — `reason.ClassificationLevel` flows to the response struct. Verify after build.++- [ ] **Step 7: Update setting_service_converter.go**++In `backend/api/v1/setting_service_converter.go`:++1. Lines 512 and 571: change `LevelId: v.LevelId` to `Level: v.Level` in both `convertToStoreDataClassificationSettingClassification` and `convertToDataClassificationSettingClassification`.++2. Lines 551-555: add `Level` field to the level converter `convertToDataClassificationSettingLevels`:++```go+v1Levels[i] = &v1pb.DataClassificationSetting_DataClassificationConfig_Level{+ Title: level.Title,+ Description: level.Description,+ Level: level.Level,+}+```++And the store-direction converter similarly needs `Level`.++- [ ] **Step 8: Update masking_evaluator_test.go**++Update test data to use `int32` `Level` field instead of `string` `LevelId`:++```go+defaultClassification := &storepb.DataClassificationSetting{+ Configs: []*storepb.DataClassificationSetting_DataClassificationConfig{+ {+ Id: defaultProjectDatabaseDataClassificationID,+ Levels: []*storepb.DataClassificationSetting_DataClassificationConfig_Level{+ {Level: 1},+ {Level: 2},+ },+ Classification: map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification{+ "1-1-1": {+ Id: "1-1-1",+ Title: "personal",+ Level: func() *int32 {+ a := int32(2)+ return &a+ }(),+ },+ },+ },+ },+}+```++Update CEL expressions in test cases from string to int:++```go+// Before:+Condition: &expr.Expr{Expression: `(resource.table_name == "no_table") || (resource.classification_level == "S2")`},++// After:+Condition: &expr.Expr{Expression: `(resource.table_name == "no_table") || (resource.classification_level == 2)`},+```++Update `wantClassLevel` from `string` to `int32`:++```go+// Before:+wantClassLevel string+// ...+wantClassLevel: "S2",++// After:+wantClassLevel int32+// ...+wantClassLevel: 2,+```++Update assertion:++```go+// Before:+a.Equal(tc.wantClassLevel, result.ClassificationLevel, tc.description)++// After:+a.Equal(tc.wantClassLevel, result.ClassificationLevel, tc.description)+// (same call, types just change)+```++- [ ] **Step 9: Build and test**++```bash+go build -ldflags "-w -s" -p=16 -o ./bytebase-build/bytebase ./backend/bin/server/main.go+go test -v -count=1 github.com/bytebase/bytebase/backend/api/v1 -run ^TestEvalMaskingLevelOfColumn$+```++- [ ] **Step 10: Lint**++```bash+golangci-lint run --allow-parallel-runners+```++Run repeatedly until no issues.++- [ ] **Step 11: Commit**++```bash+git add backend/+git commit -m "backend: change classification level from string to int32++Update CEL environment, masking evaluator, and tests to use+numeric classification levels for ordered comparisons."+```++---++## Task 4: Frontend Changes++**Files:**+- Modify: `frontend/src/plugins/cel/types/factor.ts:55`+- Modify: `frontend/src/plugins/cel/types/operator.ts:139-141`+- Modify: `frontend/src/components/SensitiveData/components/ClassificationLevelBadge.vue:50-54`+- Modify: `frontend/src/components/SensitiveData/components/ClassificationTree.vue:52,60,124,149`+- Modify: `frontend/src/components/SensitiveData/components/utils.ts:20-23`+- Modify: `frontend/src/components/SensitiveData/classification-example.json`+- Modify: `frontend/src/views/sql-editor/EditorCommon/ResultView/DataTable/common/MaskingReasonPopover.vue:46-50`++- [ ] **Step 1: Move classification_level to NumberFactorList**++In `frontend/src/plugins/cel/types/factor.ts`:++Remove `CEL_ATTRIBUTE_RESOURCE_CLASSIFICATION_LEVEL` from `StringFactorList` (line 55).++Add it to `NumberFactorList`:++```typescript+export const NumberFactorList = [+ // Risk related factors+ CEL_ATTRIBUTE_STATEMENT_AFFECTED_ROWS,+ CEL_ATTRIBUTE_STATEMENT_TABLE_ROWS,++ // Request query/export factors+ CEL_ATTRIBUTE_REQUEST_EXPIRATION_DAYS,++ // Masking rule+ CEL_ATTRIBUTE_RESOURCE_CLASSIFICATION_LEVEL,+] as const;+```++- [ ] **Step 2: Update operators for classification_level**++In `frontend/src/plugins/cel/types/operator.ts`, change classification level operators to support numeric comparisons:++```typescript+[CEL_ATTRIBUTE_RESOURCE_CLASSIFICATION_LEVEL]: uniq([+ ...EqualityOperatorList,+ ...CompareOperatorList,+ ...CollectionOperatorList,+]),+```++This enables `==`, `!=`, `<`, `<=`, `>`, `>=`, `@in`, `@not_in` — supporting expressions like `resource.classification_level <= 3`.++- [ ] **Step 3: Update classification-example.json**++```json+{+ "title": "Classification Example",+ "levels": [+ { "title": "Level 1", "description": "", "level": 1 },+ { "title": "Level 2", "description": "", "level": 2 },+ { "title": "Level 3", "description": "", "level": 3 },+ { "title": "Level 4", "description": "", "level": 4 }+ ],+ "classification": {+ "1": { "id": "1", "title": "Basic", "description": "" },+ "1-1": { "id": "1-1", "title": "Basic", "description": "", "level": 1 },+ "1-2": { "id": "1-2", "title": "Contact", "description": "", "level": 2 },+ "1-3": { "id": "1-3", "title": "Health", "description": "", "level": 4 },+ "2": { "id": "2", "title": "Relationship", "description": "" },+ "2-1": { "id": "2-1", "title": "Social", "description": "", "level": 1 },+ "2-2": { "id": "2-2", "title": "Business", "description": "", "level": 3 }+ }+}+```++- [ ] **Step 4: Update ClassificationLevelBadge.vue**++Replace the `findIndex` lookup with direct level-based color mapping:++```typescript+const levelColor = computed(() => {+ const lvl = columnClassification.value?.level ?? 0;+ return bgColorList[lvl - 1] ?? "bg-gray-200";+});++const level = computed(() => {+ return (props.classificationConfig?.levels ?? []).find(+ (l) => l.level === columnClassification.value?.level+ );+});+```++Note: `level` computed still needs the lookup to get the title for display, but `levelColor` uses the level number directly without lookup.++- [ ] **Step 5: Update ClassificationTree.vue**++Change `levelId?: string` to `level?: number` in both interfaces:++```typescript+interface TreeNode extends TreeOption {+ key: string;+ label: string;+ level?: number;+ children?: TreeNode[];+}++interface ClassificationMap {+ [key: string]: {+ id: string;+ label: string;+ level?: number;+ children: ClassificationMap;+ };+}+```++Update usages:+- Line 124: `levelId: classification.levelId` → `level: classification.level`+- Line 149: `if (!node.levelId)` → `if (node.level == null)`++- [ ] **Step 6: Update utils.ts level options**++In `frontend/src/components/SensitiveData/components/utils.ts`, update to use `level` as value:++```typescript+return config.levels.map<ResourceSelectOption<unknown>>((l) => ({+ label: l.title,+ value: l.level,+}));+```++- [ ] **Step 7: Update MaskingReasonPopover.vue**++The `classificationLevel` field is now a number. Update display if needed — the template already just displays it, so it should work. But check that `v-if="props.reason.classificationLevel"` still works (0 is falsy in JS — but level 0 means "not set", so this is fine since valid levels start at 1).++- [ ] **Step 8: Fix and type-check frontend**++```bash+pnpm --dir frontend fix+pnpm --dir frontend type-check+```++- [ ] **Step 9: Run frontend tests**++```bash+pnpm --dir frontend test+```++- [ ] **Step 10: Commit**++```bash+git add frontend/+git commit -m "frontend: change classification level from string to int++Move classification_level to NumberFactorList to enable numeric+comparisons. Update components to use level number directly."+```++---++## Task 5: Demo Data Update++**Files:**+- Modify: `backend/demo/data/dump.sql`++- [ ] **Step 1: Update classification setting in dump.sql**++Line 2987: update the DATA_CLASSIFICATION setting to use `level` (int) instead of `levelId` (string), and add `level` (int) to Level entries:++Before: `"levelId": "1"` → After: `"level": 1`+Before: `{"id": "1", "title": "Level 1"}` → After: `{"title": "Level 1", "level": 1}` (remove `id` from Level entries)++- [ ] **Step 2: Update masking rule policy in dump.sql**++Line 2854: update the MASKING_RULE policy CEL expressions:++Before: `resource.classification_level in [\"2\", \"3\"]`+After: `resource.classification_level in [2, 3]`++Before: `resource.classification_level in [\"4\"]`+After: `resource.classification_level in [4]`++- [ ] **Step 3: Update audit log entries in dump.sql**++Lines 1055, 1059, 1062, 1094: these are historical audit logs. The `levelId` references in request/response payloads and CEL expressions in audit logs should remain as-is — they're historical records showing what was actually sent at that time.++- [ ] **Step 4: Commit**++```bash+git add backend/demo/+git commit -m "demo: update classification data for int-based levels"+```++---++## Task 6: Final Verification++- [ ] **Step 1: Full backend build**++```bash+go build -ldflags "-w -s" -p=16 -o ./bytebase-build/bytebase ./backend/bin/server/main.go+```++- [ ] **Step 2: Run masking evaluator tests**++```bash+go test -v -count=1 github.com/bytebase/bytebase/backend/api/v1 -run ^TestEvalMaskingLevelOfColumn$+```++- [ ] **Step 3: Backend lint**++```bash+golangci-lint run --allow-parallel-runners+```++- [ ] **Step 4: Frontend checks**++```bash+pnpm --dir frontend fix+pnpm --dir frontend type-check+pnpm --dir frontend test+```++- [ ] **Step 5: Proto lint**++```bash+buf lint proto+```diff --git a/frontend/src/components/ExprEditor/components/ValueInput.vue b/frontend/src/components/ExprEditor/components/ValueInput.vueindex 89406d91f5..3b02ee0d72 100644--- a/frontend/src/components/ExprEditor/components/ValueInput.vue+++ b/frontend/src/components/ExprEditor/components/ValueInput.vue@@ -33,9 +33,13 @@</template><template v-if="inputType === 'MULTI-SELECT'"><MultiSelect- :value="getStringArrayValue()"+ :value="getArrayValue().map(String)":expr="expr"- @update:value="setArrayValue($event)"+ @update:value="+ isNumberFactor(factor)+ ? setArrayValue($event.map(Number))+ : setArrayValue($event)+ "/></template><template v-if="inputType === 'MULTI-INPUT'">@@ -115,7 +119,7 @@ const inputType = computed((): InputType => {if (isArrayValue.value) {return hasOption ? "MULTI-SELECT" : "MULTI-INPUT";}- if (isEqualityOperator(operator.value)) {+ if (isEqualityOperator(operator.value) || isCompareOperator(operator.value)) {if (hasOption) {return "SINGLE-SELECT";}@@ -165,7 +169,11 @@ watch([factor, operator],([factor, operator]) => {if (isNumberFactor(factor)) {- setNumberValue(0);+ if (isCollectionOperator(operator)) {+ setArrayValue([]);+ } else {+ setNumberValue(0);+ }}if (isBooleanFactor(factor)) {setBoolValue(true);diff --git a/frontend/src/components/SensitiveData/classification-example.json b/frontend/src/components/SensitiveData/classification-example.jsonindex 00a6f25513..ca07818d91 100644--- a/frontend/src/components/SensitiveData/classification-example.json+++ b/frontend/src/components/SensitiveData/classification-example.json@@ -1,38 +1,38 @@{"title": "Classification Example","levels": [- { "id": "1", "title": "Level 1", "description": "" },- { "id": "2", "title": "Level 2", "description": "" },- { "id": "3", "title": "Level 3", "description": "" },- { "id": "4", "title": "Level 4", "description": "" }+ { "title": "Level 1", "description": "", "level": 1 },+ { "title": "Level 2", "description": "", "level": 2 },+ { "title": "Level 3", "description": "", "level": 3 },+ { "title": "Level 4", "description": "", "level": 4 }],"classification": {"1": { "id": "1", "title": "Basic", "description": "" },- "1-1": { "id": "1-1", "title": "Basic", "description": "", "levelId": "1" },+ "1-1": { "id": "1-1", "title": "Basic", "description": "", "level": 1 },"1-2": {"id": "1-2","title": "Contact","description": "",- "levelId": "2"+ "level": 2},"1-3": {"id": "1-3","title": "Health","description": "",- "levelId": "4"+ "level": 4},"2": { "id": "2", "title": "Relationship", "description": "" },"2-1": {"id": "2-1","title": "Social","description": "",- "levelId": "1"+ "level": 1},"2-2": {"id": "2-2","title": "Business","description": "",- "levelId": "3"+ "level": 3}}}diff --git a/frontend/src/components/SensitiveData/components/ClassificationLevelBadge.vue b/frontend/src/components/SensitiveData/components/ClassificationLevelBadge.vueindex 422de79533..7a824592ce 100644--- a/frontend/src/components/SensitiveData/components/ClassificationLevelBadge.vue+++ b/frontend/src/components/SensitiveData/components/ClassificationLevelBadge.vue@@ -48,15 +48,13 @@ const columnClassification = computed(() => {});const levelColor = computed(() => {- const index = (props.classificationConfig?.levels ?? []).findIndex(- (level) => level.id === columnClassification.value?.levelId- );- return bgColorList[index] ?? "bg-gray-200";+ const lvl = columnClassification.value?.level ?? 0;+ return bgColorList[lvl - 1] ?? "bg-gray-200";});const level = computed(() => {return (props.classificationConfig?.levels ?? []).find(- (level) => level.id === columnClassification.value?.levelId+ (l) => l.level === columnClassification.value?.level);});</script>diff --git a/frontend/src/components/SensitiveData/components/ClassificationTree.vue b/frontend/src/components/SensitiveData/components/ClassificationTree.vueindex 7eef4d92c6..2c2b908da5 100644--- a/frontend/src/components/SensitiveData/components/ClassificationTree.vue+++ b/frontend/src/components/SensitiveData/components/ClassificationTree.vue@@ -49,7 +49,7 @@ interface LocalState {interface TreeNode extends TreeOption {key: string;label: string;- levelId?: string;+ level?: number;children?: TreeNode[];}@@ -57,7 +57,7 @@ interface ClassificationMap {[key: string]: {id: string;label: string;- levelId?: string;+ level?: number;children: ClassificationMap;};}@@ -121,7 +121,7 @@ const treeData = computed((): TreeNode[] => {tmp[classification.id] = {id: classification.id,label: classification.title,- levelId: classification.levelId,+ level: classification.level,children: {},};}@@ -137,7 +137,7 @@ const getTreeNodeList = (classificationMap: ClassificationMap): TreeNode[] => {return {key: item.id,label: `${item.id} ${item.label}`,- levelId: item.levelId,+ level: item.level,isLeaf: children.length === 0,children,};@@ -146,7 +146,7 @@ const getTreeNodeList = (classificationMap: ClassificationMap): TreeNode[] => {const renderSuffix = ({ option }: { option: TreeOption }) => {const node = option as TreeNode;- if (!node.levelId) {+ if (node.level == null) {return null;}diff --git a/frontend/src/components/SensitiveData/components/utils.ts b/frontend/src/components/SensitiveData/components/utils.tsindex 246db6bb28..14e4e6c557 100644--- a/frontend/src/components/SensitiveData/components/utils.ts+++ b/frontend/src/components/SensitiveData/components/utils.ts@@ -17,9 +17,9 @@ export const getClassificationLevelOptions = () => {if (!config?.levels) {return [];}- return config.levels.map<ResourceSelectOption<unknown>>((level) => ({- label: level.title,- value: level.id,+ return config.levels.map<ResourceSelectOption<unknown>>((l) => ({+ label: l.title,+ value: String(l.level),}));};diff --git a/frontend/src/plugins/cel/types/factor.ts b/frontend/src/plugins/cel/types/factor.tsindex 965da0d7df..0942ecf20e 100644--- a/frontend/src/plugins/cel/types/factor.ts+++ b/frontend/src/plugins/cel/types/factor.ts@@ -27,6 +27,9 @@ export const NumberFactorList = [// Request query/export factorsCEL_ATTRIBUTE_REQUEST_EXPIRATION_DAYS,++ // Masking rule+ CEL_ATTRIBUTE_RESOURCE_CLASSIFICATION_LEVEL,] as const;export type NumberFactor = (typeof NumberFactorList)[number];@@ -51,8 +54,6 @@ export const StringFactorList = [// MaskingCEL_ATTRIBUTE_RESOURCE_COLUMN_NAME,- // Masking rule- CEL_ATTRIBUTE_RESOURCE_CLASSIFICATION_LEVEL,] as const;export type StringFactor = (typeof StringFactorList)[number];diff --git a/frontend/src/plugins/cel/types/operator.ts b/frontend/src/plugins/cel/types/operator.tsindex 3a16725c29..75c84b381e 100644--- a/frontend/src/plugins/cel/types/operator.ts+++ b/frontend/src/plugins/cel/types/operator.ts@@ -137,6 +137,8 @@ const OperatorList: Record<Factor, Operator[]> = {]),[CEL_ATTRIBUTE_STATEMENT_TEXT]: uniq([...StringOperatorList]),[CEL_ATTRIBUTE_RESOURCE_CLASSIFICATION_LEVEL]: uniq([+ ...EqualityOperatorList,+ ...CompareOperatorList,...CollectionOperatorList,]),diff --git a/frontend/src/types/proto-es/v1/org_policy_service_pb.d.ts b/frontend/src/types/proto-es/v1/org_policy_service_pb.d.tsindex 2ff0506cea..4d09b80d3c 100644--- a/frontend/src/types/proto-es/v1/org_policy_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/org_policy_service_pb.d.ts@@ -452,13 +452,14 @@ export declare type MaskingRulePolicy_MaskingRule = Message<"bytebase.v1.Masking* resource.database_name: the database name.* resource.table_name: the table name.* resource.column_name: the column name.- * resource.classification_level: the classification level.+ * resource.classification_level: the classification level (integer).** Each variable support following operations:* ==: the value equals the target.* !=: the value not equals the target.* in: the value matches one of the targets.* !(in): the value not matches any of the targets.+ * <, <=, >, >=: numeric comparison (classification_level only).** For example:* resource.environment_id == "test" && resource.project_id == "sample-project"diff --git a/frontend/src/types/proto-es/v1/setting_service_pb.d.ts b/frontend/src/types/proto-es/v1/setting_service_pb.d.tsindex ad9679b436..f708a3ab78 100644--- a/frontend/src/types/proto-es/v1/setting_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/setting_service_pb.d.ts@@ -904,7 +904,6 @@ export declare type DataClassificationSetting_DataClassificationConfig = Message/*** levels is user defined level list for classification.- * The order for the level decides its priority.** @generated from field: repeated bytebase.v1.DataClassificationSetting.DataClassificationConfig.Level levels = 3;*/@@ -929,11 +928,6 @@ export declare const DataClassificationSetting_DataClassificationConfigSchema: G* @generated from message bytebase.v1.DataClassificationSetting.DataClassificationConfig.Level*/export declare type DataClassificationSetting_DataClassificationConfig_Level = Message<"bytebase.v1.DataClassificationSetting.DataClassificationConfig.Level"> & {- /**- * @generated from field: string id = 1;- */- id: string;-/*** @generated from field: string title = 2;*/@@ -943,6 +937,13 @@ export declare type DataClassificationSetting_DataClassificationConfig_Level = M* @generated from field: string description = 3;*/description: string;++ /**+ * The numeric level for ordering. Higher = more sensitive.+ *+ * @generated from field: int32 level = 4;+ */+ level: number;};/**@@ -973,9 +974,11 @@ export declare type DataClassificationSetting_DataClassificationConfig_DataClassdescription: string;/**- * @generated from field: optional string level_id = 4;+ * The sensitivity level. Maps to Level.level.+ *+ * @generated from field: optional int32 level = 4;*/- levelId?: string;+ level?: number;};/**diff --git a/frontend/src/types/proto-es/v1/setting_service_pb.js b/frontend/src/types/proto-es/v1/setting_service_pb.jsindex 99516f9766..1f7b0a9a84 100644--- a/frontend/src/types/proto-es/v1/setting_service_pb.js+++ b/frontend/src/types/proto-es/v1/setting_service_pb.js@@ -17,7 +17,7 @@ import { file_v1_issue_service } from "./issue_service_pb";* Describes the file v1/setting_service.proto.*/export const file_v1_setting_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_field_mask, file_google_type_expr, file_v1_annotation, file_v1_common, file_v1_issue_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_field_mask, file_google_type_expr, file_v1_annotation, file_v1_common, file_v1_issue_service]);/*** Describes the message bytebase.v1.ListSettingsRequest.diff --git a/frontend/src/types/proto-es/v1/sql_service_pb.d.ts b/frontend/src/types/proto-es/v1/sql_service_pb.d.tsindex 8feda33937..7d1bf68013 100644--- a/frontend/src/types/proto-es/v1/sql_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/sql_service_pb.d.ts@@ -645,11 +645,11 @@ export declare type MaskingReason = Message<"bytebase.v1.MaskingReason"> & {context: string;/**- * Whether masking was due to classification level.+ * The classification level that triggered masking.*- * @generated from field: string classification_level = 6;+ * @generated from field: int32 classification_level = 6;*/- classificationLevel: string;+ classificationLevel: number;/*** Icon associated with the semantic type (if any).diff --git a/frontend/src/types/proto-es/v1/sql_service_pb.js b/frontend/src/types/proto-es/v1/sql_service_pb.jsindex 79f9cc56fc..89a9066a86 100644--- a/frontend/src/types/proto-es/v1/sql_service_pb.js+++ b/frontend/src/types/proto-es/v1/sql_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_database_service } from "./database_service_pb";* Describes the file v1/sql_service.proto.*/export const file_v1_sql_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_database_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_database_service]);/*** Describes the message bytebase.v1.AdminExecuteRequest.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex 11ce8208ba..fc1018abb6 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -18569,9 +18569,7 @@ components:items:$ref: '#/components/schemas/bytebase.v1.DataClassificationSetting.DataClassificationConfig.Level'title: levels- description: |-- levels is user defined level list for classification.- The order for the level decides its priority.+ description: levels is user defined level list for classification.classification:type: objecttitle: classification@@ -18607,25 +18605,29 @@ components:description:type: stringtitle: description- levelId:+ level:type:- - string+ - integer- "null"- title: level_id+ title: level+ format: int32+ description: The sensitivity level. Maps to Level.level.title: DataClassificationadditionalProperties: falsebytebase.v1.DataClassificationSetting.DataClassificationConfig.Level:type: objectproperties:- id:- type: string- title: idtitle:type: stringtitle: titledescription:type: stringtitle: description+ level:+ type: integer+ title: level+ format: int32+ description: The numeric level for ordering. Higher = more sensitive.title: LeveladditionalProperties: falsebytebase.v1.DataSource:@@ -23049,9 +23051,10 @@ components:title: contextdescription: 'Additional context (e.g., "Matched global rule: PII Protection").'classificationLevel:- type: string+ type: integertitle: classification_level- description: Whether masking was due to classification level.+ format: int32+ description: The classification level that triggered masking.semanticTypeIcon:type: stringtitle: semantic_type_icon@@ -23090,13 +23093,14 @@ components:resource.database_name: the database name.resource.table_name: the table name.resource.column_name: the column name.- resource.classification_level: the classification level.+ resource.classification_level: the classification level (integer).Each variable support following operations:==: the value equals the target.!=: the value not equals the target.in: the value matches one of the targets.!(in): the value not matches any of the targets.+ <, <=, >, >=: numeric comparison (classification_level only).For example:resource.environment_id == "test" && resource.project_id == "sample-project"diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex 070b0a7635..e97e3e1b61 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -4290,7 +4290,7 @@ All other settings live in per-workspace WORKSPACE_PROFILE.| ----- | ---- | ----- | ----------- || id | [string](#string) | | id is the uuid for classification. Each project can chose one classification config. || title | [string](#string) | | |-| levels | [DataClassificationSetting.DataClassificationConfig.Level](#bytebase-store-DataClassificationSetting-DataClassificationConfig-Level) | repeated | levels is user defined level list for classification. The order for the level decides its priority. |+| levels | [DataClassificationSetting.DataClassificationConfig.Level](#bytebase-store-DataClassificationSetting-DataClassificationConfig-Level) | repeated | levels is user defined level list for classification. || classification | [DataClassificationSetting.DataClassificationConfig.ClassificationEntry](#bytebase-store-DataClassificationSetting-DataClassificationConfig-ClassificationEntry) | repeated | classification is the id - DataClassification map. The id should in [0-9]+-[0-9]+-[0-9]+ format. |@@ -4325,7 +4325,7 @@ All other settings live in per-workspace WORKSPACE_PROFILE.| id | [string](#string) | | id is the classification id in [0-9]+-[0-9]+-[0-9]+ format. || title | [string](#string) | | || description | [string](#string) | | |-| level_id | [string](#string) | optional | |+| level | [int32](#int32) | optional | The sensitivity level. Maps to Level.level. |@@ -4340,9 +4340,9 @@ All other settings live in per-workspace WORKSPACE_PROFILE.| Field | Type | Label | Description || ----- | ---- | ----- | ----------- |-| id | [string](#string) | | || title | [string](#string) | | || description | [string](#string) | | |+| level | [int32](#int32) | | The numeric level for ordering. Higher = more sensitive. |diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.htmlindex e4586bda8d..c3ec3689a4 100644--- a/proto/gen/grpc-doc/store/index.html+++ b/proto/gen/grpc-doc/store/index.html@@ -11824,8 +11824,7 @@ classification config. </p></td><td>levels</td><td><a href="#bytebase.store.DataClassificationSetting.DataClassificationConfig.Level">DataClassificationSetting.DataClassificationConfig.Level</a></td><td>repeated</td>- <td><p>levels is user defined level list for classification.-The order for the level decides its priority. </p></td>+ <td><p>levels is user defined level list for classification. </p></td></tr><tr>@@ -11906,10 +11905,10 @@ The id should in [0-9]+-[0-9]+-[0-9]+ format. </p></td></tr><tr>- <td>level_id</td>- <td><a href="#string">string</a></td>+ <td>level</td>+ <td><a href="#int32">int32</a></td><td>optional</td>- <td><p> </p></td>+ <td><p>The sensitivity level. Maps to Level.level. </p></td></tr></tbody>@@ -11930,24 +11929,24 @@ The id should in [0-9]+-[0-9]+-[0-9]+ format. </p></td><tbody><tr>- <td>id</td>+ <td>title</td><td><a href="#string">string</a></td><td></td><td><p> </p></td></tr><tr>- <td>title</td>+ <td>description</td><td><a href="#string">string</a></td><td></td><td><p> </p></td></tr><tr>- <td>description</td>- <td><a href="#string">string</a></td>+ <td>level</td>+ <td><a href="#int32">int32</a></td><td></td>- <td><p> </p></td>+ <td><p>The numeric level for ordering. Higher = more sensitive. </p></td></tr></tbody>diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex cecbd82a11..ec50396f75 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -2073,7 +2073,7 @@ IssueService manages issues for tracking database changes and tasks.| ----- | ---- | ----- | ----------- || id | [string](#string) | | id is the uuid for classification. Each project can chose one classification config. || title | [string](#string) | | |-| levels | [DataClassificationSetting.DataClassificationConfig.Level](#bytebase-v1-DataClassificationSetting-DataClassificationConfig-Level) | repeated | levels is user defined level list for classification. The order for the level decides its priority. |+| levels | [DataClassificationSetting.DataClassificationConfig.Level](#bytebase-v1-DataClassificationSetting-DataClassificationConfig-Level) | repeated | levels is user defined level list for classification. || classification | [DataClassificationSetting.DataClassificationConfig.ClassificationEntry](#bytebase-v1-DataClassificationSetting-DataClassificationConfig-ClassificationEntry) | repeated | classification is the id - DataClassification map. The id should in [0-9]+-[0-9]+-[0-9]+ format. |@@ -2108,7 +2108,7 @@ IssueService manages issues for tracking database changes and tasks.| id | [string](#string) | | id is the classification id in [0-9]+-[0-9]+-[0-9]+ format. || title | [string](#string) | | || description | [string](#string) | | |-| level_id | [string](#string) | optional | |+| level | [int32](#int32) | optional | The sensitivity level. Maps to Level.level. |@@ -2123,9 +2123,9 @@ IssueService manages issues for tracking database changes and tasks.| Field | Type | Label | Description || ----- | ---- | ----- | ----------- |-| id | [string](#string) | | || title | [string](#string) | | || description | [string](#string) | | |+| level | [int32](#int32) | | The numeric level for ordering. Higher = more sensitive. |@@ -6975,9 +6975,9 @@ A rule that defines when and how to mask data.| id | [string](#string) | | A unique identifier for the rule in UUID format. || condition | [google.type.Expr](#google-type-Expr) | | The condition for the masking rule. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec-Support variables: resource.environment_id: the environment resource id. resource.project_id: the project resource id. resource.instance_id: the instance resource id. resource.database_name: the database name. resource.table_name: the table name. resource.column_name: the column name. resource.classification_level: the classification level.+Support variables: resource.environment_id: the environment resource id. resource.project_id: the project resource id. resource.instance_id: the instance resource id. resource.database_name: the database name. resource.table_name: the table name. resource.column_name: the column name. resource.classification_level: the classification level (integer).-Each variable support following operations: ==: the value equals the target. !=: the value not equals the target. in: the value matches one of the targets. !(in): the value not matches any of the targets.+Each variable support following operations: ==: the value equals the target. !=: the value not equals the target. in: the value matches one of the targets. !(in): the value not matches any of the targets. <, <=, >, >=: numeric comparison (classification_level only).For example: resource.environment_id == "test" && resource.project_id == "sample-project" resource.instance_id == "sample-instance" && resource.database_name == "employee" && resource.table_name in ["table1", "table2"] resource.environment_id != "test" || !(resource.project_id in ["poject1", "prject2"]) resource.instance_id == "sample-instance" && (resource.database_name == "db1" || resource.database_name == "db2") || semantic_type | [string](#string) | | The semantic type of data to mask (e.g., "SSN", "EMAIL"). |@@ -7383,7 +7383,7 @@ OrgPolicyService manages organizational policies at various resource levels.| masking_rule_id | [string](#string) | | The masking rule ID that matched (if applicable). || algorithm | [string](#string) | | The masking algorithm used. || context | [string](#string) | | Additional context (e.g., "Matched global rule: PII Protection"). |-| classification_level | [string](#string) | | Whether masking was due to classification level. |+| classification_level | [int32](#int32) | | The classification level that triggered masking. || semantic_type_icon | [string](#string) | | Icon associated with the semantic type (if any). |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex 3acfe1f241..4f16c52e1c 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -6596,8 +6596,7 @@ Uses character indices (not byte offsets) for display-oriented masking. </p></td<td>levels</td><td><a href="#bytebase.v1.DataClassificationSetting.DataClassificationConfig.Level">DataClassificationSetting.DataClassificationConfig.Level</a></td><td>repeated</td>- <td><p>levels is user defined level list for classification.-The order for the level decides its priority. </p></td>+ <td><p>levels is user defined level list for classification. </p></td></tr><tr>@@ -6678,10 +6677,10 @@ The id should in [0-9]+-[0-9]+-[0-9]+ format. </p></td></tr><tr>- <td>level_id</td>- <td><a href="#string">string</a></td>+ <td>level</td>+ <td><a href="#int32">int32</a></td><td>optional</td>- <td><p> </p></td>+ <td><p>The sensitivity level. Maps to Level.level. </p></td></tr></tbody>@@ -6702,24 +6701,24 @@ The id should in [0-9]+-[0-9]+-[0-9]+ format. </p></td><tbody><tr>- <td>id</td>+ <td>title</td><td><a href="#string">string</a></td><td></td><td><p> </p></td></tr><tr>- <td>title</td>+ <td>description</td><td><a href="#string">string</a></td><td></td><td><p> </p></td></tr><tr>- <td>description</td>- <td><a href="#string">string</a></td>+ <td>level</td>+ <td><a href="#int32">int32</a></td><td></td>- <td><p> </p></td>+ <td><p>The numeric level for ordering. Higher = more sensitive. </p></td></tr></tbody>@@ -19814,13 +19813,14 @@ resource.instance_id: the instance resource id.resource.database_name: the database name.resource.table_name: the table name.resource.column_name: the column name.-resource.classification_level: the classification level.+resource.classification_level: the classification level (integer).Each variable support following operations:==: the value equals the target.!=: the value not equals the target.in: the value matches one of the targets.!(in): the value not matches any of the targets.+<, <=, >, >=: numeric comparison (classification_level only).For example:resource.environment_id == "test" && resource.project_id == "sample-project"@@ -20991,9 +20991,9 @@ Oracle and search path in Postgres. </p></td><tr><td>classification_level</td>- <td><a href="#string">string</a></td>+ <td><a href="#int32">int32</a></td><td></td>- <td><p>Whether masking was due to classification level. </p></td>+ <td><p>The classification level that triggered masking. </p></td></tr><tr>diff --git a/proto/store/store/setting.proto b/proto/store/store/setting.protoindex 6d0e934321..875b58012a 100644--- a/proto/store/store/setting.proto+++ b/proto/store/store/setting.proto@@ -171,13 +171,13 @@ message DataClassificationSetting {string title = 2;message Level {- string id = 1;string title = 2;string description = 3;+ // The numeric level for ordering. Higher = more sensitive.+ int32 level = 4;}// levels is user defined level list for classification.- // The order for the level decides its priority.repeated Level levels = 3;message DataClassification {@@ -185,7 +185,8 @@ message DataClassificationSetting {string id = 1;string title = 2;string description = 3;- optional string level_id = 4;+ // The sensitivity level. Maps to Level.level.+ optional int32 level = 4;}// classification is the id - DataClassification map.diff --git a/proto/v1/v1/org_policy_service.proto b/proto/v1/v1/org_policy_service.protoindex 3511f8e6f8..41a159b131 100644--- a/proto/v1/v1/org_policy_service.proto+++ b/proto/v1/v1/org_policy_service.proto@@ -353,13 +353,14 @@ message MaskingRulePolicy {// resource.database_name: the database name.// resource.table_name: the table name.// resource.column_name: the column name.- // resource.classification_level: the classification level.+ // resource.classification_level: the classification level (integer).//// Each variable support following operations:// ==: the value equals the target.// !=: the value not equals the target.// in: the value matches one of the targets.// !(in): the value not matches any of the targets.+ // <, <=, >, >=: numeric comparison (classification_level only).//// For example:// resource.environment_id == "test" && resource.project_id == "sample-project"diff --git a/proto/v1/v1/setting_service.proto b/proto/v1/v1/setting_service.protoindex b63268a686..b81627ff4d 100644--- a/proto/v1/v1/setting_service.proto+++ b/proto/v1/v1/setting_service.proto@@ -325,13 +325,13 @@ message DataClassificationSetting {string title = 2;message Level {- string id = 1;string title = 2;string description = 3;+ // The numeric level for ordering. Higher = more sensitive.+ int32 level = 4;}// levels is user defined level list for classification.- // The order for the level decides its priority.repeated Level levels = 3;message DataClassification {@@ -339,7 +339,8 @@ message DataClassificationSetting {string id = 1;string title = 2;string description = 3;- optional string level_id = 4;+ // The sensitivity level. Maps to Level.level.+ optional int32 level = 4;}// classification is the id - DataClassification map.diff --git a/proto/v1/v1/sql_service.proto b/proto/v1/v1/sql_service.protoindex b2079346c5..e0d65ba6c6 100644--- a/proto/v1/v1/sql_service.proto+++ b/proto/v1/v1/sql_service.proto@@ -297,8 +297,8 @@ message MaskingReason {// Additional context (e.g., "Matched global rule: PII Protection").string context = 5;- // Whether masking was due to classification level.- string classification_level = 6;+ // The classification level that triggered masking.+ int32 classification_level = 6;// Icon associated with the semantic type (if any).string semantic_type_icon = 7;