apps/redis-go
0
0
Fork 0
mirror of https://github.com/HDT3213/godis.git synced 2025-10-05 16:57:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

add some unit tests

Browse Source
This commit is contained in:
hdt3213
2021-03-31 17:11:46 +08:00
parent 4b01bbb52a
commit bf913a5aca
16 changed files with 2866 additions and 2198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
src/cluster/cluster.go
View File

@@ -1,177 +1,133 @@
package cluster
import (
"context"
"errors"
"fmt"
"github.com/HDT3213/godis/src/cluster/idgenerator"
"github.com/HDT3213/godis/src/config"
"github.com/HDT3213/godis/src/datastruct/dict"
"github.com/HDT3213/godis/src/db"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/lib/consistenthash"
"github.com/HDT3213/godis/src/lib/logger"
"github.com/HDT3213/godis/src/redis/client"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/jolestar/go-commons-pool/v2"
"runtime/debug"
"strings"
"context"
"fmt"
"github.com/HDT3213/godis/src/cluster/idgenerator"
"github.com/HDT3213/godis/src/config"
"github.com/HDT3213/godis/src/datastruct/dict"
"github.com/HDT3213/godis/src/db"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/lib/consistenthash"
"github.com/HDT3213/godis/src/lib/logger"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/jolestar/go-commons-pool/v2"
"runtime/debug"
"strings"
)
type Cluster struct {
self string
self string
peerPicker *consistenthash.Map
peerConnection map[string]*pool.ObjectPool
peerPicker *consistenthash.Map
peerConnection map[string]*pool.ObjectPool
db *db.DB
transactions *dict.SimpleDict // id -> Transaction
db *db.DB
transactions *dict.SimpleDict // id -> Transaction
idGenerator *idgenerator.IdGenerator
idGenerator *idgenerator.IdGenerator
}
const (
replicas = 4
lockSize = 64
replicas = 4
lockSize = 64
)
func MakeCluster() *Cluster {
cluster := &Cluster{
self: config.Properties.Self,
cluster := &Cluster{
self: config.Properties.Self,
db: db.MakeDB(),
transactions: dict.MakeSimple(),
peerPicker: consistenthash.New(replicas, nil),
peerConnection: make(map[string]*pool.ObjectPool),
db: db.MakeDB(),
transactions: dict.MakeSimple(),
peerPicker: consistenthash.New(replicas, nil),
peerConnection: make(map[string]*pool.ObjectPool),
idGenerator: idgenerator.MakeGenerator("godis", config.Properties.Self),
}
if config.Properties.Peers != nil && len(config.Properties.Peers) > 0 && config.Properties.Self != "" {
contains := make(map[string]bool)
peers := make([]string, 0, len(config.Properties.Peers)+1)
for _, peer := range config.Properties.Peers {
if _, ok := contains[peer]; ok {
continue
}
contains[peer] = true
peers = append(peers, peer)
}
peers = append(peers, config.Properties.Self)
cluster.peerPicker.Add(peers...)
ctx := context.Background()
for _, peer := range peers {
cluster.peerConnection[peer] = pool.NewObjectPoolWithDefaultConfig(ctx, &ConnectionFactory{
Peer: peer,
})
}
}
return cluster
idGenerator: idgenerator.MakeGenerator("godis", config.Properties.Self),
}
if config.Properties.Peers != nil && len(config.Properties.Peers) > 0 && config.Properties.Self != "" {
contains := make(map[string]bool)
peers := make([]string, 0, len(config.Properties.Peers)+1)
for _, peer := range config.Properties.Peers {
if _, ok := contains[peer]; ok {
continue
}
contains[peer] = true
peers = append(peers, peer)
}
peers = append(peers, config.Properties.Self)
cluster.peerPicker.Add(peers...)
ctx := context.Background()
for _, peer := range peers {
cluster.peerConnection[peer] = pool.NewObjectPoolWithDefaultConfig(ctx, &ConnectionFactory{
Peer: peer,
})
}
}
return cluster
}
// args contains all
type CmdFunc func(cluster *Cluster, c redis.Connection, args [][]byte) redis.Reply
func (cluster *Cluster) Close() {
cluster.db.Close()
cluster.db.Close()
}
var router = MakeRouter()
func (cluster *Cluster) Exec(c redis.Connection, args [][]byte) (result redis.Reply) {
defer func() {
if err := recover(); err != nil {
logger.Warn(fmt.Sprintf("error occurs: %v\n%s", err, string(debug.Stack())))
result = &reply.UnknownErrReply{}
}
}()
defer func() {
if err := recover(); err != nil {
logger.Warn(fmt.Sprintf("error occurs: %v\n%s", err, string(debug.Stack())))
result = &reply.UnknownErrReply{}
}
}()
cmd := strings.ToLower(string(args[0]))
cmdFunc, ok := router[cmd]
if !ok {
return reply.MakeErrReply("ERR unknown command '" + cmd + "', or not supported in cluster mode")
}
result = cmdFunc(cluster, c, args)
return
cmd := strings.ToLower(string(args[0]))
cmdFunc, ok := router[cmd]
if !ok {
return reply.MakeErrReply("ERR unknown command '" + cmd + "', or not supported in cluster mode")
}
result = cmdFunc(cluster, c, args)
return
}
func (cluster *Cluster) AfterClientClose(c redis.Connection) {
}
func (cluster *Cluster) getPeerClient(peer string) (*client.Client, error) {
connectionFactory, ok := cluster.peerConnection[peer]
if !ok {
return nil, errors.New("connection factory not found")
}
raw, err := connectionFactory.BorrowObject(context.Background())
if err != nil {
return nil, err
}
conn, ok := raw.(*client.Client)
if !ok {
return nil, errors.New("connection factory make wrong type")
}
return conn, nil
}
func (cluster *Cluster) returnPeerClient(peer string, peerClient *client.Client) error {
connectionFactory, ok := cluster.peerConnection[peer]
if !ok {
return errors.New("connection factory not found")
}
return connectionFactory.ReturnObject(context.Background(), peerClient)
}
func Ping(cluster *Cluster, c redis.Connection, args [][]byte) redis.Reply {
if len(args) == 1 {
return &reply.PongReply{}
} else if len(args) == 2 {
return reply.MakeStatusReply("\"" + string(args[1]) + "\"")
} else {
return reply.MakeErrReply("ERR wrong number of arguments for 'ping' command")
}
}
// relay command to peer
// cannot call Prepare, Commit, Rollback of self node
func (cluster *Cluster) Relay(peer string, c redis.Connection, args [][]byte) redis.Reply {
if peer == cluster.self {
// to self db
return cluster.db.Exec(c, args)
} else {
peerClient, err := cluster.getPeerClient(peer)
if err != nil {
return reply.MakeErrReply(err.Error())
}
defer func() {
_ = cluster.returnPeerClient(peer, peerClient)
}()
return peerClient.Send(args)
}
if len(args) == 1 {
return &reply.PongReply{}
} else if len(args) == 2 {
return reply.MakeStatusReply("\"" + string(args[1]) + "\"")
} else {
return reply.MakeErrReply("ERR wrong number of arguments for 'ping' command")
}
}
/*----- utils -------*/
func makeArgs(cmd string, args ...string) [][]byte {
result := make([][]byte, len(args)+1)
result[0] = []byte(cmd)
for i, arg := range args {
result[i+1] = []byte(arg)
}
return result
result := make([][]byte, len(args)+1)
result[0] = []byte(cmd)
for i, arg := range args {
result[i+1] = []byte(arg)
}
return result
}
// return peer -> keys
func (cluster *Cluster) groupBy(keys []string) map[string][]string {
result := make(map[string][]string)
for _, key := range keys {
peer := cluster.peerPicker.Get(key)
group, ok := result[peer]
if !ok {
group = make([]string, 0)
}
group = append(group, key)
result[peer] = group
}
return result
result := make(map[string][]string)
for _, key := range keys {
peer := cluster.peerPicker.Get(key)
group, ok := result[peer]
if !ok {
group = make([]string, 0)
}
group = append(group, key)
result[peer] = group
}
return result
}

52
src/cluster/com.go Normal file
View File

@@ -0,0 +1,52 @@
// communicate with peers within cluster
package cluster
import (
"context"
"errors"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/client"
"github.com/HDT3213/godis/src/redis/reply"
)
func (cluster *Cluster) getPeerClient(peer string) (*client.Client, error) {
connectionFactory, ok := cluster.peerConnection[peer]
if !ok {
return nil, errors.New("connection factory not found")
}
raw, err := connectionFactory.BorrowObject(context.Background())
if err != nil {
return nil, err
}
conn, ok := raw.(*client.Client)
if !ok {
return nil, errors.New("connection factory make wrong type")
}
return conn, nil
}
func (cluster *Cluster) returnPeerClient(peer string, peerClient *client.Client) error {
connectionFactory, ok := cluster.peerConnection[peer]
if !ok {
return errors.New("connection factory not found")
}
return connectionFactory.ReturnObject(context.Background(), peerClient)
}
// relay command to peer
// cannot call Prepare, Commit, Rollback of self node
func (cluster *Cluster) Relay(peer string, c redis.Connection, args [][]byte) redis.Reply {
if peer == cluster.self {
// to self db
return cluster.db.Exec(c, args)
} else {
peerClient, err := cluster.getPeerClient(peer)
if err != nil {
return reply.MakeErrReply(err.Error())
}
defer func() {
_ = cluster.returnPeerClient(peer, peerClient)
}()
return peerClient.Send(args)
}
}

162
src/datastruct/set/set.go
View File

@@ -3,114 +3,114 @@ package set
import "github.com/HDT3213/godis/src/datastruct/dict"
type Set struct {
dict dict.Dict
dict dict.Dict
}
func Make() *Set {
return &Set{
dict: dict.MakeSimple(),
}
return &Set{
dict: dict.MakeSimple(),
}
}
func MakeFromVals(members ...string)*Set {
set := &Set{
dict: dict.MakeConcurrent(len(members)),
}
for _, member := range members {
set.Add(member)
}
return set
func MakeFromVals(members ...string) *Set {
set := &Set{
dict: dict.MakeConcurrent(len(members)),
}
for _, member := range members {
set.Add(member)
}
return set
}
func (set *Set)Add(val string)int {
return set.dict.Put(val, true)
func (set *Set) Add(val string) int {
return set.dict.Put(val, nil)
}
func (set *Set)Remove(val string)int {
return set.dict.Remove(val)
func (set *Set) Remove(val string) int {
return set.dict.Remove(val)
}
func (set *Set)Has(val string)bool {
_, exists := set.dict.Get(val)
return exists
func (set *Set) Has(val string) bool {
_, exists := set.dict.Get(val)
return exists
}
func (set *Set)Len()int {
return set.dict.Len()
func (set *Set) Len() int {
return set.dict.Len()
}
func (set *Set)ToSlice()[]string {
slice := make([]string, set.Len())
i := 0
set.dict.ForEach(func(key string, val interface{})bool {
if i < len(slice) {
slice[i] = key
} else {
// set extended during traversal
slice = append(slice, key)
}
i++
return true
})
return slice
func (set *Set) ToSlice() []string {
slice := make([]string, set.Len())
i := 0
set.dict.ForEach(func(key string, val interface{}) bool {
if i < len(slice) {
slice[i] = key
} else {
// set extended during traversal
slice = append(slice, key)
}
i++
return true
})
return slice
}
func (set *Set)ForEach(consumer func(member string)bool) {
set.dict.ForEach(func(key string, val interface{})bool {
return consumer(key)
})
func (set *Set) ForEach(consumer func(member string) bool) {
set.dict.ForEach(func(key string, val interface{}) bool {
return consumer(key)
})
}
func (set *Set)Intersect(another *Set)*Set {
if set == nil {
panic("set is nil")
}
func (set *Set) Intersect(another *Set) *Set {
if set == nil {
panic("set is nil")
}
result := Make()
another.ForEach(func(member string)bool {
if set.Has(member) {
result.Add(member)
}
return true
})
return result
result := Make()
another.ForEach(func(member string) bool {
if set.Has(member) {
result.Add(member)
}
return true
})
return result
}
func (set *Set)Union(another *Set)*Set {
if set == nil {
panic("set is nil")
}
result := Make()
another.ForEach(func(member string)bool {
result.Add(member)
return true
})
set.ForEach(func(member string)bool {
result.Add(member)
return true
})
return result
func (set *Set) Union(another *Set) *Set {
if set == nil {
panic("set is nil")
}
result := Make()
another.ForEach(func(member string) bool {
result.Add(member)
return true
})
set.ForEach(func(member string) bool {
result.Add(member)
return true
})
return result
}
func (set *Set)Diff(another *Set)*Set {
if set == nil {
panic("set is nil")
}
func (set *Set) Diff(another *Set) *Set {
if set == nil {
panic("set is nil")
}
result := Make()
set.ForEach(func(member string)bool {
if !another.Has(member) {
result.Add(member)
}
return true
})
return result
result := Make()
set.ForEach(func(member string) bool {
if !another.Has(member) {
result.Add(member)
}
return true
})
return result
}
func (set *Set)RandomMembers(limit int)[]string {
return set.dict.RandomKeys(limit)
func (set *Set) RandomMembers(limit int) []string {
return set.dict.RandomKeys(limit)
}
func (set *Set)RandomDistinctMembers(limit int)[]string {
return set.dict.RandomDistinctKeys(limit)
func (set *Set) RandomDistinctMembers(limit int) []string {
return set.dict.RandomDistinctKeys(limit)
}

422
src/db/geo.go
View File

@@ -1,249 +1,251 @@
package db
import (
"fmt"
"github.com/HDT3213/godis/src/datastruct/sortedset"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/lib/geohash"
"github.com/HDT3213/godis/src/redis/reply"
"strconv"
"strings"
"fmt"
"github.com/HDT3213/godis/src/datastruct/sortedset"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/lib/geohash"
"github.com/HDT3213/godis/src/redis/reply"
"strconv"
"strings"
)
func GeoAdd(db *DB, args [][]byte) redis.Reply {
if len(args) < 4 || len(args)%3 != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geoadd' command")
}
key := string(args[0])
size := (len(args) - 1) / 3
elements := make([]*sortedset.Element, size)
for i := 0; i < size; i += 1 {
lngStr := string(args[3*i+1])
latStr := string(args[3*i+2])
lng, err := strconv.ParseFloat(lngStr, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
lat, err := strconv.ParseFloat(latStr, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
if lat < -90 || lat > 90 || lng < -180 || lng > 180 {
return reply.MakeErrReply(fmt.Sprintf("ERR invalid longitude,latitude pair %s,%s", latStr, lngStr))
}
code := float64(geohash.Encode(lat, lng))
elements[i] = &sortedset.Element{
Member: string(args[3*i+3]),
Score: code,
}
}
if len(args) < 4 || len(args)%3 != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geoadd' command")
}
key := string(args[0])
size := (len(args) - 1) / 3
elements := make([]*sortedset.Element, size)
for i := 0; i < size; i += 1 {
lngStr := string(args[3*i+1])
latStr := string(args[3*i+2])
lng, err := strconv.ParseFloat(lngStr, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
lat, err := strconv.ParseFloat(latStr, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
if lat < -90 || lat > 90 || lng < -180 || lng > 180 {
return reply.MakeErrReply(fmt.Sprintf("ERR invalid longitude,latitude pair %s,%s", latStr, lngStr))
}
code := float64(geohash.Encode(lat, lng))
elements[i] = &sortedset.Element{
Member: string(args[3*i+3]),
Score: code,
}
}
// lock
db.Lock(key)
defer db.UnLock(key)
// lock
db.Lock(key)
defer db.UnLock(key)
// get or init entity
sortedSet, _, errReply := db.getOrInitSortedSet(key)
if errReply != nil {
return errReply
}
// get or init entity
sortedSet, _, errReply := db.getOrInitSortedSet(key)
if errReply != nil {
return errReply
}
i := 0
for _, e := range elements {
if sortedSet.Add(e.Member, e.Score) {
i++
}
}
i := 0
for _, e := range elements {
if sortedSet.Add(e.Member, e.Score) {
i++
}
}
db.AddAof(makeAofCmd("geoadd", args))
db.AddAof(makeAofCmd("geoadd", args))
return reply.MakeIntReply(int64(i))
return reply.MakeIntReply(int64(i))
}
func GeoPos(db *DB, args [][]byte) redis.Reply {
// parse args
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geopos' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
// parse args
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geopos' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
positions := make([][]byte, len(args)-1)
for i := 0; i < len(args)-1; i++ {
member := string(args[i+1])
elem, exists := sortedSet.Get(member)
if !exists {
positions[i] = (&reply.EmptyMultiBulkReply{}).ToBytes()
continue
}
lat, lng := geohash.Decode(uint64(elem.Score))
lngStr := strconv.FormatFloat(lng, 'f', -1, 64)
latStr := strconv.FormatFloat(lat, 'f', -1, 64)
positions[i] = reply.MakeMultiBulkReply([][]byte{
[]byte(lngStr), []byte(latStr),
}).ToBytes()
}
return reply.MakeMultiRawReply(positions)
positions := make([][]byte, len(args)-1)
for i := 0; i < len(args)-1; i++ {
member := string(args[i+1])
elem, exists := sortedSet.Get(member)
if !exists {
positions[i] = (&reply.EmptyMultiBulkReply{}).ToBytes()
continue
}
lat, lng := geohash.Decode(uint64(elem.Score))
lngStr := strconv.FormatFloat(lng, 'f', -1, 64)
latStr := strconv.FormatFloat(lat, 'f', -1, 64)
positions[i] = reply.MakeMultiBulkReply([][]byte{
[]byte(lngStr), []byte(latStr),
}).ToBytes()
}
return reply.MakeMultiRawReply(positions)
}
func GeoDist(db *DB, args [][]byte) redis.Reply {
// parse args
if len(args) != 3 && len(args) != 4 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geodist' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
// parse args
if len(args) != 3 && len(args) != 4 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geodist' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
positions := make([][]float64, 2)
for i := 1; i < 3; i++ {
member := string(args[i])
elem, exists := sortedSet.Get(member)
if !exists {
return &reply.NullBulkReply{}
}
lat, lng := geohash.Decode(uint64(elem.Score))
positions[i-1] = []float64{lat, lng}
}
unit := "m"
if len(args) == 4 {
unit = strings.ToLower(string(args[3]))
}
dis := geohash.Distance(positions[0][1], positions[0][0], positions[1][1], positions[1][0])
switch unit {
case "m":
disStr := strconv.FormatFloat(dis, 'f', -1, 64)
return reply.MakeBulkReply([]byte(disStr))
case "km":
disStr := strconv.FormatFloat(dis/1000, 'f', -1, 64)
return reply.MakeBulkReply([]byte(disStr))
}
return reply.MakeErrReply("ERR unsupported unit provided. please use m, km")
positions := make([][]float64, 2)
for i := 1; i < 3; i++ {
member := string(args[i])
elem, exists := sortedSet.Get(member)
if !exists {
return &reply.NullBulkReply{}
}
lat, lng := geohash.Decode(uint64(elem.Score))
positions[i-1] = []float64{lat, lng}
}
unit := "m"
if len(args) == 4 {
unit = strings.ToLower(string(args[3]))
}
dis := geohash.Distance(positions[0][0], positions[0][1], positions[1][0], positions[1][1])
switch unit {
case "m":
disStr := strconv.FormatFloat(dis, 'f', -1, 64)
return reply.MakeBulkReply([]byte(disStr))
case "km":
disStr := strconv.FormatFloat(dis/1000, 'f', -1, 64)
return reply.MakeBulkReply([]byte(disStr))
}
return reply.MakeErrReply("ERR unsupported unit provided. please use m, km")
}
func GeoHash(db *DB, args [][]byte) redis.Reply {
// parse args
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geohash' command")
}
// parse args
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'geohash' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
strs := make([][]byte, len(args)-1)
for i := 0; i < len(args)-1; i++ {
member := string(args[i+1])
elem, exists := sortedSet.Get(member)
if !exists {
strs[i] = (&reply.EmptyMultiBulkReply{}).ToBytes()
continue
}
str := geohash.ToString(geohash.FromInt(uint64(elem.Score)))
strs[i] = []byte(str)
}
return reply.MakeMultiBulkReply(strs)
strs := make([][]byte, len(args)-1)
for i := 0; i < len(args)-1; i++ {
member := string(args[i+1])
elem, exists := sortedSet.Get(member)
if !exists {
strs[i] = (&reply.EmptyMultiBulkReply{}).ToBytes()
continue
}
str := geohash.ToString(geohash.FromInt(uint64(elem.Score)))
strs[i] = []byte(str)
}
return reply.MakeMultiBulkReply(strs)
}
func GeoRadius(db *DB, args [][]byte) redis.Reply {
// parse args
if len(args) < 5 {
return reply.MakeErrReply("ERR wrong number of arguments for 'georadius' command")
}
// parse args
if len(args) < 5 {
return reply.MakeErrReply("ERR wrong number of arguments for 'georadius' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
lng, err := strconv.ParseFloat(string(args[1]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
lat, err := strconv.ParseFloat(string(args[2]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
radius, err := strconv.ParseFloat(string(args[3]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
unit := strings.ToLower(string(args[4]))
if unit == "m" {
} else if unit == "km" {
radius *= 1000
} else {
return reply.MakeErrReply("ERR unsupported unit provided. please use m, km")
}
return geoRadius0(sortedSet, lat, lng, radius)
lng, err := strconv.ParseFloat(string(args[1]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
lat, err := strconv.ParseFloat(string(args[2]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
radius, err := strconv.ParseFloat(string(args[3]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
unit := strings.ToLower(string(args[4]))
if unit == "m" {
} else if unit == "km" {
radius *= 1000
} else {
return reply.MakeErrReply("ERR unsupported unit provided. please use m, km")
}
return geoRadius0(sortedSet, lat, lng, radius)
}
func GeoRadiusByMember(db *DB, args [][]byte) redis.Reply {
// parse args
if len(args) < 4 {
return reply.MakeErrReply("ERR wrong number of arguments for 'georadiusbymember' command")
}
// parse args
if len(args) < 3 {
return reply.MakeErrReply("ERR wrong number of arguments for 'georadiusbymember' command")
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
key := string(args[0])
sortedSet, errReply := db.getAsSortedSet(key)
if errReply != nil {
return errReply
}
if sortedSet == nil {
return &reply.NullBulkReply{}
}
member := string(args[1])
elem, ok := sortedSet.Get(member)
if !ok {
return &reply.NullBulkReply{}
}
lat, lng := geohash.Decode(uint64(elem.Score))
member := string(args[1])
elem, ok := sortedSet.Get(member)
if !ok {
return &reply.NullBulkReply{}
}
lat, lng := geohash.Decode(uint64(elem.Score))
radius, err := strconv.ParseFloat(string(args[2]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
unit := strings.ToLower(string(args[4]))
if unit == "m" {
} else if unit == "km" {
radius *= 1000
} else {
return reply.MakeErrReply("ERR unsupported unit provided. please use m, km")
}
return geoRadius0(sortedSet, lat, lng, radius)
radius, err := strconv.ParseFloat(string(args[2]), 64)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
if len(args) > 3 {
unit := strings.ToLower(string(args[3]))
if unit == "m" {
} else if unit == "km" {
radius *= 1000
} else {
return reply.MakeErrReply("ERR unsupported unit provided. please use m, km")
}
}
return geoRadius0(sortedSet, lat, lng, radius)
}
func geoRadius0(sortedSet *sortedset.SortedSet, lat float64, lng float64, radius float64) redis.Reply {
areas := geohash.GetNeighbours(lat, lng, radius)
members := make([][]byte, 0)
for _, area := range areas {
lower := &sortedset.ScoreBorder{Value: float64(area[0])}
upper := &sortedset.ScoreBorder{Value: float64(area[1])}
elements := sortedSet.RangeByScore(lower, upper, 0, -1, true)
for _, elem := range elements {
members = append(members, []byte(elem.Member))
}
}
return reply.MakeMultiBulkReply(members)
areas := geohash.GetNeighbours(lat, lng, radius)
members := make([][]byte, 0)
for _, area := range areas {
lower := &sortedset.ScoreBorder{Value: float64(area[0])}
upper := &sortedset.ScoreBorder{Value: float64(area[1])}
elements := sortedSet.RangeByScore(lower, upper, 0, -1, true)
for _, elem := range elements {
members = append(members, []byte(elem.Member))
}
}
return reply.MakeMultiBulkReply(members)
}

87
src/db/geo_test.go Normal file
View File

@@ -0,0 +1,87 @@
package db
import (
"fmt"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/HDT3213/godis/src/redis/reply/asserts"
"strconv"
"testing"
)
func TestGeoHash(t *testing.T) {
FlushDB(testDB, toArgs())
key := RandString(10)
pos := RandString(10)
result := GeoAdd(testDB, toArgs(key, "13.361389", "38.115556", pos))
asserts.AssertIntReply(t, result, 1)
result = GeoHash(testDB, toArgs(key, pos))
asserts.AssertMultiBulkReply(t, result, []string{"sqc8b49rnys00"})
}
func TestGeoRadius(t *testing.T) {
FlushDB(testDB, toArgs())
key := RandString(10)
pos1 := RandString(10)
pos2 := RandString(10)
GeoAdd(testDB, toArgs(key,
"13.361389", "38.115556", pos1,
"15.087269", "37.502669", pos2,
))
result := GeoRadius(testDB, toArgs(key, "15", "37", "200", "km"))
asserts.AssertMultiBulkReplySize(t, result, 2)
}
func TestGeoRadiusByMember(t *testing.T) {
FlushDB(testDB, toArgs())
key := RandString(10)
pos1 := RandString(10)
pos2 := RandString(10)
pivot := RandString(10)
GeoAdd(testDB, toArgs(key,
"13.361389", "38.115556", pos1,
"17.087269", "38.502669", pos2,
"13.583333", "37.316667", pivot,
))
result := GeoRadiusByMember(testDB, toArgs(key, pivot, "100", "km"))
asserts.AssertMultiBulkReplySize(t, result, 2)
}
func TestGeoPos(t *testing.T) {
FlushDB(testDB, toArgs())
key := RandString(10)
pos1 := RandString(10)
pos2 := RandString(10)
GeoAdd(testDB, toArgs(key,
"13.361389", "38.115556", pos1,
))
result := GeoPos(testDB, toArgs(key, pos1, pos2))
expected := "*2\r\n*2\r\n$18\r\n13.361386698670685\r\n$17\r\n38.11555536696687\r\n*0\r\n"
if string(result.ToBytes()) != expected {
t.Error("test failed")
}
}
func TestGeoDist(t *testing.T) {
FlushDB(testDB, toArgs())
key := RandString(10)
pos1 := RandString(10)
pos2 := RandString(10)
GeoAdd(testDB, toArgs(key,
"13.361389", "38.115556", pos1,
"15.087269", "37.502669", pos2,
))
result := GeoDist(testDB, toArgs(key, pos1, pos2, "km"))
bulkReply, ok := result.(*reply.BulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", result.ToBytes()))
return
}
dist, err := strconv.ParseFloat(string(bulkReply.Arg), 10)
if err != nil {
t.Error(err)
return
}
if dist < 166.274 || dist > 166.275 {
t.Errorf("expected 166.274, actual: %f", dist)
}
}

351
src/db/hash_test.go
View File

@@ -1,200 +1,215 @@
package db
import (
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/redis/reply"
"math/rand"
"strconv"
"testing"
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/HDT3213/godis/src/redis/reply/asserts"
"strconv"
"testing"
)
func TestHSet(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
FlushAll(testDB, [][]byte{})
size := 100
// test hset
key := strconv.FormatInt(int64(rand.Int()), 10)
values := make(map[string][]byte, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
field := strconv.Itoa(i)
values[field] = []byte(value)
result := HSet(testDB, toArgs(key, field, value))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(1) {
t.Error(fmt.Sprintf("expected %d, actually %d", 1, intResult.Code))
}
}
// test hset
key := RandString(10)
values := make(map[string][]byte, size)
for i := 0; i < size; i++ {
value := RandString(10)
field := strconv.Itoa(i)
values[field] = []byte(value)
result := HSet(testDB, toArgs(key, field, value))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(1) {
t.Error(fmt.Sprintf("expected %d, actually %d", 1, intResult.Code))
}
}
// test hget and hexists
for field, v := range values {
actual := HGet(testDB, toArgs(key, field))
expected := reply.MakeBulkReply(v)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(actual.ToBytes())))
}
actual = HExists(testDB, toArgs(key, field))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(1) {
t.Error(fmt.Sprintf("expected %d, actually %d", 1, intResult.Code))
}
}
// test hget and hexists
for field, v := range values {
actual := HGet(testDB, toArgs(key, field))
expected := reply.MakeBulkReply(v)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(actual.ToBytes())))
}
actual = HExists(testDB, toArgs(key, field))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(1) {
t.Error(fmt.Sprintf("expected %d, actually %d", 1, intResult.Code))
}
}
// test hlen
actual := HLen(testDB, toArgs(key))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(len(values)) {
t.Error(fmt.Sprintf("expected %d, actually %d", len(values), intResult.Code))
}
// test hlen
actual := HLen(testDB, toArgs(key))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(len(values)) {
t.Error(fmt.Sprintf("expected %d, actually %d", len(values), intResult.Code))
}
}
func TestHDel(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
FlushAll(testDB, [][]byte{})
size := 100
// set values
key := strconv.FormatInt(int64(rand.Int()), 10)
fields := make([]string, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
field := strconv.Itoa(i)
fields[i] = field
HSet(testDB, toArgs(key, field, value))
}
// set values
key := RandString(10)
fields := make([]string, size)
for i := 0; i < size; i++ {
value := RandString(10)
field := strconv.Itoa(i)
fields[i] = field
HSet(testDB, toArgs(key, field, value))
}
// test HDel
args := []string{key}
args = append(args, fields...)
actual := HDel(testDB, toArgs(args...))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(len(fields)) {
t.Error(fmt.Sprintf("expected %d, actually %d", len(fields), intResult.Code))
}
// test HDel
args := []string{key}
args = append(args, fields...)
actual := HDel(testDB, toArgs(args...))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(len(fields)) {
t.Error(fmt.Sprintf("expected %d, actually %d", len(fields), intResult.Code))
}
actual = HLen(testDB, toArgs(key))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(0) {
t.Error(fmt.Sprintf("expected %d, actually %d", 0, intResult.Code))
}
actual = HLen(testDB, toArgs(key))
if intResult, _ := actual.(*reply.IntReply); intResult.Code != int64(0) {
t.Error(fmt.Sprintf("expected %d, actually %d", 0, intResult.Code))
}
}
func TestHMSet(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
FlushAll(testDB, [][]byte{})
size := 100
// test hset
key := strconv.FormatInt(int64(rand.Int()), 10)
fields := make([]string, size)
values := make([]string, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
fields[i] = strconv.FormatInt(int64(rand.Int()), 10)
values[i] = strconv.FormatInt(int64(rand.Int()), 10)
setArgs = append(setArgs, fields[i], values[i])
}
result := HMSet(testDB, toArgs(setArgs...))
if _, ok := result.(*reply.OkReply); !ok {
t.Error(fmt.Sprintf("expected ok, actually %s", string(result.ToBytes())))
}
// test hset
key := RandString(10)
fields := make([]string, size)
values := make([]string, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
fields[i] = RandString(10)
values[i] = RandString(10)
setArgs = append(setArgs, fields[i], values[i])
}
result := HMSet(testDB, toArgs(setArgs...))
if _, ok := result.(*reply.OkReply); !ok {
t.Error(fmt.Sprintf("expected ok, actually %s", string(result.ToBytes())))
}
// test HMGet
getArgs := []string{key}
getArgs = append(getArgs, fields...)
actual := HMGet(testDB, toArgs(getArgs...))
expected := reply.MakeMultiBulkReply(toArgs(values...))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(actual.ToBytes())))
}
// test HMGet
getArgs := []string{key}
getArgs = append(getArgs, fields...)
actual := HMGet(testDB, toArgs(getArgs...))
expected := reply.MakeMultiBulkReply(toArgs(values...))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(actual.ToBytes())))
}
}
func TestHGetAll(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
fields := make([]string, size)
valueSet := make(map[string]bool, size)
valueMap := make(map[string]string)
all := make([]string, 0)
for i := 0; i < size; i++ {
fields[i] = strconv.FormatInt(int64(rand.Int()), 10)
value := strconv.FormatInt(int64(rand.Int()), 10)
all = append(all, fields[i], value)
valueMap[fields[i]] = value
valueSet[value] = true
HSet(testDB, toArgs(key, fields[i], value))
}
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
fields := make([]string, size)
valueSet := make(map[string]bool, size)
valueMap := make(map[string]string)
all := make([]string, 0)
for i := 0; i < size; i++ {
fields[i] = RandString(10)
value := RandString(10)
all = append(all, fields[i], value)
valueMap[fields[i]] = value
valueSet[value] = true
HSet(testDB, toArgs(key, fields[i], value))
}
// test HGetAll
result := HGetAll(testDB, toArgs(key))
multiBulk, ok := result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected MultiBulkReply, actually %s", string(result.ToBytes())))
}
if 2*len(fields) != len(multiBulk.Args) {
t.Error(fmt.Sprintf("expected %d items , actually %d ", 2*len(fields), len(multiBulk.Args)))
}
for i := range fields {
field := string(multiBulk.Args[2*i])
actual := string(multiBulk.Args[2*i+1])
expected, ok := valueMap[field]
if !ok {
t.Error(fmt.Sprintf("unexpected field %s", field))
continue
}
if actual != expected {
t.Error(fmt.Sprintf("expected %s, actually %s", expected, actual))
}
}
// test HGetAll
result := HGetAll(testDB, toArgs(key))
multiBulk, ok := result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected MultiBulkReply, actually %s", string(result.ToBytes())))
}
if 2*len(fields) != len(multiBulk.Args) {
t.Error(fmt.Sprintf("expected %d items , actually %d ", 2*len(fields), len(multiBulk.Args)))
}
for i := range fields {
field := string(multiBulk.Args[2*i])
actual := string(multiBulk.Args[2*i+1])
expected, ok := valueMap[field]
if !ok {
t.Error(fmt.Sprintf("unexpected field %s", field))
continue
}
if actual != expected {
t.Error(fmt.Sprintf("expected %s, actually %s", expected, actual))
}
}
// test HKeys
result = HKeys(testDB, toArgs(key))
multiBulk, ok = result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected MultiBulkReply, actually %s", string(result.ToBytes())))
}
if len(fields) != len(multiBulk.Args) {
t.Error(fmt.Sprintf("expected %d items , actually %d ", len(fields), len(multiBulk.Args)))
}
for _, v := range multiBulk.Args {
field := string(v)
if _, ok := valueMap[field]; !ok {
t.Error(fmt.Sprintf("unexpected field %s", field))
}
}
// test HKeys
result = HKeys(testDB, toArgs(key))
multiBulk, ok = result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected MultiBulkReply, actually %s", string(result.ToBytes())))
}
if len(fields) != len(multiBulk.Args) {
t.Error(fmt.Sprintf("expected %d items , actually %d ", len(fields), len(multiBulk.Args)))
}
for _, v := range multiBulk.Args {
field := string(v)
if _, ok := valueMap[field]; !ok {
t.Error(fmt.Sprintf("unexpected field %s", field))
}
}
// test HVals
result = HVals(testDB, toArgs(key))
multiBulk, ok = result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected MultiBulkReply, actually %s", string(result.ToBytes())))
}
if len(fields) != len(multiBulk.Args) {
t.Error(fmt.Sprintf("expected %d items , actually %d ", len(fields), len(multiBulk.Args)))
}
for _, v := range multiBulk.Args {
value := string(v)
_, ok := valueSet[value]
if !ok {
t.Error(fmt.Sprintf("unexpected value %s", value))
}
}
// test HVals
result = HVals(testDB, toArgs(key))
multiBulk, ok = result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected MultiBulkReply, actually %s", string(result.ToBytes())))
}
if len(fields) != len(multiBulk.Args) {
t.Error(fmt.Sprintf("expected %d items , actually %d ", len(fields), len(multiBulk.Args)))
}
for _, v := range multiBulk.Args {
value := string(v)
_, ok := valueSet[value]
if !ok {
t.Error(fmt.Sprintf("unexpected value %s", value))
}
}
}
func TestHIncrBy(t *testing.T) {
FlushAll(testDB, [][]byte{})
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
result := HIncrBy(testDB, toArgs(key, "a", "1"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "1" {
t.Error(fmt.Sprintf("expected %s, actually %s", "1", string(bulkResult.Arg)))
}
result = HIncrBy(testDB, toArgs(key, "a", "1"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "2" {
t.Error(fmt.Sprintf("expected %s, actually %s", "2", string(bulkResult.Arg)))
}
key := RandString(10)
result := HIncrBy(testDB, toArgs(key, "a", "1"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "1" {
t.Error(fmt.Sprintf("expected %s, actually %s", "1", string(bulkResult.Arg)))
}
result = HIncrBy(testDB, toArgs(key, "a", "1"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "2" {
t.Error(fmt.Sprintf("expected %s, actually %s", "2", string(bulkResult.Arg)))
}
result = HIncrByFloat(testDB, toArgs(key, "b", "1.2"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "1.2" {
t.Error(fmt.Sprintf("expected %s, actually %s", "1.2", string(bulkResult.Arg)))
}
result = HIncrByFloat(testDB, toArgs(key, "b", "1.2"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "2.4" {
t.Error(fmt.Sprintf("expected %s, actually %s", "2.4", string(bulkResult.Arg)))
}
}
func TestHSetNX(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
field := RandString(10)
value := RandString(10)
result := HSetNX(testDB, toArgs(key, field, value))
asserts.AssertIntReply(t, result, 1)
value2 := RandString(10)
result = HSetNX(testDB, toArgs(key, field, value2))
asserts.AssertIntReply(t, result, 0)
result = HGet(testDB, toArgs(key, field))
asserts.AssertBulkReply(t, result, value)
result = HIncrByFloat(testDB, toArgs(key, "b", "1.2"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "1.2" {
t.Error(fmt.Sprintf("expected %s, actually %s", "1.2", string(bulkResult.Arg)))
}
result = HIncrByFloat(testDB, toArgs(key, "b", "1.2"))
if bulkResult, _ := result.(*reply.BulkReply); string(bulkResult.Arg) != "2.4" {
t.Error(fmt.Sprintf("expected %s, actually %s", "2.4", string(bulkResult.Arg)))
}
}

11
src/db/keys.go
View File

@@ -76,7 +76,7 @@ func Type(db *DB, args [][]byte) redis.Reply {
return reply.MakeStatusReply("string")
case *list.LinkedList:
return reply.MakeStatusReply("list")
case *dict.Dict:
case dict.Dict:
return reply.MakeStatusReply("hash")
case *set.Set:
return reply.MakeStatusReply("set")
@@ -101,10 +101,11 @@ func Rename(db *DB, args [][]byte) redis.Reply {
return reply.MakeErrReply("no such key")
}
rawTTL, hasTTL := db.TTLMap.Get(src)
db.Persist(src) // clean src and dest with their ttl
db.Persist(dest)
db.Put(dest, entity)
db.Remove(src)
if hasTTL {
db.Persist(src) // clean src and dest with their ttl
db.Persist(dest)
expireTime, _ := rawTTL.(time.Time)
db.Expire(dest, expireTime)
}
@@ -135,6 +136,8 @@ func RenameNx(db *DB, args [][]byte) redis.Reply {
db.Removes(src, dest) // clean src and dest with their ttl
db.Put(dest, entity)
if hasTTL {
db.Persist(src) // clean src and dest with their ttl
db.Persist(dest)
expireTime, _ := rawTTL.(time.Time)
db.Expire(dest, expireTime)
}
@@ -161,7 +164,7 @@ func Expire(db *DB, args [][]byte) redis.Reply {
expireAt := time.Now().Add(ttl)
db.Expire(key, expireAt)
db.AddAof(makeExpireCmd(key, expireAt), )
db.AddAof(makeExpireCmd(key, expireAt))
return reply.MakeIntReply(1)
}

197
src/db/keys_test.go Normal file
View File

@@ -0,0 +1,197 @@
package db
import (
"fmt"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/HDT3213/godis/src/redis/reply/asserts"
"strconv"
"testing"
"time"
)
func TestExists(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
Set(testDB, toArgs(key, value))
result := Exists(testDB, toArgs(key))
asserts.AssertIntReply(t, result, 1)
key = RandString(10)
result = Exists(testDB, toArgs(key))
asserts.AssertIntReply(t, result, 0)
}
func TestType(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
Set(testDB, toArgs(key, value))
result := Type(testDB, toArgs(key))
asserts.AssertStatusReply(t, result, "string")
Del(testDB, toArgs(key))
result = Type(testDB, toArgs(key))
asserts.AssertStatusReply(t, result, "none")
RPush(testDB, toArgs(key, value))
result = Type(testDB, toArgs(key))
asserts.AssertStatusReply(t, result, "list")
Del(testDB, toArgs(key))
HSet(testDB, toArgs(key, key, value))
result = Type(testDB, toArgs(key))
asserts.AssertStatusReply(t, result, "hash")
Del(testDB, toArgs(key))
SAdd(testDB, toArgs(key, value))
result = Type(testDB, toArgs(key))
asserts.AssertStatusReply(t, result, "set")
Del(testDB, toArgs(key))
ZAdd(testDB, toArgs(key, "1", value))
result = Type(testDB, toArgs(key))
asserts.AssertStatusReply(t, result, "zset")
}
func TestRename(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
newKey := key + RandString(2)
Set(testDB, toArgs(key, value, "ex", "1000"))
result := Rename(testDB, toArgs(key, newKey))
if _, ok := result.(*reply.OkReply); !ok {
t.Error("expect ok")
return
}
result = Exists(testDB, toArgs(key))
asserts.AssertIntReply(t, result, 0)
result = Exists(testDB, toArgs(newKey))
asserts.AssertIntReply(t, result, 1)
// check ttl
result = TTL(testDB, toArgs(newKey))
intResult, ok := result.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", result.ToBytes()))
return
}
if intResult.Code <= 0 {
t.Errorf("expected ttl more than 0, actual: %d", intResult.Code)
return
}
}
func TestRenameNx(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
newKey := key + RandString(2)
Set(testDB, toArgs(key, value, "ex", "1000"))
result := RenameNx(testDB, toArgs(key, newKey))
if _, ok := result.(*reply.OkReply); !ok {
t.Error("expect ok")
return
}
result = Exists(testDB, toArgs(key))
asserts.AssertIntReply(t, result, 0)
result = Exists(testDB, toArgs(newKey))
asserts.AssertIntReply(t, result, 1)
result = TTL(testDB, toArgs(newKey))
intResult, ok := result.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", result.ToBytes()))
return
}
if intResult.Code <= 0 {
t.Errorf("expected ttl more than 0, actual: %d", intResult.Code)
return
}
}
func TestTTL(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
Set(testDB, toArgs(key, value))
result := Expire(testDB, toArgs(key, "1000"))
asserts.AssertIntReply(t, result, 1)
result = TTL(testDB, toArgs(key))
intResult, ok := result.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", result.ToBytes()))
return
}
if intResult.Code <= 0 {
t.Errorf("expected ttl more than 0, actual: %d", intResult.Code)
return
}
result = Persist(testDB, toArgs(key))
asserts.AssertIntReply(t, result, 1)
result = TTL(testDB, toArgs(key))
asserts.AssertIntReply(t, result, -1)
result = PExpire(testDB, toArgs(key, "1000000"))
asserts.AssertIntReply(t, result, 1)
result = PTTL(testDB, toArgs(key))
intResult, ok = result.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", result.ToBytes()))
return
}
if intResult.Code <= 0 {
t.Errorf("expected ttl more than 0, actual: %d", intResult.Code)
return
}
}
func TestExpireAt(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
Set(testDB, toArgs(key, value))
expireAt := time.Now().Add(time.Minute).Unix()
result := ExpireAt(testDB, toArgs(key, strconv.FormatInt(expireAt, 10)))
asserts.AssertIntReply(t, result, 1)
result = TTL(testDB, toArgs(key))
intResult, ok := result.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", result.ToBytes()))
return
}
if intResult.Code <= 0 {
t.Errorf("expected ttl more than 0, actual: %d", intResult.Code)
return
}
expireAt = time.Now().Add(time.Minute).Unix()
result = PExpireAt(testDB, toArgs(key, strconv.FormatInt(expireAt*1000, 10)))
asserts.AssertIntReply(t, result, 1)
result = TTL(testDB, toArgs(key))
intResult, ok = result.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", result.ToBytes()))
return
}
if intResult.Code <= 0 {
t.Errorf("expected ttl more than 0, actual: %d", intResult.Code)
return
}
}
func TestKeys(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
Set(testDB, toArgs(key, value))
Set(testDB, toArgs("a:"+key, value))
Set(testDB, toArgs("b:"+key, value))
result := Keys(testDB, toArgs("*"))
asserts.AssertMultiBulkReplySize(t, result, 3)
result = Keys(testDB, toArgs("a:*"))
asserts.AssertMultiBulkReplySize(t, result, 1)
result = Keys(testDB, toArgs("?:*"))
asserts.AssertMultiBulkReplySize(t, result, 2)
}

656
src/db/list_test.go
View File

@@ -1,386 +1,384 @@
package db
import (
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/redis/reply"
"math/rand"
"strconv"
"testing"
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/redis/reply"
"strconv"
"testing"
)
func TestPush(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
FlushAll(testDB, [][]byte{})
size := 100
// rpush single
key := strconv.FormatInt(int64(rand.Int()), 10)
values := make([][]byte, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
values[i] = []byte(value)
result := RPush(testDB, toArgs(key, value))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(i+1) {
t.Error(fmt.Sprintf("expected %d, actually %d", i+1, intResult.Code))
}
}
actual := LRange(testDB, toArgs(key, "0", "-1"))
expected := reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// rpush single
key := RandString(10)
values := make([][]byte, size)
for i := 0; i < size; i++ {
value := RandString(10)
values[i] = []byte(value)
result := RPush(testDB, toArgs(key, value))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(i+1) {
t.Error(fmt.Sprintf("expected %d, actually %d", i+1, intResult.Code))
}
}
actual := LRange(testDB, toArgs(key, "0", "-1"))
expected := reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// rpush multi
key = strconv.FormatInt(int64(rand.Int()), 10)
values = make([][]byte, size+1)
values[0] = []byte(key)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
values[i+1] = []byte(value)
}
result := RPush(testDB, values)
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(size) {
t.Error(fmt.Sprintf("expected %d, actually %d", size, intResult.Code))
}
actual = LRange(testDB, toArgs(key, "0", "-1"))
expected = reply.MakeMultiBulkReply(values[1:])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// rpush multi
key = RandString(10)
values = make([][]byte, size+1)
values[0] = []byte(key)
for i := 0; i < size; i++ {
value := RandString(10)
values[i+1] = []byte(value)
}
result := RPush(testDB, values)
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(size) {
t.Error(fmt.Sprintf("expected %d, actually %d", size, intResult.Code))
}
actual = LRange(testDB, toArgs(key, "0", "-1"))
expected = reply.MakeMultiBulkReply(values[1:])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// left push single
key = strconv.FormatInt(int64(rand.Int()), 10)
values = make([][]byte, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
values[size-i-1] = []byte(value)
result = LPush(testDB, toArgs(key, value))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(i+1) {
t.Error(fmt.Sprintf("expected %d, actually %d", i+1, intResult.Code))
}
}
actual = LRange(testDB, toArgs(key, "0", "-1"))
expected = reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// left push single
key = RandString(10)
values = make([][]byte, size)
for i := 0; i < size; i++ {
value := RandString(10)
values[size-i-1] = []byte(value)
result = LPush(testDB, toArgs(key, value))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(i+1) {
t.Error(fmt.Sprintf("expected %d, actually %d", i+1, intResult.Code))
}
}
actual = LRange(testDB, toArgs(key, "0", "-1"))
expected = reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// left push multi
key = strconv.FormatInt(int64(rand.Int()), 10)
values = make([][]byte, size+1)
values[0] = []byte(key)
expectedValues := make([][]byte, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
values[i+1] = []byte(value)
expectedValues[size-i-1] = []byte(value)
}
result = LPush(testDB, values)
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(size) {
t.Error(fmt.Sprintf("expected %d, actually %d", size, intResult.Code))
}
actual = LRange(testDB, toArgs(key, "0", "-1"))
expected = reply.MakeMultiBulkReply(expectedValues)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
// left push multi
key = RandString(10)
values = make([][]byte, size+1)
values[0] = []byte(key)
expectedValues := make([][]byte, size)
for i := 0; i < size; i++ {
value := RandString(10)
values[i+1] = []byte(value)
expectedValues[size-i-1] = []byte(value)
}
result = LPush(testDB, values)
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(size) {
t.Error(fmt.Sprintf("expected %d, actually %d", size, intResult.Code))
}
actual = LRange(testDB, toArgs(key, "0", "-1"))
expected = reply.MakeMultiBulkReply(expectedValues)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("push error")
}
Del(testDB, toArgs(key))
}
func TestLRange(t *testing.T) {
// prepare list
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
values := make([][]byte, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
RPush(testDB, toArgs(key, value))
values[i] = []byte(value)
}
// prepare list
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
values := make([][]byte, size)
for i := 0; i < size; i++ {
value := RandString(10)
RPush(testDB, toArgs(key, value))
values[i] = []byte(value)
}
start := "0"
end := "9"
actual := LRange(testDB, toArgs(key, start, end))
expected := reply.MakeMultiBulkReply(values[0:10])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start := "0"
end := "9"
actual := LRange(testDB, toArgs(key, start, end))
expected := reply.MakeMultiBulkReply(values[0:10])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "0"
end = "200"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "0"
end = "200"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "0"
end = "-10"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values[0 : size-10+1])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "0"
end = "-10"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values[0 : size-10+1])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "0"
end = "-200"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values[0:0])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "0"
end = "-200"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values[0:0])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "-10"
end = "-1"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values[90:])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
start = "-10"
end = "-1"
actual = LRange(testDB, toArgs(key, start, end))
expected = reply.MakeMultiBulkReply(values[90:])
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("range error [%s, %s]", start, end))
}
}
func TestLIndex(t *testing.T) {
// prepare list
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
values := make([][]byte, size)
for i := 0; i < size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
RPush(testDB, toArgs(key, value))
values[i] = []byte(value)
}
// prepare list
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
values := make([][]byte, size)
for i := 0; i < size; i++ {
value := RandString(10)
RPush(testDB, toArgs(key, value))
values[i] = []byte(value)
}
result := LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(size) {
t.Error(fmt.Sprintf("expected %d, actually %d", size, intResult.Code))
}
result := LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != int64(size) {
t.Error(fmt.Sprintf("expected %d, actually %d", size, intResult.Code))
}
for i := 0; i < size; i++ {
result = LIndex(testDB, toArgs(key, strconv.Itoa(i)))
expected := reply.MakeBulkReply(values[i])
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
for i := 0; i < size; i++ {
result = LIndex(testDB, toArgs(key, strconv.Itoa(i)))
expected := reply.MakeBulkReply(values[i])
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
for i := 1; i <= size; i++ {
result = LIndex(testDB, toArgs(key, strconv.Itoa(-i)))
expected := reply.MakeBulkReply(values[size-i])
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
for i := 1; i <= size; i++ {
result = LIndex(testDB, toArgs(key, strconv.Itoa(-i)))
expected := reply.MakeBulkReply(values[size-i])
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
}
func TestLRem(t *testing.T) {
// prepare list
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
values := []string{key, "a", "b", "a", "a", "c", "a", "a"}
RPush(testDB, toArgs(values...))
// prepare list
FlushAll(testDB, [][]byte{})
key := RandString(10)
values := []string{key, "a", "b", "a", "a", "c", "a", "a"}
RPush(testDB, toArgs(values...))
result := LRem(testDB, toArgs(key, "1", "a"))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 1 {
t.Error(fmt.Sprintf("expected %d, actually %d", 1, intResult.Code))
}
result = LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 6 {
t.Error(fmt.Sprintf("expected %d, actually %d", 6, intResult.Code))
}
result := LRem(testDB, toArgs(key, "1", "a"))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 1 {
t.Error(fmt.Sprintf("expected %d, actually %d", 1, intResult.Code))
}
result = LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 6 {
t.Error(fmt.Sprintf("expected %d, actually %d", 6, intResult.Code))
}
result = LRem(testDB, toArgs(key, "-2", "a"))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 2 {
t.Error(fmt.Sprintf("expected %d, actually %d", 2, intResult.Code))
}
result = LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 4 {
t.Error(fmt.Sprintf("expected %d, actually %d", 4, intResult.Code))
}
result = LRem(testDB, toArgs(key, "-2", "a"))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 2 {
t.Error(fmt.Sprintf("expected %d, actually %d", 2, intResult.Code))
}
result = LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 4 {
t.Error(fmt.Sprintf("expected %d, actually %d", 4, intResult.Code))
}
result = LRem(testDB, toArgs(key, "0", "a"))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 2 {
t.Error(fmt.Sprintf("expected %d, actually %d", 2, intResult.Code))
}
result = LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 2 {
t.Error(fmt.Sprintf("expected %d, actually %d", 2, intResult.Code))
}
result = LRem(testDB, toArgs(key, "0", "a"))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 2 {
t.Error(fmt.Sprintf("expected %d, actually %d", 2, intResult.Code))
}
result = LLen(testDB, toArgs(key))
if intResult, _ := result.(*reply.IntReply); intResult.Code != 2 {
t.Error(fmt.Sprintf("expected %d, actually %d", 2, intResult.Code))
}
}
func TestLSet(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
values := []string{key, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
FlushAll(testDB, [][]byte{})
key := RandString(10)
values := []string{key, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
// test positive index
size := len(values) - 1
for i := 0; i < size; i++ {
indexStr := strconv.Itoa(i)
value := strconv.FormatInt(int64(rand.Int()), 10)
result := LSet(testDB, toArgs(key, indexStr, value))
if _, ok := result.(*reply.OkReply); !ok {
t.Error(fmt.Sprintf("expected OK, actually %s", string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, indexStr))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
// test negative index
for i := 1; i <= size; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
result := LSet(testDB, toArgs(key, strconv.Itoa(-i), value))
if _, ok := result.(*reply.OkReply); !ok {
t.Error(fmt.Sprintf("expected OK, actually %s", string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, strconv.Itoa(len(values)-i-1)))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
// test positive index
size := len(values) - 1
for i := 0; i < size; i++ {
indexStr := strconv.Itoa(i)
value := RandString(10)
result := LSet(testDB, toArgs(key, indexStr, value))
if _, ok := result.(*reply.OkReply); !ok {
t.Error(fmt.Sprintf("expected OK, actually %s", string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, indexStr))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
// test negative index
for i := 1; i <= size; i++ {
value := RandString(10)
result := LSet(testDB, toArgs(key, strconv.Itoa(-i), value))
if _, ok := result.(*reply.OkReply); !ok {
t.Error(fmt.Sprintf("expected OK, actually %s", string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, strconv.Itoa(len(values)-i-1)))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
// test illegal index
value := strconv.FormatInt(int64(rand.Int()), 10)
result := LSet(testDB, toArgs(key, strconv.Itoa(-len(values)-1), value))
expected := reply.MakeErrReply("ERR index out of range")
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LSet(testDB, toArgs(key, strconv.Itoa(len(values)), value))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LSet(testDB, toArgs(key, "a", value))
expected = reply.MakeErrReply("ERR value is not an integer or out of range")
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
// test illegal index
value := RandString(10)
result := LSet(testDB, toArgs(key, strconv.Itoa(-len(values)-1), value))
expected := reply.MakeErrReply("ERR index out of range")
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LSet(testDB, toArgs(key, strconv.Itoa(len(values)), value))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LSet(testDB, toArgs(key, "a", value))
expected = reply.MakeErrReply("ERR value is not an integer or out of range")
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
func TestLPop(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
values := []string{key, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
size := len(values) - 1
FlushAll(testDB, [][]byte{})
key := RandString(10)
values := []string{key, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
size := len(values) - 1
for i := 0; i < size; i++ {
result := LPop(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(values[i+1]))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
result := RPop(testDB, toArgs(key))
expected := &reply.NullBulkReply{}
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
for i := 0; i < size; i++ {
result := LPop(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(values[i+1]))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
result := RPop(testDB, toArgs(key))
expected := &reply.NullBulkReply{}
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
func TestRPop(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
values := []string{key, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
size := len(values) - 1
FlushAll(testDB, [][]byte{})
key := RandString(10)
values := []string{key, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
size := len(values) - 1
for i := 0; i < size; i++ {
result := RPop(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(values[len(values)-i-1]))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
result := RPop(testDB, toArgs(key))
expected := &reply.NullBulkReply{}
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
for i := 0; i < size; i++ {
result := RPop(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(values[len(values)-i-1]))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
result := RPop(testDB, toArgs(key))
expected := &reply.NullBulkReply{}
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
func TestRPopLPush(t *testing.T) {
FlushAll(testDB, [][]byte{})
key1 := strconv.FormatInt(int64(rand.Int()), 10)
key2 := strconv.FormatInt(int64(rand.Int()), 10)
values := []string{key1, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
size := len(values) - 1
FlushAll(testDB, [][]byte{})
key1 := RandString(10)
key2 := RandString(10)
values := []string{key1, "a", "b", "c", "d", "e", "f"}
RPush(testDB, toArgs(values...))
size := len(values) - 1
for i := 0; i < size; i++ {
result := RPopLPush(testDB, toArgs(key1, key2))
expected := reply.MakeBulkReply([]byte(values[len(values)-i-1]))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key2, "0"))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
result := RPop(testDB, toArgs(key1))
expected := &reply.NullBulkReply{}
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
for i := 0; i < size; i++ {
result := RPopLPush(testDB, toArgs(key1, key2))
expected := reply.MakeBulkReply([]byte(values[len(values)-i-1]))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key2, "0"))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
result := RPop(testDB, toArgs(key1))
expected := &reply.NullBulkReply{}
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
}
func TestRPushX(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
result := RPushX(testDB, toArgs(key, "1"))
expected := reply.MakeIntReply(int64(0))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
FlushAll(testDB, [][]byte{})
key := RandString(10)
result := RPushX(testDB, toArgs(key, "1"))
expected := reply.MakeIntReply(int64(0))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
RPush(testDB, toArgs(key, "1"))
for i := 0; i < 10; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
result := RPushX(testDB, toArgs(key, value))
expected := reply.MakeIntReply(int64(i + 2))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, "-1"))
expected2 := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected2.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected2.ToBytes()), string(result.ToBytes())))
}
}
RPush(testDB, toArgs(key, "1"))
for i := 0; i < 10; i++ {
value := RandString(10)
result := RPushX(testDB, toArgs(key, value))
expected := reply.MakeIntReply(int64(i + 2))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, "-1"))
expected2 := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected2.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected2.ToBytes()), string(result.ToBytes())))
}
}
}
func TestLPushX(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
result := RPushX(testDB, toArgs(key, "1"))
expected := reply.MakeIntReply(int64(0))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
FlushAll(testDB, [][]byte{})
key := RandString(10)
result := RPushX(testDB, toArgs(key, "1"))
expected := reply.MakeIntReply(int64(0))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
LPush(testDB, toArgs(key, "1"))
for i := 0; i < 10; i++ {
value := strconv.FormatInt(int64(rand.Int()), 10)
result := LPushX(testDB, toArgs(key, value))
expected := reply.MakeIntReply(int64(i + 2))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, "0"))
expected2 := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected2.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected2.ToBytes()), string(result.ToBytes())))
}
}
LPush(testDB, toArgs(key, "1"))
for i := 0; i < 10; i++ {
value := RandString(10)
result := LPushX(testDB, toArgs(key, value))
expected := reply.MakeIntReply(int64(i + 2))
if !utils.BytesEquals(result.ToBytes(), expected.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected.ToBytes()), string(result.ToBytes())))
}
result = LIndex(testDB, toArgs(key, "0"))
expected2 := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(result.ToBytes(), expected2.ToBytes()) {
t.Error(fmt.Sprintf("expected %s, actually %s", string(expected2.ToBytes()), string(result.ToBytes())))
}
}
}

858
src/db/set.go
View File

@@ -1,511 +1,509 @@
package db
import (
HashSet "github.com/HDT3213/godis/src/datastruct/set"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/reply"
"strconv"
HashSet "github.com/HDT3213/godis/src/datastruct/set"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/reply"
"strconv"
)
func (db *DB)getAsSet(key string)(*HashSet.Set, reply.ErrorReply) {
entity, exists := db.Get(key)
if !exists {
return nil, nil
}
set, ok := entity.Data.(*HashSet.Set)
if !ok {
return nil, &reply.WrongTypeErrReply{}
}
return set, nil
func (db *DB) getAsSet(key string) (*HashSet.Set, reply.ErrorReply) {
entity, exists := db.Get(key)
if !exists {
return nil, nil
}
set, ok := entity.Data.(*HashSet.Set)
if !ok {
return nil, &reply.WrongTypeErrReply{}
}
return set, nil
}
func (db *DB) getOrInitSet(key string)(set *HashSet.Set, inited bool, errReply reply.ErrorReply) {
set, errReply = db.getAsSet(key)
if errReply != nil {
return nil, false, errReply
}
inited = false
if set == nil {
set = HashSet.Make()
db.Put(key, &DataEntity{
Data: set,
})
inited = true
}
return set, inited, nil
func (db *DB) getOrInitSet(key string) (set *HashSet.Set, inited bool, errReply reply.ErrorReply) {
set, errReply = db.getAsSet(key)
if errReply != nil {
return nil, false, errReply
}
inited = false
if set == nil {
set = HashSet.Make()
db.Put(key, &DataEntity{
Data: set,
})
inited = true
}
return set, inited, nil
}
func SAdd(db *DB, args [][]byte) redis.Reply {
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sadd' command")
}
key := string(args[0])
members := args[1:]
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sadd' command")
}
key := string(args[0])
members := args[1:]
// lock
db.Lock(key)
defer db.UnLock(key)
// lock
db.Lock(key)
defer db.UnLock(key)
// get or init entity
set, _, errReply := db.getOrInitSet(key)
if errReply != nil {
return errReply
}
counter := 0
for _, member := range members {
counter += set.Add(string(member))
}
db.AddAof(makeAofCmd("sadd", args))
return reply.MakeIntReply(int64(counter))
// get or init entity
set, _, errReply := db.getOrInitSet(key)
if errReply != nil {
return errReply
}
counter := 0
for _, member := range members {
counter += set.Add(string(member))
}
db.AddAof(makeAofCmd("sadd", args))
return reply.MakeIntReply(int64(counter))
}
func SIsMember(db *DB, args [][]byte) redis.Reply {
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sismember' command")
}
key := string(args[0])
member := string(args[1])
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sismember' command")
}
key := string(args[0])
member := string(args[1])
// get set
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return reply.MakeIntReply(0)
}
// get set
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return reply.MakeIntReply(0)
}
has := set.Has(member)
if has {
return reply.MakeIntReply(1)
} else {
return reply.MakeIntReply(0)
}
has := set.Has(member)
if has {
return reply.MakeIntReply(1)
} else {
return reply.MakeIntReply(0)
}
}
func SRem(db *DB, args [][]byte) redis.Reply {
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'srem' command")
}
key := string(args[0])
members := args[1:]
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'srem' command")
}
key := string(args[0])
members := args[1:]
// lock
db.Lock(key)
defer db.UnLock(key)
// lock
db.Lock(key)
defer db.UnLock(key)
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return reply.MakeIntReply(0)
}
counter := 0
for _, member := range members {
counter += set.Remove(string(member))
}
if set.Len() == 0 {
db.Remove(key)
}
if counter > 0 {
db.AddAof(makeAofCmd("srem", args))
}
return reply.MakeIntReply(int64(counter))
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return reply.MakeIntReply(0)
}
counter := 0
for _, member := range members {
counter += set.Remove(string(member))
}
if set.Len() == 0 {
db.Remove(key)
}
if counter > 0 {
db.AddAof(makeAofCmd("srem", args))
}
return reply.MakeIntReply(int64(counter))
}
func SCard(db *DB, args [][]byte) redis.Reply {
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'scard' command")
}
key := string(args[0])
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'scard' command")
}
key := string(args[0])
// get or init entity
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return reply.MakeIntReply(0)
}
return reply.MakeIntReply(int64(set.Len()))
// get or init entity
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return reply.MakeIntReply(0)
}
return reply.MakeIntReply(int64(set.Len()))
}
func SMembers(db *DB, args [][]byte) redis.Reply {
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'smembers' command")
}
key := string(args[0])
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'smembers' command")
}
key := string(args[0])
// lock
db.Locker.RLock(key)
defer db.Locker.RUnLock(key)
// lock
db.Locker.RLock(key)
defer db.Locker.RUnLock(key)
// get or init entity
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return &reply.EmptyMultiBulkReply{}
}
// get or init entity
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return &reply.EmptyMultiBulkReply{}
}
arr := make([][]byte, set.Len())
i := 0
set.ForEach(func (member string)bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
arr := make([][]byte, set.Len())
i := 0
set.ForEach(func(member string) bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
}
func SInter(db *DB, args [][]byte) redis.Reply {
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sinter' command")
}
keys := make([]string, len(args))
for i, arg := range args {
keys[i] = string(arg)
}
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sinter' command")
}
keys := make([]string, len(args))
for i, arg := range args {
keys[i] = string(arg)
}
// lock
db.Locker.RLocks(keys...)
defer db.Locker.RUnLocks(keys...)
// lock
db.Locker.RLocks(keys...)
defer db.Locker.RUnLocks(keys...)
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return &reply.EmptyMultiBulkReply{}
}
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return &reply.EmptyMultiBulkReply{}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Intersect(set)
if result.Len() == 0 {
// early termination
return &reply.EmptyMultiBulkReply{}
}
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Intersect(set)
if result.Len() == 0 {
// early termination
return &reply.EmptyMultiBulkReply{}
}
}
}
arr := make([][]byte, result.Len())
i := 0
result.ForEach(func (member string)bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
arr := make([][]byte, result.Len())
i := 0
result.ForEach(func(member string) bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
}
func SInterStore(db *DB, args [][]byte) redis.Reply {
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sinterstore' command")
}
dest := string(args[0])
keys := make([]string, len(args) - 1)
keyArgs := args[1:]
for i, arg := range keyArgs {
keys[i] = string(arg)
}
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sinterstore' command")
}
dest := string(args[0])
keys := make([]string, len(args)-1)
keyArgs := args[1:]
for i, arg := range keyArgs {
keys[i] = string(arg)
}
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
db.Lock(dest)
defer db.UnLock(dest)
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
db.Lock(dest)
defer db.UnLock(dest)
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
db.Remove(dest) // clean ttl and old value
return &reply.EmptyMultiBulkReply{}
}
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
db.Remove(dest) // clean ttl and old value
return &reply.EmptyMultiBulkReply{}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Intersect(set)
if result.Len() == 0 {
// early termination
db.Remove(dest) // clean ttl and old value
return reply.MakeIntReply(0)
}
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Intersect(set)
if result.Len() == 0 {
// early termination
db.Remove(dest) // clean ttl and old value
return reply.MakeIntReply(0)
}
}
}
set := HashSet.MakeFromVals(result.ToSlice()...)
db.Put(dest, &DataEntity{
Data: set,
})
db.AddAof(makeAofCmd("sinterstore", args))
return reply.MakeIntReply(int64(set.Len()))
set := HashSet.MakeFromVals(result.ToSlice()...)
db.Put(dest, &DataEntity{
Data: set,
})
db.AddAof(makeAofCmd("sinterstore", args))
return reply.MakeIntReply(int64(set.Len()))
}
func SUnion(db *DB, args [][]byte) redis.Reply {
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sunion' command")
}
keys := make([]string, len(args))
for i, arg := range args {
keys[i] = string(arg)
}
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sunion' command")
}
keys := make([]string, len(args))
for i, arg := range args {
keys[i] = string(arg)
}
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
continue
}
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
continue
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Union(set)
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Union(set)
}
}
if result == nil {
// all keys are empty set
return &reply.EmptyMultiBulkReply{}
}
arr := make([][]byte, result.Len())
i := 0
result.ForEach(func (member string)bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
if result == nil {
// all keys are empty set
return &reply.EmptyMultiBulkReply{}
}
arr := make([][]byte, result.Len())
i := 0
result.ForEach(func(member string) bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
}
func SUnionStore(db *DB, args [][]byte) redis.Reply {
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sunionstore' command")
}
dest := string(args[0])
keys := make([]string, len(args) - 1)
keyArgs := args[1:]
for i, arg := range keyArgs {
keys[i] = string(arg)
}
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sunionstore' command")
}
dest := string(args[0])
keys := make([]string, len(args)-1)
keyArgs := args[1:]
for i, arg := range keyArgs {
keys[i] = string(arg)
}
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
db.Lock(dest)
defer db.UnLock(dest)
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
db.Lock(dest)
defer db.UnLock(dest)
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
continue
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Union(set)
}
}
var result *HashSet.Set
for _, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
continue
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Union(set)
}
}
db.Remove(dest) // clean ttl
if result == nil {
// all keys are empty set
return &reply.EmptyMultiBulkReply{}
}
db.Remove(dest) // clean ttl
if result == nil {
// all keys are empty set
return &reply.EmptyMultiBulkReply{}
}
set := HashSet.MakeFromVals(result.ToSlice()...)
db.Put(dest, &DataEntity{
Data: set,
})
set := HashSet.MakeFromVals(result.ToSlice()...)
db.Put(dest, &DataEntity{
Data: set,
})
db.AddAof(makeAofCmd("sunionstore", args))
return reply.MakeIntReply(int64(set.Len()))
db.AddAof(makeAofCmd("sunionstore", args))
return reply.MakeIntReply(int64(set.Len()))
}
func SDiff(db *DB, args [][]byte) redis.Reply {
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sdiff' command")
}
keys := make([]string, len(args))
for i, arg := range args {
keys[i] = string(arg)
}
if len(args) < 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sdiff' command")
}
keys := make([]string, len(args))
for i, arg := range args {
keys[i] = string(arg)
}
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
var result *HashSet.Set
for i, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
if i == 0 {
// early termination
return &reply.EmptyMultiBulkReply{}
} else {
continue
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Diff(set)
if result.Len() == 0 {
// early termination
return &reply.EmptyMultiBulkReply{}
}
}
}
var result *HashSet.Set
for i, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
if i == 0 {
// early termination
return &reply.EmptyMultiBulkReply{}
} else {
continue
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Diff(set)
if result.Len() == 0 {
// early termination
return &reply.EmptyMultiBulkReply{}
}
}
}
if result == nil {
// all keys are nil
return &reply.EmptyMultiBulkReply{}
}
arr := make([][]byte, result.Len())
i := 0
result.ForEach(func (member string)bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
if result == nil {
// all keys are nil
return &reply.EmptyMultiBulkReply{}
}
arr := make([][]byte, result.Len())
i := 0
result.ForEach(func(member string) bool {
arr[i] = []byte(member)
i++
return true
})
return reply.MakeMultiBulkReply(arr)
}
func SDiffStore(db *DB, args [][]byte) redis.Reply {
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sdiffstore' command")
}
dest := string(args[0])
keys := make([]string, len(args) - 1)
keyArgs := args[1:]
for i, arg := range keyArgs {
keys[i] = string(arg)
}
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'sdiffstore' command")
}
dest := string(args[0])
keys := make([]string, len(args)-1)
keyArgs := args[1:]
for i, arg := range keyArgs {
keys[i] = string(arg)
}
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
db.Lock(dest)
defer db.Locker.UnLock(dest)
// lock
db.RLocks(keys...)
defer db.RUnLocks(keys...)
db.Lock(dest)
defer db.Locker.UnLock(dest)
var result *HashSet.Set
for i, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
if i == 0 {
// early termination
db.Remove(dest)
return &reply.EmptyMultiBulkReply{}
} else {
continue
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Diff(set)
if result.Len() == 0 {
// early termination
db.Remove(dest)
return &reply.EmptyMultiBulkReply{}
}
}
}
var result *HashSet.Set
for i, key := range keys {
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
if i == 0 {
// early termination
db.Remove(dest)
return &reply.EmptyMultiBulkReply{}
} else {
continue
}
}
if result == nil {
// init
result = HashSet.MakeFromVals(set.ToSlice()...)
} else {
result = result.Diff(set)
if result.Len() == 0 {
// early termination
db.Remove(dest)
return &reply.EmptyMultiBulkReply{}
}
}
}
if result == nil {
// all keys are nil
db.Remove(dest)
return &reply.EmptyMultiBulkReply{}
}
set := HashSet.MakeFromVals(result.ToSlice()...)
db.Put(dest, &DataEntity{
Data: set,
})
if result == nil {
// all keys are nil
db.Remove(dest)
return &reply.EmptyMultiBulkReply{}
}
set := HashSet.MakeFromVals(result.ToSlice()...)
db.Put(dest, &DataEntity{
Data: set,
})
db.AddAof(makeAofCmd("sdiffstore", args))
return reply.MakeIntReply(int64(set.Len()))
db.AddAof(makeAofCmd("sdiffstore", args))
return reply.MakeIntReply(int64(set.Len()))
}
func SRandMember(db *DB, args [][]byte) redis.Reply {
if len(args) != 1 && len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'srandmember' command")
}
key := string(args[0])
// lock
db.RLock(key)
defer db.RUnLock(key)
if len(args) != 1 && len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'srandmember' command")
}
key := string(args[0])
// lock
db.RLock(key)
defer db.RUnLock(key)
// get or init entity
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return &reply.NullBulkReply{}
}
if len(args) == 1 {
members := set.RandomMembers(1)
return reply.MakeBulkReply([]byte(members[0]))
} else {
count64, err := strconv.ParseInt(string(args[1]), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
count := int(count64)
// get or init entity
set, errReply := db.getAsSet(key)
if errReply != nil {
return errReply
}
if set == nil {
return &reply.NullBulkReply{}
}
if len(args) == 1 {
members := set.RandomMembers(1)
return reply.MakeBulkReply([]byte(members[0]))
} else {
count64, err := strconv.ParseInt(string(args[1]), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
count := int(count64)
if count > 0 {
members := set.RandomMembers(count)
if count > 0 {
members := set.RandomDistinctMembers(count)
result := make([][]byte, len(members))
for i, v := range members {
result[i] = []byte(v)
}
return reply.MakeMultiBulkReply(result)
} else if count < 0 {
members := set.RandomDistinctMembers(-count)
result := make([][]byte, len(members))
for i, v := range members {
result[i] = []byte(v)
}
return reply.MakeMultiBulkReply(result)
} else {
return &reply.EmptyMultiBulkReply{}
}
}
result := make([][]byte, len(members))
for i, v := range members {
result[i] = []byte(v)
}
return reply.MakeMultiBulkReply(result)
} else if count < 0 {
members := set.RandomMembers(-count)
result := make([][]byte, len(members))
for i, v := range members {
result[i] = []byte(v)
}
return reply.MakeMultiBulkReply(result)
} else {
return &reply.EmptyMultiBulkReply{}
}
}
}

181
src/db/set_test.go Normal file
View File

@@ -0,0 +1,181 @@
package db
import (
"fmt"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/HDT3213/godis/src/redis/reply/asserts"
"strconv"
"testing"
)
// basic add get and remove
func TestSAdd(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
// test sadd
key := RandString(10)
for i := 0; i < size; i++ {
member := strconv.Itoa(i)
result := SAdd(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, 1)
}
// test scard
result := SCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size)
// test is member
for i := 0; i < size; i++ {
member := strconv.Itoa(i)
result := SIsMember(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, 1)
}
// test members
result = SMembers(testDB, toArgs(key))
multiBulk, ok := result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", result.ToBytes()))
return
}
if len(multiBulk.Args) != size {
t.Error(fmt.Sprintf("expected %d elements, actually %d", size, len(multiBulk.Args)))
return
}
}
func TestSRem(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
// mock data
key := RandString(10)
for i := 0; i < size; i++ {
member := strconv.Itoa(i)
SAdd(testDB, toArgs(key, member))
}
for i := 0; i < size; i++ {
member := strconv.Itoa(i)
SRem(testDB, toArgs(key, member))
result := SIsMember(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, 0)
}
}
func TestSInter(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
step := 10
keys := make([]string, 0)
start := 0
for i := 0; i < 4; i++ {
key := RandString(10)
keys = append(keys, key)
for j := start; j < size+start; j++ {
member := strconv.Itoa(j)
SAdd(testDB, toArgs(key, member))
}
start += step
}
result := SInter(testDB, toArgs(keys...))
asserts.AssertMultiBulkReplySize(t, result, 70)
destKey := RandString(10)
keysWithDest := []string{destKey}
keysWithDest = append(keysWithDest, keys...)
result = SInterStore(testDB, toArgs(keysWithDest...))
asserts.AssertIntReply(t, result, 70)
}
func TestSUnion(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
step := 10
keys := make([]string, 0)
start := 0
for i := 0; i < 4; i++ {
key := RandString(10)
keys = append(keys, key)
for j := start; j < size+start; j++ {
member := strconv.Itoa(j)
SAdd(testDB, toArgs(key, member))
}
start += step
}
result := SUnion(testDB, toArgs(keys...))
asserts.AssertMultiBulkReplySize(t, result, 130)
destKey := RandString(10)
keysWithDest := []string{destKey}
keysWithDest = append(keysWithDest, keys...)
result = SUnionStore(testDB, toArgs(keysWithDest...))
asserts.AssertIntReply(t, result, 130)
}
func TestSDiff(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
step := 20
keys := make([]string, 0)
start := 0
for i := 0; i < 3; i++ {
key := RandString(10)
keys = append(keys, key)
for j := start; j < size+start; j++ {
member := strconv.Itoa(j)
SAdd(testDB, toArgs(key, member))
}
start += step
}
result := SDiff(testDB, toArgs(keys...))
asserts.AssertMultiBulkReplySize(t, result, step)
destKey := RandString(10)
keysWithDest := []string{destKey}
keysWithDest = append(keysWithDest, keys...)
result = SDiffStore(testDB, toArgs(keysWithDest...))
asserts.AssertIntReply(t, result, step)
}
func TestSRandMember(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
for j := 0; j < 100; j++ {
member := strconv.Itoa(j)
SAdd(testDB, toArgs(key, member))
}
result := SRandMember(testDB, toArgs(key))
br, ok := result.(*reply.BulkReply)
if !ok && len(br.Arg) > 0 {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", result.ToBytes()))
return
}
result = SRandMember(testDB, toArgs(key, "10"))
asserts.AssertMultiBulkReplySize(t, result, 10)
multiBulk, ok := result.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", result.ToBytes()))
return
}
m := make(map[string]struct{})
for _, arg := range multiBulk.Args {
m[string(arg)] = struct{}{}
}
if len(m) != 10 {
t.Error(fmt.Sprintf("expected 10 members, actually %d", len(m)))
return
}
result = SRandMember(testDB, toArgs(key, "110"))
asserts.AssertMultiBulkReplySize(t, result, 100)
result = SRandMember(testDB, toArgs(key, "-10"))
asserts.AssertMultiBulkReplySize(t, result, 10)
result = SRandMember(testDB, toArgs(key, "-110"))
asserts.AssertMultiBulkReplySize(t, result, 110)
}

486
src/db/sortedset_test.go
View File

@@ -1,298 +1,298 @@
package db
import (
"github.com/HDT3213/godis/src/redis/reply/asserts"
"math/rand"
"strconv"
"testing"
"github.com/HDT3213/godis/src/redis/reply/asserts"
"math/rand"
"strconv"
"testing"
)
func TestZAdd(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
FlushAll(testDB, [][]byte{})
size := 100
// add new members
key := strconv.FormatInt(int64(rand.Int()), 10)
members := make([]string, size)
scores := make([]float64, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(rand.Int()), 10)
scores[i] = rand.Float64()
setArgs = append(setArgs, strconv.FormatFloat(scores[i], 'f', -1, 64), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
asserts.AssertIntReply(t, result, size)
// add new members
key := RandString(10)
members := make([]string, size)
scores := make([]float64, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = RandString(10)
scores[i] = rand.Float64()
setArgs = append(setArgs, strconv.FormatFloat(scores[i], 'f', -1, 64), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
asserts.AssertIntReply(t, result, size)
// test zscore and zrank
for i, member := range members {
result := ZScore(testDB, toArgs(key, member))
score := strconv.FormatFloat(scores[i], 'f', -1, 64)
asserts.AssertBulkReply(t, result, score)
}
// test zscore and zrank
for i, member := range members {
result := ZScore(testDB, toArgs(key, member))
score := strconv.FormatFloat(scores[i], 'f', -1, 64)
asserts.AssertBulkReply(t, result, score)
}
// test zcard
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size)
// test zcard
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size)
// update members
setArgs = []string{key}
for i := 0; i < size; i++ {
scores[i] = rand.Float64() + 100
setArgs = append(setArgs, strconv.FormatFloat(scores[i], 'f', -1, 64), members[i])
}
result = ZAdd(testDB, toArgs(setArgs...))
asserts.AssertIntReply(t, result, 0) // return number of new members
// update members
setArgs = []string{key}
for i := 0; i < size; i++ {
scores[i] = rand.Float64() + 100
setArgs = append(setArgs, strconv.FormatFloat(scores[i], 'f', -1, 64), members[i])
}
result = ZAdd(testDB, toArgs(setArgs...))
asserts.AssertIntReply(t, result, 0) // return number of new members
// test updated score
for i, member := range members {
result := ZScore(testDB, toArgs(key, member))
score := strconv.FormatFloat(scores[i], 'f', -1, 64)
asserts.AssertBulkReply(t, result, score)
}
// test updated score
for i, member := range members {
result := ZScore(testDB, toArgs(key, member))
score := strconv.FormatFloat(scores[i], 'f', -1, 64)
asserts.AssertBulkReply(t, result, score)
}
}
func TestZRank(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(rand.Int()), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = RandString(10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
// test zrank
for i, member := range members {
result := ZRank(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, i)
// test zrank
for i, member := range members {
result := ZRank(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, i)
result = ZRevRank(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, size-i-1)
}
result = ZRevRank(testDB, toArgs(key, member))
asserts.AssertIntReply(t, result, size-i-1)
}
}
func TestZRange(t *testing.T) {
// prepare
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(rand.Int()), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
reverseMembers := make([]string, size)
for i, v := range members {
reverseMembers[size-i-1] = v
}
// prepare
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = RandString(10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
reverseMembers := make([]string, size)
for i, v := range members {
reverseMembers[size-i-1] = v
}
start := "0"
end := "9"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[0:10])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[0:10])
start := "0"
end := "9"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[0:10])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[0:10])
start = "0"
end = "200"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members)
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers)
start = "0"
end = "200"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members)
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers)
start = "0"
end = "-10"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[0:size-10+1])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[0:size-10+1])
start = "0"
end = "-10"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[0:size-10+1])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[0:size-10+1])
start = "0"
end = "-200"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[0:0])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[0:0])
start = "0"
end = "-200"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[0:0])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[0:0])
start = "-10"
end = "-1"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[90:])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[90:])
start = "-10"
end = "-1"
result = ZRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, members[90:])
result = ZRevRange(testDB, toArgs(key, start, end))
asserts.AssertMultiBulkReply(t, result, reverseMembers[90:])
}
func reverse(src []string) []string {
result := make([]string, len(src))
for i, v := range src {
result[len(src)-i-1] = v
}
return result
result := make([]string, len(src))
for i, v := range src {
result[len(src)-i-1] = v
}
return result
}
func TestZRangeByScore(t *testing.T) {
// prepare
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
// prepare
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
min := "20"
max := "30"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[20:31])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[20:31]))
min := "20"
max := "30"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[20:31])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[20:31]))
min = "-10"
max = "10"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[0:11])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[0:11]))
min = "-10"
max = "10"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[0:11])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[0:11]))
min = "90"
max = "110"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[90:])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[90:]))
min = "90"
max = "110"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[90:])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[90:]))
min = "(20"
max = "(30"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[21:30])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[21:30]))
min = "(20"
max = "(30"
result = ZRangeByScore(testDB, toArgs(key, min, max))
asserts.AssertMultiBulkReply(t, result, members[21:30])
result = ZRevRangeByScore(testDB, toArgs(key, max, min))
asserts.AssertMultiBulkReply(t, result, reverse(members[21:30]))
min = "20"
max = "40"
result = ZRangeByScore(testDB, toArgs(key, min, max, "LIMIT", "5", "5"))
asserts.AssertMultiBulkReply(t, result, members[25:30])
result = ZRevRangeByScore(testDB, toArgs(key, max, min, "LIMIT", "5", "5"))
asserts.AssertMultiBulkReply(t, result, reverse(members[31:36]))
min = "20"
max = "40"
result = ZRangeByScore(testDB, toArgs(key, min, max, "LIMIT", "5", "5"))
asserts.AssertMultiBulkReply(t, result, members[25:30])
result = ZRevRangeByScore(testDB, toArgs(key, max, min, "LIMIT", "5", "5"))
asserts.AssertMultiBulkReply(t, result, reverse(members[31:36]))
}
func TestZRem(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
args := []string{key}
args = append(args, members[0:10]...)
result := ZRem(testDB, toArgs(args...))
asserts.AssertIntReply(t, result, 10)
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size-10)
args := []string{key}
args = append(args, members[0:10]...)
result := ZRem(testDB, toArgs(args...))
asserts.AssertIntReply(t, result, 10)
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size-10)
// test ZRemRangeByRank
FlushAll(testDB, [][]byte{})
size = 100
key = strconv.FormatInt(int64(rand.Int()), 10)
members = make([]string, size)
scores = make([]int, size)
setArgs = []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
// test ZRemRangeByRank
FlushAll(testDB, [][]byte{})
size = 100
key = RandString(10)
members = make([]string, size)
scores = make([]int, size)
setArgs = []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
result = ZRemRangeByRank(testDB, toArgs(key, "0", "9"))
asserts.AssertIntReply(t, result, 10)
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size-10)
result = ZRemRangeByRank(testDB, toArgs(key, "0", "9"))
asserts.AssertIntReply(t, result, 10)
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size-10)
// test ZRemRangeByScore
FlushAll(testDB, [][]byte{})
size = 100
key = strconv.FormatInt(int64(rand.Int()), 10)
members = make([]string, size)
scores = make([]int, size)
setArgs = []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
// test ZRemRangeByScore
FlushAll(testDB, [][]byte{})
size = 100
key = RandString(10)
members = make([]string, size)
scores = make([]int, size)
setArgs = []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
ZAdd(testDB, toArgs(setArgs...))
result = ZRemRangeByScore(testDB, toArgs(key, "0", "9"))
asserts.AssertIntReply(t, result, 10)
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size-10)
result = ZRemRangeByScore(testDB, toArgs(key, "0", "9"))
asserts.AssertIntReply(t, result, 10)
result = ZCard(testDB, toArgs(key))
asserts.AssertIntReply(t, result, size-10)
}
func TestZCount(t *testing.T) {
// prepare
FlushAll(testDB, [][]byte{})
size := 100
key := strconv.FormatInt(int64(rand.Int()), 10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
// prepare
FlushAll(testDB, [][]byte{})
size := 100
key := RandString(10)
members := make([]string, size)
scores := make([]int, size)
setArgs := []string{key}
for i := 0; i < size; i++ {
members[i] = strconv.FormatInt(int64(i), 10)
scores[i] = i
setArgs = append(setArgs, strconv.FormatInt(int64(scores[i]), 10), members[i])
}
result := ZAdd(testDB, toArgs(setArgs...))
min := "20"
max := "30"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 11)
min := "20"
max := "30"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 11)
min = "-10"
max = "10"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 11)
min = "-10"
max = "10"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 11)
min = "90"
max = "110"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 10)
min = "90"
max = "110"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 10)
min = "(20"
max = "(30"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 9)
min = "(20"
max = "(30"
result = ZCount(testDB, toArgs(key, min, max))
asserts.AssertIntReply(t, result, 9)
}
func TestZIncrBy(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
ZAdd(testDB, toArgs(key, "10", "a"))
result := ZIncrBy(testDB, toArgs(key, "10", "a"))
asserts.AssertBulkReply(t, result, "20")
FlushAll(testDB, [][]byte{})
key := RandString(10)
ZAdd(testDB, toArgs(key, "10", "a"))
result := ZIncrBy(testDB, toArgs(key, "10", "a"))
asserts.AssertBulkReply(t, result, "20")
result = ZScore(testDB, toArgs(key, "a"))
asserts.AssertBulkReply(t, result, "20")
result = ZScore(testDB, toArgs(key, "a"))
asserts.AssertBulkReply(t, result, "20")
}

847
src/db/string.go
View File

@@ -1,509 +1,508 @@
package db
import (
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/shopspring/decimal"
"strconv"
"strings"
"time"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/shopspring/decimal"
"strconv"
"strings"
"time"
)
func (db *DB) getAsString(key string) ([]byte, reply.ErrorReply) {
entity, ok := db.Get(key)
if !ok {
return nil, nil
}
bytes, ok := entity.Data.([]byte)
if !ok {
return nil, &reply.WrongTypeErrReply{}
}
return bytes, nil
entity, ok := db.Get(key)
if !ok {
return nil, nil
}
bytes, ok := entity.Data.([]byte)
if !ok {
return nil, &reply.WrongTypeErrReply{}
}
return bytes, nil
}
func Get(db *DB, args [][]byte) redis.Reply {
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'get' command")
}
key := string(args[0])
bytes, err := db.getAsString(key)
if err != nil {
return err
}
if bytes == nil {
return &reply.NullBulkReply{}
}
return reply.MakeBulkReply(bytes)
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'get' command")
}
key := string(args[0])
bytes, err := db.getAsString(key)
if err != nil {
return err
}
if bytes == nil {
return &reply.NullBulkReply{}
}
return reply.MakeBulkReply(bytes)
}
const (
upsertPolicy = iota // default
insertPolicy // set nx
updatePolicy // set ex
upsertPolicy = iota // default
insertPolicy // set nx
updatePolicy // set ex
)
const unlimitedTTL int64 = 0
// SET key value [EX seconds] [PX milliseconds] [NX|XX]
func Set(db *DB, args [][]byte) redis.Reply {
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'set' command")
}
key := string(args[0])
value := args[1]
policy := upsertPolicy
ttl := unlimitedTTL
if len(args) < 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'set' command")
}
key := string(args[0])
value := args[1]
policy := upsertPolicy
ttl := unlimitedTTL
// parse options
if len(args) > 2 {
for i := 2; i < len(args); i++ {
arg := strings.ToUpper(string(args[i]))
if arg == "NX" { // insert
if policy == updatePolicy {
return &reply.SyntaxErrReply{}
}
policy = insertPolicy
} else if arg == "XX" { // update policy
if policy == insertPolicy {
return &reply.SyntaxErrReply{}
}
policy = updatePolicy
} else if arg == "EX" { // ttl in seconds
if ttl != unlimitedTTL {
// ttl has been set
return &reply.SyntaxErrReply{}
}
if i+1 >= len(args) {
return &reply.SyntaxErrReply{}
}
ttlArg, err := strconv.ParseInt(string(args[i+1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in set")
}
ttl = ttlArg * 1000
i++ // skip next arg
} else if arg == "PX" { // ttl in milliseconds
if ttl != unlimitedTTL {
return &reply.SyntaxErrReply{}
}
if i+1 >= len(args) {
return &reply.SyntaxErrReply{}
}
ttlArg, err := strconv.ParseInt(string(args[i+1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in set")
}
ttl = ttlArg
i++ // skip next arg
} else {
return &reply.SyntaxErrReply{}
}
}
}
// parse options
if len(args) > 2 {
for i := 2; i < len(args); i++ {
arg := strings.ToUpper(string(args[i]))
if arg == "NX" { // insert
if policy == updatePolicy {
return &reply.SyntaxErrReply{}
}
policy = insertPolicy
} else if arg == "XX" { // update policy
if policy == insertPolicy {
return &reply.SyntaxErrReply{}
}
policy = updatePolicy
} else if arg == "EX" { // ttl in seconds
if ttl != unlimitedTTL {
// ttl has been set
return &reply.SyntaxErrReply{}
}
if i+1 >= len(args) {
return &reply.SyntaxErrReply{}
}
ttlArg, err := strconv.ParseInt(string(args[i+1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in set")
}
ttl = ttlArg * 1000
i++ // skip next arg
} else if arg == "PX" { // ttl in milliseconds
if ttl != unlimitedTTL {
return &reply.SyntaxErrReply{}
}
if i+1 >= len(args) {
return &reply.SyntaxErrReply{}
}
ttlArg, err := strconv.ParseInt(string(args[i+1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in set")
}
ttl = ttlArg
i++ // skip next arg
} else {
return &reply.SyntaxErrReply{}
}
}
}
entity := &DataEntity{
Data: value,
}
entity := &DataEntity{
Data: value,
}
db.Persist(key) // clean ttl
var result int
switch policy {
case upsertPolicy:
result = db.Put(key, entity)
case insertPolicy:
result = db.PutIfAbsent(key, entity)
case updatePolicy:
result = db.PutIfExists(key, entity)
}
/*
* 如果设置了ttl 则以最新的ttl为准
* 如果没有设置ttl 是新增key的情况，不设置ttl。
* 如果没有设置ttl 且已存在key的 不修改ttl 但需要增加aof
*/
if ttl != unlimitedTTL {
expireTime := time.Now().Add(time.Duration(ttl) * time.Millisecond)
db.Expire(key, expireTime)
db.AddAof(reply.MakeMultiBulkReply([][]byte{
[]byte("SET"),
args[0],
args[1],
}))
db.AddAof(makeExpireCmd(key, expireTime))
} else if result > 0{
db.Persist(key) // override ttl
db.AddAof(makeAofCmd("set", args))
}else{
db.AddAof(makeAofCmd("set", args))
}
db.Persist(key) // clean ttl
var result int
switch policy {
case upsertPolicy:
result = db.Put(key, entity)
case insertPolicy:
result = db.PutIfAbsent(key, entity)
case updatePolicy:
result = db.PutIfExists(key, entity)
}
/*
* 如果设置了ttl 则以最新的ttl为准
* 如果没有设置ttl 是新增key的情况，不设置ttl。
* 如果没有设置ttl 且已存在key的 不修改ttl 但需要增加aof
*/
if ttl != unlimitedTTL {
expireTime := time.Now().Add(time.Duration(ttl) * time.Millisecond)
db.Expire(key, expireTime)
db.AddAof(reply.MakeMultiBulkReply([][]byte{
[]byte("SET"),
args[0],
args[1],
}))
db.AddAof(makeExpireCmd(key, expireTime))
} else if result > 0 {
db.Persist(key) // override ttl
db.AddAof(makeAofCmd("set", args))
} else {
db.AddAof(makeAofCmd("set", args))
}
if policy == upsertPolicy || result > 0 {
return &reply.OkReply{}
} else {
return &reply.NullBulkReply{}
}
if policy == upsertPolicy || result > 0 {
return &reply.OkReply{}
} else {
return &reply.NullBulkReply{}
}
}
func SetNX(db *DB, args [][]byte) redis.Reply {
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'setnx' command")
}
key := string(args[0])
value := args[1]
entity := &DataEntity{
Data: value,
}
result := db.PutIfAbsent(key, entity)
if result > 0 {
db.AddAof(makeAofCmd("setnx", args))
}
return reply.MakeIntReply(int64(result))
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'setnx' command")
}
key := string(args[0])
value := args[1]
entity := &DataEntity{
Data: value,
}
result := db.PutIfAbsent(key, entity)
db.AddAof(makeAofCmd("setnx", args))
return reply.MakeIntReply(int64(result))
}
func SetEX(db *DB, args [][]byte) redis.Reply {
if len(args) != 3 {
return reply.MakeErrReply("ERR wrong number of arguments for 'setex' command")
}
key := string(args[0])
value := args[2]
if len(args) != 3 {
return reply.MakeErrReply("ERR wrong number of arguments for 'setex' command")
}
key := string(args[0])
value := args[2]
ttlArg, err := strconv.ParseInt(string(args[1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in setex")
}
ttl := ttlArg * 1000
ttlArg, err := strconv.ParseInt(string(args[1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in setex")
}
ttl := ttlArg * 1000
entity := &DataEntity{
Data: value,
}
entity := &DataEntity{
Data: value,
}
db.Lock(key)
defer db.UnLock(key)
db.Lock(key)
defer db.UnLock(key)
result := db.Put(key, entity)
expireTime := time.Now().Add(time.Duration(ttl) * time.Millisecond)
db.Expire(key, expireTime)
if result > 0 {
db.AddAof(makeAofCmd("setex", args))
db.AddAof(makeExpireCmd(key, expireTime))
}
return &reply.OkReply{}
db.Put(key, entity)
expireTime := time.Now().Add(time.Duration(ttl) * time.Millisecond)
db.Expire(key, expireTime)
db.AddAof(makeAofCmd("setex", args))
db.AddAof(makeExpireCmd(key, expireTime))
return &reply.OkReply{}
}
func PSetEX(db *DB, args [][]byte) redis.Reply {
if len(args) != 3 {
return reply.MakeErrReply("ERR wrong number of arguments for 'psetex' command")
}
key := string(args[0])
value := args[1]
if len(args) != 3 {
return reply.MakeErrReply("ERR wrong number of arguments for 'setex' command")
}
key := string(args[0])
value := args[2]
ttl, err := strconv.ParseInt(string(args[1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttl <= 0 {
return reply.MakeErrReply("ERR invalid expire time in psetex")
}
ttlArg, err := strconv.ParseInt(string(args[1]), 10, 64)
if err != nil {
return &reply.SyntaxErrReply{}
}
if ttlArg <= 0 {
return reply.MakeErrReply("ERR invalid expire time in setex")
}
entity := &DataEntity{
Data: value,
}
result := db.PutIfExists(key, entity)
if result > 0 {
db.AddAof(makeAofCmd("psetex", args))
if ttl != unlimitedTTL {
expireTime := time.Now().Add(time.Duration(ttl) * time.Millisecond)
db.Expire(key, expireTime)
db.AddAof(makeExpireCmd(key, expireTime))
}
}
return &reply.OkReply{}
entity := &DataEntity{
Data: value,
}
db.Lock(key)
defer db.UnLock(key)
db.Put(key, entity)
expireTime := time.Now().Add(time.Duration(ttlArg) * time.Millisecond)
db.Expire(key, expireTime)
db.AddAof(makeAofCmd("setex", args))
db.AddAof(makeExpireCmd(key, expireTime))
return &reply.OkReply{}
}
func MSet(db *DB, args [][]byte) redis.Reply {
if len(args)%2 != 0 || len(args) == 0 {
return reply.MakeErrReply("ERR wrong number of arguments for 'mset' command")
}
if len(args)%2 != 0 || len(args) == 0 {
return reply.MakeErrReply("ERR wrong number of arguments for 'mset' command")
}
size := len(args) / 2
keys := make([]string, size)
values := make([][]byte, size)
for i := 0; i < size; i++ {
keys[i] = string(args[2*i])
values[i] = args[2*i+1]
}
size := len(args) / 2
keys := make([]string, size)
values := make([][]byte, size)
for i := 0; i < size; i++ {
keys[i] = string(args[2*i])
values[i] = args[2*i+1]
}
db.Locks(keys...)
defer db.UnLocks(keys...)
db.Locks(keys...)
defer db.UnLocks(keys...)
for i, key := range keys {
value := values[i]
db.Put(key, &DataEntity{Data: value})
}
db.AddAof(makeAofCmd("mset", args))
return &reply.OkReply{}
for i, key := range keys {
value := values[i]
db.Put(key, &DataEntity{Data: value})
}
db.AddAof(makeAofCmd("mset", args))
return &reply.OkReply{}
}
func MGet(db *DB, args [][]byte) redis.Reply {
if len(args) == 0 {
return reply.MakeErrReply("ERR wrong number of arguments for 'mget' command")
}
keys := make([]string, len(args))
for i, v := range args {
keys[i] = string(v)
}
if len(args) == 0 {
return reply.MakeErrReply("ERR wrong number of arguments for 'mget' command")
}
keys := make([]string, len(args))
for i, v := range args {
keys[i] = string(v)
}
result := make([][]byte, len(args))
for i, key := range keys {
bytes, err := db.getAsString(key)
if err != nil {
_, isWrongType := err.(*reply.WrongTypeErrReply)
if isWrongType {
result[i] = nil
continue
} else {
return err
}
}
result[i] = bytes // nil or []byte
}
result := make([][]byte, len(args))
for i, key := range keys {
bytes, err := db.getAsString(key)
if err != nil {
_, isWrongType := err.(*reply.WrongTypeErrReply)
if isWrongType {
result[i] = nil
continue
} else {
return err
}
}
result[i] = bytes // nil or []byte
}
return reply.MakeMultiBulkReply(result)
return reply.MakeMultiBulkReply(result)
}
func MSetNX(db *DB, args [][]byte) redis.Reply {
// parse args
if len(args)%2 != 0 || len(args) == 0 {
return reply.MakeErrReply("ERR wrong number of arguments for 'msetnx' command")
}
size := len(args) / 2
values := make([][]byte, size)
keys := make([]string, size)
for i := 0; i < size; i++ {
keys[i] = string(args[2*i])
values[i] = args[2*i+1]
}
// parse args
if len(args)%2 != 0 || len(args) == 0 {
return reply.MakeErrReply("ERR wrong number of arguments for 'msetnx' command")
}
size := len(args) / 2
values := make([][]byte, size)
keys := make([]string, size)
for i := 0; i < size; i++ {
keys[i] = string(args[2*i])
values[i] = args[2*i+1]
}
// lock keys
db.Locks(keys...)
defer db.UnLocks(keys...)
// lock keys
db.Locks(keys...)
defer db.UnLocks(keys...)
for _, key := range keys {
_, exists := db.Get(key)
if exists {
return reply.MakeIntReply(0)
}
}
for _, key := range keys {
_, exists := db.Get(key)
if exists {
return reply.MakeIntReply(0)
}
}
for i, key := range keys {
value := values[i]
db.Put(key, &DataEntity{Data: value})
}
db.AddAof(makeAofCmd("msetnx", args))
return reply.MakeIntReply(1)
for i, key := range keys {
value := values[i]
db.Put(key, &DataEntity{Data: value})
}
db.AddAof(makeAofCmd("msetnx", args))
return reply.MakeIntReply(1)
}
func GetSet(db *DB, args [][]byte) redis.Reply {
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'getset' command")
}
key := string(args[0])
value := args[1]
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'getset' command")
}
key := string(args[0])
value := args[1]
old, err := db.getAsString(key)
if err != nil {
return err
}
old, err := db.getAsString(key)
if err != nil {
return err
}
db.Put(key, &DataEntity{Data: value})
db.Persist(key) // override ttl
db.AddAof(makeAofCmd("getset", args))
return reply.MakeBulkReply(old)
db.Put(key, &DataEntity{Data: value})
db.Persist(key) // override ttl
db.AddAof(makeAofCmd("getset", args))
if old == nil {
return new(reply.NullBulkReply)
}
return reply.MakeBulkReply(old)
}
func Incr(db *DB, args [][]byte) redis.Reply {
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'incr' command")
}
key := string(args[0])
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'incr' command")
}
key := string(args[0])
db.Lock(key)
defer db.UnLock(key)
db.Lock(key)
defer db.UnLock(key)
bytes, err := db.getAsString(key)
if err != nil {
return err
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val+1, 10)),
})
db.AddAof(makeAofCmd("incr", args))
return reply.MakeIntReply(val + 1)
} else {
db.Put(key, &DataEntity{
Data: []byte("1"),
})
db.AddAof(makeAofCmd("incr", args))
return reply.MakeIntReply(1)
}
bytes, err := db.getAsString(key)
if err != nil {
return err
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val+1, 10)),
})
db.AddAof(makeAofCmd("incr", args))
return reply.MakeIntReply(val + 1)
} else {
db.Put(key, &DataEntity{
Data: []byte("1"),
})
db.AddAof(makeAofCmd("incr", args))
return reply.MakeIntReply(1)
}
}
func IncrBy(db *DB, args [][]byte) redis.Reply {
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'incrby' command")
}
key := string(args[0])
rawDelta := string(args[1])
delta, err := strconv.ParseInt(rawDelta, 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'incrby' command")
}
key := string(args[0])
rawDelta := string(args[1])
delta, err := strconv.ParseInt(rawDelta, 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Lock(key)
defer db.UnLock(key)
db.Lock(key)
defer db.UnLock(key)
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val+delta, 10)),
})
db.AddAof(makeAofCmd("incrby", args))
return reply.MakeIntReply(val + delta)
} else {
db.Put(key, &DataEntity{
Data: args[1],
})
db.AddAof(makeAofCmd("incrby", args))
return reply.MakeIntReply(delta)
}
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val+delta, 10)),
})
db.AddAof(makeAofCmd("incrby", args))
return reply.MakeIntReply(val + delta)
} else {
db.Put(key, &DataEntity{
Data: args[1],
})
db.AddAof(makeAofCmd("incrby", args))
return reply.MakeIntReply(delta)
}
}
func IncrByFloat(db *DB, args [][]byte) redis.Reply {
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'incrbyfloat' command")
}
key := string(args[0])
rawDelta := string(args[1])
delta, err := decimal.NewFromString(rawDelta)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'incrbyfloat' command")
}
key := string(args[0])
rawDelta := string(args[1])
delta, err := decimal.NewFromString(rawDelta)
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
db.Lock(key)
defer db.UnLock(key)
db.Lock(key)
defer db.UnLock(key)
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := decimal.NewFromString(string(bytes))
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
resultBytes := []byte(val.Add(delta).String())
db.Put(key, &DataEntity{
Data: resultBytes,
})
db.AddAof(makeAofCmd("incrbyfloat", args))
return reply.MakeBulkReply(resultBytes)
} else {
db.Put(key, &DataEntity{
Data: args[1],
})
db.AddAof(makeAofCmd("incrbyfloat", args))
return reply.MakeBulkReply(args[1])
}
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := decimal.NewFromString(string(bytes))
if err != nil {
return reply.MakeErrReply("ERR value is not a valid float")
}
resultBytes := []byte(val.Add(delta).String())
db.Put(key, &DataEntity{
Data: resultBytes,
})
db.AddAof(makeAofCmd("incrbyfloat", args))
return reply.MakeBulkReply(resultBytes)
} else {
db.Put(key, &DataEntity{
Data: args[1],
})
db.AddAof(makeAofCmd("incrbyfloat", args))
return reply.MakeBulkReply(args[1])
}
}
func Decr(db *DB, args [][]byte) redis.Reply {
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'decr' command")
}
key := string(args[0])
if len(args) != 1 {
return reply.MakeErrReply("ERR wrong number of arguments for 'decr' command")
}
key := string(args[0])
db.Lock(key)
defer db.UnLock(key)
db.Lock(key)
defer db.UnLock(key)
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val-1, 10)),
})
db.AddAof(makeAofCmd("decr", args))
return reply.MakeIntReply(val - 1)
} else {
entity := &DataEntity{
Data: []byte("-1"),
}
db.Put(key, entity)
db.AddAof(makeAofCmd("decr", args))
return reply.MakeIntReply(-1)
}
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val-1, 10)),
})
db.AddAof(makeAofCmd("decr", args))
return reply.MakeIntReply(val - 1)
} else {
entity := &DataEntity{
Data: []byte("-1"),
}
db.Put(key, entity)
db.AddAof(makeAofCmd("decr", args))
return reply.MakeIntReply(-1)
}
}
func DecrBy(db *DB, args [][]byte) redis.Reply {
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'decrby' command")
}
key := string(args[0])
rawDelta := string(args[1])
delta, err := strconv.ParseInt(rawDelta, 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
if len(args) != 2 {
return reply.MakeErrReply("ERR wrong number of arguments for 'decrby' command")
}
key := string(args[0])
rawDelta := string(args[1])
delta, err := strconv.ParseInt(rawDelta, 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Lock(key)
defer db.UnLock(key)
db.Lock(key)
defer db.UnLock(key)
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val-delta, 10)),
})
db.AddAof(makeAofCmd("decrby", args))
return reply.MakeIntReply(val - delta)
} else {
valueStr := strconv.FormatInt(-delta, 10)
db.Put(key, &DataEntity{
Data: []byte(valueStr),
})
db.AddAof(makeAofCmd("decrby", args))
return reply.MakeIntReply(-delta)
}
bytes, errReply := db.getAsString(key)
if errReply != nil {
return errReply
}
if bytes != nil {
val, err := strconv.ParseInt(string(bytes), 10, 64)
if err != nil {
return reply.MakeErrReply("ERR value is not an integer or out of range")
}
db.Put(key, &DataEntity{
Data: []byte(strconv.FormatInt(val-delta, 10)),
})
db.AddAof(makeAofCmd("decrby", args))
return reply.MakeIntReply(val - delta)
} else {
valueStr := strconv.FormatInt(-delta, 10)
db.Put(key, &DataEntity{
Data: []byte(valueStr),
})
db.AddAof(makeAofCmd("decrby", args))
return reply.MakeIntReply(-delta)
}
}

380
src/db/string_test.go
View File

@@ -1,152 +1,288 @@
package db
import (
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/redis/reply"
"math/rand"
"strconv"
"testing"
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/redis/reply"
"github.com/HDT3213/godis/src/redis/reply/asserts"
"strconv"
"testing"
)
var testDB = makeTestDB()
func TestSet(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
value := strconv.FormatInt(int64(rand.Int()), 10)
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
// normal set
Set(testDB, toArgs(key, value))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
// normal set
Set(testDB, toArgs(key, value))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
// set nx
actual = Set(testDB, toArgs(key, value, "NX"))
if _, ok := actual.(*reply.NullBulkReply); !ok {
t.Error("expected true actual false")
}
// set nx
actual = Set(testDB, toArgs(key, value, "NX"))
if _, ok := actual.(*reply.NullBulkReply); !ok {
t.Error("expected true actual false")
}
FlushAll(testDB, [][]byte{})
key = strconv.FormatInt(int64(rand.Int()), 10)
value = strconv.FormatInt(int64(rand.Int()), 10)
Set(testDB, toArgs(key, value, "NX"))
actual = Get(testDB, toArgs(key))
expected = reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
FlushAll(testDB, [][]byte{})
key = RandString(10)
value = RandString(10)
Set(testDB, toArgs(key, value, "NX"))
actual = Get(testDB, toArgs(key))
expected = reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
// set xx
FlushAll(testDB, [][]byte{})
key = strconv.FormatInt(int64(rand.Int()), 10)
value = strconv.FormatInt(int64(rand.Int()), 10)
actual = Set(testDB, toArgs(key, value, "XX"))
if _, ok := actual.(*reply.NullBulkReply); !ok {
t.Error("expected true actually false ")
}
// set xx
FlushAll(testDB, [][]byte{})
key = RandString(10)
value = RandString(10)
actual = Set(testDB, toArgs(key, value, "XX"))
if _, ok := actual.(*reply.NullBulkReply); !ok {
t.Error("expected true actually false ")
}
Set(testDB, toArgs(key, value))
Set(testDB, toArgs(key, value, "XX"))
actual = Get(testDB, toArgs(key))
expected = reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
Set(testDB, toArgs(key, value))
Set(testDB, toArgs(key, value, "XX"))
actual = Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, actual, value)
// set ex
Del(testDB, toArgs(key))
ttl := "1000"
Set(testDB, toArgs(key, value, "EX", ttl))
actual = Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, actual, value)
actual = TTL(testDB, toArgs(key))
intResult, ok := actual.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", actual.ToBytes()))
return
}
if intResult.Code <= 0 || intResult.Code > 1000 {
t.Error(fmt.Sprintf("expected int between [0, 1000], actually %d", intResult.Code))
return
}
// set px
Del(testDB, toArgs(key))
ttlPx := "1000000"
Set(testDB, toArgs(key, value, "PX", ttlPx))
actual = Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, actual, value)
actual = TTL(testDB, toArgs(key))
intResult, ok = actual.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", actual.ToBytes()))
return
}
if intResult.Code <= 0 || intResult.Code > 1000 {
t.Error(fmt.Sprintf("expected int between [0, 1000], actually %d", intResult.Code))
return
}
}
func TestSetNX(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
value := strconv.FormatInt(int64(rand.Int()), 10)
SetNX(testDB, toArgs(key, value))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
SetNX(testDB, toArgs(key, value))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
actual = SetNX(testDB, toArgs(key, value))
expected2 := reply.MakeIntReply(int64(0))
if !utils.BytesEquals(actual.ToBytes(), expected2.ToBytes()) {
t.Error("expected: " + string(expected2.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
actual = SetNX(testDB, toArgs(key, value))
expected2 := reply.MakeIntReply(int64(0))
if !utils.BytesEquals(actual.ToBytes(), expected2.ToBytes()) {
t.Error("expected: " + string(expected2.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
func TestSetEX(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := strconv.FormatInt(int64(rand.Int()), 10)
value := strconv.FormatInt(int64(rand.Int()), 10)
ttl := "1000"
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
ttl := "1000"
SetEX(testDB, toArgs(key, ttl, value))
actual := Get(testDB, toArgs(key))
expected2 := reply.MakeBulkReply([]byte(value))
if !utils.BytesEquals(actual.ToBytes(), expected2.ToBytes()) {
t.Error("expected: " + string(expected2.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
SetEX(testDB, toArgs(key, ttl, value))
actual := Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, actual, value)
actual = TTL(testDB, toArgs(key))
intResult, ok := actual.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", actual.ToBytes()))
return
}
if intResult.Code <= 0 || intResult.Code > 1000 {
t.Error(fmt.Sprintf("expected int between [0, 1000], actually %d", intResult.Code))
return
}
}
func TestPSetEX(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
ttl := "1000000"
PSetEX(testDB, toArgs(key, ttl, value))
actual := Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, actual, value)
actual = PTTL(testDB, toArgs(key))
intResult, ok := actual.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", actual.ToBytes()))
return
}
if intResult.Code <= 0 || intResult.Code > 1000000 {
t.Error(fmt.Sprintf("expected int between [0, 1000], actually %d", intResult.Code))
return
}
}
func TestMSet(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 10
keys := make([]string, size)
values := make([][]byte, size)
args := make([]string, 0, size*2)
for i := 0; i < size; i++ {
keys[i] = strconv.FormatInt(int64(rand.Int()), 10)
value := strconv.FormatInt(int64(rand.Int()), 10)
values[i] = []byte(value)
args = append(args, keys[i], value)
}
MSet(testDB, toArgs(args...))
actual := MGet(testDB, toArgs(keys...))
expected := reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
FlushAll(testDB, [][]byte{})
size := 10
keys := make([]string, size)
values := make([][]byte, size)
args := make([]string, 0, size*2)
for i := 0; i < size; i++ {
keys[i] = RandString(10)
value := RandString(10)
values[i] = []byte(value)
args = append(args, keys[i], value)
}
MSet(testDB, toArgs(args...))
actual := MGet(testDB, toArgs(keys...))
expected := reply.MakeMultiBulkReply(values)
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
func TestIncr(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 10
key := strconv.FormatInt(int64(rand.Int()), 10)
for i := 0; i < size; i++ {
Incr(testDB, toArgs(key))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(i+1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
for i := 0; i < size; i++ {
IncrBy(testDB, toArgs(key, "-1"))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(size-i-1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
FlushAll(testDB, [][]byte{})
size := 10
key := RandString(10)
for i := 0; i < size; i++ {
Incr(testDB, toArgs(key))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(i+1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
for i := 0; i < size; i++ {
IncrBy(testDB, toArgs(key, "-1"))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(size-i-1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
FlushAll(testDB, [][]byte{})
key = strconv.FormatInt(int64(rand.Int()), 10)
for i := 0; i < size; i++ {
IncrBy(testDB, toArgs(key, "1"))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(i+1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
for i := 0; i < size; i++ {
IncrByFloat(testDB, toArgs(key, "-1.0"))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(size-i-1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
FlushAll(testDB, [][]byte{})
key = RandString(10)
for i := 0; i < size; i++ {
IncrBy(testDB, toArgs(key, "1"))
actual := Get(testDB, toArgs(key))
expected := reply.MakeBulkReply([]byte(strconv.FormatInt(int64(i+1), 10)))
if !utils.BytesEquals(actual.ToBytes(), expected.ToBytes()) {
t.Error("expected: " + string(expected.ToBytes()) + ", actual: " + string(actual.ToBytes()))
}
}
Del(testDB, toArgs(key))
for i := 0; i < size; i++ {
IncrByFloat(testDB, toArgs(key, "-1.0"))
actual := Get(testDB, toArgs(key))
expected := -i - 1
bulk, ok := actual.(*reply.BulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", actual.ToBytes()))
return
}
val, err := strconv.ParseFloat(string(bulk.Arg), 10)
if err != nil {
t.Error(err)
return
}
if int(val) != expected {
t.Errorf("expect %d, actual: %d", expected, int(val))
return
}
}
}
func TestDecr(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 10
key := RandString(10)
for i := 0; i < size; i++ {
Decr(testDB, toArgs(key))
actual := Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, actual, strconv.Itoa(-i-1))
}
Del(testDB, toArgs(key))
for i := 0; i < size; i++ {
DecrBy(testDB, toArgs(key, "1"))
actual := Get(testDB, toArgs(key))
expected := -i - 1
bulk, ok := actual.(*reply.BulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", actual.ToBytes()))
return
}
val, err := strconv.ParseFloat(string(bulk.Arg), 10)
if err != nil {
t.Error(err)
return
}
if int(val) != expected {
t.Errorf("expect %d, actual: %d", expected, int(val))
return
}
}
}
func TestGetSet(t *testing.T) {
FlushAll(testDB, [][]byte{})
key := RandString(10)
value := RandString(10)
result := GetSet(testDB, toArgs(key, value))
_, ok := result.(*reply.NullBulkReply)
if !ok {
t.Errorf("expect null bulk reply, get: %s", string(result.ToBytes()))
return
}
value2 := RandString(10)
result = GetSet(testDB, toArgs(key, value2))
asserts.AssertBulkReply(t, result, value)
result = Get(testDB, toArgs(key))
asserts.AssertBulkReply(t, result, value2)
}
func TestMSetNX(t *testing.T) {
FlushAll(testDB, [][]byte{})
size := 10
args := make([]string, 0, size*2)
for i := 0; i < size; i++ {
str := RandString(10)
args = append(args, str, str)
}
result := MSetNX(testDB, toArgs(args...))
asserts.AssertIntReply(t, result, 1)
result = MSetNX(testDB, toArgs(args[0:4]...))
asserts.AssertIntReply(t, result, 0)
}

39
src/db/util_test.go
View File

@@ -1,24 +1,35 @@
package db
import (
"github.com/HDT3213/godis/src/datastruct/dict"
"github.com/HDT3213/godis/src/datastruct/lock"
"time"
"github.com/HDT3213/godis/src/datastruct/dict"
"github.com/HDT3213/godis/src/datastruct/lock"
"math/rand"
"time"
)
func makeTestDB() *DB {
return &DB{
Data: dict.MakeConcurrent(1),
TTLMap: dict.MakeConcurrent(ttlDictSize),
Locker: lock.Make(lockerSize),
interval: 5 * time.Second,
}
return &DB{
Data: dict.MakeConcurrent(1),
TTLMap: dict.MakeConcurrent(ttlDictSize),
Locker: lock.Make(lockerSize),
interval: 5 * time.Second,
}
}
func toArgs(cmd ...string) [][]byte {
args := make([][]byte, len(cmd))
for i, s := range cmd {
args[i] = []byte(s)
}
return args
args := make([][]byte, len(cmd))
for i, s := range cmd {
args[i] = []byte(s)
}
return args
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
func RandString(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}

105
src/redis/reply/asserts/assert.go
View File

@@ -1,49 +1,82 @@
package asserts
import (
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/reply"
"testing"
"fmt"
"github.com/HDT3213/godis/src/datastruct/utils"
"github.com/HDT3213/godis/src/interface/redis"
"github.com/HDT3213/godis/src/redis/reply"
"runtime"
"testing"
)
func AssertIntReply(t *testing.T, actual redis.Reply, expected int) {
intResult, ok := actual.(*reply.IntReply)
if !ok {
t.Error(fmt.Sprintf("expected int reply, actually %s", actual.ToBytes()))
return
}
if intResult.Code != int64(expected) {
t.Error(fmt.Sprintf("expected %d, actually %d", expected, intResult.Code))
}
intResult, ok := actual.(*reply.IntReply)
if !ok {
t.Errorf("expected int reply, actually %s, %s", actual.ToBytes(), printStack())
return
}
if intResult.Code != int64(expected) {
t.Errorf("expected %d, actually %d, %s", expected, intResult.Code, printStack())
}
}
func AssertBulkReply(t *testing.T, actual redis.Reply, expected string) {
bulkReply, ok := actual.(*reply.BulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", actual.ToBytes()))
return
}
if !utils.BytesEquals(bulkReply.Arg, []byte(expected)) {
t.Error(fmt.Sprintf("expected %s, actually %s", expected, actual.ToBytes()))
}
bulkReply, ok := actual.(*reply.BulkReply)
if !ok {
t.Errorf("expected bulk reply, actually %s, %s", actual.ToBytes(), printStack())
return
}
if !utils.BytesEquals(bulkReply.Arg, []byte(expected)) {
t.Errorf("expected %s, actually %s, %s", expected, actual.ToBytes(), printStack())
}
}
func AssertStatusReply(t *testing.T, actual redis.Reply, expected string) {
statusReply, ok := actual.(*reply.StatusReply)
if !ok {
t.Errorf("expected bulk reply, actually %s, %s", actual.ToBytes(), printStack())
return
}
if statusReply.Status != expected {
t.Errorf("expected %s, actually %s, %s", expected, actual.ToBytes(), printStack())
}
}
func AssertMultiBulkReply(t *testing.T, actual redis.Reply, expected []string) {
multiBulk, ok := actual.(*reply.MultiBulkReply)
if !ok {
t.Error(fmt.Sprintf("expected bulk reply, actually %s", actual.ToBytes()))
return
}
if len(multiBulk.Args) != len(expected) {
t.Error(fmt.Sprintf("expected %d elements, actually %d", len(expected), len(multiBulk.Args)))
return
}
for i, v := range multiBulk.Args {
actual := string(v)
if actual != expected[i] {
t.Error(fmt.Sprintf("expected %s, actually %s", expected[i], actual))
}
}
multiBulk, ok := actual.(*reply.MultiBulkReply)
if !ok {
t.Errorf("expected bulk reply, actually %s, %s", actual.ToBytes(), printStack())
return
}
if len(multiBulk.Args) != len(expected) {
t.Errorf("expected %d elements, actually %d, %s",
len(expected), len(multiBulk.Args), printStack())
return
}
for i, v := range multiBulk.Args {
str := string(v)
if str != expected[i] {
t.Errorf("expected %s, actually %s, %s", expected[i], actual, printStack())
}
}
}
func AssertMultiBulkReplySize(t *testing.T, actual redis.Reply, expected int) {
multiBulk, ok := actual.(*reply.MultiBulkReply)
if !ok {
t.Errorf("expected bulk reply, actually %s, %s", actual.ToBytes(), printStack())
return
}
if len(multiBulk.Args) != expected {
t.Errorf("expected %d elements, actually %d, %s", expected, len(multiBulk.Args), printStack())
return
}
}
func printStack() string {
_, file, no, ok := runtime.Caller(2)
if ok {
return fmt.Sprintf("at %s#%d", file, no)
}
return ""
}