feat(expt-item-centric): 放开 createExpt filter 普通列 + tag, set 级下传服务端裁剪

创建侧白名单放开普通业务列 (field_name 任意, field_type 加
string/double/bool/float/integer, query_type 加 match/not_match 对齐下游
data_filter 词表), field_name 改为只校验非空。

matcher: contains/not_contains 重命名为 match/not_match (对齐 data 模块标准
词, 逻辑不变); matchFilterField 加 field_type=tag 分支, 读 item.Tags 的
TagName 做存在性匹配。

scheduler exptStartMultiSet: 新增 extractNormalColumnFilter (抽普通列 ->
entity.Filter) + extractTagFilter (抽 tag -> entity.TagFilter), List/BatchGet
两路拉取都带 Filter+TagFilter 下传。commercial 走 ml_flow 服务端裁剪, 开源版
下游无字段降级全量 (抽象-实现分离)。item_id not_in 仍逐页内存排除 (下游无
not_in 专用字段), 补注释说明非全集进内存 + TODO。

单测: 普通列放行/非法 query_type/field_name 空; match/not_match; tag 命中/
无 tag/端到端; extractNormalColumnFilter/extractTagFilter。全 PASS。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: xueyizheng

backend/modules/evaluation/domain/entity/expt_eval_set_config_validation.go

@@ -24,10 +24,17 @@ var (
 	// alias 字符集白名单 [a-zA-Z0-9_-]
 	aliasPattern = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
 
-	// filter 字段白名单
-	allowedFilterFieldNames = map[string]struct{}{"item_id": {}}                                              // tag key 走 field_type=tag 放行
-	allowedFilterFieldTypes = map[string]struct{}{"long": {}, "tag": {}}                                       // long(item_id) / tag
-	allowedFilterQueryTypes = map[string]struct{}{"eq": {}, "not_eq": {}, "in": {}, "not_in": {}}              // 单层比较
+	// filter 字段白名单 (对齐下游 data_filter.thrift FieldType / QueryType 词表)
+	//   field_type: long(item_id) / tag(标签) / string,double,bool,float,integer(普通业务列)
+	//   query_type: 单层比较 + match/not_match(子串)
+	//   field_name: 只校验非空 (item_id / tag key / 普通列名), 不查 schema 是否存在
+	allowedFilterFieldTypes = map[string]struct{}{
+		"long": {}, "tag": {},
+		"string": {}, "double": {}, "bool": {}, "float": {}, "integer": {},
+	}
+	allowedFilterQueryTypes = map[string]struct{}{
+		"eq": {}, "not_eq": {}, "in": {}, "not_in": {}, "match": {}, "not_match": {},
+	}
 )
 
 // ValidateEvalSetConfigs 校验新路径 (MultiSetConfig) 的多评测集配置。
@@ -103,7 +110,8 @@ func ValidateEvalSetConfigs(configs []*EvalSetConfig) error {
 	return nil
 }
 
-// validateFilter 对 item_filter / evaluator filter 套用白名单：字段名/类型/操作符白名单、单层不嵌套、数量上限、点选基本校验。
+// validateFilter 对 item_filter / evaluator filter 套用白名单：field_type/query_type 白名单、
+// field_name 非空、数量上限、item_id 点选基本校验。支持 item_id / tag / 普通业务列三类。
 func validateFilter(f *ExptItemFilter, path string) error {
 	if f == nil {
 		return nil
@@ -120,17 +128,15 @@ func validateFilter(f *ExptItemFilter, path string) error {
 		}
 		// field_type 白名单
 		if _, ok := allowedFilterFieldTypes[ff.FieldType]; !ok {
-			return invalidParam(fmt.Sprintf("%s.filter_fields[%d]: field_type %q not allowed (only long/tag)", path, fi, ff.FieldType))
+			return invalidParam(fmt.Sprintf("%s.filter_fields[%d]: field_type %q not allowed (long/tag/string/double/bool/float/integer)", path, fi, ff.FieldType))
 		}
 		// query_type 白名单
 		if _, ok := allowedFilterQueryTypes[ff.QueryType]; !ok {
-			return invalidParam(fmt.Sprintf("%s.filter_fields[%d]: query_type %q not allowed (only eq/not_eq/in/not_in)", path, fi, ff.QueryType))
+			return invalidParam(fmt.Sprintf("%s.filter_fields[%d]: query_type %q not allowed (eq/not_eq/in/not_in/match/not_match)", path, fi, ff.QueryType))
 		}
-		// field_name 白名单: item_id 显式放行；其余仅当 field_type=tag 时视为 tag key 放行
-		if _, ok := allowedFilterFieldNames[ff.FieldName]; !ok {
-			if ff.FieldType != "tag" {
-				return invalidParam(fmt.Sprintf("%s.filter_fields[%d]: field_name %q not allowed (only item_id or tag key with field_type=tag)", path, fi, ff.FieldName))
-			}
+		// field_name 只校验非空 (item_id / tag key / 普通列名), 不查评测集 schema 是否存在
+		if ff.FieldName == "" {
+			return invalidParam(fmt.Sprintf("%s.filter_fields[%d]: field_name must not be empty", path, fi))
 		}
 		// 点选 (item_id in) 基本校验: values 非空。
 		// TODO: 文档要求"点选 values 必须全部属于对应 eval_set_version 快照(缺一报错)"，依赖 Data 侧按 version 拉 item 接口，

backend/modules/evaluation/domain/entity/expt_eval_set_config_validation_test.go

@@ -99,13 +99,35 @@ func TestValidateEvalSetConfigs(t *testing.T) {
 				{EvalSetID: 1, EvalSetVersionID: 11, EvaluatorConfs: []*ExptEvaluatorConf{
 					{EvaluatorVersionID: 100, Filter: &ExptItemFilter{
 						FilterFields: []*ExptItemFilterField{
-							{FieldName: "item_id", FieldType: "double", QueryType: "eq"},
+							{FieldName: "item_id", FieldType: "unknown_type", QueryType: "eq"},
 						},
 					}},
 				}},
 			},
 			wantErr: true,
 		},
+		{
+			name: "非法: filter query_type 超白名单 (contains 已不在白名单)",
+			configs: []*EvalSetConfig{
+				{EvalSetID: 1, EvalSetVersionID: 11, ItemFilter: &ExptItemFilter{
+					FilterFields: []*ExptItemFilterField{
+						{FieldName: "category", FieldType: "string", QueryType: "contains"},
+					},
+				}},
+			},
+			wantErr: true,
+		},
+		{
+			name: "非法: filter field_name 为空",
+			configs: []*EvalSetConfig{
+				{EvalSetID: 1, EvalSetVersionID: 11, ItemFilter: &ExptItemFilter{
+					FilterFields: []*ExptItemFilterField{
+						{FieldName: "", FieldType: "string", QueryType: "eq", Values: []string{"x"}},
+					},
+				}},
+			},
+			wantErr: true,
+		},
 		{
 			name: "非法: filter query_type 超白名单",
 			configs: []*EvalSetConfig{
@@ -151,6 +173,31 @@ func TestValidateEvalSetConfigs(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "合法: 普通列 string + match",
+			configs: []*EvalSetConfig{
+				{EvalSetID: 1, EvalSetVersionID: 11, ItemFilter: &ExptItemFilter{
+					FilterFields: []*ExptItemFilterField{
+						{FieldName: "category", FieldType: "string", QueryType: "match", Values: []string{"math"}},
+					},
+				}},
+			},
+			wantErr: false,
+		},
+		{
+			name: "合法: 普通列 + tag + item_id 混合",
+			configs: []*EvalSetConfig{
+				{EvalSetID: 1, EvalSetVersionID: 11, ItemFilter: &ExptItemFilter{
+					QueryAndOr: "and",
+					FilterFields: []*ExptItemFilterField{
+						{FieldName: "item_id", FieldType: "long", QueryType: "in", Values: []string{"1"}},
+						{FieldName: "lang", FieldType: "tag", QueryType: "eq", Values: []string{"zh"}},
+						{FieldName: "difficulty", FieldType: "integer", QueryType: "not_eq", Values: []string{"5"}},
+					},
+				}},
+			},
+			wantErr: false,
+		},
 	}
 
 	for _, tt := range tests {

backend/modules/evaluation/domain/service/expt_item_filter_match.go

@@ -76,10 +76,8 @@ func MatchExptItemFilter(filter *entity.ExptItemFilter, item *entity.EvaluationS
 
 // matchFilterField 单字段匹配。
 //   - field_name=item_id: 用 item.ItemID 比较 (item 级, 不依赖 turn)
-//   - 其余: 从 turn.FieldDataList 按 name/key 取字段文本值
-//
-// 注: tag (field_type=tag) 暂未支持 — matcher 尚无 tag 分支, 配 tag 会走文本路径匹配不上,
-// 见 tech debt; 普通 turn 字段创建侧白名单当前未放行 (仅 item_id / tag)。
+//   - field_type=tag: 用 item.Tags 里持有的 tag 名集合做存在性比较 (对齐下游 TagFilter 语义)
+//   - 其余 (普通列): 从 turn.FieldDataList 按 name/key 取字段文本值
 func matchFilterField(ff *entity.ExptItemFilterField, item *entity.EvaluationSetItem, turn *entity.Turn) bool {
 	// item_id: 直接读 item 级 ItemID, 不走 turn 文本路径
 	if ff.FieldName == "item_id" {
@@ -89,17 +87,52 @@ func matchFilterField(ff *entity.ExptItemFilterField, item *entity.EvaluationSet
 		return matchByQueryType(ff.QueryType, strconv.FormatInt(item.ItemID, 10), ff.Values)
 	}
 
+	// tag: 按 item.Tags 的 TagName 存在性匹配。
+	// 期望 tag 名取自 ff.Values (与 set 级 extractTagFilter 收集口径一致); 命中=item 含其一。
+	if strings.EqualFold(ff.FieldType, "tag") {
+		return matchTagField(ff, item)
+	}
+
 	actual, ok := getFieldTextValue(ff.FieldName, item, turn)
 	if !ok {
 		return matchMissingField(ff.QueryType)
 	}
 	return matchByQueryType(ff.QueryType, actual, ff.Values)
 }
 
+// matchTagField 按 item 持有的 tag 名集合做 in/not_in 风格匹配。
+//   - in/eq/match: item 含 ff.Values 中任一 tag → 命中
+//   - not_in/not_eq/not_match: item 不含任一 → 命中 (取反)
+//   - item 无 tag: 走 matchMissingField (in→不命中, not_in→命中)
+func matchTagField(ff *entity.ExptItemFilterField, item *entity.EvaluationSetItem) bool {
+	if item == nil || len(item.Tags) == 0 {
+		return matchMissingField(ff.QueryType)
+	}
+	owned := make(map[string]struct{}, len(item.Tags))
+	for _, t := range item.Tags {
+		if t != nil && t.TagName != "" {
+			owned[t.TagName] = struct{}{}
+		}
+	}
+	hit := false
+	for _, v := range ff.Values {
+		if _, ok := owned[v]; ok {
+			hit = true
+			break
+		}
+	}
+	switch strings.ToLower(ff.QueryType) {
+	case "not_equal", "ne", "not_in", "not_eq", "not_match":
+		return !hit
+	default: // eq/in/match/空
+		return hit
+	}
+}
+
 // matchMissingField 字段不存在时的语义: equal/in 不命中 (false); not_equal/not_in 取反命中 (true)。
 func matchMissingField(queryType string) bool {
 	switch strings.ToLower(queryType) {
-	case "not_equal", "ne", "not_in", "not_eq":
+	case "not_equal", "ne", "not_in", "not_eq", "not_match":
 		return true
 	}
 	return false
@@ -143,14 +176,14 @@ func matchByQueryType(queryType, actual string, values []string) bool {
 			}
 		}
 		return true
-	case "contains":
+	case "match":
 		for _, v := range values {
 			if strings.Contains(actual, v) {
 				return true
 			}
 		}
 		return false
-	case "not_contains":
+	case "not_match":
 		for _, v := range values {
 			if strings.Contains(actual, v) {
 				return false

backend/modules/evaluation/domain/service/expt_item_filter_match_test.go

@@ -133,17 +133,38 @@ func TestMatchExptItemFilter_OrLogic_AnyMatch(t *testing.T) {
 	assert.True(t, matched, "OR: 任一字段命中即命中")
 }
 
-func TestMatchByQueryType_Contains(t *testing.T) {
+func TestMatchByQueryType_Match(t *testing.T) {
 	turn := turnWith("content", "the quick brown fox")
 	matched, err := MatchExptItemFilter(&entity.ExptItemFilter{
 		FilterFields: []*entity.ExptItemFilterField{
-			{FieldName: "content", QueryType: "contains", Values: []string{"quick"}},
+			{FieldName: "content", FieldType: "string", QueryType: "match", Values: []string{"quick"}},
 		},
 	}, nil, turn)
 	assert.NoError(t, err)
 	assert.True(t, matched)
 }
 
+func TestMatchByQueryType_NotMatch(t *testing.T) {
+	turn := turnWith("content", "the quick brown fox")
+	// not_match: 子串不存在才命中
+	matched, err := MatchExptItemFilter(&entity.ExptItemFilter{
+		FilterFields: []*entity.ExptItemFilterField{
+			{FieldName: "content", FieldType: "string", QueryType: "not_match", Values: []string{"slow"}},
+		},
+	}, nil, turn)
+	assert.NoError(t, err)
+	assert.True(t, matched)
+
+	// not_match: 子串存在则不命中
+	matched, err = MatchExptItemFilter(&entity.ExptItemFilter{
+		FilterFields: []*entity.ExptItemFilterField{
+			{FieldName: "content", FieldType: "string", QueryType: "not_match", Values: []string{"quick"}},
+		},
+	}, nil, turn)
+	assert.NoError(t, err)
+	assert.False(t, matched)
+}
+
 func TestMatchByQueryType_NotEqual_FieldMissing_True(t *testing.T) {
 	// 字段不存在时 not_equal 应返回 true (按取反语义,缺失=不等)
 	turn := &entity.Turn{}
@@ -226,3 +247,67 @@ func TestShouldRunByFilter_ItemID(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, run, "Exclude + item_id 命中 → 不跑")
 }
+
+// TestMatchFilterField_Tag 验证 field_type=tag 走 item.Tags 的 TagName 存在性匹配。
+func TestMatchFilterField_Tag(t *testing.T) {
+	item := &entity.EvaluationSetItem{
+		ItemID: 1,
+		Tags:   []*entity.ResourceTag{{TagName: "zh"}, {TagName: "hard"}},
+	}
+	turn := &entity.Turn{} // tag 不依赖 turn
+
+	cases := []struct {
+		name      string
+		queryType string
+		values    []string
+		want      bool
+	}{
+		{"in 命中(含 zh)", "in", []string{"zh", "en"}, true},
+		{"in 不命中(都不含)", "in", []string{"en", "fr"}, false},
+		{"eq 命中", "eq", []string{"hard"}, true},
+		{"not_in 命中(不含→取反)", "not_in", []string{"en"}, true},
+		{"not_in 不命中(含→取反)", "not_in", []string{"zh"}, false},
+		{"match 命中(走存在性,不做子串)", "match", []string{"zh"}, true},
+		{"not_match 含→不命中", "not_match", []string{"zh"}, false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			ff := &entity.ExptItemFilterField{FieldName: "lang", FieldType: "tag", QueryType: c.queryType, Values: c.values}
+			got := matchFilterField(ff, item, turn)
+			assert.Equal(t, c.want, got)
+		})
+	}
+}
+
+// TestMatchFilterField_Tag_NoTags item 无 tag 时走 matchMissingField (in→不命中, not_in→命中)。
+func TestMatchFilterField_Tag_NoTags(t *testing.T) {
+	item := &entity.EvaluationSetItem{ItemID: 1} // 无 Tags
+	turn := &entity.Turn{}
+
+	in := &entity.ExptItemFilterField{FieldName: "lang", FieldType: "tag", QueryType: "in", Values: []string{"zh"}}
+	assert.False(t, matchFilterField(in, item, turn), "无 tag + in → 不命中")
+
+	notIn := &entity.ExptItemFilterField{FieldName: "lang", FieldType: "tag", QueryType: "not_in", Values: []string{"zh"}}
+	assert.True(t, matchFilterField(notIn, item, turn), "无 tag + not_in → 命中")
+}
+
+// TestShouldRunByFilter_Tag 端到端: Include + tag 命中→跑; 不命中→不跑。
+func TestShouldRunByFilter_Tag(t *testing.T) {
+	item := &entity.EvaluationSetItem{ItemID: 1, Tags: []*entity.ResourceTag{{TagName: "zh"}}}
+	turn := &entity.Turn{}
+
+	hit := &entity.ExptItemFilter{FilterFields: []*entity.ExptItemFilterField{
+		{FieldName: "lang", FieldType: "tag", QueryType: "in", Values: []string{"zh"}},
+	}}
+	miss := &entity.ExptItemFilter{FilterFields: []*entity.ExptItemFilterField{
+		{FieldName: "lang", FieldType: "tag", QueryType: "in", Values: []string{"en"}},
+	}}
+
+	run, err := ShouldRunByFilter(hit, filterModeInclude, item, turn)
+	assert.NoError(t, err)
+	assert.True(t, run, "Include + tag 命中 → 跑")
+
+	run, err = ShouldRunByFilter(miss, filterModeInclude, item, turn)
+	assert.NoError(t, err)
+	assert.False(t, run, "Include + tag 不命中 → 不跑(Skipped)")
+}