forked from mirror/ledisdb
support sort command
This commit is contained in:
siddontang
parent
adbfd4b945
commit
b5c78640aa
|
|
@ -0,0 +1,232 @@
|
||||||
|
package ledis
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"github.com/siddontang/ledisdb/store"
|
||||||
|
"sort"
|
||||||
|
"strconv"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Limit struct {
|
||||||
|
Offset int
|
||||||
|
Size int
|
||||||
|
}
|
||||||
|
|
||||||
|
func getSortRange(values [][]byte, offset int, size int) (int, int) {
|
||||||
|
var start = 0
|
||||||
|
if offset > 0 {
|
||||||
|
start = offset
|
||||||
|
}
|
||||||
|
|
||||||
|
valueLen := len(values)
|
||||||
|
var end = valueLen - 1
|
||||||
|
if size > 0 {
|
||||||
|
end = start + size - 1
|
||||||
|
}
|
||||||
|
|
||||||
|
if start >= valueLen {
|
||||||
|
start = valueLen - 1
|
||||||
|
end = valueLen - 2
|
||||||
|
}
|
||||||
|
|
||||||
|
if end >= valueLen {
|
||||||
|
end = valueLen - 1
|
||||||
|
}
|
||||||
|
|
||||||
|
return start, end
|
||||||
|
}
|
||||||
|
|
||||||
|
var hashPattern = []byte("*->")
|
||||||
|
|
||||||
|
func (db *DB) lookupKeyByPattern(pattern []byte, subKey []byte) []byte {
|
||||||
|
// If the pattern is #, return the substitution key itself
|
||||||
|
if bytes.Equal(pattern, []byte{'#'}) {
|
||||||
|
return subKey
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we can't find '*' in the pattern, return nil
|
||||||
|
if !bytes.Contains(pattern, []byte{'*'}) {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
key := pattern
|
||||||
|
var field []byte = nil
|
||||||
|
|
||||||
|
// Find out if we're dealing with a hash dereference
|
||||||
|
if n := bytes.Index(pattern, hashPattern); n > 0 && n+3 < len(pattern) {
|
||||||
|
key = pattern[0 : n+1]
|
||||||
|
field = pattern[n+3:]
|
||||||
|
}
|
||||||
|
|
||||||
|
// Perform the '*' substitution
|
||||||
|
key = bytes.Replace(key, []byte{'*'}, subKey, 1)
|
||||||
|
|
||||||
|
var value []byte
|
||||||
|
if field == nil {
|
||||||
|
value, _ = db.Get(key)
|
||||||
|
} else {
|
||||||
|
value, _ = db.HGet(key, field)
|
||||||
|
}
|
||||||
|
|
||||||
|
return value
|
||||||
|
}
|
||||||
|
|
||||||
|
type sortItem struct {
|
||||||
|
value []byte
|
||||||
|
cmpValue []byte
|
||||||
|
score float64
|
||||||
|
}
|
||||||
|
|
||||||
|
type sortItemSlice struct {
|
||||||
|
alpha bool
|
||||||
|
sortByPattern bool
|
||||||
|
items []sortItem
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *sortItemSlice) Len() int {
|
||||||
|
return len(s.items)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *sortItemSlice) Swap(i, j int) {
|
||||||
|
s.items[i], s.items[j] = s.items[j], s.items[i]
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *sortItemSlice) Less(i, j int) bool {
|
||||||
|
s1 := s.items[i]
|
||||||
|
s2 := s.items[j]
|
||||||
|
if !s.alpha {
|
||||||
|
if s1.score < s2.score {
|
||||||
|
return true
|
||||||
|
} else if s1.score > s2.score {
|
||||||
|
return false
|
||||||
|
} else {
|
||||||
|
return bytes.Compare(s1.value, s2.value) < 0
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if s.sortByPattern {
|
||||||
|
if s1.cmpValue == nil || s2.cmpValue == nil {
|
||||||
|
if s1.cmpValue == nil {
|
||||||
|
return true
|
||||||
|
} else {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Unlike redis, we only use bytes compare
|
||||||
|
return bytes.Compare(s1.cmpValue, s2.cmpValue) < 0
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Unlike redis, we only use bytes compare
|
||||||
|
return bytes.Compare(s1.value, s2.value) < 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (db *DB) xsort(values [][]byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
|
||||||
|
if len(values) == 0 {
|
||||||
|
return [][]byte{}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
start, end := getSortRange(values, offset, size)
|
||||||
|
|
||||||
|
dontsort := 0
|
||||||
|
|
||||||
|
if sortBy != nil {
|
||||||
|
if !bytes.Contains(sortBy, []byte{'*'}) {
|
||||||
|
dontsort = 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
items := &sortItemSlice{
|
||||||
|
alpha: alpha,
|
||||||
|
sortByPattern: sortBy != nil,
|
||||||
|
items: make([]sortItem, len(values)),
|
||||||
|
}
|
||||||
|
|
||||||
|
for i, value := range values {
|
||||||
|
items.items[i].value = value
|
||||||
|
items.items[i].score = 0
|
||||||
|
items.items[i].cmpValue = nil
|
||||||
|
|
||||||
|
if dontsort == 0 {
|
||||||
|
var cmpValue []byte
|
||||||
|
if sortBy != nil {
|
||||||
|
cmpValue = db.lookupKeyByPattern(sortBy, value)
|
||||||
|
} else {
|
||||||
|
// use value iteself to sort by
|
||||||
|
cmpValue = value
|
||||||
|
}
|
||||||
|
|
||||||
|
if cmpValue == nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
if alpha {
|
||||||
|
if sortBy != nil {
|
||||||
|
items.items[i].cmpValue = cmpValue
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
score, err := strconv.ParseFloat(string(cmpValue), 64)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("%s scores can't be converted into double", cmpValue)
|
||||||
|
}
|
||||||
|
items.items[i].score = score
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if dontsort == 0 {
|
||||||
|
if !desc {
|
||||||
|
sort.Sort(items)
|
||||||
|
} else {
|
||||||
|
sort.Sort(sort.Reverse(items))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var resLen int = end - start + 1
|
||||||
|
if len(sortGet) > 0 {
|
||||||
|
resLen = len(sortGet) * (end - start + 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
res := make([][]byte, 0, resLen)
|
||||||
|
for i := start; i <= end; i++ {
|
||||||
|
if len(sortGet) == 0 {
|
||||||
|
res = append(res, items.items[i].value)
|
||||||
|
} else {
|
||||||
|
for _, getPattern := range sortGet {
|
||||||
|
v := db.lookupKeyByPattern(getPattern, items.items[i].value)
|
||||||
|
res = append(res, v)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return res, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
|
||||||
|
values, err := db.LRange(key, 0, -1)
|
||||||
|
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (db *DB) XSSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
|
||||||
|
values, err := db.SMembers(key)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
|
||||||
|
values, err := db.ZRangeByLex(key, nil, nil, store.RangeClose, 0, -1)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,123 @@
|
||||||
|
package ledis
|
||||||
|
|
||||||
|
import (
|
||||||
|
"runtime/debug"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func testBuildValues(values ...string) [][]byte {
|
||||||
|
v := make([][]byte, 0, len(values))
|
||||||
|
for _, value := range values {
|
||||||
|
v = append(v, []byte(value))
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
func checkSortRes(t *testing.T, res [][]byte, values ...string) {
|
||||||
|
if len(res) != len(values) {
|
||||||
|
debug.PrintStack()
|
||||||
|
t.Fatalf("invalid xsort res len, %d = %d", len(res), len(values))
|
||||||
|
}
|
||||||
|
|
||||||
|
for i := 0; i < len(res); i++ {
|
||||||
|
if string(res[i]) != values[i] {
|
||||||
|
debug.PrintStack()
|
||||||
|
t.Fatalf("invalid xsort res at %d, %s != %s", i, res[i], values[i])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func checkTestSort(t *testing.T, db *DB, items []string, offset int, size int, alpha bool,
|
||||||
|
desc bool, sortBy []byte, sortGet [][]byte, checkValues []string) {
|
||||||
|
|
||||||
|
vv := testBuildValues(items...)
|
||||||
|
|
||||||
|
res, err := db.xsort(vv, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
checkSortRes(t, res, checkValues...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSort(t *testing.T) {
|
||||||
|
db := getTestDB()
|
||||||
|
|
||||||
|
db.FlushAll()
|
||||||
|
|
||||||
|
// Prepare data
|
||||||
|
db.MSet(
|
||||||
|
KVPair{[]byte("weight_1"), []byte("30")},
|
||||||
|
KVPair{[]byte("weight_2"), []byte("20")},
|
||||||
|
KVPair{[]byte("weight_3"), []byte("10")},
|
||||||
|
KVPair{[]byte("weight_a"), []byte("60")},
|
||||||
|
KVPair{[]byte("weight_b"), []byte("50")},
|
||||||
|
KVPair{[]byte("weight_c"), []byte("40")})
|
||||||
|
|
||||||
|
db.HSet([]byte("hash_weight_1"), []byte("index"), []byte("30"))
|
||||||
|
db.HSet([]byte("hash_weight_2"), []byte("index"), []byte("20"))
|
||||||
|
db.HSet([]byte("hash_weight_3"), []byte("index"), []byte("10"))
|
||||||
|
db.HSet([]byte("hash_weight_a"), []byte("index"), []byte("60"))
|
||||||
|
db.HSet([]byte("hash_weight_b"), []byte("index"), []byte("50"))
|
||||||
|
db.HSet([]byte("hash_weight_c"), []byte("index"), []byte("40"))
|
||||||
|
|
||||||
|
db.MSet(
|
||||||
|
KVPair{[]byte("object_1"), []byte("30")},
|
||||||
|
KVPair{[]byte("object_2"), []byte("20")},
|
||||||
|
KVPair{[]byte("object_3"), []byte("10")},
|
||||||
|
KVPair{[]byte("number_1"), []byte("10")},
|
||||||
|
KVPair{[]byte("number_2"), []byte("20")},
|
||||||
|
KVPair{[]byte("number_3"), []byte("30")},
|
||||||
|
KVPair{[]byte("object_a"), []byte("60")},
|
||||||
|
KVPair{[]byte("object_b"), []byte("50")},
|
||||||
|
KVPair{[]byte("object_c"), []byte("40")},
|
||||||
|
KVPair{[]byte("number_a"), []byte("40")},
|
||||||
|
KVPair{[]byte("number_b"), []byte("50")},
|
||||||
|
KVPair{[]byte("number_c"), []byte("60")})
|
||||||
|
|
||||||
|
db.HSet([]byte("hash_object_1"), []byte("index"), []byte("30"))
|
||||||
|
db.HSet([]byte("hash_object_2"), []byte("index"), []byte("20"))
|
||||||
|
db.HSet([]byte("hash_object_3"), []byte("index"), []byte("10"))
|
||||||
|
db.HSet([]byte("hash_number_1"), []byte("index"), []byte("10"))
|
||||||
|
db.HSet([]byte("hash_number_2"), []byte("index"), []byte("20"))
|
||||||
|
db.HSet([]byte("hash_number_3"), []byte("index"), []byte("30"))
|
||||||
|
|
||||||
|
db.HSet([]byte("hash_object_a"), []byte("index"), []byte("60"))
|
||||||
|
db.HSet([]byte("hash_object_b"), []byte("index"), []byte("50"))
|
||||||
|
db.HSet([]byte("hash_object_c"), []byte("index"), []byte("40"))
|
||||||
|
db.HSet([]byte("hash_number_a"), []byte("index"), []byte("40"))
|
||||||
|
db.HSet([]byte("hash_number_b"), []byte("index"), []byte("50"))
|
||||||
|
db.HSet([]byte("hash_number_c"), []byte("index"), []byte("60"))
|
||||||
|
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, nil, nil, []string{"1", "2", "3"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, 1, false, false, nil, nil, []string{"1"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, 2, false, false, nil, nil, []string{"1", "2"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, 3, false, false, nil, nil, []string{"1", "2", "3"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, 4, false, false, nil, nil, []string{"1", "2", "3"})
|
||||||
|
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, true, false, nil, nil, []string{"1", "2", "3"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, true, nil, nil, []string{"3", "2", "1"})
|
||||||
|
|
||||||
|
if _, err := db.xsort(testBuildValues("c", "b", "a"), 0, -1, false, false, nil, nil); err == nil {
|
||||||
|
t.Fatal("must nil")
|
||||||
|
}
|
||||||
|
|
||||||
|
checkTestSort(t, db, []string{"c", "b", "a"}, 0, -1, true, false, nil, nil, []string{"a", "b", "c"})
|
||||||
|
checkTestSort(t, db, []string{"c", "b", "a"}, 0, -1, true, true, nil, nil, []string{"c", "b", "a"})
|
||||||
|
|
||||||
|
checkTestSort(t, db, []string{"1", "2", "3"}, 0, 1, false, false, nil, nil, []string{"1"})
|
||||||
|
checkTestSort(t, db, []string{"1", "2", "3"}, 0, 1, false, true, nil, nil, []string{"3"})
|
||||||
|
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, []byte("abc"), nil, []string{"3", "2", "1"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, []byte("weight_*"), nil, []string{"3", "2", "1"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, true, []byte("weight_*"), nil, []string{"1", "2", "3"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, []byte("hash_weight_*->index"), nil, []string{"3", "2", "1"})
|
||||||
|
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, nil, [][]byte{[]byte("object_*")}, []string{"30", "20", "10"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, nil, [][]byte{[]byte("number_*")}, []string{"10", "20", "30"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, nil, [][]byte{[]byte("#"), []byte("number_*")},
|
||||||
|
[]string{"1", "10", "2", "20", "3", "30"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, nil, [][]byte{[]byte("object_*"), []byte("number_*")},
|
||||||
|
[]string{"30", "10", "20", "20", "10", "30"})
|
||||||
|
checkTestSort(t, db, []string{"3", "2", "1"}, 0, -1, false, false, nil, [][]byte{[]byte("object_*_abc")}, []string{"", "", ""})
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,118 @@
|
||||||
|
package server
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
func xsort(c *client, tp string, key []byte, offset int, size int, alpha bool,
|
||||||
|
desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
|
||||||
|
var ay [][]byte
|
||||||
|
var err error
|
||||||
|
switch strings.ToUpper(tp) {
|
||||||
|
case "LIST":
|
||||||
|
ay, err = c.db.XLSort(key, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
case "SET":
|
||||||
|
ay, err = c.db.XSSort(key, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
case "ZSET":
|
||||||
|
ay, err = c.db.XZSort(key, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
default:
|
||||||
|
err = fmt.Errorf("invalid key type %s", tp)
|
||||||
|
}
|
||||||
|
return ay, err
|
||||||
|
}
|
||||||
|
|
||||||
|
func xlsortCommand(c *client) error {
|
||||||
|
return handleXSort(c, "LIST")
|
||||||
|
}
|
||||||
|
func xssortCommand(c *client) error {
|
||||||
|
return handleXSort(c, "SET")
|
||||||
|
}
|
||||||
|
func xzsortCommand(c *client) error {
|
||||||
|
return handleXSort(c, "ZSET")
|
||||||
|
}
|
||||||
|
|
||||||
|
var ascArg = []byte("asc")
|
||||||
|
var descArg = []byte("desc")
|
||||||
|
var alphaArg = []byte("alpha")
|
||||||
|
var limitArg = []byte("limit")
|
||||||
|
var storeArg = []byte("store")
|
||||||
|
var byArg = []byte("by")
|
||||||
|
var getArg = []byte("get")
|
||||||
|
|
||||||
|
func handleXSort(c *client, tp string) error {
|
||||||
|
args := c.args
|
||||||
|
if len(args) == 0 {
|
||||||
|
return ErrCmdParams
|
||||||
|
}
|
||||||
|
|
||||||
|
key := args[0]
|
||||||
|
desc := false
|
||||||
|
alpha := false
|
||||||
|
offset := 0
|
||||||
|
size := 0
|
||||||
|
var storeKey []byte
|
||||||
|
var sortBy []byte
|
||||||
|
var sortGet [][]byte
|
||||||
|
var err error
|
||||||
|
|
||||||
|
for i := 1; i < len(args); {
|
||||||
|
if bytes.EqualFold(args[i], ascArg) {
|
||||||
|
desc = false
|
||||||
|
} else if bytes.EqualFold(args[i], descArg) {
|
||||||
|
desc = true
|
||||||
|
} else if bytes.EqualFold(args[i], alphaArg) {
|
||||||
|
alpha = true
|
||||||
|
} else if bytes.EqualFold(args[i], limitArg) && i+2 < len(args) {
|
||||||
|
if offset, err = strconv.Atoi(string(args[i+1])); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if size, err = strconv.Atoi(string(args[i+2])); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
i = i + 2
|
||||||
|
} else if bytes.EqualFold(args[i], storeArg) && i+1 < len(args) {
|
||||||
|
storeKey = args[i+1]
|
||||||
|
i++
|
||||||
|
} else if bytes.EqualFold(args[i], byArg) && i+1 < len(args) {
|
||||||
|
sortBy = args[i+1]
|
||||||
|
i++
|
||||||
|
} else if bytes.EqualFold(args[i], getArg) && i+1 < len(args) {
|
||||||
|
sortGet = append(sortGet, args[i+1])
|
||||||
|
i++
|
||||||
|
} else {
|
||||||
|
return ErrCmdParams
|
||||||
|
}
|
||||||
|
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
|
||||||
|
ay, err := xsort(c, tp, key, offset, size, alpha, desc, sortBy, sortGet)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
if storeKey == nil {
|
||||||
|
c.resp.writeSliceArray(ay)
|
||||||
|
} else {
|
||||||
|
// not threadsafe now, need lock???
|
||||||
|
if _, err = c.db.LClear(storeKey); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
if n, err := c.db.RPush(storeKey, ay...); err != nil {
|
||||||
|
return err
|
||||||
|
} else {
|
||||||
|
c.resp.writeInteger(n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
register("xlsort", xlsortCommand)
|
||||||
|
register("xssort", xssortCommand)
|
||||||
|
register("xzsort", xzsortCommand)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,91 @@
|
||||||
|
package server
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
goledis "github.com/siddontang/ledisdb/client/go/ledis"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func checkTestSortRes(ay interface{}, checks []string) error {
|
||||||
|
values, ok := ay.([]interface{})
|
||||||
|
if !ok {
|
||||||
|
return fmt.Errorf("invalid res type %T, must [][]byte", ay)
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(values) != len(checks) {
|
||||||
|
return fmt.Errorf("invalid res number %d != %d", len(values), len(checks))
|
||||||
|
}
|
||||||
|
|
||||||
|
for i, _ := range values {
|
||||||
|
if string(values[i].([]byte)) != checks[i] {
|
||||||
|
return fmt.Errorf("invalid res at %d, %s != %s", i, values[i], checks[i])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSort(t *testing.T) {
|
||||||
|
c := getTestConn()
|
||||||
|
defer c.Close()
|
||||||
|
|
||||||
|
key := "my_sort_key"
|
||||||
|
storeKey := "my_sort_store_key"
|
||||||
|
|
||||||
|
if _, err := c.Do("LPUSH", key, 3, 2, 1); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := c.Do("MSET", "weight_1", 3, "weight_2", 2, "weight_3", 1); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := c.Do("MSET", "object_1", 10, "object_2", 20, "object_3", 30); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ay, err := c.Do("XLSORT", key); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"1", "2", "3"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ay, err := c.Do("XLSORT", key, "DESC"); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"3", "2", "1"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ay, err := c.Do("XLSORT", key, "LIMIT", 0, 1); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"1"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ay, err := c.Do("XLSORT", key, "BY", "weight_*"); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"3", "2", "1"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ay, err := c.Do("XLSORT", key, "GET", "object_*"); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"10", "20", "30"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ay, err := c.Do("XLSORT", key, "GET", "object_*", "GET", "#"); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"10", "1", "20", "2", "30", "3"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if n, err := goledis.Int(c.Do("XLSORT", key, "STORE", storeKey)); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if n != 3 {
|
||||||
|
t.Fatalf("invalid return store sort number, %d != 3", n)
|
||||||
|
} else if ay, err := c.Do("LRANGE", storeKey, 0, -1); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
} else if err = checkTestSortRes(ay, []string{"1", "2", "3"}); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue