kvutil

type Cache[K comparable, V Model] struct {
	// contains filtered or unexported fields
}

type CacheConfig[K comparable, V Model] struct {

	// Storage must return a Storage implementation which will be used
	// as the underlying key-value storage.
	Storage func(ctx context.Context) Storage

	// IDFunc returns the primary key of a Model object.
	IDFunc func(V) K

	// KeyFunc specifies the key function to use with the storage.
	KeyFunc Key

	// MGetBatchSize optionally specifies the batch size for one MGet
	// calling to storage. The default is 200.
	MGetBatchSize int

	// MSetBatchSize optionally specifies the batch size for one MSet
	// calling to storage. The default is 200.
	MSetBatchSize int

	// DeleteBatchSize optionally specifies the batch size for one Delete
	// calling to storage. The default is 200.
	DeleteBatchSize int

	// LRUCache optionally enables LRU cache, which may help to improve
	// the performance for high concurrency use-case.
	LRUCache lru.Interface[K, V]

	// LRUExpiration specifies the expiration time for data in LRU cache.
	// The default is one second.
	LRUExpiration time.Duration

	// Loader optionally specifies a function to load data from underlying
	// persistent storage when the data is missing from cache.
	Loader Loader[K, V]

	// LoaderBatchSize optionally specifies the batch size for calling
	// Loader. The default is 500.
	LoaderBatchSize int

	// CacheExpiration specifies the expiration time to cache the data to
	// Storage, when Loader is configured and data are loaded by Loader.
	// The default is zero, which means no expiration.
	CacheExpiration time.Duration

	// CacheLoaderResultAsync makes the Cache to save data from Loader
	// to Storage async, errors returned from Storage.MSet will be ignored.
	// The default is false, it reports errors to the caller.
	CacheLoaderResultAsync bool
}

type KVPair struct {
	K string
	V []byte
}

type Key func(args ...any) string

type KeyFactory struct {
	// contains filtered or unexported fields
}

type Loader[K comparable, V Model] func(ctx context.Context, pks []K) (map[K]V, error)

type Model interface {
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
}

type ShardingCache[K comparable, V ShardingModel] struct {
	// contains filtered or unexported fields
}

type ShardingCacheConfig[K comparable, V ShardingModel] struct {

	// Storage must return a Storage implementation which will be used
	// as the underlying key-value storage.
	Storage func(ctx context.Context) Storage

	// IDFunc returns the primary key of a ShardingModel object.
	IDFunc func(V) K

	// KeyFunc specifies the key function to use with the storage.
	KeyFunc Key

	// ShardingSize configures the maximum length of data in a shard.
	// When the serialization result of V is longer than ShardingSize,
	// the data will be split into shards to save to storage.
	//
	// ShardingSize must be greater than zero, else it panics.
	ShardingSize int

	// MGetBatchSize optionally specifies the batch size for one MGet
	// calling to storage. The default is 200.
	MGetBatchSize int

	// MSetBatchSize optionally specifies the batch size for one MSet
	// calling to storage. The default is 200.
	MSetBatchSize int

	// DeleteBatchSize optionally specifies the batch size for one Delete
	// calling to storage. The default is 200.
	DeleteBatchSize int
}

type ShardingData struct {
	TotalNum int32  `protobuf:"varint,1,opt,name=total_num,json=totalNum,proto3" json:"total_num,omitempty"`
	ShardNum int32  `protobuf:"varint,2,opt,name=shard_num,json=shardNum,proto3" json:"shard_num,omitempty"`
	Digest   []byte `protobuf:"bytes,3,opt,name=digest,proto3" json:"digest,omitempty"`
	Data     []byte `protobuf:"bytes,4,opt,name=data,json=data,proto3" json:"data,omitempty"`
}

type ShardingModel interface {
	Model

	// GetShardingData returns whether a model is a shard or a complete model.
	// When the returned bool value is false, the returned ShardingData
	// can be a zero value, and shall not be used.
	GetShardingData() (ShardingData, bool)

	// SetShardingData sets a shard data to a new model created when
	// doing serialization to split data into shards and save to storage.
	SetShardingData(data ShardingData)
}

type Storage interface {
	MGet(ctx context.Context, keys ...string) ([][]byte, error)
	MSet(ctx context.Context, kvPairs []KVPair, expiration time.Duration) error
	Delete(ctx context.Context, keys ...string) error
}