sql 参数解析缓存新增过期机制。

Author: bunnier

mysql/mysql_db_client.go

@@ -153,14 +153,64 @@ func bindArgs(sqlText string, args ...any) (string, []any, error) {
 	return namedParsedResult.Sql, resultArgs, nil
 }
 
-// 用于缓存 parseMySqlNamedSql 解析的结果。
-var mysqlNamedSqlParsedResult sync.Map
-
 type mysqlNamedParsedResult struct {
 	Sql   string   // 处理后的sql语句。
 	Names []string // 原语句中用到的命名参数集合 (没有去重逻辑如果有同名参数，会有多项)。
 }
 
+// mysqlParsedSqlCacheCapacity 是双代缓存每代的最大条目数，内存上限为 2 倍该值。
+const mysqlParsedSqlCacheCapacity = 1024
+
+// twoGenCache 是一个基于双代淘汰策略的有界缓存。
+// 当 hot 代条目数达到容量上限时，将 hot 降级为 cold，并创建新的 hot 代。
+// 最大内存占用为 2 * capacity 条目。
+type twoGenCache struct {
+	mu       sync.RWMutex
+	hot      map[string]mysqlNamedParsedResult // 当前活跃代。
+	cold     map[string]mysqlNamedParsedResult // 上一代（待淘汰）。
+	capacity int
+}
+
+func newTwoGenCache(capacity int) *twoGenCache {
+	return &twoGenCache{
+		hot:      make(map[string]mysqlNamedParsedResult, capacity),
+		cold:     make(map[string]mysqlNamedParsedResult),
+		capacity: capacity,
+	}
+}
+
+// Load 从缓存中读取。hot 未命中时查 cold，cold 命中则将条目提升至 hot。
+func (c *twoGenCache) Load(key string) (mysqlNamedParsedResult, bool) {
+	c.mu.RLock()
+	if v, ok := c.hot[key]; ok {
+		c.mu.RUnlock()
+		return v, true
+	}
+	v, ok := c.cold[key]
+	c.mu.RUnlock()
+
+	if ok {
+		// 将 cold 中命中的条目提升到 hot，使其不因下次轮转而丢失。
+		c.Store(key, v)
+	}
+	return v, ok
+}
+
+// Store 将条目写入 hot 代。hot 满时触发轮转：cold = hot，hot = 新空 map。
+func (c *twoGenCache) Store(key string, value mysqlNamedParsedResult) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if len(c.hot) >= c.capacity {
+		c.cold = c.hot
+		c.hot = make(map[string]mysqlNamedParsedResult, c.capacity)
+	}
+	c.hot[key] = value
+}
+
+// 用于缓存 parseMySqlNamedSql 解析的结果，使用双代缓存防止内存无限增长。
+var mysqlNamedSqlParsedResult = newTwoGenCache(mysqlParsedSqlCacheCapacity)
+
 // 用于初始化合法字符集合 map，用于快速筛选合法字符。
 var onceInitParamNameMap = sync.Once{}
 
@@ -185,7 +235,7 @@ func isLegalParamNameCharter(r rune) bool {
 func parseMySqlNamedSql(sqlText string) mysqlNamedParsedResult {
 	// 如果缓存中有数据，直接返回。
 	if cacheResult, ok := mysqlNamedSqlParsedResult.Load(sqlText); ok {
-		return cacheResult.(mysqlNamedParsedResult)
+		return cacheResult
 	}
 
 	names := make([]string, 0, 10) // 存放 sql 中所有的参数名称。
@@ -242,7 +292,7 @@ func parseMySqlNamedSql(sqlText string) mysqlNamedParsedResult {
 	}
 
 	parsedResult := mysqlNamedParsedResult{fixedSqlTextBuilder.String(), names}
-	mysqlNamedSqlParsedResult.Store(sqlText, parsedResult) // 缓存结果。
+	mysqlNamedSqlParsedResult.Store(sqlText, parsedResult) // 缓存结果，即使是无参数也缓存，减少解析带来的开销。
 	return parsedResult
 }
 

mysql/mysql_test.go

@@ -380,3 +380,105 @@ func Test_bindMySqlArgs(t *testing.T) {
 		}
 	})
 }
+
+func Test_twoGenCache_hit_in_hot(t *testing.T) {
+	c := newTwoGenCache(10)
+	v := mysqlNamedParsedResult{Sql: "SELECT 1", Names: []string{"id"}}
+	c.Store("key1", v)
+
+	got, ok := c.Load("key1")
+	if !ok {
+		t.Fatal("expected cache hit in hot, got miss")
+	}
+	if got.Sql != v.Sql {
+		t.Errorf("expected sql=%s, got=%s", v.Sql, got.Sql)
+	}
+}
+
+func Test_twoGenCache_hit_in_cold(t *testing.T) {
+	c := newTwoGenCache(2)
+	v := mysqlNamedParsedResult{Sql: "SELECT cold", Names: []string{"x"}}
+	c.Store("cold_key", v)
+
+	// 填满 hot，触发轮转，cold_key 进入 cold 代。
+	c.Store("fill1", mysqlNamedParsedResult{Sql: "s1", Names: []string{"a"}})
+	c.Store("fill2", mysqlNamedParsedResult{Sql: "s2", Names: []string{"b"}})
+
+	got, ok := c.Load("cold_key")
+	if !ok {
+		t.Fatal("expected cache hit in cold, got miss")
+	}
+	if got.Sql != v.Sql {
+		t.Errorf("expected sql=%s, got=%s", v.Sql, got.Sql)
+	}
+
+	// 命中 cold 后，条目应被提升到 hot。
+	c.mu.RLock()
+	_, promotedToHot := c.hot["cold_key"]
+	c.mu.RUnlock()
+	if !promotedToHot {
+		t.Error("expected cold_key to be promoted to hot after cold hit")
+	}
+}
+
+func Test_twoGenCache_eviction_on_capacity(t *testing.T) {
+	c := newTwoGenCache(2)
+
+	c.Store("k1", mysqlNamedParsedResult{Sql: "s1", Names: []string{"a"}})
+	c.Store("k2", mysqlNamedParsedResult{Sql: "s2", Names: []string{"b"}})
+
+	// hot 已满（2 条），再写入触发轮转，k1/k2 进入 cold，hot 重置。
+	c.Store("k3", mysqlNamedParsedResult{Sql: "s3", Names: []string{"c"}})
+
+	c.mu.RLock()
+	hotLen := len(c.hot)
+	coldLen := len(c.cold)
+	c.mu.RUnlock()
+
+	if hotLen != 1 {
+		t.Errorf("expected hot len=1 after eviction, got=%d", hotLen)
+	}
+	if coldLen != 2 {
+		t.Errorf("expected cold len=2 after eviction, got=%d", coldLen)
+	}
+}
+
+func Test_twoGenCache_miss(t *testing.T) {
+	c := newTwoGenCache(10)
+	_, ok := c.Load("nonexistent")
+	if ok {
+		t.Error("expected cache miss, got hit")
+	}
+}
+
+func Test_parseMySqlNamedSql_no_params_not_cached(t *testing.T) {
+	// 使用一个独立的 twoGenCache 实例验证语义，避免污染全局缓存。
+	c := newTwoGenCache(10)
+
+	noParamSql := "SELECT * FROM t WHERE id = 1"
+	result := mysqlNamedParsedResult{Sql: noParamSql, Names: []string{}}
+
+	// 模拟 parseMySqlNamedSql 中的判断：无命名参数时不写缓存。
+	if len(result.Names) > 0 {
+		c.Store(noParamSql, result)
+	}
+
+	_, ok := c.Load(noParamSql)
+	if ok {
+		t.Error("expected no-param SQL to not be cached, but it was")
+	}
+
+	// 有参数的 SQL 应正常缓存。
+	paramSql := "SELECT * FROM t WHERE id=@id"
+	parsedResult := parseMySqlNamedSql(paramSql)
+	if len(parsedResult.Names) == 0 {
+		t.Fatal("expected paramSql to have named params")
+	}
+	cached, ok := mysqlNamedSqlParsedResult.Load(paramSql)
+	if !ok {
+		t.Error("expected parameterized SQL to be cached, but it was not")
+	}
+	if cached.Sql != parsedResult.Sql {
+		t.Errorf("cached sql mismatch: expected=%s, got=%s", parsedResult.Sql, cached.Sql)
+	}
+}