add MGet/Mset methods

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

redis.go

@@ -3,6 +3,8 @@ package redis // import "go.unistack.org/micro-store-redis/v3"
 import (
 	"context"
 	"fmt"
+	"reflect"
+	"strings"
 	"time"
 
 	"github.com/go-redis/redis/v8"
@@ -14,18 +16,20 @@ type rkv struct {
 	cli  redisClient
 }
 
-// TODO: add ability to set some redis options https://pkg.go.dev/github.com/go-redis/redis/v8#Options
 type redisClient interface {
 	Get(ctx context.Context, key string) *redis.StringCmd
 	Del(ctx context.Context, keys ...string) *redis.IntCmd
 	Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd
 	Keys(ctx context.Context, pattern string) *redis.StringSliceCmd
+	MGet(ctx context.Context, keys ...string) *redis.SliceCmd
+	MSet(ctx context.Context, kv ...interface{}) *redis.StatusCmd
 	Exists(ctx context.Context, keys ...string) *redis.IntCmd
+	Ping(ctx context.Context) *redis.StatusCmd
 	Close() error
 }
 
 func (r *rkv) Connect(ctx context.Context) error {
-	return nil
+	return r.cli.Ping(ctx).Err()
 }
 
 func (r *rkv) Init(opts ...store.Option) error {
@@ -45,17 +49,19 @@ func (r *rkv) Exists(ctx context.Context, key string, opts ...store.ExistsOption
 	if len(options.Namespace) == 0 {
 		options.Namespace = r.opts.Namespace
 	}
+	if options.Namespace != "" {
+		key = fmt.Sprintf("%s%s", r.opts.Namespace, key)
+	}
 	if r.opts.Timeout > 0 {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, r.opts.Timeout)
 		defer cancel()
 	}
-	rkey := fmt.Sprintf("%s%s", options.Namespace, key)
-	st, err := r.cli.Exists(ctx, rkey).Result()
+	val, err := r.cli.Exists(ctx, key).Result()
 	if err != nil {
 		return err
 	}
-	if st == 0 {
+	if val == 0 {
 		return store.ErrNotFound
 	}
 	return nil
@@ -66,13 +72,15 @@ func (r *rkv) Read(ctx context.Context, key string, val interface{}, opts ...sto
 	if len(options.Namespace) == 0 {
 		options.Namespace = r.opts.Namespace
 	}
+	if options.Namespace != "" {
+		key = fmt.Sprintf("%s%s", options.Namespace, key)
+	}
 	if r.opts.Timeout > 0 {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, r.opts.Timeout)
 		defer cancel()
 	}
-	rkey := fmt.Sprintf("%s%s", options.Namespace, key)
-	buf, err := r.cli.Get(ctx, rkey).Bytes()
+	buf, err := r.cli.Get(ctx, key).Bytes()
 	if err != nil && err == redis.Nil {
 		return store.ErrNotFound
 	} else if err != nil {
@@ -81,34 +89,97 @@ func (r *rkv) Read(ctx context.Context, key string, val interface{}, opts ...sto
 	if buf == nil {
 		return store.ErrNotFound
 	}
-	/*
-			d, err := r.Client.TTL(rkey).Result()
-			if err != nil {
-				return nil, err
-			}
-
-			records = append(records, &store.Record{
-				Key:    key,
-				Value:  val,
-				Expiry: d,
-			})
-		}
-	*/
 	return r.opts.Codec.Unmarshal(buf, val)
 }
 
+func (r *rkv) MRead(ctx context.Context, keys []string, vals interface{}, opts ...store.ReadOption) error {
+	if len(keys) == 1 {
+		vt := reflect.ValueOf(vals)
+		if vt.Kind() == reflect.Ptr {
+			vt = reflect.Indirect(vt)
+			return r.Read(ctx, keys[0], vt.Index(0).Interface(), opts...)
+		}
+	}
+	options := store.NewReadOptions(opts...)
+	rkeys := make([]string, 0, len(keys))
+	if len(options.Namespace) == 0 {
+		options.Namespace = r.opts.Namespace
+	}
+	for _, key := range keys {
+		if options.Namespace != "" {
+			rkeys = append(rkeys, fmt.Sprintf("%s%s", options.Namespace, key))
+		} else {
+			rkeys = append(rkeys, key)
+		}
+	}
+	if r.opts.Timeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, r.opts.Timeout)
+		defer cancel()
+	}
+	rvals, err := r.cli.MGet(ctx, rkeys...).Result()
+	if err != nil && err == redis.Nil {
+		return store.ErrNotFound
+	} else if err != nil {
+		return err
+	}
+	if len(rvals) == 0 {
+		return store.ErrNotFound
+	}
+
+	vv := reflect.ValueOf(vals)
+	vt := reflect.TypeOf(vals)
+	switch vv.Kind() {
+	case reflect.Ptr:
+		vv = reflect.Indirect(vv)
+		vt = vt.Elem()
+	}
+	if vv.Kind() != reflect.Slice {
+		return store.ErrNotFound
+	}
+	nvv := reflect.MakeSlice(vt, len(rvals), len(rvals))
+	vt = vt.Elem()
+	for idx := 0; idx < len(rvals); idx++ {
+		if rvals[idx] == nil {
+			continue
+		}
+
+		itm := nvv.Index(idx)
+		var buf []byte
+		switch b := rvals[idx].(type) {
+		case []byte:
+			buf = b
+		case string:
+			buf = []byte(b)
+		}
+		// special case for raw data
+		if vt.Kind() == reflect.Slice && vt.Elem().Kind() == reflect.Uint8 {
+			itm.Set(reflect.MakeSlice(itm.Type(), len(buf), len(buf)))
+		} else {
+			itm.Set(reflect.New(vt.Elem()))
+		}
+		if err = r.opts.Codec.Unmarshal(buf, itm.Interface()); err != nil {
+			return err
+		}
+	}
+	vv.Set(nvv)
+	return nil
+}
+
 func (r *rkv) Delete(ctx context.Context, key string, opts ...store.DeleteOption) error {
 	options := store.NewDeleteOptions(opts...)
 	if len(options.Namespace) == 0 {
 		options.Namespace = r.opts.Namespace
 	}
+	if options.Namespace == "" {
+		return r.cli.Del(ctx, key).Err()
+	}
 	if r.opts.Timeout > 0 {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, r.opts.Timeout)
 		defer cancel()
 	}
-	rkey := fmt.Sprintf("%s%s", options.Namespace, key)
-	return r.cli.Del(ctx, rkey).Err()
+	return r.cli.Del(ctx, fmt.Sprintf("%s%s", options.Namespace, key)).Err()
 }
 
 func (r *rkv) Write(ctx context.Context, key string, val interface{}, opts ...store.WriteOption) error {
@@ -116,18 +187,19 @@ func (r *rkv) Write(ctx context.Context, key string, val interface{}, opts ...st
 	if len(options.Namespace) == 0 {
 		options.Namespace = r.opts.Namespace
 	}
-
-	rkey := fmt.Sprintf("%s%s", options.Namespace, key)
 	buf, err := r.opts.Codec.Marshal(val)
 	if err != nil {
 		return err
 	}
+	if options.Namespace != "" {
+		key = fmt.Sprintf("%s%s", options.Namespace, key)
+	}
 	if r.opts.Timeout > 0 {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, r.opts.Timeout)
 		defer cancel()
 	}
-	return r.cli.Set(ctx, rkey, buf, options.TTL).Err()
+	return r.cli.Set(ctx, key, buf, options.TTL).Err()
 }
 
 func (r *rkv) List(ctx context.Context, opts ...store.ListOption) ([]string, error) {
@@ -135,18 +207,30 @@ func (r *rkv) List(ctx context.Context, opts ...store.ListOption) ([]string, err
 	if len(options.Namespace) == 0 {
 		options.Namespace = r.opts.Namespace
 	}
+
+	rkey := fmt.Sprintf("%s%s*", options.Namespace, options.Prefix)
+	if options.Suffix != "" {
+		rkey += options.Suffix
+	}
 	if r.opts.Timeout > 0 {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, r.opts.Timeout)
 		defer cancel()
 	}
 	// TODO: add support for prefix/suffix/limit
-	keys, err := r.cli.Keys(ctx, "*").Result()
+	keys, err := r.cli.Keys(ctx, rkey).Result()
 	if err != nil {
 		return nil, err
 	}
+	if options.Namespace == "" {
+		return keys, nil
+	}
 
-	return keys, nil
+	nkeys := make([]string, 0, len(keys))
+	for _, key := range keys {
+		nkeys = append(nkeys, strings.TrimPrefix(key, options.Namespace))
+	}
+	return nkeys, nil
 }
 
 func (r *rkv) Options() store.Options {
@@ -161,7 +245,7 @@ func (r *rkv) String() string {
 	return "redis"
 }
 
-func NewStore(opts ...store.Option) store.Store {
+func NewStore(opts ...store.Option) *rkv {
 	return &rkv{opts: store.NewOptions(opts...)}
 }