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

add zlexcount, zremrangebylex, zrankbylex, zrevrankbylex to zset

Browse Source
This commit is contained in:
damonslh
2023-05-28 21:37:15 +08:00
committed by finley
parent 74421ba3f2
commit 96a37cc7cb
9 changed files with 811 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
database/sortedset_test.go
View File

@@ -1,11 +1,12 @@
package database
import (
"github.com/hdt3213/godis/lib/utils"
"github.com/hdt3213/godis/redis/protocol/asserts"
"math/rand"
"strconv"
"testing"
"github.com/hdt3213/godis/lib/utils"
"github.com/hdt3213/godis/redis/protocol/asserts"
)
func TestZAdd(t *testing.T) {
@@ -321,3 +322,444 @@ func TestZPopMin(t *testing.T) {
result = testDB.Exec(nil, utils.ToCmdLine("ZPopMin", key+"2", "2"))
asserts.AssertErrReply(t, result, "WRONGTYPE Operation against a key holding the wrong kind of value")
}
func TestZLexCount(t *testing.T) {
testDB.Flush()
key := utils.RandString(10)
// a b c d e
result := testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "e", "0", "d", "0", "c", "0", "b", "0", "a"))
asserts.AssertNotError(t, result)
// case1
result1 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(-", "(+"))
asserts.AssertIntReply(t, result1, 0)
// case2
result2 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(-", "(g"))
asserts.AssertIntReply(t, result2, 5)
// case3
result3 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(-", "(c"))
asserts.AssertIntReply(t, result3, 2)
// case4
result4 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(-", "[c"))
asserts.AssertIntReply(t, result4, 3)
// case5
result5 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(a", "(+"))
asserts.AssertIntReply(t, result5, 0)
// case6
result6 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[-", "[+"))
asserts.AssertIntReply(t, result6, 0)
// case
result7 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[-", "(g"))
asserts.AssertIntReply(t, result7, 5)
// case8
result8 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[-", "(c"))
asserts.AssertIntReply(t, result8, 2)
// case9
result9 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[-", "[c"))
asserts.AssertIntReply(t, result9, 3)
// case10
result10 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(a", "[+"))
asserts.AssertIntReply(t, result10, 0)
// case11
result11 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "-", "+"))
asserts.AssertIntReply(t, result11, 5)
// case12
result12 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "-", "(c"))
asserts.AssertIntReply(t, result12, 2)
// case13
result13 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "-", "[c"))
asserts.AssertIntReply(t, result13, 3)
// case14
result14 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(aa", "(c"))
asserts.AssertIntReply(t, result14, 1)
// case15
result15 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(aa", "[c"))
asserts.AssertIntReply(t, result15, 2)
// case16
result16 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[aa", "(c"))
asserts.AssertIntReply(t, result16, 1)
// case17
result17 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[aa", "[c"))
asserts.AssertIntReply(t, result17, 2)
// case18
result18 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(a", "(ee"))
asserts.AssertIntReply(t, result18, 4)
// case19
result19 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(a", "[ee"))
asserts.AssertIntReply(t, result19, 4)
// case20
result20 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[a", "(ee"))
asserts.AssertIntReply(t, result20, 5)
// case21
result21 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[a", "[ee"))
asserts.AssertIntReply(t, result21, 5)
// case22
result22 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(aa", "(ee"))
asserts.AssertIntReply(t, result22, 4)
// case23
result23 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "(aa", "[ee"))
asserts.AssertIntReply(t, result23, 4)
// case24
result24 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[aa", "(ee"))
asserts.AssertIntReply(t, result24, 4)
// case25
result25 := testDB.Exec(nil, utils.ToCmdLine("ZLexCount", key, "[aa", "[ee"))
asserts.AssertIntReply(t, result25, 4)
}
func TestZRangeByLex(t *testing.T) {
testDB.Flush()
key := utils.RandString(10)
// a b c d e
result := testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "e", "0", "d", "0", "c", "0", "b", "0", "a"))
asserts.AssertNotError(t, result)
// case1
result1 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+"))
asserts.AssertMultiBulkReply(t, result1, []string{"a", "b", "c", "d", "e"})
// case2
result2 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "(z"))
asserts.AssertMultiBulkReply(t, result2, []string{"a", "b", "c", "d", "e"})
// case3
result3 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(-", "[z"))
asserts.AssertMultiBulkReply(t, result3, []string{"a", "b", "c", "d", "e"})
// case4
result4 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[a", "[e"))
asserts.AssertMultiBulkReply(t, result4, []string{"a", "b", "c", "d", "e"})
// case5
result5 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "[e"))
asserts.AssertMultiBulkReply(t, result5, []string{"b", "c", "d", "e"})
// case6
result6 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[a", "(e"))
asserts.AssertMultiBulkReply(t, result6, []string{"a", "b", "c", "d"})
// case7
result7 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "(e"))
asserts.AssertMultiBulkReply(t, result7, []string{"b", "c", "d"})
// case8
result8 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(aa", "(ee"))
asserts.AssertMultiBulkReply(t, result8, []string{"b", "c", "d", "e"})
// case9
result9 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(aa", "[ee"))
asserts.AssertMultiBulkReply(t, result9, []string{"b", "c", "d", "e"})
// case10
result10 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[aa", "(ee"))
asserts.AssertMultiBulkReply(t, result10, []string{"b", "c", "d", "e"})
// case11
result11 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[aa", "[ee"))
asserts.AssertMultiBulkReply(t, result11, []string{"b", "c", "d", "e"})
// case12
result12 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(aa", "(e"))
asserts.AssertMultiBulkReply(t, result12, []string{"b", "c", "d"})
// case13
result13 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(aa", "[e"))
asserts.AssertMultiBulkReply(t, result13, []string{"b", "c", "d", "e"})
// case14
result14 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[aa", "(e"))
asserts.AssertMultiBulkReply(t, result14, []string{"b", "c", "d"})
// case15
result15 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[aa", "[e"))
asserts.AssertMultiBulkReply(t, result15, []string{"b", "c", "d", "e"})
// case16
result16 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "(ee"))
asserts.AssertMultiBulkReply(t, result16, []string{"b", "c", "d", "e"})
// case17
result17 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "[ee"))
asserts.AssertMultiBulkReply(t, result17, []string{"b", "c", "d", "e"})
// case18
result18 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[a", "(ee"))
asserts.AssertMultiBulkReply(t, result18, []string{"a", "b", "c", "d", "e"})
// case19
result19 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[a", "[ee"))
asserts.AssertMultiBulkReply(t, result19, []string{"a", "b", "c", "d", "e"})
// case20
result20 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(-", "(+"))
asserts.AssertMultiBulkReplySize(t, result20, 0)
// case21
result21 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "(+"))
asserts.AssertMultiBulkReplySize(t, result21, 0)
// case22
result22 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[-", "[+"))
asserts.AssertMultiBulkReplySize(t, result22, 0)
// case23
result23 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(z", "(g"))
asserts.AssertMultiBulkReplySize(t, result23, 0)
// case24
result24 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[-", "(g"))
asserts.AssertMultiBulkReply(t, result24, []string{"a", "b", "c", "d", "e"})
// case25
result25 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[-", "(c"))
asserts.AssertMultiBulkReply(t, result25, []string{"a", "b"})
// case26
result26 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[-", "[c"))
asserts.AssertMultiBulkReply(t, result26, []string{"a", "b", "c"})
// case27
result27 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "(e", "limit", "0", "-1"))
asserts.AssertMultiBulkReply(t, result27, []string{"b", "c", "d"})
// case28
result28 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "(e", "limit", "0", "1"))
asserts.AssertMultiBulkReply(t, result28, []string{"b"})
// case28
result29 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "(a", "(e", "limit", "-1", "1"))
asserts.AssertMultiBulkReplySize(t, result29, 0)
// case30
result30 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "[a", "[e", "limit", "2", "100"))
asserts.AssertMultiBulkReply(t, result30, []string{"c", "d", "e"})
// case30
result31 := testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+", "limit", "2", "2"))
asserts.AssertMultiBulkReply(t, result31, []string{"c", "d"})
}
func TestZRemRangeByLex(t *testing.T) {
testDB.Flush()
key := utils.RandString(10)
// a b c d e
asserts.AssertNotError(t, testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "e", "0", "d", "0", "c", "0", "b", "0", "a")))
// case1
asserts.AssertIntReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRemRangeByLex", key, "-", "+")),
5)
asserts.AssertMultiBulkReplySize(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
0)
// case2
testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "e", "0", "d", "0", "c", "0", "b", "0", "a"))
asserts.AssertIntReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRemRangeByLex", key, "-", "[c")),
3)
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"d", "e"})
// case3
testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "a", "0", "b", "0", "c"))
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"a", "b", "c", "d", "e"})
asserts.AssertIntReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRemRangeByLex", key, "(c", "+")),
2)
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"a", "b", "c"})
// case4
testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "d", "0", "e"))
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"a", "b", "c", "d", "e"})
asserts.AssertIntReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRemRangeByLex", key, "(a", "(d")),
2)
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"a", "d", "e"})
// case5
testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "b", "0", "c"))
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"a", "b", "c", "d", "e"})
asserts.AssertIntReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRemRangeByLex", key, "[a", "[d")),
4)
asserts.AssertMultiBulkReply(t,
testDB.Exec(nil, utils.ToCmdLine("ZRangeByLex", key, "-", "+")),
[]string{"e"})
}
func TestZRevRangeByLex(t *testing.T) {
testDB.Flush()
key := utils.RandString(10)
// a b c d e
result := testDB.Exec(nil, utils.ToCmdLine("ZAdd", key, "0", "e", "0", "d", "0", "c", "0", "b", "0", "a"))
asserts.AssertNotError(t, result)
// case1
result1 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "+", "-"))
asserts.AssertMultiBulkReply(t, result1, []string{"e", "d", "c", "b", "a"})
// case2
result2 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(z", "-"))
asserts.AssertMultiBulkReply(t, result2, []string{"e", "d", "c", "b", "a"})
// case3
result3 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[z", "-"))
asserts.AssertMultiBulkReply(t, result3, []string{"e", "d", "c", "b", "a"})
// case4
result4 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[e", "[a"))
asserts.AssertMultiBulkReply(t, result4, []string{"e", "d", "c", "b", "a"})
// case5
result5 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[e", "(a"))
asserts.AssertMultiBulkReply(t, result5, []string{"e", "d", "c", "b"})
// case6
result6 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "[a"))
asserts.AssertMultiBulkReply(t, result6, []string{"d", "c", "b", "a"})
// case7
result7 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "(a"))
asserts.AssertMultiBulkReply(t, result7, []string{"d", "c", "b"})
// case8
result8 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(ee", "(aa"))
asserts.AssertMultiBulkReply(t, result8, []string{"e", "d", "c", "b"})
// case9
result9 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[ee", "(aa"))
asserts.AssertMultiBulkReply(t, result9, []string{"e", "d", "c", "b"})
// case10
result10 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(ee", "[aa"))
asserts.AssertMultiBulkReply(t, result10, []string{"e", "d", "c", "b"})
// case11
result11 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[ee", "[aa"))
asserts.AssertMultiBulkReply(t, result11, []string{"e", "d", "c", "b"})
// case12
result12 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "(aa"))
asserts.AssertMultiBulkReply(t, result12, []string{"d", "c", "b"})
// case13
result13 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[e", "(aa"))
asserts.AssertMultiBulkReply(t, result13, []string{"e", "d", "c", "b"})
// case14
result14 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "[aa"))
asserts.AssertMultiBulkReply(t, result14, []string{"d", "c", "b"})
// case15
result15 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[e", "[aa"))
asserts.AssertMultiBulkReply(t, result15, []string{"e", "d", "c", "b"})
// case16
result16 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(ee", "(a"))
asserts.AssertMultiBulkReply(t, result16, []string{"e", "d", "c", "b"})
// case17
result17 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[ee", "(a"))
asserts.AssertMultiBulkReply(t, result17, []string{"e", "d", "c", "b"})
// case18
result18 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(ee", "[a"))
asserts.AssertMultiBulkReply(t, result18, []string{"e", "d", "c", "b", "a"})
// case19
result19 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[ee", "[a"))
asserts.AssertMultiBulkReply(t, result19, []string{"e", "d", "c", "b", "a"})
// case20
result20 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(+", "(-"))
asserts.AssertMultiBulkReplySize(t, result20, 0)
// case21
result21 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(+", "(a"))
asserts.AssertMultiBulkReplySize(t, result21, 0)
// case22
result22 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[+", "[-"))
asserts.AssertMultiBulkReplySize(t, result22, 0)
// case23
result23 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(g", "[-"))
asserts.AssertMultiBulkReply(t, result23, []string{"e", "d", "c", "b", "a"})
// case24
result24 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(c", "[-"))
asserts.AssertMultiBulkReply(t, result24, []string{"b", "a"})
// case25
result25 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[c", "[-"))
asserts.AssertMultiBulkReply(t, result25, []string{"c", "b", "a"})
// case26
result26 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "(a", "limit", "0", "-1"))
asserts.AssertMultiBulkReply(t, result26, []string{"d", "c", "b"})
// case27
result27 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "(a", "limit", "0", "1"))
asserts.AssertMultiBulkReply(t, result27, []string{"d"})
// case28
result28 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "(e", "(a", "limit", "-1", "1"))
asserts.AssertMultiBulkReplySize(t, result28, 0)
// case29
result29 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "[e", "[a", "limit", "2", "100"))
asserts.AssertMultiBulkReply(t, result29, []string{"c", "b", "a"})
// case30
result30 := testDB.Exec(nil, utils.ToCmdLine("ZRevRangeByLex", key, "+", "-", "limit", "2", "2"))
asserts.AssertMultiBulkReply(t, result30, []string{"c", "b"})
}