Double Data Storage

entry/entry.go

@@ -12,11 +12,17 @@ type Entry struct {
 	Expiry int64
 }
 
-func (e Entry) IsExpired() bool {
+func (e *Entry) CopyData() []byte {
+	result := make([]byte, len(e.Data))
+	copy(result, e.Data)
+	return result
+}
+
+func (e *Entry) IsExpired() bool {
 	return e.IsExpiredWithUnixMilli(time.Now().UnixMilli())
 }
 
-func (e Entry) IsExpiredWithUnixMilli(now int64) bool {
+func (e *Entry) IsExpiredWithUnixMilli(now int64) bool {
 	return e.Expiry > 0 && e.Expiry <= now
 }
 

entry/type_boolean.go

@@ -0,0 +1,23 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsBool() (bool, error) {
+	if e.Type != types.BOOLEAN {
+		return false, errors.ErrTypeMismatch(types.BOOLEAN, e.Type)
+	}
+	return len(e.Data) > 0 && e.Data[0] == 1, nil
+}
+
+func FromBool(value bool, exp time.Duration) Entry {
+	v := byte(0)
+	if value {
+		v = 1
+	}
+	return NewEntry(types.BOOLEAN, []byte{v}, exp)
+}

entry/type_float.go

@@ -0,0 +1,31 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsFloat32() (float32, error) {
+	if e.Type != types.FLOAT32 {
+		return 0, errors.ErrTypeMismatch(types.FLOAT32, e.Type)
+	}
+	return utils.Binary2Float32(e.Data)
+}
+
+func FromFloat32(value float32, exp time.Duration) Entry {
+	return NewEntry(types.FLOAT32, utils.Float32toBinary(value), exp)
+}
+
+func (e *Entry) AsFloat64() (float64, error) {
+	if e.Type != types.FLOAT64 {
+		return 0, errors.ErrTypeMismatch(types.FLOAT64, e.Type)
+	}
+	return utils.Binary2Float64(e.Data)
+}
+
+func FromFloat64(key string, value float64, exp time.Duration) Entry {
+	return NewEntry(types.FLOAT64, utils.Float64toBinary(value), exp)
+}

entry/type_integer.go

@@ -0,0 +1,42 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsInt16() (int16, error) {
+	if e.Type != types.INT16 {
+		return 0, errors.ErrTypeMismatch(types.INT16, e.Type)
+	}
+	return utils.Binary2Int16(e.Data)
+}
+
+func FromInt16(value int16, exp time.Duration) Entry {
+	return NewEntry(types.INT16, utils.Int16toBinary(value), exp)
+}
+
+func (e *Entry) AsInt32() (int32, error) {
+	if e.Type != types.INT32 {
+		return 0, errors.ErrTypeMismatch(types.INT32, e.Type)
+	}
+	return utils.Binary2Int32(e.Data)
+}
+
+func FromInt32(key string, value int32, exp time.Duration) Entry {
+	return NewEntry(types.INT32, utils.Int32toBinary(value), exp)
+}
+
+func (e *Entry) AsInt64() (int64, error) {
+	if e.Type != types.INT64 {
+		return 0, errors.ErrTypeMismatch(types.INT64, e.Type)
+	}
+	return utils.Binary2Int64(e.Data)
+}
+
+func FromInt64(key string, value int64, exp time.Duration) Entry {
+	return NewEntry(types.INT64, utils.Int64toBinary(value), exp)
+}

entry/type_json.go

@@ -0,0 +1,27 @@
+package entry
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsJSON(target interface{}) error {
+	if e.Type != types.JSON {
+		return errors.ErrTypeMismatch(types.JSON, e.Type)
+	}
+	if len(e.Data) == 0 {
+		return errors.ErrDataEmpty
+	}
+	return json.Unmarshal(e.Data, target)
+}
+
+func FromJSON(value interface{}, exp time.Duration) (Entry, error) {
+	if data, err := json.Marshal(value); err != nil {
+		return Entry{}, err
+	} else {
+		return NewEntry(types.JSON, data, exp), nil
+	}
+}

entry/type_raw.go

@@ -0,0 +1,28 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsRaw() ([]byte, error) {
+	if e.Type != types.RAW {
+		return nil, errors.ErrTypeMismatch(types.RAW, e.Type)
+	}
+
+	return e.CopyData(), nil
+}
+
+func (e *Entry) AsRawNoCopy() ([]byte, error) {
+	if e.Type != types.RAW {
+		return nil, errors.ErrTypeMismatch(types.RAW, e.Type)
+	}
+
+	return e.Data, nil
+}
+
+func FromRaw(value []byte, exp time.Duration) Entry {
+	return NewEntry(types.RAW, value, exp)
+}

entry/type_string.go

@@ -0,0 +1,19 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsString() (string, error) {
+	if e.Type != types.STRING {
+		return "", errors.ErrTypeMismatch(types.STRING, e.Type)
+	}
+	return string(e.Data), nil
+}
+
+func FromString(value string, exp time.Duration) Entry {
+	return NewEntry(types.STRING, []byte(value), exp)
+}

entry/type_time.go

@@ -0,0 +1,28 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsTime() (time.Time, error) {
+	var t time.Time
+	if e.Type != types.TIME {
+		return t, errors.ErrTypeMismatch(types.TIME, e.Type)
+	}
+	if len(e.Data) == 0 {
+		return t, errors.ErrDataEmpty
+	}
+	err := t.UnmarshalBinary(e.Data)
+	return t, err
+}
+
+func FromTime(value time.Time, exp time.Duration) (Entry, error) {
+	if b, err := value.MarshalBinary(); err != nil {
+		return Entry{}, err
+	} else {
+		return NewEntry(types.TIME, b, exp), nil
+	}
+}

entry/type_uinteger.go

@@ -0,0 +1,42 @@
+package entry
+
+import (
+	"time"
+
+	"github.com/found-cake/CacheStore/errors"
+	"github.com/found-cake/CacheStore/utils"
+	"github.com/found-cake/CacheStore/utils/types"
+)
+
+func (e *Entry) AsUInt16() (uint16, error) {
+	if e.Type != types.UINT16 {
+		return 0, errors.ErrTypeMismatch(types.UINT16, e.Type)
+	}
+	return utils.Binary2UInt16(e.Data)
+}
+
+func FromUInt16(value uint16, exp time.Duration) Entry {
+	return NewEntry(types.UINT16, utils.UInt16toBinary(value), exp)
+}
+
+func (e *Entry) AsUInt32() (uint32, error) {
+	if e.Type != types.UINT32 {
+		return 0, errors.ErrTypeMismatch(types.UINT32, e.Type)
+	}
+	return utils.Binary2UInt32(e.Data)
+}
+
+func FromUInt32(value uint32, exp time.Duration) Entry {
+	return NewEntry(types.UINT32, utils.UInt32toBinary(value), exp)
+}
+
+func (e *Entry) AsUInt64() (uint64, error) {
+	if e.Type != types.UINT64 {
+		return 0, errors.ErrTypeMismatch(types.UINT64, e.Type)
+	}
+	return utils.Binary2UInt64(e.Data)
+}
+
+func FromUInt64(value uint64, exp time.Duration) Entry {
+	return NewEntry(types.UINT64, utils.UInt64toBinary(value), exp)
+}

errors/errors.go

@@ -11,6 +11,10 @@ import (
 
 var (
 	ErrKeyEmpty            = errors.New("key cannot be empty")
+	ErrDataEmpty           = errors.New("data cannot be empty")
+	ErrIsClosed            = errors.New("cache store is closed")
+	ErrAlreadyCommit       = errors.New("transaction already committed")
+	ErrNotLocked           = errors.New("read transaction not locked")
 	ErrValueNil            = errors.New("value cannot be null")
 	ErrDBNotInit           = errors.New("database not initialized")
 	ErrFileNameEmpty       = errors.New("filename cannot be empty")
@@ -28,9 +32,9 @@ func ErrNoDataForKey(key string) error {
 	return fmt.Errorf("no data found for key: %s", key)
 }
 
-func ErrTypeMismatch(key string, expected, actual types.DataType) error {
-	return fmt.Errorf("type mismatch for key '%s': expected %s, got %s",
-		key, expected.String(), actual.String())
+func ErrTypeMismatch(expected, actual types.DataType) error {
+	return fmt.Errorf("type mismatch: expected %s, got %s",
+		expected.String(), actual.String())
 }
 
 func ErrUnsignedUnderflow[T generic.Unsigned](key string, current, delta T) error {

sqlite/sqlite.go

@@ -52,18 +52,19 @@ func NewSqliteStore(filename string) (*SqliteStore, error) {
 	}, nil
 }
 
-func (s *SqliteStore) LoadFromDB() (map[string]entry.Entry, error) {
+func (s *SqliteStore) LoadFromDB() (map[string]entry.Entry, map[string]entry.Entry, error) {
 	if s.db == nil {
-		return nil, errors.ErrDBNotInit
+		return nil, nil, errors.ErrDBNotInit
 	}
 
 	rows, err := s.db.Query("SELECT key, data_type, data, expiry FROM cache_data")
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	defer rows.Close()
 
-	dbData := make(map[string]entry.Entry)
+	tempdb := make(map[string]entry.Entry)
+	persidb := make(map[string]entry.Entry)
 	now := time.Now().UnixMilli()
 	for rows.Next() {
 		var key string
@@ -76,18 +77,25 @@ func (s *SqliteStore) LoadFromDB() (map[string]entry.Entry, error) {
 			continue
 		}
 
+		if expiry == 0 {
+			persidb[key] = entry.Entry{
+				Type: dataType,
+				Data: data,
+			}
+		}
+
 		if expiry > 0 && expiry <= now {
 			continue
 		}
 
-		dbData[key] = entry.Entry{
+		tempdb[key] = entry.Entry{
 			Type:   dataType,
 			Data:   data,
 			Expiry: expiry,
 		}
 	}
 
-	return dbData, nil
+	return tempdb, persidb, nil
 }
 
 func (s *SqliteStore) SaveDirtyData(set_dirtys map[string]entry.Entry, delete_dirtys []string) error {

sqlite/sqlite_test.go

@@ -28,7 +28,7 @@ func TestNewSqliteStore_InvalidFileName(t *testing.T) {
 
 func TestNewSqliteStore_NoDBInit(t *testing.T) {
 	s := &SqliteStore{}
-	_, err := s.LoadFromDB()
+	_, _, err := s.LoadFromDB()
 	if err == nil {
 		t.Error("expected error for not initialized sql")
 	}
@@ -66,7 +66,7 @@ func TestSqliteStore_Save_ForceLock(t *testing.T) {
 	store.mux.Unlock()
 	<-unlocked
 
-	loaded, err := store.LoadFromDB()
+	loaded, _, err := store.LoadFromDB()
 	if err != nil {
 		t.Fatalf("load error: %v", err)
 	}
@@ -102,7 +102,7 @@ func TestSqliteStore_SaveDirtyData(t *testing.T) {
 		t.Errorf("force lock Save failed: %v", err)
 	}
 
-	loaded, err := store.LoadFromDB()
+	loaded, _, err := store.LoadFromDB()
 	if err != nil {
 		t.Fatalf("load error: %v", err)
 	}
@@ -116,7 +116,7 @@ func TestSqliteStore_SaveDirtyData(t *testing.T) {
 
 	store.SaveDirtyData(dirtyData, []string{"foo"})
 
-	loaded, err = store.LoadFromDB()
+	loaded, _, err = store.LoadFromDB()
 	if err != nil {
 		t.Fatalf("load error: %v", err)
 	}
@@ -154,7 +154,7 @@ func TestSqliteStore_Load(t *testing.T) {
 	if err != nil {
 		t.Errorf("force lock Save failed: %v", err)
 	}
-	loaded, err := store.LoadFromDB()
+	loaded, _, err := store.LoadFromDB()
 	if err != nil {
 		t.Fatalf("load error: %v", err)
 	}
@@ -177,7 +177,7 @@ func TestSqliteStore_Load_FilterExpired(t *testing.T) {
 		t.Errorf("force lock Save failed: %v", err)
 	}
 	time.Sleep(200 * time.Millisecond)
-	loaded, err := store.LoadFromDB()
+	loaded, _, err := store.LoadFromDB()
 	if err != nil {
 		t.Fatalf("load error: %v", err)
 	}