mirror
/
ledisdb
mirror of https://github.com/ledisdb/ledisdb.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

add kv bit operation support 

old bitmap type will be deprecated later
This commit is contained in:
siddontang 2015-02-05 15:37:17 +08:00
parent 1540f81e68
commit b94a604f7a
12 changed files with 1619 additions and 1046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ledis/const.go
View File

@ -98,3 +98,10 @@ const (
DBInTransaction uint8 = 0x1
DBInMulti uint8 = 0x2
)
const (
BitAND = "and"
BitOR = "or"
BitXOR = "xor"
BitNot = "not"
)

78
ledis/scan_test.go
View File

@ -250,52 +250,52 @@ func TestDBLScan(t *testing.T) {
}
func TestDBBScan(t *testing.T) {
db := getTestDB()
// db := getTestDB()
db.bFlush()
// db.bFlush()
k1 := []byte("k1")
if _, err := db.BSetBit(k1, 1, 1); err != nil {
t.Fatal(err.Error())
}
// k1 := []byte("k1")
// if _, err := db.BSetBit(k1, 1, 1); err != nil {
// t.Fatal(err.Error())
// }
k2 := []byte("k2")
if _, err := db.BSetBit(k2, 1, 1); err != nil {
t.Fatal(err.Error())
}
k3 := []byte("k3")
// k2 := []byte("k2")
// if _, err := db.BSetBit(k2, 1, 1); err != nil {
// t.Fatal(err.Error())
// }
// k3 := []byte("k3")
if _, err := db.BSetBit(k3, 1, 0); err != nil {
t.Fatal(err.Error())
}
// if _, err := db.BSetBit(k3, 1, 0); err != nil {
// t.Fatal(err.Error())
// }
if v, err := db.BScan(nil, 1, true, ""); err != nil {
t.Fatal(err)
} else if len(v) != 1 {
t.Fatal("invalid length ", len(v))
} else if string(v[0]) != "k1" {
t.Fatal("invalid value ", string(v[0]))
}
// if v, err := db.BScan(nil, 1, true, ""); err != nil {
// t.Fatal(err)
// } else if len(v) != 1 {
// t.Fatal("invalid length ", len(v))
// } else if string(v[0]) != "k1" {
// t.Fatal("invalid value ", string(v[0]))
// }
if v, err := db.BScan(k1, 2, true, ""); err != nil {
t.Fatal(err)
} else if len(v) != 2 {
t.Fatal("invalid length ", len(v))
} else if string(v[0]) != "k1" {
t.Fatal("invalid value ", string(v[0]))
} else if string(v[1]) != "k2" {
t.Fatal("invalid value ", string(v[1]))
}
// if v, err := db.BScan(k1, 2, true, ""); err != nil {
// t.Fatal(err)
// } else if len(v) != 2 {
// t.Fatal("invalid length ", len(v))
// } else if string(v[0]) != "k1" {
// t.Fatal("invalid value ", string(v[0]))
// } else if string(v[1]) != "k2" {
// t.Fatal("invalid value ", string(v[1]))
// }
if v, err := db.BScan(k1, 2, false, ""); err != nil {
t.Fatal(err)
} else if len(v) != 2 {
t.Fatal("invalid length ", len(v))
} else if string(v[0]) != "k2" {
t.Fatal("invalid value ", string(v[0]))
} else if string(v[1]) != "k3" {
t.Fatal("invalid value ", string(v[1]))
}
// if v, err := db.BScan(k1, 2, false, ""); err != nil {
// t.Fatal(err)
// } else if len(v) != 2 {
// t.Fatal("invalid length ", len(v))
// } else if string(v[0]) != "k2" {
// t.Fatal("invalid value ", string(v[0]))
// } else if string(v[1]) != "k3" {
// t.Fatal("invalid value ", string(v[1]))
// }
}

36
ledis/t_bit.go
View File

@ -3,6 +3,7 @@ package ledis
import (
"encoding/binary"
"errors"
"github.com/siddontang/go/log"
"github.com/siddontang/go/num"
"github.com/siddontang/ledisdb/store"
"sort"
@ -50,19 +51,6 @@ const (
maxSeq uint32 = uint32((maxByteSize << 3) - 1)
)
var bitsInByte = [256]int32{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3,
4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3,
3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4,
5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4,
3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4,
5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2,
2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3,
4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4,
5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,
6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5,
6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}
var fillBits = [...]uint8{1, 3, 7, 15, 31, 63, 127, 255}
var emptySegment []byte = make([]byte, segByteSize, segByteSize)
@ -442,6 +430,8 @@ func (db *DB) bCountSeg(key []byte, seq uint32, soff uint32, eoff uint32) (cnt i
}
func (db *DB) BGet(key []byte) (data []byte, err error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if err = checkKeySize(key); err != nil {
return
}
@ -476,6 +466,8 @@ func (db *DB) BGet(key []byte) (data []byte, err error) {
}
func (db *DB) BDelete(key []byte) (drop int64, err error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if err = checkKeySize(key); err != nil {
return
}
@ -492,6 +484,8 @@ func (db *DB) BDelete(key []byte) (drop int64, err error) {
}
func (db *DB) BSetBit(key []byte, offset int32, val uint8) (ori uint8, err error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if err = checkKeySize(key); err != nil {
return
}
@ -528,6 +522,8 @@ func (db *DB) BSetBit(key []byte, offset int32, val uint8) (ori uint8, err error
}
func (db *DB) BMSetBit(key []byte, args ...BitPair) (place int64, err error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if err = checkKeySize(key); err != nil {
return
}
@ -608,6 +604,8 @@ func (db *DB) BMSetBit(key []byte, args ...BitPair) (place int64, err error) {
}
func (db *DB) BGetBit(key []byte, offset int32) (uint8, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if seq, off, err := db.bParseOffset(key, offset); err != nil {
return 0, err
} else {
@ -631,6 +629,8 @@ func (db *DB) BGetBit(key []byte, offset int32) (uint8, error) {
// }
func (db *DB) BCount(key []byte, start int32, end int32) (cnt int32, err error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
var sseq, soff uint32
if sseq, soff, err = db.bParseOffset(key, start); err != nil {
return
@ -686,6 +686,8 @@ func (db *DB) BCount(key []byte, start int32, end int32) (cnt int32, err error)
}
func (db *DB) BTail(key []byte) (int32, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
// effective length of data, the highest bit-pos set in history
tailSeq, tailOff, err := db.bGetMeta(key)
if err != nil {
@ -701,6 +703,8 @@ func (db *DB) BTail(key []byte) (int32, error) {
}
func (db *DB) BOperation(op uint8, dstkey []byte, srckeys ...[]byte) (blen int32, err error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
// blen -
// the total bit size of data stored in destination key,
// that is equal to the size of the longest input string.
@ -865,6 +869,7 @@ func (db *DB) BOperation(op uint8, dstkey []byte, srckeys ...[]byte) (blen int32
}
func (db *DB) BExpire(key []byte, duration int64) (int64, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if duration <= 0 {
return 0, errExpireValue
}
@ -877,6 +882,7 @@ func (db *DB) BExpire(key []byte, duration int64) (int64, error) {
}
func (db *DB) BExpireAt(key []byte, when int64) (int64, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if when <= time.Now().Unix() {
return 0, errExpireValue
}
@ -889,6 +895,7 @@ func (db *DB) BExpireAt(key []byte, when int64) (int64, error) {
}
func (db *DB) BTTL(key []byte) (int64, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if err := checkKeySize(key); err != nil {
return -1, err
}
@ -897,6 +904,7 @@ func (db *DB) BTTL(key []byte) (int64, error) {
}
func (db *DB) BPersist(key []byte) (int64, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
if err := checkKeySize(key); err != nil {
return 0, err
}
@ -915,10 +923,12 @@ func (db *DB) BPersist(key []byte) (int64, error) {
}
func (db *DB) BScan(key []byte, count int, inclusive bool, match string) ([][]byte, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
return db.scan(BitMetaType, key, count, inclusive, match)
}
func (db *DB) BRevScan(key []byte, count int, inclusive bool, match string) ([][]byte, error) {
log.Error("bitmap type will be deprecated later, please use bit operations in kv type")
return db.revscan(BitMetaType, key, count, inclusive, match)
}

1148
ledis/t_bit_test.go
View File

File diff suppressed because it is too large Load Diff

276
ledis/t_kv.go
View File

@ -1,9 +1,12 @@
package ledis
import (
"encoding/binary"
"errors"
"fmt"
"github.com/siddontang/go/num"
"github.com/siddontang/ledisdb/store"
"strings"
"time"
)
@ -434,19 +437,7 @@ func (db *DB) SetRange(key []byte, offset int, value []byte) (int64, error) {
return int64(len(oldValue)), nil
}
func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
valLen := len(value)
func getRange(start int, end int, valLen int) (int, int) {
if start < 0 {
start = valLen + start
}
@ -466,6 +457,23 @@ func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if end >= valLen {
end = valLen - 1
}
return start, end
}
func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
valLen := len(value)
start, end = getRange(start, end, valLen)
if start > end {
return nil, nil
@ -519,3 +527,245 @@ func (db *DB) Append(key []byte, value []byte) (int64, error) {
return int64(len(oldValue)), nil
}
func (db *DB) BitOP(op string, destKey []byte, srcKeys ...[]byte) (int64, error) {
if err := checkKeySize(destKey); err != nil {
return 0, err
}
op = strings.ToLower(op)
if len(srcKeys) == 0 {
return 0, nil
} else if op == BitNot && len(srcKeys) > 1 {
return 0, fmt.Errorf("BITOP NOT has only one srckey")
} else if len(srcKeys) < 2 {
return 0, nil
}
key := db.encodeKVKey(srcKeys[0])
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if op == BitNot {
for i := 0; i < len(value); i++ {
value[i] ^= value[i]
}
} else {
for j := 1; j < len(srcKeys); j++ {
if err := checkKeySize(srcKeys[j]); err != nil {
return 0, err
}
key = db.encodeKVKey(srcKeys[j])
ovalue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if len(value) < len(ovalue) {
value, ovalue = ovalue, value
}
for i := 0; i < len(ovalue); i++ {
switch op {
case BitAND:
value[i] &= ovalue[i]
case BitOR:
value[i] |= ovalue[i]
case BitXOR:
value[i] ^= ovalue[i]
default:
return 0, fmt.Errorf("invalid op type: %s", op)
}
}
for i := len(ovalue); i < len(value); i++ {
switch op {
case BitAND:
value[i] &= 0
case BitOR:
value[i] |= 0
case BitXOR:
value[i] ^= 0
}
}
}
}
key = db.encodeKVKey(destKey)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
if err := t.Commit(); err != nil {
return 0, err
}
return int64(len(value)), nil
}
var bitsInByte = [256]int32{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3,
4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3,
3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4,
5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4,
3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4,
5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2,
2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3,
4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4,
5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,
6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5,
6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}
func numberBitCount(i uint32) uint32 {
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24
}
func (db *DB) BitCount(key []byte, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
var n int64 = 0
pos := 0
for ; pos+4 <= len(value); pos = pos + 4 {
n += int64(numberBitCount(binary.BigEndian.Uint32(value[pos : pos+4])))
}
for ; pos < len(value); pos++ {
n += int64(bitsInByte[value[pos]])
}
return n, nil
}
func (db *DB) BitPos(key []byte, on int, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
var skipValue uint8 = 0
if on == 0 {
skipValue = 0xFF
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
for i, v := range value {
if uint8(v) != skipValue {
for j := 0; j < 8; j++ {
isNull := uint8(v)&(1<<uint8(7-j)) == 0
if (on == 1 && !isNull) || (on == 0 && isNull) {
return int64((start+i)*8 + j), nil
}
}
}
}
return -1, nil
}
func (db *DB) SetBit(key []byte, offset int, on int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := int(uint32(offset) >> 3)
extra := byteOffset + 1 - len(value)
if extra > 0 {
value = append(value, make([]byte, extra)...)
}
byteVal := value[byteOffset]
bit := 7 - uint8(uint32(offset)&0x7)
bitVal := byteVal & (1 << bit)
byteVal &= ^(1 << bit)
byteVal |= (uint8(on&0x1) << bit)
value[byteOffset] = byteVal
t.Put(key, value)
if err := t.Commit(); err != nil {
return 0, err
}
if bitVal > 0 {
return 1, nil
} else {
return 0, nil
}
}
func (db *DB) GetBit(key []byte, offset int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := uint32(offset) >> 3
bit := 7 - uint8(uint32(offset)&0x7)
if byteOffset >= uint32(len(value)) {
return 0, nil
}
bitVal := value[byteOffset] & (1 << bit)
if bitVal > 0 {
return 1, nil
} else {
return 0, nil
}
}

149
ledis/t_kv_test.go
View File

@ -98,6 +98,155 @@ func TestDBKV(t *testing.T) {
} else if n != 11 {
t.Fatal(n)
}
key5 := []byte("testdb_kv_bit")
if n, err := db.SetBit(key5, 7, 1); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := db.GetBit(key5, 0); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := db.GetBit(key5, 7); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := db.GetBit(key5, 100); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := db.BitCount(key5, 0, -1); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := db.BitPos(key5, 1, 0, -1); err != nil {
t.Fatal(err)
} else if n != 7 {
t.Fatal(n)
}
if n, err := db.SetBit(key5, 7, 0); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if err := db.Set(key5, []byte{0xff, 0xf0, 0x00}); err != nil {
t.Fatal(err)
}
if n, err := db.BitPos(key5, 0, 0, -1); err != nil {
t.Fatal(err)
} else if n != 12 {
t.Fatal(n)
}
if err := db.Set(key5, []byte{0x00, 0xff, 0xf0}); err != nil {
t.Fatal(err)
}
if n, err := db.BitPos(key5, 1, 0, -1); err != nil {
t.Fatal(err)
} else if n != 8 {
t.Fatal(n)
}
if n, err := db.BitPos(key5, 1, 2, -1); err != nil {
t.Fatal(err)
} else if n != 16 {
t.Fatal(n)
}
if err := db.Set(key5, []byte{0x00, 0x00, 0x00}); err != nil {
t.Fatal(err)
}
if n, err := db.BitPos(key5, 1, 0, -1); err != nil {
t.Fatal(err)
} else if n != -1 {
t.Fatal(n)
}
if err := db.Set(key5, []byte("foobar")); err != nil {
t.Fatal(err)
}
if n, err := db.BitCount(key5, 0, -1); err != nil {
t.Fatal(err)
} else if n != 26 {
t.Fatal(n)
}
if n, err := db.BitCount(key5, 0, 0); err != nil {
t.Fatal(err)
} else if n != 4 {
t.Fatal(n)
}
if n, err := db.BitCount(key5, 1, 1); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(n)
}
key6 := []byte("testdb_kv_bitop_desc")
if err := db.Set(key4, []byte("foobar")); err != nil {
t.Fatal(err)
}
if err := db.Set(key5, []byte("abcdef")); err != nil {
t.Fatal(err)
}
if n, err := db.BitOP(BitAND, key6, key4, key5); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(err)
}
if v, err := db.Get(key6); err != nil {
t.Fatal(err)
} else if string(v) != "`bc`ab" {
t.Fatal(string(v))
}
if err := db.Set(key4, []byte("fooba")); err != nil {
t.Fatal(err)
}
if n, err := db.BitOP(BitOR, key6, key4, key5); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(err)
}
if v, err := db.Get(key6); err != nil {
t.Fatal(err)
} else if string(v) != "goofef" {
t.Fatal(string(v))
}
if n, err := db.BitOP(BitAND, key6, key4, key5); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(err)
}
if v, err := db.Get(key6); err != nil {
t.Fatal(err)
} else if string(v) != "`bc`a\x00" {
t.Fatal(string(v))
}
}
func TestKVPersist(t *testing.T) {

64
ledis/t_ttl_test.go
View File

@ -195,50 +195,50 @@ func setAdaptor(db *DB) *adaptor {
}
func bitAdaptor(db *DB) *adaptor {
adp := new(adaptor)
adp.showIdent = func() string {
return "bit-adaptor"
}
// func bitAdaptor(db *DB) *adaptor {
// adp := new(adaptor)
// adp.showIdent = func() string {
// return "bit-adaptor"
// }
adp.set = func(k []byte, v []byte) (int64, error) {
datas := make([]BitPair, 3)
datas[0] = BitPair{0, 1}
datas[1] = BitPair{2, 1}
datas[2] = BitPair{5, 1}
// adp.set = func(k []byte, v []byte) (int64, error) {
// datas := make([]BitPair, 3)
// datas[0] = BitPair{0, 1}
// datas[1] = BitPair{2, 1}
// datas[2] = BitPair{5, 1}
if _, err := db.BMSetBit(k, datas...); err != nil {
return 0, err
} else {
return int64(len(datas)), nil
}
}
// if _, err := db.BMSetBit(k, datas...); err != nil {
// return 0, err
// } else {
// return int64(len(datas)), nil
// }
// }
adp.exists = func(k []byte) (int64, error) {
var start, end int32 = 0, -1
if blen, err := db.BCount(k, start, end); err != nil || blen <= 0 {
return 0, err
} else {
return 1, nil
}
}
// adp.exists = func(k []byte) (int64, error) {
// var start, end int32 = 0, -1
// if blen, err := db.BCount(k, start, end); err != nil || blen <= 0 {
// return 0, err
// } else {
// return 1, nil
// }
// }
adp.del = db.BDelete
adp.expire = db.BExpire
adp.expireAt = db.BExpireAt
adp.ttl = db.BTTL
// adp.del = db.BDelete
// adp.expire = db.BExpire
// adp.expireAt = db.BExpireAt
// adp.ttl = db.BTTL
return adp
}
// return adp
// }
func allAdaptors(db *DB) []*adaptor {
adps := make([]*adaptor, 6)
adps := make([]*adaptor, 5)
adps[0] = kvAdaptor(db)
adps[1] = listAdaptor(db)
adps[2] = hashAdaptor(db)
adps[3] = zsetAdaptor(db)
adps[4] = setAdaptor(db)
adps[5] = bitAdaptor(db)
//adps[5] = bitAdaptor(db)
return adps
}

722
server/cmd_bit_test.go
View File

@ -1,367 +1,367 @@
package server
import (
"github.com/siddontang/ledisdb/client/go/ledis"
"testing"
)
func TestBit(t *testing.T) {
testBitGetSet(t)
testBitMset(t)
testBitCount(t)
testBitOpt(t)
}
func testBitGetSet(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("test_cmd_bin_basic")
// get / set
if v, err := ledis.Int(c.Do("bgetbit", key, 1024)); err != nil {
t.Fatal(err)
} else if v != 0 {
t.Fatal(v)
}
if ori, err := ledis.Int(c.Do("bsetbit", key, 1024, 1)); err != nil {
t.Fatal(err)
} else if ori != 0 {
t.Fatal(ori)
}
if v, err := ledis.Int(c.Do("bgetbit", key, 1024)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
// fetch from revert pos
c.Do("bsetbit", key, 1000, 1)
if v, err := ledis.Int(c.Do("bgetbit", key, -1)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
if v, err := ledis.Int(c.Do("bgetbit", key, -25)); err != nil {
t.Fatal(err)
} else if v != 1 {
t.Fatal(v)
}
// delete
if drop, err := ledis.Int(c.Do("bdelete", key)); err != nil {
t.Fatal(err)
} else if drop != 1 {
t.Fatal(drop)
}
if drop, err := ledis.Int(c.Do("bdelete", key)); err != nil {
t.Fatal(err)
} else if drop != 0 {
t.Fatal(drop)
}
}
func testBitMset(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("test_cmd_bin_mset")
if n, err := ledis.Int(
c.Do("bmsetbit", key,
500, 0,
100, 1,
200, 1,
1000, 1,
900, 0,
500000, 1,
600, 0,
300, 1,
100000, 1)); err != nil {
t.Fatal(err)
} else if n != 9 {
t.Fatal(n)
}
fillPos := []int{100, 200, 300, 1000, 100000, 500000}
for _, pos := range fillPos {
v, err := ledis.Int(c.Do("bgetbit", key, pos))
if err != nil || v != 1 {
t.Fatal(pos)
}
}
// err
if n, err := ledis.Int(
c.Do("bmsetbit", key, 3, 0, 2, 1, 3, 0, 1, 1)); err == nil || n != 0 {
t.Fatal(n) // duplication on pos
}
}
func testBitCount(t *testing.T) {
c := getTestConn()
defer c.Close()
key := []byte("test_cmd_bin_count")
sum := 0
for pos := 1; pos < 1000000; pos += 10001 {
c.Do("bsetbit", key, pos, 1)
sum++
}
if n, err := ledis.Int(c.Do("bcount", key)); err != nil {
t.Fatal(err)
} else if n != sum {
t.Fatal(n)
}
}
func testBitOpt(t *testing.T) {
c := getTestConn()
defer c.Close()
dstk := []byte("bin_op_res")
kmiss := []byte("bin_op_miss")
k0 := []byte("bin_op_0")
k1 := []byte("bin_op_1")
c.Do("bmsetbit", k0, 10, 1, 30, 1, 50, 1, 70, 1, 100, 1)
c.Do("bmsetbit", k1, 20, 1, 40, 1, 60, 1, 80, 1, 100, 1)
// case - lack of args
// todo ...
// case - 'not' on inexisting key
if blen, err := ledis.Int(
c.Do("bopt", "not", dstk, kmiss)); err != nil {
t.Fatal(err)
} else if blen != 0 {
t.Fatal(blen)
}
if v, _ := ledis.String(c.Do("bget", dstk)); v != "" {
t.Fatal(v)
}
// case - 'and', 'or', 'xor' with inexisting key
opts := []string{"and", "or", "xor"}
for _, op := range opts {
if blen, err := ledis.Int(
c.Do("bopt", op, dstk, kmiss, k0)); err != nil {
t.Fatal(err)
} else if blen != 0 {
t.Fatal(blen)
}
}
// case - 'and'
if blen, err := ledis.Int(
c.Do("bopt", "and", dstk, k0, k1)); err != nil {
t.Fatal(err)
} else if blen != 101 {
t.Fatal(blen)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 0 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 0 {
t.Fatal(v)
}
// case - 'or'
if blen, err := ledis.Int(
c.Do("bopt", "or", dstk, k0, k1)); err != nil {
t.Fatal(err)
} else if blen != 101 {
t.Fatal(blen)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
t.Fatal(v)
}
// case - 'xor'
if blen, err := ledis.Int(
c.Do("bopt", "xor", dstk, k0, k1)); err != nil {
t.Fatal(err)
} else if blen != 101 {
t.Fatal(blen)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 0 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
t.Fatal(v)
}
if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
t.Fatal(v)
}
return
}
func TestBitErrorParams(t *testing.T) {
c := getTestConn()
defer c.Close()
if _, err := c.Do("bget"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bdelete"); err == nil {
t.Fatal("invalid err of %v", err)
}
// bsetbit
if _, err := c.Do("bsetbit"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bsetbit", "test_bsetbit"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bsetbit", "test_bsetbit", "o", "v"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bsetbit", "test_bsetbit", "o", 1); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bsetbit", "test_bsetbit", -1, 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
if _, err := c.Do("bsetbit", "test_bsetbit", 1, "v"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bsetbit", "test_bsetbit", 1, 2); err == nil {
t.Fatal("invalid err of %v", err)
}
//bgetbit
if _, err := c.Do("bgetbit", "test_bgetbit"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bgetbit", "test_bgetbit", "o"); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bgetbit", "test_bgetbit", -1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
//bmsetbit
if _, err := c.Do("bmsetbit", "test_bmsetbit"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bmsetbit", "test_bmsetbit", 0, 1, 2); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", "v"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", 1); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bmsetbit", "test_bmsetbit", -1, 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, "v"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 2); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 0.1); err == nil {
t.Fatal("invalid err of %v", err)
}
//bcount
// import (
// "github.com/siddontang/ledisdb/client/go/ledis"
// "testing"
// )
// func TestBit(t *testing.T) {
// testBitGetSet(t)
// testBitMset(t)
// testBitCount(t)
// testBitOpt(t)
// }
// func testBitGetSet(t *testing.T) {
// c := getTestConn()
// defer c.Close()
// key := []byte("test_cmd_bin_basic")
// // get / set
// if v, err := ledis.Int(c.Do("bgetbit", key, 1024)); err != nil {
// t.Fatal(err)
// } else if v != 0 {
// t.Fatal(v)
// }
// if ori, err := ledis.Int(c.Do("bsetbit", key, 1024, 1)); err != nil {
// t.Fatal(err)
// } else if ori != 0 {
// t.Fatal(ori)
// }
// if v, err := ledis.Int(c.Do("bgetbit", key, 1024)); err != nil {
// t.Fatal(err)
// } else if v != 1 {
// t.Fatal(v)
// }
// // fetch from revert pos
// c.Do("bsetbit", key, 1000, 1)
// if v, err := ledis.Int(c.Do("bgetbit", key, -1)); err != nil {
// t.Fatal(err)
// } else if v != 1 {
// t.Fatal(v)
// }
// if v, err := ledis.Int(c.Do("bgetbit", key, -25)); err != nil {
// t.Fatal(err)
// } else if v != 1 {
// t.Fatal(v)
// }
// // delete
// if drop, err := ledis.Int(c.Do("bdelete", key)); err != nil {
// t.Fatal(err)
// } else if drop != 1 {
// t.Fatal(drop)
// }
// if drop, err := ledis.Int(c.Do("bdelete", key)); err != nil {
// t.Fatal(err)
// } else if drop != 0 {
// t.Fatal(drop)
// }
// }
// func testBitMset(t *testing.T) {
// c := getTestConn()
// defer c.Close()
// key := []byte("test_cmd_bin_mset")
// if n, err := ledis.Int(
// c.Do("bmsetbit", key,
// 500, 0,
// 100, 1,
// 200, 1,
// 1000, 1,
// 900, 0,
// 500000, 1,
// 600, 0,
// 300, 1,
// 100000, 1)); err != nil {
// t.Fatal(err)
// } else if n != 9 {
// t.Fatal(n)
// }
// fillPos := []int{100, 200, 300, 1000, 100000, 500000}
// for _, pos := range fillPos {
// v, err := ledis.Int(c.Do("bgetbit", key, pos))
// if err != nil || v != 1 {
// t.Fatal(pos)
// }
// }
// // err
// if n, err := ledis.Int(
// c.Do("bmsetbit", key, 3, 0, 2, 1, 3, 0, 1, 1)); err == nil || n != 0 {
// t.Fatal(n) // duplication on pos
// }
// }
// func testBitCount(t *testing.T) {
// c := getTestConn()
// defer c.Close()
// key := []byte("test_cmd_bin_count")
// sum := 0
// for pos := 1; pos < 1000000; pos += 10001 {
// c.Do("bsetbit", key, pos, 1)
// sum++
// }
// if n, err := ledis.Int(c.Do("bcount", key)); err != nil {
// t.Fatal(err)
// } else if n != sum {
// t.Fatal(n)
// }
// }
// func testBitOpt(t *testing.T) {
// c := getTestConn()
// defer c.Close()
// dstk := []byte("bin_op_res")
// kmiss := []byte("bin_op_miss")
// k0 := []byte("bin_op_0")
// k1 := []byte("bin_op_1")
// c.Do("bmsetbit", k0, 10, 1, 30, 1, 50, 1, 70, 1, 100, 1)
// c.Do("bmsetbit", k1, 20, 1, 40, 1, 60, 1, 80, 1, 100, 1)
// // case - lack of args
// // todo ...
// // case - 'not' on inexisting key
// if blen, err := ledis.Int(
// c.Do("bopt", "not", dstk, kmiss)); err != nil {
// t.Fatal(err)
// } else if blen != 0 {
// t.Fatal(blen)
// }
// if v, _ := ledis.String(c.Do("bget", dstk)); v != "" {
// t.Fatal(v)
// }
// // case - 'and', 'or', 'xor' with inexisting key
// opts := []string{"and", "or", "xor"}
// for _, op := range opts {
// if blen, err := ledis.Int(
// c.Do("bopt", op, dstk, kmiss, k0)); err != nil {
// t.Fatal(err)
// } else if blen != 0 {
// t.Fatal(blen)
// }
// }
// // case - 'and'
// if blen, err := ledis.Int(
// c.Do("bopt", "and", dstk, k0, k1)); err != nil {
// t.Fatal(err)
// } else if blen != 101 {
// t.Fatal(blen)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
// t.Fatal(v)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 0 {
// t.Fatal(v)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 0 {
// t.Fatal(v)
// }
// // case - 'or'
// if blen, err := ledis.Int(
// c.Do("bopt", "or", dstk, k0, k1)); err != nil {
// t.Fatal(err)
// } else if blen != 101 {
// t.Fatal(blen)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 1 {
// t.Fatal(v)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
// t.Fatal(v)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
// t.Fatal(v)
// }
// // case - 'xor'
// if blen, err := ledis.Int(
// c.Do("bopt", "xor", dstk, k0, k1)); err != nil {
// t.Fatal(err)
// } else if blen != 101 {
// t.Fatal(blen)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 100)); v != 0 {
// t.Fatal(v)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 20)); v != 1 {
// t.Fatal(v)
// }
// if v, _ := ledis.Int(c.Do("bgetbit", dstk, 40)); v != 1 {
// t.Fatal(v)
// }
// return
// }
// func TestBitErrorParams(t *testing.T) {
// c := getTestConn()
// defer c.Close()
// if _, err := c.Do("bget"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bdelete"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// // bsetbit
// if _, err := c.Do("bsetbit"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bsetbit", "test_bsetbit"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bsetbit", "test_bsetbit", "o", "v"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bsetbit", "test_bsetbit", "o", 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// // if _, err := c.Do("bsetbit", "test_bsetbit", -1, 1); err == nil {
// // t.Fatal("invalid err of %v", err)
// // }
// if _, err := c.Do("bsetbit", "test_bsetbit", 1, "v"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bsetbit", "test_bsetbit", 1, 2); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// //bgetbit
// if _, err := c.Do("bgetbit", "test_bgetbit"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bgetbit", "test_bgetbit", "o"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// // if _, err := c.Do("bgetbit", "test_bgetbit", -1); err == nil {
// // t.Fatal("invalid err of %v", err)
// // }
// //bmsetbit
// if _, err := c.Do("bmsetbit", "test_bmsetbit"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bmsetbit", "test_bmsetbit", 0, 1, 2); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", "v"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// // if _, err := c.Do("bmsetbit", "test_bmsetbit", -1, 1); err == nil {
// // t.Fatal("invalid err of %v", err)
// // }
// if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, "v"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 2); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 0.1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// //bcount
if _, err := c.Do("bcount"); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bcount"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
if _, err := c.Do("bcount", "a", "b", "c"); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bcount", "a", "b", "c"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
if _, err := c.Do("bcount", 1, "a"); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bcount", 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
//bopt
if _, err := c.Do("bopt"); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bopt", "and", 1); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bopt", "x", 1); err == nil {
t.Fatal("invalid err of %v", err)
}
if _, err := c.Do("bopt", ""); err == nil {
t.Fatal("invalid err of %v", err)
}
//bexpire
if _, err := c.Do("bexpire", "test_bexpire"); err == nil {
t.Fatal("invalid err of %v", err)
}
//bexpireat
if _, err := c.Do("bexpireat", "test_bexpireat"); err == nil {
t.Fatal("invalid err of %v", err)
}
//bttl
if _, err := c.Do("bttl"); err == nil {
t.Fatal("invalid err of %v", err)
}
// if _, err := c.Do("bcount", 1, "a"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// // if _, err := c.Do("bcount", 1); err == nil {
// // t.Fatal("invalid err of %v", err)
// // }
// //bopt
// if _, err := c.Do("bopt"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bopt", "and", 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bopt", "x", 1); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// if _, err := c.Do("bopt", ""); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// //bexpire
// if _, err := c.Do("bexpire", "test_bexpire"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// //bexpireat
// if _, err := c.Do("bexpireat", "test_bexpireat"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// //bttl
// if _, err := c.Do("bttl"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
//bpersist
if _, err := c.Do("bpersist"); err == nil {
t.Fatal("invalid err of %v", err)
}
}
// //bpersist
// if _, err := c.Do("bpersist"); err == nil {
// t.Fatal("invalid err of %v", err)
// }
// }

130
server/cmd_kv.go
View File

@ -467,13 +467,142 @@ func strlenCommand(c *client) error {
return nil
}
func parseBitRange(args [][]byte) (start int, end int, err error) {
start = 0
end = -1
if len(args) > 0 {
if start, err = strconv.Atoi(string(args[0])); err != nil {
return
}
}
if len(args) == 2 {
if end, err = strconv.Atoi(string(args[1])); err != nil {
return
}
}
return
}
func bitcountCommand(c *client) error {
args := c.args
if len(args) == 0 || len(args) > 3 {
return ErrCmdParams
}
key := args[0]
start, end, err := parseBitRange(args[1:])
if err != nil {
return err
}
if n, err := c.db.BitCount(key, start, end); err != nil {
return err
} else {
c.resp.writeInteger(n)
}
return nil
}
func bitopCommand(c *client) error {
args := c.args
if len(args) < 3 {
return ErrCmdParams
}
op := string(args[0])
destKey := args[1]
srcKeys := args[2:]
if n, err := c.db.BitOP(op, destKey, srcKeys...); err != nil {
return err
} else {
c.resp.writeInteger(n)
}
return nil
}
func bitposCommand(c *client) error {
args := c.args
if len(args) < 2 {
return ErrCmdParams
}
key := args[0]
bit, err := strconv.Atoi(string(args[1]))
if err != nil {
return err
}
start, end, err := parseBitRange(args[2:])
if err != nil {
return err
}
if n, err := c.db.BitPos(key, bit, start, end); err != nil {
return err
} else {
c.resp.writeInteger(n)
}
return nil
}
func getbitCommand(c *client) error {
args := c.args
if len(args) != 2 {
return ErrCmdParams
}
key := args[0]
offset, err := strconv.Atoi(string(args[1]))
if err != nil {
return err
}
if n, err := c.db.GetBit(key, offset); err != nil {
return err
} else {
c.resp.writeInteger(n)
}
return nil
}
func setbitCommand(c *client) error {
args := c.args
if len(args) != 3 {
return ErrCmdParams
}
key := args[0]
offset, err := strconv.Atoi(string(args[1]))
if err != nil {
return err
}
value, err := strconv.Atoi(string(args[2]))
if err != nil {
return err
}
if n, err := c.db.SetBit(key, offset, value); err != nil {
return err
} else {
c.resp.writeInteger(n)
}
return nil
}
func init() {
register("append", appendCommand)
register("bitcount", bitcountCommand)
register("bitop", bitopCommand)
register("bitpos", bitposCommand)
register("decr", decrCommand)
register("decrby", decrbyCommand)
register("del", delCommand)
register("exists", existsCommand)
register("get", getCommand)
register("getbit", getbitCommand)
register("getrange", getrangeCommand)
register("getset", getsetCommand)
register("incr", incrCommand)
@ -481,6 +610,7 @@ func init() {
register("mget", mgetCommand)
register("mset", msetCommand)
register("set", setCommand)
register("setbit", setbitCommand)
register("setnx", setnxCommand)
register("setex", setexCommand)
register("setrange", setrangeCommand)

40
server/cmd_kv_test.go
View File

@ -104,6 +104,46 @@ func TestKV(t *testing.T) {
t.Fatal(v)
}
bitKey := "bit_key"
if n, err := ledis.Int(c.Do("setbit", bitKey, 7, 1)); err != nil {
t.Fatal(err)
} else if n != 0 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("getbit", bitKey, 7)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("bitcount", bitKey)); err != nil {
t.Fatal(err)
} else if n != 1 {
t.Fatal(n)
}
if n, err := ledis.Int(c.Do("bitpos", bitKey, 1)); err != nil {
t.Fatal(err)
} else if n != 7 {
t.Fatal(n)
}
c.Do("set", "key1", "foobar")
c.Do("set", "key2", "abcdef")
if n, err := ledis.Int(c.Do("bitop", "and", "bit_dest_key", "key1", "key2")); err != nil {
t.Fatal(err)
} else if n != 6 {
t.Fatal(n)
}
if v, err := ledis.String(c.Do("get", "bit_dest_key")); err != nil {
t.Fatal(err)
} else if v != "`bc`ab" {
t.Fatal(v)
}
}
func TestKVM(t *testing.T) {

3
server/cmd_ttl_test.go
View File

@ -13,7 +13,7 @@ func now() int64 {
func TestExpire(t *testing.T) {
// test for kv, list, hash, set, zset, bitmap in all
ttlType := []string{"k", "l", "h", "s", "z", "b"}
ttlType := []string{"k", "l", "h", "s", "z"}
var (
expire string
@ -61,7 +61,6 @@ func TestExpire(t *testing.T) {
key = "bitmap_ttl"
c.Do("bsetbit", key, 0, 1)
}
// expire + ttl
exp := int64(10)
if n, err := ledis.Int(c.Do(expire, key, exp)); err != nil {

12
server/scan_test.go
View File

@ -33,7 +33,6 @@ func TestScan(t *testing.T) {
testListScan(t, c)
testZSetScan(t, c)
testSetScan(t, c)
testBitScan(t, c)
}
@ -154,14 +153,3 @@ func testSetScan(t *testing.T, c *ledis.Client) {
checkScan(t, c, "xsscan")
checkRevScan(t, c, "xsrevscan")
}
func testBitScan(t *testing.T, c *ledis.Client) {
for i := 0; i < 10; i++ {
if _, err := c.Do("bsetbit", fmt.Sprintf("%d", i), 1024, 1); err != nil {
t.Fatal(err)
}
}
checkScan(t, c, "xbscan")
checkRevScan(t, c, "xbrevscan")
}