Merge branch 'master' into ttl-set

Author: sjcsjc123

README.md

@@ -17,7 +17,7 @@ English | [简体中文](https://github.com/ByteStorage/flydb/blob/master/README
 You can install FlyDB using the Go command line tool:
 
 ```GO
-go get github.com/ByteStorage/FlyDB@v1.0.13
+go get github.com/ByteStorage/FlyDB@v1.1.0
 ```
 
 Or clone this project from github:

structure/hash.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ByteStorage/FlyDB/config"
 	"github.com/ByteStorage/FlyDB/engine"
 	_const "github.com/ByteStorage/FlyDB/lib/const"
+	"regexp"
 	"strconv"
 	"time"
 )
@@ -1158,21 +1159,41 @@ func (hs *HashStructure) HTypes(k string, f interface{}) (string, error) {
 //
 // []string: A list of field names in the hash.
 // error: An error if occurred during the operation, or nil on success.
-func (hs *HashStructure) Keys() []string {
+func (hs *HashStructure) Keys(regx string) ([]string, error) {
+	toRegexp := convertToRegexp(regx)
+	compile, err := regexp.Compile(toRegexp)
+	if err != nil {
+		return nil, err
+	}
 	// Get all the keys from the database
-	byte_keys := hs.db.GetListKeys()
+	byteKeys := hs.db.GetListKeys()
 
 	// Create a new slice of strings
 	keys := make([]string, 0)
 
-	for _, key := range byte_keys {
-		// Check if the key has the identifier suffix
-		if !keysIdentify(key) {
-			keys = append(keys, string(key))
+	for _, key := range byteKeys {
+		if compile.MatchString(string(key)) {
+			// Check if the key has the identifier suffix
+			if !keysIdentify(key) {
+				fields := hs.GetFields(string(key))
+				ok := true
+				for _, field := range fields {
+					_, err := hs.HGet(string(key), field)
+					if err != nil {
+						ok = false
+						break
+					}
+				}
+				if !ok {
+					continue
+				}
+				keys = append(keys, string(key))
+			}
 		}
+
 	}
 
-	return keys
+	return keys, nil
 }
 
 // GetFields returns a list of all field names in the hash stored at the specified key.

structure/hash_test.go

@@ -553,6 +553,22 @@ func TestHashStructure_GetFields(t *testing.T) {
 	fields2 := hash.GetFields("qqqqqq")
 	assert.Equal(t, fields2, []string{"!qqq!1", "!qqq!2", "!qqq!3"})
 
+	keys, err := hash.Keys("*")
+	assert.Nil(t, err)
+	assert.Equal(t, keys, []string{"qqqqqq", "qweqwe"})
+
+	keys, err = hash.Keys("q*")
+	assert.Nil(t, err)
+	assert.Equal(t, keys, []string{"qqqqqq", "qweqwe"})
+
+	keys, err = hash.Keys("qq*")
+	assert.Nil(t, err)
+	assert.Equal(t, keys, []string{"qqqqqq"})
+
+	keys, err = hash.Keys("q?*")
+	assert.Nil(t, err)
+	assert.Equal(t, keys, []string{"qqqqqq", "qweqwe"})
+
 }
 
 func TestHashStructure_HGetAllFieldAndValue(t *testing.T) {

structure/list.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"regexp"
 	"time"
 
 	"encoding/gob"
@@ -433,11 +434,27 @@ func (l *ListStructure) LIndex(key string, index int) (interface{}, error) {
 }
 
 // Keys returns all the keys of the list structure.
-func (l *ListStructure) Keys() ([]string, error) {
+func (l *ListStructure) Keys(regx string) ([]string, error) {
+	toRegexp := convertToRegexp(regx)
+	compile, err := regexp.Compile(toRegexp)
+	if err != nil {
+		return nil, err
+	}
 	var keys []string
-	byte_keys := l.db.GetListKeys()
-	for _, key := range byte_keys {
-		keys = append(keys, string(key))
+	byteKeys := l.db.GetListKeys()
+	for _, key := range byteKeys {
+		// match prefix and key
+		if compile.MatchString(string(key)) {
+			// check if deleted
+			db, _, err := l.getListFromDB(string(key), true)
+			if err != nil {
+				continue
+			}
+			if db.Length == 0 {
+				continue
+			}
+			keys = append(keys, string(key))
+		}
 	}
 	return keys, nil
 }

structure/list_test.go

@@ -379,16 +379,32 @@ func TestListStructure_Keys(t *testing.T) {
 	list, _ := initList()
 	defer list.db.Clean()
 
-	listErr = list.LPush("1", randkv.RandomValue(100), 0)
+	listErr = list.LPush("111", randkv.RandomValue(100), 0)
 	assert.Nil(t, listErr)
 
-	listErr = list.LPush("2", randkv.RandomValue(100), 0)
+	listErr = list.LPush("122", randkv.RandomValue(100), 0)
 	assert.Nil(t, listErr)
 
-	listErr = list.LPush("q", randkv.RandomValue(100), 0)
+	listErr = list.LPush("123", randkv.RandomValue(100), 0)
 	assert.Nil(t, listErr)
 
-	keys, err := list.Keys()
+	keys, err := list.Keys("*")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 3)
+
+	keys, err = list.Keys("1*")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 3)
+
+	keys, err = list.Keys("12*")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 2)
+
+	keys, err = list.Keys("123")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 1)
+
+	keys, err = list.Keys("1?*")
 	assert.Nil(t, err)
 	assert.Equal(t, len(keys), 3)
 }

structure/set.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ByteStorage/FlyDB/engine"
 	_const "github.com/ByteStorage/FlyDB/lib/const"
 	"github.com/ByteStorage/FlyDB/lib/encoding"
+	"regexp"
 	"time"
 )
 
@@ -229,6 +230,27 @@ func (s *SetStructure) SDiff(keys ...string) ([]string, error) {
 	return diffMembers, nil
 }
 
+// Keys returns all the keys of the set structure
+func (s *SetStructure) Keys(regx string) ([]string, error) {
+	toRegexp := convertToRegexp(regx)
+	compile, err := regexp.Compile(toRegexp)
+	if err != nil {
+		return nil, err
+	}
+	var keys []string
+	byteKeys := s.db.GetListKeys()
+	for _, key := range byteKeys {
+		if compile.MatchString(string(key)) {
+			// check if deleted
+			if !s.exists(string(key)) {
+				continue
+			}
+			keys = append(keys, string(key))
+		}
+	}
+	return keys, nil
+}
+
 // SUnionStore calculates and stores the union of multiple sets
 // in a destination set.
 //
@@ -385,7 +407,7 @@ type FSetWithTTL struct {
 
 // setSetToDB
 func (s *SetStructure) setSetToDB(key []byte, zSetValue *FSets, ttl time.Duration) error {
-	// 创建新的结构体实例，包含zSetValue和TTL值
+	// create a new zSetValueWithTTL struct
 	var expire int64 = 0
 
 	if ttl != 0 {
@@ -398,7 +420,7 @@ func (s *SetStructure) setSetToDB(key []byte, zSetValue *FSets, ttl time.Duratio
 	}
 
 	val := encoding.NewMessagePackEncoder()
-	err := val.Encode(valueWithTTL) // 编码包含zSetValue和TTL的新的结构体
+	err := val.Encode(valueWithTTL) // Encode the value along with TTL
 	if err != nil {
 		return err
 	}
@@ -427,15 +449,6 @@ func (s *FSets) exists(member ...string) bool {
 	return true
 }
 
-func (s *SetStructure) Keys() ([]string, error) {
-	var keys []string
-	byte_keys := s.db.GetListKeys()
-	for _, key := range byte_keys {
-		keys = append(keys, string(key))
-	}
-	return keys, nil
-}
-
 func (s *SetStructure) Stop() error {
 	err := s.db.Close()
 	return err

structure/set_test.go

@@ -1139,3 +1139,41 @@ func TestFSets_remove(t *testing.T) {
 		})
 	}
 }
+
+func TestSetStructure_Keys(t *testing.T) {
+	set, _ := initTestSetDb()
+	defer set.db.Clean()
+
+	err = set.SAdd("testKey11", "non1", 0)
+	assert.Nil(t, err)
+
+	err = set.SAdd("testKey12", "non1", 0)
+	assert.Nil(t, err)
+
+	err = set.SAdd("testKey3", "non1", 0)
+	assert.Nil(t, err)
+
+	err = set.SAdd("testKey4", "non1", 0)
+	assert.Nil(t, err)
+
+	keys, err := set.Keys("*")
+	assert.Nil(t, err)
+	assert.Equal(t, 4, len(keys))
+
+	keys, err = set.Keys("testKey*")
+	assert.Nil(t, err)
+	assert.Equal(t, 4, len(keys))
+
+	keys, err = set.Keys("testKey1*")
+	assert.Nil(t, err)
+	assert.Equal(t, 2, len(keys))
+
+	keys, err = set.Keys("testKey?*")
+	assert.Nil(t, err)
+	assert.Equal(t, 4, len(keys))
+
+	keys, err = set.Keys("testKey111?*")
+	assert.Nil(t, err)
+	assert.Equal(t, 0, len(keys))
+
+}

structure/string.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ByteStorage/FlyDB/config"
 	"github.com/ByteStorage/FlyDB/engine"
 	_const "github.com/ByteStorage/FlyDB/lib/const"
+	"regexp"
 	"strconv"
 	"time"
 )
@@ -311,20 +312,24 @@ func (s *StringStructure) DecrBy(key string, amount int, ttl int64) error {
 }
 
 // Keys returns all keys matching pattern
-func (s *StringStructure) Keys() ([]string, error) {
+func (s *StringStructure) Keys(regx string) ([]string, error) {
+	toRegexp := convertToRegexp(regx)
+	compile, err := regexp.Compile(toRegexp)
+	if err != nil {
+		return nil, err
+	}
 	var keys []string
 	byteKeys := s.db.GetListKeys()
 	for _, key := range byteKeys {
-		// check if key is expired
-		_, err := s.Get(string(key))
-		if err != nil {
-			if errors.Is(err, _const.ErrKeyIsExpired) {
+		if compile.MatchString(string(key)) {
+			// check if key is expired
+			_, err := s.Get(string(key))
+			if err != nil {
 				continue
-			} else {
-				return nil, err
 			}
+			keys = append(keys, string(key))
 		}
-		keys = append(keys, string(key))
+
 	}
 	return keys, nil
 }

structure/string_test.go

@@ -425,13 +425,13 @@ func TestStringStructure_Keys(t *testing.T) {
 	str, _ := initdb()
 	defer str.db.Clean()
 
-	err = str.Set("1", randkv.RandomValue(100), 1)
+	err = str.Set("11", randkv.RandomValue(100), 1)
 	assert.Nil(t, err)
 
-	err = str.Set("2", randkv.RandomValue(100), 2)
+	err = str.Set("21", randkv.RandomValue(100), 2)
 	assert.Nil(t, err)
 
-	err = str.Set("3", randkv.RandomValue(100), 0)
+	err = str.Set("31", randkv.RandomValue(100), 0)
 	assert.Nil(t, err)
 
 	err = str.Set("hhh", randkv.RandomValue(100), 0)
@@ -442,9 +442,21 @@ func TestStringStructure_Keys(t *testing.T) {
 
 	time.Sleep(2 * time.Second)
 
-	keys, err := str.Keys()
+	keys, err := str.Keys("*")
 	assert.Nil(t, err)
 	assert.Equal(t, len(keys), 3)
+
+	keys, err = str.Keys("1*")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 0)
+
+	keys, err = str.Keys("3*")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 1)
+
+	keys, err = str.Keys("*1")
+	assert.Nil(t, err)
+	assert.Equal(t, len(keys), 1)
 }
 
 func TestStringStructure_TTL(t *testing.T) {

structure/types.go

@@ -2,7 +2,9 @@ package structure
 
 import (
 	"errors"
+	"regexp"
 	"strconv"
+	"strings"
 )
 
 type DataStructure = byte
@@ -189,3 +191,15 @@ func convertToFloat(Value interface{}) (float64, error) {
 		return 0, errors.New("unsupported type")
 	}
 }
+
+func convertToRegexp(pattern string) string {
+	// 转义正则特殊字符
+	re := regexp.MustCompile(`([\[\]\(\)\{\}\^\$\.\+])`)
+	pattern = re.ReplaceAllString(pattern, `\$1`)
+
+	// 将 * 和 ? 转换为对应的正则表达式
+	pattern = strings.ReplaceAll(pattern, "*", ".*")
+	pattern = strings.ReplaceAll(pattern, "?", ".")
+
+	return "^" + pattern + "$" // 添加 ^ 和 $ 以确保完全匹配
+}