feat: improve coverage of TempTableCache

Author: pieterlukasse

tests/utils_tests/utils_test.go

@@ -422,3 +422,71 @@ func TestCheckAndGetLastCustomConceptVariableDef(t *testing.T) {
 	}
 
 }
+
+func TestTempTableCache(t *testing.T) {
+	setUp(t)
+	var tempTableCache = &utils.CacheSimple{
+		Data:    make(map[string]interface{}),
+		MaxSize: 3,
+	}
+	tempTableCache.Set("abc_key", "abc_value")
+	value, exists := tempTableCache.Get("abc_key")
+	if value == nil || !exists || value != "abc_value" {
+		t.Errorf("Expected abc_value but got: exists=%v, value=%s", exists, value)
+	}
+
+	// The cache has maxsize 3.
+	// Scenario 1: After adding 3 new items, the .Get("abc_key") should result in empty,
+	// as it will have been removed.
+	// Scenario 2: The cache will keep items that were re-set (.Set) or recently retrieved (with .Get) "warm",
+	// meaning that they get moved to the end of the queue of who gets dropped next from cache. So, in
+	// this scenario, we want to add 2 new items, then .Get("abc_key"), then add one more item, and
+	// assert that  "abc_key" is still in, while the older of the 2 new items got dropped.
+
+	// (Scenario 1) Add 3 new items; "abc_key" should be removed
+	tempTableCache.Set("key1", "value1")
+	tempTableCache.Set("key2", "value2")
+	tempTableCache.Set("key3", "value3")
+	value, exists = tempTableCache.Get("abc_key")
+	if exists {
+		t.Errorf("Expected abc_key to be evicted, but it still exists with value: %v", value)
+	}
+
+	// (Scenario 2) Keep "abc_key" warm and verify eviction order
+	tempTableCache.Set("abc_key", "abc_value")
+	tempTableCache.Set("key4", "value4")
+	tempTableCache.Set("key5", "value5")
+	_, _ = tempTableCache.Get("abc_key") // Access abc_key to keep it warm
+	tempTableCache.Set("key6", "value6") // Since abc_key is warm, key4 should be evicted at this point
+	value, exists = tempTableCache.Get("abc_key")
+	if !exists || value != "abc_value" {
+		t.Errorf("Expected abc_key to be retained, but it was evicted")
+	}
+	value, exists = tempTableCache.Get("key4")
+	if exists {
+		t.Errorf("Expected key4 to be evicted, but it still exists with value: %v", value)
+	}
+
+	// Scenario 3: like scenario 2, but with Set. The .Set method
+	// should be repeatable and also keeps the entry "warm"
+	// (Scenario 2) Keep "abc_key" warm and verify eviction order
+	tempTableCache.Set("abc_key", "abc_value")
+	tempTableCache.Set("key4", "value4")
+	tempTableCache.Set("key5", "value5")
+	tempTableCache.Set("abc_key", "new_value1") // Reset abc_key to keep it warm, updating its value at the same time
+	tempTableCache.Set("abc_key", "new_value2") // Reset abc_key to keep it warm, updating its value at the same time
+	tempTableCache.Set("abc_key", "new_value3") // Reset abc_key to keep it warm, updating its value at the same time
+	tempTableCache.Set("key6", "value6")        // Since abc_key is warm, key4 should be evicted at this point
+	value, exists = tempTableCache.Get("abc_key")
+	if !exists || value != "new_value3" {
+		t.Errorf("Expected abc_key to be retained, but it was evicted, or expected value does not match. Value: %s", value)
+	}
+	value, exists = tempTableCache.Get("key4")
+	if exists {
+		t.Errorf("Expected key4 to be evicted, but it still exists with value: %v", value)
+	}
+	value, exists = tempTableCache.Get("key5")
+	if !exists || value != "value5" {
+		t.Errorf("Expected abc_key to be retained, but it was evicted, or expected value does not match. Value: %s", value)
+	}
+}

utils/temptablecache.go

@@ -6,16 +6,16 @@ import (
 
 // TempTableCache is a thread-safe cache for storing temporary table mappings
 var TempTableCache = &CacheSimple{
-	data:        make(map[string]interface{}),
-	maxSize:     10,
+	Data:        make(map[string]interface{}),
+	MaxSize:     100, // Note: this might need some tweaking if in a highly concurrent space...which is not the case now. Setting it too high risks too many temp tables..filling db.
 	accessOrder: make([]string, 0),
 }
 
 // Defines a thread-safe in-memory cache
 type CacheSimple struct {
-	data        map[string]interface{}
+	Data        map[string]interface{}
+	MaxSize     int
 	mu          sync.RWMutex
-	maxSize     int
 	accessOrder []string // Keeps track of insertion order for cleanup
 }
 
@@ -24,7 +24,7 @@ func (c *CacheSimple) Get(key string) (interface{}, bool) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 
-	value, exists := c.data[key]
+	value, exists := c.Data[key]
 	// If the key already exists, update its position in the queue, so it is kept a bit longer:
 	if exists {
 		c.moveToEnd(key)
@@ -38,24 +38,24 @@ func (c *CacheSimple) Set(key string, value interface{}) {
 	defer c.mu.Unlock()
 
 	// If the key already exists, update its value and move it to the end of the access order
-	if _, exists := c.data[key]; exists {
-		c.data[key] = value
+	if _, exists := c.Data[key]; exists {
+		c.Data[key] = value
 		c.moveToEnd(key)
 		return
 	}
 
 	// Add the new key-value pair
-	c.data[key] = value
+	c.Data[key] = value
 	c.accessOrder = append(c.accessOrder, key)
 
 	// If the cache exceeds its maximum size, remove the oldest / least recently accessed entry
-	if len(c.accessOrder) > c.maxSize {
+	if len(c.accessOrder) > c.MaxSize {
 		oldestKey := c.accessOrder[0]
 		c.accessOrder = c.accessOrder[1:]
-		delete(c.data, oldestKey)
-
+		delete(c.Data, oldestKey)
+		c.removeFromOrder(oldestKey)
 		// Optionally drop the corresponding table
-		dropTable(oldestKey)
+		// dropTable(key) - probably not necessary if DB cleans up tmp tables automatically when session closes
 	}
 }
 
@@ -64,9 +64,11 @@ func (c *CacheSimple) Delete(key string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
-	if _, exists := c.data[key]; exists {
-		delete(c.data, key)
+	if _, exists := c.Data[key]; exists {
+		delete(c.Data, key)
 		c.removeFromOrder(key)
+		// Optionally drop the corresponding table
+		// dropTable(key) - probably not necessary if DB cleans up tmp tables automatically when session closes
 	}
 }
 
@@ -90,9 +92,3 @@ func (c *CacheSimple) removeFromOrder(key string) {
 		}
 	}
 }
-
-// Drops a temporary table (to be implemented based on your database logic)
-func dropTable(key string) {
-	// Add logic to drop the temporary table associated with the key
-	// Example: db.Exec(fmt.Sprintf("DROP TABLE %s", key))
-}