fix: singleflight context isolation, composite key behavior, and key collision

- query: use db.Statement.Context for singleflight leader cache reads
  (BatchGetPrimaryCache, BatchGetUniqueCache, GetSearchCache) so leader
  cancellation does not affect cache lookups.
- query: log unique cache write count only; avoid logging full uniqueKvs payload.
- cache: document that BatchSetUniqueCache mutates the caller's kvs slice.
- helpers: composite primary/unique keys use Cartesian product
  (generateCartesianProduct) so e.g. user_id=1, role_id IN (1,2,3) yields
  ["1:1","1:2","1:3"]; add TestGetPrimaryKeysFromWhereClause_CompositeKeyCartesianProduct.
- helpers: getObjectsAfterLoad composite key: treat nil ValueOf and zero values
  as invalid and skip incomplete keys (valid flag, no partial key append).
- util/key: encode composite key parts with base64.RawURLEncoding to avoid
  collision (e.g. "a:b","c" vs "a","b:c"); add TestGenPrimaryCacheKey_NoCollision;
  update key_test expected values for encoded output.

Author: asjdf

cache/cache.go

@@ -189,7 +189,8 @@ func (c *Gorm2Cache) BatchGetUniqueCache(ctx context.Context, tableName string,
 	return c.cache.BatchGetValues(ctx, cacheKeys)
 }
 
-// BatchSetUniqueCache 批量设置unique键缓存
+// BatchSetUniqueCache 批量设置unique键缓存。
+// 注意：会原地修改 kvs 中每个元素的 Key 为完整缓存 key，调用方不应再使用传入的 kvs。
 func (c *Gorm2Cache) BatchSetUniqueCache(ctx context.Context, tableName string, uniqueIndexName string, kvs []util.Kv) error {
 	for idx, kv := range kvs {
 		// kv.Key 已经是最终格式（单个值或已用":"连接的联合unique键），直接传入

cache/helpers.go

@@ -97,31 +97,12 @@ func getPrimaryKeysFromWhereClause(db *gorm.DB) []string {
 		return uniqueStringSlice(fieldValuesMap[primaryKeyFields[0].DBName])
 	}
 
-	// 对于联合主键：需要组合所有字段的值
-	// 先获取每个字段的值列表长度，取最小值（因为可能有IN查询）
-	maxLen := len(fieldValuesMap[primaryKeyFields[0].DBName])
-	for _, field := range primaryKeyFields[1:] {
-		if len(fieldValuesMap[field.DBName]) < maxLen {
-			maxLen = len(fieldValuesMap[field.DBName])
-		}
-	}
-
-	// 生成联合主键key
-	primaryKeys := make([]string, 0, maxLen)
-	for i := 0; i < maxLen; i++ {
-		keyParts := make([]string, 0, len(primaryKeyFields))
-		for _, field := range primaryKeyFields {
-			values := fieldValuesMap[field.DBName]
-			if i < len(values) {
-				keyParts = append(keyParts, values[i])
-			} else {
-				// 如果某个字段的值不够，使用最后一个值
-				keyParts = append(keyParts, values[len(values)-1])
-			}
-		}
-		primaryKeys = append(primaryKeys, strings.Join(keyParts, ":"))
+	// 对于联合主键：生成所有字段值的笛卡尔积（如 user_id=1, role_id IN (1,2,3) -> "1:1","1:2","1:3"）
+	valueSlices := make([][]string, 0, len(primaryKeyFields))
+	for _, field := range primaryKeyFields {
+		valueSlices = append(valueSlices, fieldValuesMap[field.DBName])
 	}
-
+	primaryKeys := generateCartesianProduct(valueSlices, ":")
 	return uniqueStringSlice(primaryKeys)
 }
 
@@ -312,44 +293,29 @@ func getUniqueKeysFromWhereClause(db *gorm.DB) map[string][]string {
 				result[indexName] = uniqueStringSlice(fieldValuesMap[index.Fields[0].Field.DBName])
 			}
 		} else {
-			// 联合unique键
+			// 联合unique键：笛卡尔积
 			if len(index.Fields) == 0 {
 				continue
 			}
-			firstField := index.Fields[0].Field
-			if firstField == nil {
-				continue
-			}
-			maxLen := len(fieldValuesMap[firstField.DBName])
-			for _, fieldOption := range index.Fields[1:] {
+			valueSlices := make([][]string, 0, len(index.Fields))
+			skip := false
+			for _, fieldOption := range index.Fields {
 				if fieldOption.Field == nil {
-					continue
+					skip = true
+					break
 				}
-				if len(fieldValuesMap[fieldOption.Field.DBName]) < maxLen {
-					maxLen = len(fieldValuesMap[fieldOption.Field.DBName])
+				vals := fieldValuesMap[fieldOption.Field.DBName]
+				if len(vals) == 0 {
+					skip = true
+					break
 				}
+				valueSlices = append(valueSlices, vals)
 			}
-
-			uniqueKeys := make([]string, 0, maxLen)
-			for i := 0; i < maxLen; i++ {
-				keyParts := make([]string, 0, len(index.Fields))
-				for _, fieldOption := range index.Fields {
-					if fieldOption.Field == nil {
-						continue
-					}
-					values := fieldValuesMap[fieldOption.Field.DBName]
-					if i < len(values) {
-						keyParts = append(keyParts, values[i])
-					} else if len(values) > 0 {
-						keyParts = append(keyParts, values[len(values)-1])
-					}
+			if !skip && len(valueSlices) == len(index.Fields) {
+				uniqueKeys := generateCartesianProduct(valueSlices, ":")
+				if len(uniqueKeys) > 0 {
+					result[indexName] = uniqueStringSlice(uniqueKeys)
 				}
-				if len(keyParts) == len(index.Fields) {
-					uniqueKeys = append(uniqueKeys, strings.Join(keyParts, ":"))
-				}
-			}
-			if len(uniqueKeys) > 0 {
-				result[indexName] = uniqueStringSlice(uniqueKeys)
 			}
 		}
 	}
@@ -557,22 +523,23 @@ func getObjectsAfterLoad(db *gorm.DB) (primaryKeys []string, objects []interface
 				primaryKeys = append(primaryKeys, fmt.Sprintf("%v", primaryKey))
 			}
 		} else {
-			// 联合主键
+			// 联合主键：必须所有字段都能取到非零值，且 ValueOf 非 nil
 			keyParts := make([]string, 0, len(primaryKeyFields))
-			allZero := true
+			valid := true
 			for _, field := range primaryKeyFields {
 				valueOf := field.ValueOf
-				if valueOf != nil {
-					primaryKey, isZero := valueOf(context.Background(), elemValue)
-					if isZero {
-						allZero = true
-						break
-					}
-					allZero = false
-					keyParts = append(keyParts, fmt.Sprintf("%v", primaryKey))
+				if valueOf == nil {
+					valid = false
+					break
 				}
+				primaryKey, isZero := valueOf(context.Background(), elemValue)
+				if isZero {
+					valid = false
+					break
+				}
+				keyParts = append(keyParts, fmt.Sprintf("%v", primaryKey))
 			}
-			if allZero {
+			if !valid || len(keyParts) != len(primaryKeyFields) {
 				continue
 			}
 			primaryKeys = append(primaryKeys, strings.Join(keyParts, ":"))
@@ -636,6 +603,44 @@ func getUniqueKeysFromObjects(db *gorm.DB, objects []interface{}) map[string]map
 	return result
 }
 
+// generateCartesianProduct 对多列值做笛卡尔积，每行用 sep 连接成一条 key。
+// 例如 valueSlices = [["1"], ["1","2","3"]] -> ["1:1","1:2","1:3"]。
+func generateCartesianProduct(valueSlices [][]string, sep string) []string {
+	if len(valueSlices) == 0 {
+		return nil
+	}
+	n := 1
+	for _, s := range valueSlices {
+		if len(s) == 0 {
+			return nil
+		}
+		n *= len(s)
+	}
+	result := make([]string, 0, n)
+	idx := make([]int, len(valueSlices))
+	for {
+		parts := make([]string, len(valueSlices))
+		for i, s := range valueSlices {
+			parts[i] = s[idx[i]]
+		}
+		result = append(result, strings.Join(parts, sep))
+		// next combination
+		j := len(valueSlices) - 1
+		for j >= 0 {
+			idx[j]++
+			if idx[j] < len(valueSlices[j]) {
+				break
+			}
+			idx[j] = 0
+			j--
+		}
+		if j < 0 {
+			break
+		}
+	}
+	return result
+}
+
 func uniqueStringSlice(slice []string) []string {
 	retSlice := make([]string, 0)
 	mmap := make(map[string]struct{})

cache/helpers_test.go

@@ -375,6 +375,49 @@ func TestGetPrimaryKeyFields(t *testing.T) {
 	}
 }
 
+// TestGetPrimaryKeysFromWhereClause_CompositeKeyCartesianProduct ensures
+// composite primary key with differing value counts (e.g. user_id=1, role_id IN (1,2,3))
+// yields Cartesian product ["1:1","1:2","1:3"], not just ["1:1"].
+func TestGetPrimaryKeysFromWhereClause_CompositeKeyCartesianProduct(t *testing.T) {
+	s := &schema.Schema{
+		Table: "user_roles",
+	}
+	s.Fields = []*schema.Field{
+		{DBName: "user_id", PrimaryKey: true},
+		{DBName: "role_id", PrimaryKey: true},
+		{DBName: "name", PrimaryKey: false},
+	}
+	db := &gorm.DB{
+		Statement: &gorm.Statement{
+			Schema: s,
+		},
+	}
+	db.Statement.Clauses = map[string]clause.Clause{
+		"WHERE": {
+			Expression: clause.Where{
+				Exprs: []clause.Expression{
+					clause.Eq{Column: "user_id", Value: 1},
+					clause.IN{Column: "role_id", Values: []interface{}{1, 2, 3}},
+				},
+			},
+		},
+	}
+	got := getPrimaryKeysFromWhereClause(db)
+	want := []string{"1:1", "1:2", "1:3"}
+	if len(got) != len(want) {
+		t.Fatalf("expected %d keys, got %d: %v", len(want), len(got), got)
+	}
+	seen := make(map[string]bool)
+	for _, k := range got {
+		seen[k] = true
+	}
+	for _, w := range want {
+		if !seen[w] {
+			t.Errorf("missing expected key %q, got %v", w, got)
+		}
+	}
+}
+
 func TestGetAllUniqueIndexes(t *testing.T) {
 	tests := []struct {
 		name          string

cache/query.go

@@ -137,10 +137,10 @@ func (h *queryHandler) BeforeQuery() func(db *gorm.DB) {
 					return
 				}
 
-				// primary cache hit
-				cacheValues, err := cache.BatchGetPrimaryCache(ctx, tableName, primaryKeys)
+				// primary cache hit (use db.Statement.Context: when leader it is bgCtx to avoid cascading cancel)
+				cacheValues, err := cache.BatchGetPrimaryCache(db.Statement.Context, tableName, primaryKeys)
 				if err != nil {
-					cache.Logger.CtxError(ctx, "[BeforeQuery] get primary cache value for key %v error: %v", primaryKeys, err)
+					cache.Logger.CtxError(db.Statement.Context, "[BeforeQuery] get primary cache value for key %v error: %v", primaryKeys, err)
 					db.Error = nil
 					return
 				}
@@ -193,10 +193,10 @@ func (h *queryHandler) BeforeQuery() func(db *gorm.DB) {
 						continue
 					}
 
-					// unique cache hit
-					cacheValues, err := cache.BatchGetUniqueCache(ctx, tableName, uniqueIndexName, uniqueKeys)
+					// unique cache hit (use db.Statement.Context: when leader it is bgCtx to avoid cascading cancel)
+					cacheValues, err := cache.BatchGetUniqueCache(db.Statement.Context, tableName, uniqueIndexName, uniqueKeys)
 					if err != nil {
-						cache.Logger.CtxError(ctx, "[BeforeQuery] get unique cache value for index %s key %v error: %v", uniqueIndexName, uniqueKeys, err)
+						cache.Logger.CtxError(db.Statement.Context, "[BeforeQuery] get unique cache value for index %s key %v error: %v", uniqueIndexName, uniqueKeys, err)
 						continue
 					}
 					if len(cacheValues) != len(uniqueKeys) {
@@ -228,11 +228,11 @@ func (h *queryHandler) BeforeQuery() func(db *gorm.DB) {
 			}
 
 			trySearchCache := func() (hit bool) {
-				// search cache hit
-				cacheValue, err := cache.GetSearchCache(ctx, tableName, sql, db.Statement.Vars...)
+				// search cache hit (use db.Statement.Context: when leader it is bgCtx to avoid cascading cancel)
+				cacheValue, err := cache.GetSearchCache(db.Statement.Context, tableName, sql, db.Statement.Vars...)
 				if err != nil {
 					if !errors.Is(err, storage.ErrCacheNotFound) {
-						cache.Logger.CtxError(ctx, "[BeforeQuery] get cache value for sql %s error: %v", sql, err)
+						cache.Logger.CtxError(db.Statement.Context, "[BeforeQuery] get cache value for sql %s error: %v", sql, err)
 					}
 					db.Error = nil
 					return
@@ -419,7 +419,7 @@ func (h *queryHandler) AfterQuery() func(db *gorm.DB) {
 									}
 								}
 								if len(uniqueKvs) > 0 {
-									cache.Logger.CtxInfo(ctx, "[AfterQuery] start to set unique cache for index %s kvs: %+v", indexName, uniqueKvs)
+									cache.Logger.CtxInfo(ctx, "[AfterQuery] start to set unique cache for index %s count=%d", indexName, len(uniqueKvs))
 									err := cache.BatchSetUniqueCache(ctx, tableName, indexName, uniqueKvs)
 									if err != nil {
 										cache.Logger.CtxError(ctx, "[AfterQuery] batch set unique cache for index %s error: %v", indexName, err)

util/key.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"encoding/base64"
 	"fmt"
 	"math/rand"
 	"reflect"
@@ -19,17 +20,25 @@ func GenInstanceId() string {
 	return string(str)
 }
 
+// joinKeyParts 对多段做 base64 编码后用 sep 连接，避免 "a:b","c" 与 "a","b:c" 碰撞
+func joinKeyParts(parts []string, sep string) string {
+	if len(parts) == 0 {
+		return ""
+	}
+	if len(parts) == 1 {
+		return parts[0]
+	}
+	encoded := make([]string, len(parts))
+	for i, p := range parts {
+		encoded[i] = base64.RawURLEncoding.EncodeToString([]byte(p))
+	}
+	return strings.Join(encoded, sep)
+}
+
 // GenPrimaryCacheKey 生成主键缓存key，支持单个主键和联合主键
-// 如果传入多个参数，会按顺序用":"连接；如果只传入一个参数，直接使用（可能是已经连接好的联合主键）
+// 联合主键各段会做 base64 编码，避免含 ":" 的值产生 key 碰撞
 func GenPrimaryCacheKey(instanceId string, tableName string, primaryKeyValues ...string) string {
-	var key string
-	if len(primaryKeyValues) == 1 {
-		// 单个参数，直接使用（可能是单个主键值，也可能是已经连接好的联合主键）
-		key = primaryKeyValues[0]
-	} else {
-		// 多个参数，用":"连接
-		key = strings.Join(primaryKeyValues, ":")
-	}
+	key := joinKeyParts(primaryKeyValues, ":")
 	return fmt.Sprintf("%s:%s:p:%s:%s", GormCachePrefix, instanceId, tableName, key)
 }
 
@@ -54,16 +63,9 @@ func GenPrimaryCachePrefix(instanceId string, tableName string) string {
 }
 
 // GenUniqueCacheKey 生成unique键缓存key，支持单个unique键和联合unique键
-// 如果传入多个参数，会按顺序用":"连接；如果只传入一个参数，直接使用（可能是已经连接好的联合unique键）
+// 联合unique键各段会做 base64 编码，避免含 ":" 的值产生 key 碰撞
 func GenUniqueCacheKey(instanceId string, tableName string, uniqueIndexName string, uniqueKeyValues ...string) string {
-	var key string
-	if len(uniqueKeyValues) == 1 {
-		// 单个参数，直接使用（可能是单个unique键值，也可能是已经连接好的联合unique键）
-		key = uniqueKeyValues[0]
-	} else {
-		// 多个参数，用":"连接
-		key = strings.Join(uniqueKeyValues, ":")
-	}
+	key := joinKeyParts(uniqueKeyValues, ":")
 	return fmt.Sprintf("%s:%s:u:%s:%s:%s", GormCachePrefix, instanceId, tableName, uniqueIndexName, key)
 }