fix: new thoughts of design

Author: yusank

datastruct/consts.go

@@ -0,0 +1,19 @@
+package datastruct
+
+import (
+	"errors"
+)
+
+type KeyType string
+
+const (
+	KeyTypeString    KeyType = "string"
+	KeyTypeList      KeyType = "list"
+	KeyTypeSet       KeyType = "set"
+	KeyTypeSortedSet KeyType = "sortedSet"
+	KeyTypeHashMap   KeyType = "hashMap"
+)
+
+var (
+	ErrNil = errors.New("redis: not found")
+)

datastruct/memory.go

@@ -4,7 +4,35 @@ import (
 	"sync"
 )
 
+var defaultCache = newMemoryCache()
+
 // MemoryCache 总数结构
 type MemoryCache struct {
-	Keys sync.Map
+	keys sync.Map
+}
+
+func newMemoryCache() *MemoryCache {
+	return &MemoryCache{keys: sync.Map{}}
+}
+
+type KeyInfo struct {
+	Type KeyType
+}
+
+func (m *MemoryCache) Exists(key string) bool {
+	_, ok := m.keys.Load(key)
+	return ok
+}
+
+func (m *MemoryCache) Set(key string, kt KeyType) {
+	m.keys.Store(key, &KeyInfo{Type: kt})
+}
+
+func (m *MemoryCache) Type(key string) (kt KeyType, found bool) {
+	v, ok := m.keys.Load(key)
+	if !ok {
+		return "", false
+	}
+
+	return v.(*KeyInfo).Type, true
 }

datastruct/operate.go

@@ -0,0 +1,50 @@
+package datastruct
+
+import (
+	"sync"
+)
+
+type String struct {
+	m  sync.Map
+	mc *MemoryCache
+}
+
+func newString(mc *MemoryCache) *String {
+	return &String{
+		m:  sync.Map{},
+		mc: mc,
+	}
+}
+
+var (
+	StringImpl = newString(defaultCache)
+)
+
+func (s *String) Set(key, value string, options []string) error {
+	s.mc.Set(key, KeyTypeString)
+
+	s.m.Store(key, value)
+	return nil
+}
+
+func (s *String) Get(key string) (value string, err error) {
+	v, ok := s.m.Load(key)
+	if !ok {
+		return "", ErrNil
+	}
+
+	return v.(string), nil
+}
+
+func (s *String) MGet(keys []string) (values []string, err error) {
+	for _, key := range keys {
+		v, ok := s.m.Load(key)
+		if !ok {
+			values = append(values, "")
+		}
+
+		values = append(values, v.(string))
+	}
+
+	return
+}

datastruct/string.go

@@ -34,8 +34,8 @@ func TestEncodeDataWithSimpleString(t *testing.T) {
 
 func TestEncodeDataWithArray(t *testing.T) {
 	var want = "*2\r\n$6\r\nHello \r\n$5\r\nWorld\r\n"
-	assert.Equal(t, want, encodeDataWithArray(
-		encodeBulkString("Hello "),
-		encodeBulkString("World"),
+	assert.Equal(t, want, encodeBulkStrings(
+		"Hello ",
+		"World",
 	))
 }

protocol/encode_test.go

@@ -1,3 +1,15 @@
 # redis
 
-Implement how to execute redis command.
+Implement how to execute redis command.
+
+## TODO
+
+拆开 command 的实现和数据底层操作的逻辑,最后根据根命令找到对应的方法,然后传入 Command struct,但是这样做很有可能会出现 cycle import 问题,
+这个可以通过定义 interface 的方式解决不直接调用实现即可,但是如何通过 command 确定要调的方法呢?
+
+## 暂时想法
+
+1. 由 `exec` 方法作为入口,内部实现对 `datastruct` 包内的方法的封装,
+2. `datastruct` 包保持独立,不引入 redis 或者 protocol 包
+
+![redis.exec](..//static/redis.png)

redis/README.md

@@ -36,15 +36,6 @@ func NewCommandFromMsg(msg *protocol.Message) *Command {
 // 2. found cmd excute func
 
 func (c *Command) Execute(ctx context.Context) (rsp []byte, err error) {
-	f, ok := KnownCommands[c.Command]
-	if !ok {
-		return wrapError(ErrUnknownCommand), nil
-	}
-
-	result, err := f(c)
-	if err != nil {
-		return wrapError(err), nil
-	}
-
-	return wrapResult(result), nil
+	//return exec(c)
+	return wrapResult([]string{RespOK}), err
 }

redis/command.go

@@ -2,16 +2,6 @@ package redis
 
 import "errors"
 
-type KeyType string
-
-const (
-	KeyTypeString    KeyType = "string"
-	KeyTypeList      KeyType = "list"
-	KeyTypeSet       KeyType = "set"
-	KeyTypeSortedSet KeyType = "sortedSet"
-	KeyTypeHashMap   KeyType = "hashMap"
-)
-
 var (
 	ErrUnknownCommand = errors.New("unknown command key")
 )

redis/consts.go

@@ -0,0 +1,16 @@
+package redis
+
+// exec 实现 Command 到 真正执行底层数据操作的过程
+func exec(c *Command) (reply []interface{}, err error) {
+	f, ok := KnownCommands[c.Command]
+	if !ok {
+		return nil, ErrUnknownCommand
+	}
+
+	result, err := f(c)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

redis/exec.go

@@ -1,28 +1,26 @@
 package redis
 
 // ExecuteFunc define command execute, returns slice of string as result and error if has any error occur .
-type ExecuteFunc func(*Command) ([]string, error)
+type ExecuteFunc func(*Command) ([]interface{}, error)
 
-func defaultExecFunc(c *Command) ([]string, error) {
-	return []string{RespOK}, nil
+func defaultExecFunc(c *Command) ([]interface{}, error) {
+	return []interface{}{RespOK}, nil
 }
 
 var KnownCommands = map[string]ExecuteFunc{
 	// native
-	"command": func(c *Command) ([]string, error) {
-		return []string{RespCommand}, nil
+	"command": func(c *Command) ([]interface{}, error) {
+		return []interface{}{RespCommand}, nil
 	},
-	"ping": func(c *Command) ([]string, error) {
-		return []string{RespPong}, nil
+	"ping": func(c *Command) ([]interface{}, error) {
+		return []interface{}{RespPong}, nil
 	},
 	// strings
 	"append": defaultExecFunc,
 	"incr":   defaultExecFunc,
 	"decr":   defaultExecFunc,
 	"get":    defaultExecFunc,
-	"mget": func(c *Command) ([]string, error) {
-		return c.Values, nil
-	},
-	"set": defaultExecFunc,
+	"mget":   defaultExecFunc,
+	"set":    defaultExecFunc,
 	//... more
 }