perf: improve performance search for keys we already found

misc: update readme
i Please enter the commit message for your changes. Lines starting

Author: Flo4604

README.md

@@ -11,18 +11,16 @@ It does not support all the features of unkey-cache yet.
 - [x] Memory Store
 - [x] Redis Store
 - [x] Libsql Store
+      The following Table is needed:
 
 ```sql
-  The following Table is needed:
-  CREATE TABLE cache (
+CREATE TABLE cache
+(
     key TEXT PRIMARY KEY,
-    fresh_until TIMESTAMP,
-    stale_until TIMESTAMP,
-    value TEXT
-  );
-
-  CREATE INDEX idx_fresh_until ON cache (fresh_until);
-  CREATE INDEX idx_stale_until ON cache (stale_until);
+    fresh_until INTEGER,
+    stale_until INTEGER,
+    value       TEXT
+);
 ```
 
 Todo:

example/example.go

@@ -68,8 +68,8 @@ func init() {
 	})
 
 	dbName := "local.db"
-	primaryUrl := "libsql://YOUR_DB.turso.io"
-	authToken := "YOUR_AUTH_TOKEN"
+	primaryUrl := os.Getenv("TURSO_URL")
+	authToken := os.Getenv("TURSO_TOKEN")
 
 	dir, err := os.MkdirTemp("", "libsql-*")
 	if err != nil {
@@ -79,7 +79,9 @@ func init() {
 
 	dbPath := filepath.Join(dir, dbName)
 
-	connector, err := libsql.NewEmbeddedReplicaConnector(dbPath, primaryUrl,
+	connector, err := libsql.NewEmbeddedReplicaConnector(
+		dbPath,
+		primaryUrl,
 		libsql.WithAuthToken(authToken),
 	)
 
@@ -95,7 +97,7 @@ func init() {
 		TableName: "cache",
 	})
 
-	encryption := middleware.WithEncryption("YOUR_SECRET")
+	encryption := middleware.WithEncryption(os.Getenv("ENCRYPTION_KEY"))
 	libSqlEncrypted := encryption.Wrap(libsql)
 
 	c := Cache{
@@ -156,10 +158,15 @@ func main() {
 		Description: "This is a test post",
 	}
 
-	service.cache.String.Set(ctx, "hallo", "welt", nil)
-	stringValue, found, err := service.cache.String.Get(ctx, "hallo")
+	stringValue, err := service.cache.String.Swr(ctx, "hallo", func(string) (*string, error) {
+		str := "welt"
+		return &str, nil
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
 
-	log.Printf("stringValue has value: %+v found %+v err %+v", *stringValue, found, err)
+	log.Printf("stringValue has value: %+v err %+v", *stringValue, err)
 	if err := service.cache.EncryptedStruct.Set(ctx, "p1", p, nil); err != nil {
 		log.Printf("error: %+v", err)
 	}
@@ -334,10 +341,20 @@ func main() {
 
 	start := time.Now()
 	// get them all
-	manyStrings, err := service.cache.User.GetMany(ctx, keys)
+	manyStrings, err := service.cache.String.GetMany(ctx, keys)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	log.Printf("manyStrings: %d took %s", len(manyStrings), time.Since(start))
+	foundKeys := 0
+	notFound := 0
+	for _, m := range manyStrings {
+		if m.Found {
+			foundKeys++
+		} else {
+			notFound++
+		}
+	}
+
+	log.Printf("manyStrings: %d took %s and found %d and not found %d", len(manyStrings), time.Since(start), foundKeys, notFound)
 }

middleware.go

@@ -3,5 +3,5 @@ package cache
 // StoreMiddleware represents a middleware for wrapping a Store
 type StoreMiddleware interface {
 	// Wrap takes a Store and returns a new Store with added functionality
-	Wrap(store Store) Store
+	Wrap(Store) Store
 }

middleware/encryption/encryption.go

@@ -8,6 +8,7 @@ import (
 	"encoding/base64"
 	"fmt"
 	"io"
+	"log"
 	"reflect"
 	"strings"
 
@@ -186,18 +187,21 @@ func (e *EncryptedStore) Decrypt(encryptedValue *EncryptedValue) (string, error)
 func FromBase64Key(base64EncodedKey string) cache.StoreMiddleware {
 	key, err := base64.StdEncoding.DecodeString(base64EncodedKey)
 	if err != nil {
-		panic(err)
+		log.Printf("error: %+v", err)
+		return nil
 	}
 
 	// Verify key length for AES-256
 	if len(key) != 32 {
-		panic(err)
+		log.Printf("error: %+v", err)
+		return nil
 	}
 
 	// Create AES cipher to verify the key
 	_, err = aes.NewCipher(key)
 	if err != nil {
-		panic(err)
+		log.Printf("error: %+v", err)
+		return nil
 	}
 
 	// Compute SHA-256 hash of the key

pkg/util/util.go

@@ -0,0 +1,9 @@
+package util
+
+func MapToString(m map[string]struct{}) []string {
+	ret := make([]string, 0)
+	for k := range m {
+		ret = append(ret, k)
+	}
+	return ret
+}

store.go

@@ -7,6 +7,7 @@ import (
 type Store interface {
 	Name() string
 
+	CreateCacheKey(namespace types.TNamespace, key string) string
 	Get(namespace types.TNamespace, key string, T any) (value types.TValue, found bool, err error)
 	GetMany(namespace types.TNamespace, keys []string, T any) ([]types.TValue, error)
 	Set(namespace types.TNamespace, key string, value types.TValue) error

store/libsql/libsql.go

@@ -6,6 +6,8 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/Southclaws/fault"
+	"github.com/Southclaws/fault/fmsg"
 	"github.com/steamsets/go-cache/pkg/types"
 )
 
@@ -36,12 +38,16 @@ func (l *LibsqlStore) Name() string {
 	return l.name
 }
 
-func (l *LibsqlStore) CreateCacheKey(namespace string, key string) string {
+func (l *LibsqlStore) CreateCacheKey(namespace types.TNamespace, key string) string {
 	return string(namespace) + "::" + key
 }
 
+func (l *LibsqlStore) UndoCacheKey(namespace types.TNamespace, key string) string {
+	return strings.TrimPrefix(key, string(namespace)+"::")
+}
+
 func (l *LibsqlStore) Get(ns types.TNamespace, key string, T any) (value types.TValue, found bool, err error) {
-	cacheKey := l.CreateCacheKey(string(ns), key)
+	cacheKey := l.CreateCacheKey(ns, key)
 	val := types.TValue{Found: false, Key: cacheKey}
 	raw := make([]byte, 0)
 
@@ -60,6 +66,7 @@ func (l *LibsqlStore) Get(ns types.TNamespace, key string, T any) (value types.T
 		return value, false, err
 	}
 
+	val.Key = l.UndoCacheKey(ns, val.Key)
 	val.Found = true
 	val.Value = v.Value
 
@@ -74,35 +81,35 @@ func (l *LibsqlStore) GetMany(ns types.TNamespace, keys []string, T any) ([]type
 
 	keysToGet := make([]interface{}, 0)
 	for _, key := range keys {
-		keysToGet = append(keysToGet, l.CreateCacheKey(string(ns), key))
+		keysToGet = append(keysToGet, l.CreateCacheKey(ns, key))
 	}
 
 	rows, err := l.config.DB.Query("SELECT key, fresh_until, stale_until, value FROM "+l.config.TableName+" WHERE key IN ("+strings.Join(placeHolders, ",")+")", keysToGet...)
 	if err != nil {
-		return nil, err
+		return nil, fault.Wrap(err, fmsg.With("failed to exec query"))
 	}
 
 	defer rows.Close()
 
 	values := make([]types.TValue, 0)
 
 	for rows.Next() {
-		var val types.TValue
+		val := types.TValue{}
 		raw := make([]byte, 0)
 
 		if err := rows.Scan(&val.Key, &val.FreshUntil, &val.StaleUntil, &raw); err != nil {
-			return nil, err
+			return nil, fault.Wrap(err, fmsg.With("failed to scan row"))
 		}
 
 		localT := reflect.New(reflect.TypeOf(T).Elem()).Interface()
-
-		v, err := types.SetTIntoTValue(raw, localT)
+		v, err := types.SetTIntoValue(raw, localT)
 		if err != nil {
 			return nil, err
 		}
 
+		val.Key = l.UndoCacheKey(ns, val.Key)
 		val.Found = true
-		val.Value = v
+		val.Value = v.Value
 		values = append(values, val)
 	}
 
@@ -121,7 +128,7 @@ func (l *LibsqlStore) Set(ns types.TNamespace, key string, value types.TValue) e
 
 	_, err = l.config.DB.Exec(
 		"INSERT OR REPLACE INTO "+l.config.TableName+" (key, fresh_until, stale_until, value) VALUES(?, ?, ?, ?)",
-		l.CreateCacheKey(string(ns), key),
+		l.CreateCacheKey(ns, key),
 		value.FreshUntil,
 		value.StaleUntil,
 		string(b),
@@ -151,7 +158,7 @@ func (l *LibsqlStore) SetMany(ns types.TNamespace, values []types.TValue, opts *
 			}
 
 			sql = sql + "(?, ?, ?, ?),"
-			params = append(params, l.CreateCacheKey(string(ns), v.Key), v.FreshUntil, v.StaleUntil, string(b))
+			params = append(params, l.CreateCacheKey(ns, v.Key), v.FreshUntil, v.StaleUntil, string(b))
 		}
 
 		sql = sql[:len(sql)-1]
@@ -174,7 +181,7 @@ func (l *LibsqlStore) Remove(ns types.TNamespace, key []string) error {
 	keysToDelete := make([]string, 0)
 
 	for _, key := range key {
-		keysToDelete = append(keysToDelete, l.CreateCacheKey(string(ns), key))
+		keysToDelete = append(keysToDelete, l.CreateCacheKey(ns, key))
 	}
 
 	_, err := l.config.DB.Exec("DELETE FROM "+l.config.TableName+" WHERE key IN ("+strings.Join(placeHolders, ",")+")", keysToDelete)

tiered.go

@@ -3,14 +3,14 @@ package cache
 import (
 	"context"
 	"errors"
-	"slices"
 	"strings"
 	"time"
 
 	"github.com/Southclaws/fault"
 	"github.com/Southclaws/fault/fmsg"
 	"github.com/steamsets/go-cache/pkg/telemetry"
 	"github.com/steamsets/go-cache/pkg/types"
+	"github.com/steamsets/go-cache/pkg/util"
 )
 
 type tieredCache[T any] struct {
@@ -115,22 +115,24 @@ func (t tieredCache[T]) GetMany(ctx context.Context, ns types.TNamespace, keys [
 		return nil, errors.New("no stores found")
 	}
 
+	keysToGet := make(map[string]struct{}, 0)
 	valuesToSet := make([]types.TValue, 0)
 	foundValues := make(map[string]types.TValue)
 
 	// We need to check for all keys in all stores
 	// If we can't find one key in a store we need to check the lower stores for all values except
 	// the ones that we already found
 
-	// Hack, not sure why but I need to copy the whole array in order to not modify the original
-	keysToFind := make([]string, len(keys))
-	copy(keysToFind, keys)
+	for _, key := range keys {
+		keysToGet[key] = struct{}{}
+	}
 
 	for _, store := range t.stores {
 		// we already found all keys
-		if len(keysToFind) == 0 {
+		if len(keysToGet) == 0 {
 			break
 		}
+		keysToFind := util.MapToString(keysToGet)
 
 		var result T
 		ctx, span := telemetry.NewSpan(ctx, store.Name()+".get-many")
@@ -139,8 +141,8 @@ func (t tieredCache[T]) GetMany(ctx context.Context, ns types.TNamespace, keys [
 			telemetry.AttributeKV{Key: "keys", Value: keysToFind},
 			telemetry.AttributeKV{Key: "namespace", Value: string(ns)},
 		)
-		values, err := store.GetMany(t.ns, keysToFind, &result)
 
+		values, err := store.GetMany(t.ns, keysToFind, &result)
 		if err != nil {
 			telemetry.RecordError(span, err)
 			return nil, fault.Wrap(err, fmsg.With(store.Name()+" failed to get keys: "+strings.Join(keys, ",")))
@@ -150,15 +152,8 @@ func (t tieredCache[T]) GetMany(ctx context.Context, ns types.TNamespace, keys [
 			if v.Found {
 				// Since we found it set it to the lower stores
 				valuesToSet = append(valuesToSet, v)
-
 				// But we should not look for it again
-				for i, k := range keysToFind {
-					if k == v.Key {
-						keysToFind = slices.Delete(keysToFind, i, i+1)
-						break
-					}
-				}
-
+				delete(keysToGet, v.Key)
 				foundValues[v.Key] = v
 			}
 		}
@@ -172,7 +167,7 @@ func (t tieredCache[T]) GetMany(ctx context.Context, ns types.TNamespace, keys [
 				_, span := telemetry.NewSpan(ctx, lowerStore.Name()+".set-many")
 				defer span.End()
 				telemetry.WithAttributes(span,
-					telemetry.AttributeKV{Key: "keys", Value: keysToFind},
+					telemetry.AttributeKV{Key: "keys_amount", Value: len(keysToGet)},
 					telemetry.AttributeKV{Key: "namespace", Value: string(ns)},
 				)
 				if err := lowerStore.SetMany(t.ns, valuesToSet, nil); err != nil {
@@ -187,7 +182,6 @@ func (t tieredCache[T]) GetMany(ctx context.Context, ns types.TNamespace, keys [
 	}
 
 	valuesToReturn := make([]types.TValue, 0)
-
 	// Now we need to map all the values which we did find or didn't
 	for _, key := range keys {
 		if v, ok := foundValues[key]; !ok {