//返回下标处于区域 [begin, end] 的元素. begin 和 end 可以是负数
//
// name queue 的名字.
// begin 正整数, 从此下标处开始返回。从 0 开始。
// end 整数, 结束下标。可以是负数, 表示返回所有。
// [slice，range] 命令
// 返回 v，返回元素的数组，为空时返回 nil
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) slice(name string, args ...int) (v []Value, err error) {
begin := 0
end := -1
index := 0
if len(args) > 0 {
begin = args[0]
}
if len(args) > 1 {
end = args[1]
}
if len(args) > 2 {
index = args[2]
}
resp, err := this.Do(qslice_cmd[index], name, begin, end)
if err != nil {
return nil, goerr.NewError(err, "%s %s error", qslice_cmd[index], name)
}
size := len(resp)
if size >= 1 && resp[0] == "ok" {
for i := 1; i < size; i++ {
v = append(v, Value(resp[i]))
}
return
}
return nil, makeError(resp, name)
}
//设置过期
//
// key 要设置过期的 key
// ttl 存活时间(秒)
// 返回 re，设置是否成功，如果当前 key 不存在返回 false
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Expire(key string, ttl int64) (re bool, err error) {
resp, err := this.Do("expire", key, ttl)
if err != nil {
return false, goerr.NewError(err, "Expire %s error", key)
}
if len(resp) == 2 && resp[0] == "ok" {
return resp[1] == "1", nil
}
return false, makeError(resp, key, ttl)
}
//更新 key 对应的 value, 并返回更新前的旧的 value.
//
// key 键值
// val 存贮的 value 值,val只支持基本的类型，如果要支持复杂的类型，需要开启连接池的 Encoding 选项
// 返回 一个 Value,可以方便的向其它类型转换.如果 key 不存在则返回 "", 否则返回 key 对应的值内容.
// 返回 一个可能的错误，操作成功返回 nil
func (this *Client) Getset(key string, val interface{}) (Value, error) {
resp, err := this.Do("getset", key, val)
if err != nil {
return "", goerr.NewError(err, "Getset %s error", key)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]), nil
}
return "", makeError(resp, key)
}
//返回队列的最后一个元素.
//
// key 队列的名字
// 返回 val，返回的值.
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qback(key string) (Value, error) {
resp, err := this.Do("qback", key)
if err != nil {
return "", goerr.NewError(err, "Qback %s error", key)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]), nil
}
return "", makeError(resp, key)
}
//返回指定位置的元素. 0 表示第一个元素, 1 是第二个 ... -1 是最后一个.
//
// key 队列的名字
// index 指定的位置，可传负数.
// 返回 val，返回的值.
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qget(key string, index int64) (Value, error) {
resp, err := this.Do("qget", key, index)
if err != nil {
return "", goerr.NewError(err, "Qget %s error", key)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]), nil
}
return "", makeError(resp, key)
}
//获取 hashmap 中指定 key 的值内容.
//
// setName hashmap 的名字
// key hashmap 的 key
// 返回 value key 的值
// 返回 err，执行的错误
func (this *Client) Hget(setName, key string) (value Value, err error) {
resp, err := this.Do("hget", setName, key)
if err != nil {
return "", goerr.NewError(err, "Hget %s/%s error", setName, key)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]), nil
}
return "", makeError(resp, setName, key)
}
//删除 hashmap 中的指定 key，不能通过返回值来判断被删除的 key 是否存在.
//
// setName hashmap 的名字
// key hashmap 的 key
// 返回 err，执行的错误
func (this *Client) Hdel(setName, key string) (err error) {
resp, err := this.Do("hdel", setName, key)
if err != nil {
return goerr.NewError(err, "Hdel %s/%s error", setName, key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, setName, key)
}
func (this *Client) Zget(setName, key string) (score int64, err error) {
resp, err := this.Do("zget", setName, key)
if err != nil {
return 0, goerr.NewError(err, "Zget %s/%s error", setName, key)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return 0, makeError(resp, setName, key)
}
//当 key 不存在时, 设置指定 key 的值内容. 如果已存在, 则不设置.
//
// key 键值
// val 存贮的 value 值,val只支持基本的类型，如果要支持复杂的类型，需要开启连接池的 Encoding 选项
// 返回 err，可能的错误，操作成功返回 nil
// 返回 val 1: value 已经设置, 0: key 已经存在, 不更新.
func (this *Client) Setnx(key string, val interface{}) (Value, error) {
resp, err := this.Do("setnx", key, this.encoding(val, false))
if err != nil {
return "", goerr.NewError(err, "Setnx %s error", key)
}
if len(resp) > 0 && resp[0] == "ok" {
return Value(resp[1]), nil
}
return "", makeError(resp, key)
}
//返回队列的长度.
//
// name 队列的名字
// 返回 size，队列的长度；
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qsize(name string) (size int64, err error) {
resp, err := this.Do("qsize", name)
if err != nil {
return -1, goerr.NewError(err, "Qsize %s error", name)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return -1, makeError(resp, name)
}
//删除 hashmap 中的所有 key
//
// setName hashmap 的名字
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Hclear(setName string) (err error) {
resp, err := this.Do("hclear", setName)
if err != nil {
return goerr.NewError(err, "Hclear %s error", setName)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, setName)
}
func (this *Client) Zset(setName, key string, score int64) (err error) {
resp, err := this.Do("zset", setName, key, this.encoding(score, false))
if err != nil {
return goerr.NewError(err, "Zset %s/%s error", setName, key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, setName, key)
}
//判断指定的 key 是否存在于 hashmap 中.
//
// setName hashmap 的名字
// key hashmap 的 key
// 返回 re，如果当前 key 不存在返回 false
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Hexists(setName, key string) (re bool, err error) {
resp, err := this.Do("hexists", setName, key)
if err != nil {
return false, goerr.NewError(err, "Hexists %s/%s error", setName, key)
}
if len(resp) == 2 && resp[0] == "ok" {
return resp[1] == "1", nil
}
return false, makeError(resp, setName, key)
}
//设置 hashmap 中指定 key 对应的值内容.
//
// setName hashmap 的名字
// key hashmap 的 key
// value key 的值
// 返回 err，执行的错误
func (this *Client) Hset(setName, key string, value interface{}) (err error) {
resp, err := this.Do("hset", setName, key, this.encoding(value, false))
if err != nil {
return goerr.NewError(err, "Hset %s/%s error", setName, key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, setName, key)
}
//返回 key(只针对 KV 类型) 的存活时间.
//
// key 要删除的 key
// 返回 ttl，key 的存活时间(秒), -1 表示没有设置存活时间.
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Ttl(key string) (ttl int64, err error) {
resp, err := this.Do("ttl", key)
if err != nil {
return -1, goerr.NewError(err, "Ttl %s error", key)
}
//response looks like this: [ok 1]
if len(resp) > 0 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return -1, makeError(resp, key)
}
func (this *Client) Zcount(setName string, start, end interface{}) (count int64, err error) {
resp, err := this.Do("zcount", setName, this.encoding(start, false), this.encoding(end, false))
if err != nil {
return -1, goerr.NewError(err, "Zcount %s %v %v error", setName, start, end)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return -1, makeError(resp, setName)
}
//计算字符串的长度(字节数).
//
// key 键值
// 返回 字符串的长度, key 不存在则返回 0.
// 返回 err，可能的错误，操作成功返回 nil
func (this *Client) Strlen(key string) (int64, error) {
resp, err := this.Do("strlen", key)
if err != nil {
return -1, goerr.NewError(err, "Strlen %s error", key)
}
if len(resp) > 1 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return -1, makeError(resp, key)
}
//列出处于区间 (key_start, key_end] 的 key 列表.("", ""] 表示整个区间.
//
// keyStart int 返回的起始 key(不包含), 空字符串表示 -inf.
// keyEnd int 返回的结束 key(包含), 空字符串表示 +inf.
// limit int 最多返回这么多个元素.
// 返回 返回包含 key 的数组.
// 返回 err，可能的错误，操作成功返回 nil
func (this *Client) Keys(keyStart, keyEnd string, limit int64) ([]string, error) {
resp, err := this.Do("keys", keyStart, keyEnd, limit)
if err != nil {
return nil, goerr.NewError(err, "Keys %s error", keyStart, keyEnd, limit)
}
if len(resp) > 0 && resp[0] == "ok" {
return resp[1:], nil
}
return nil, makeError(resp, keyStart, keyEnd, limit)
}
//删除指定 key
//
// key 要删除的 key
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Del(key string) error {
resp, err := this.Do("del", key)
if err != nil {
return goerr.NewError(err, "Del %s error", key)
}
//response looks like this: [ok 1]
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, key)
}
//设置 hashmap 中指定 key 对应的值增加 num. 参数 num 可以为负数.
//
// setName - hashmap 的名字.
// key 键值
// num 增加的值
// 返回 val，整数，增加 num 后的新值
// 返回 err，可能的错误，操作成功返回 nil
func (this *Client) Hincr(setName, key string, num int64) (val int64, err error) {
resp, err := this.Do("hincr", setName, key, num)
if err != nil {
return -1, goerr.NewError(err, "Hincr %s error", key)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return -1, makeError(resp, key)
}
//更新位于 index 位置的元素. 如果超过现有的元素范围, 会返回错误.
//
// key 队列的名字
// index 指定的位置，可传负数.
// val 传入的值.
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qset(key string, index int64, val interface{}) (err error) {
var resp []string
resp, err = this.Do("qset", key, index, this.encoding(val, false))
if err != nil {
return goerr.NewError(err, "Qset %s error", key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, key)
}
//从队列头部删除多个元素.
//
// name queue 的名字.
// size 最多从队列删除这么多个元素
// reverse 可选，是否反向执行
// 返回 delSize，返回被删除的元素数量
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qtrim(name string, size int, reverse ...bool) (delSize int64, err error) {
index := 0
if len(reverse) > 0 && reverse[0] {
index = 1
}
resp, err := this.Do(qtrim_cmd[index], name, size)
if err != nil {
return -1, goerr.NewError(err, "%s %s error", qtrim_cmd[index], name)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]).Int64(), nil
}
return -1, makeError(resp, name)
}
//从队列首部弹出最后一个元素.
//
// name 队列的名字
// 返回 v，返回一个元素，并在队列中删除 v；队列为空时返回空值
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qpop(name string, reverse ...bool) (v Value, err error) {
index := 1
if len(reverse) > 0 && !reverse[0] {
index = 0
}
resp, err := this.Do(qpop_cmd[index], name)
if err != nil {
return "", goerr.NewError(err, "%s %s error", qpop_cmd[index], name)
}
if len(resp) == 2 && resp[0] == "ok" {
return Value(resp[1]), nil
}
return "", makeError(resp, name)
}
func (this *Client) Zincr(setName string, key string, num int64) (int64, error) {
if len(key) == 0 {
return 0, nil
}
resp, err := this.Do("zincr", setName, key, this.encoding(num, false))
if err != nil {
return 0, goerr.NewError(err, "Zincr %s %s %v", setName, key, num)
}
if len(resp) > 1 && resp[0] == "ok" {
return to.Int64(resp[1]), nil
}
return 0, makeError(resp, setName, key)
}
//批量删除 hashmap 中的 key.（输入分片）
//
// setName - hashmap 的名字.
// keys - 包含 key 的数组.
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) MultiHdelArray(setName string, key []string) (err error) {
if len(key) == 0 {
return nil
}
resp, err := this.Do("multi_hdel", setName, key)
if err != nil {
return goerr.NewError(err, "MultiHdel %s %s error", setName, key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, key)
}
//批量删除一批 key 和其对应的值内容.
//
// key，要删除的 key，可以为多个
// 返回 err，可能的错误，操作成功返回 nil
func (this *Client) MultiDel(key ...string) (err error) {
if len(key) == 0 {
return nil
}
resp, err := this.Do("multi_del", key)
if err != nil {
return goerr.NewError(err, "MultiDel %s error", key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, key)
}
//设置指定 key 的值内容
//
// key 键值
// val 存贮的 value 值,val只支持基本的类型，如果要支持复杂的类型，需要开启连接池的 Encoding 选项
// ttl 可选，设置的过期时间，单位为秒
// 返回 err，可能的错误，操作成功返回 nil
func (this *Client) Set(key string, val interface{}, ttl ...int64) (err error) {
var resp []string
if len(ttl) > 0 {
resp, err = this.Do("setx", key, this.encoding(val, false), ttl[0])
} else {
resp, err = this.Do("set", key, this.encoding(val, false))
}
if err != nil {
return goerr.NewError(err, "Set %s error", key)
}
if len(resp) > 0 && resp[0] == "ok" {
return nil
}
return makeError(resp, key)
}
// if err != nil {
// return 255, goerr.NewError(err, "Getbit %s error", key)
// }
// if len(resp) == 2 && resp[0] == "ok" {
// return Value(resp[1]).Byte(), nil
// }
// return 255, makeError(resp, key)
//}
//获取字符串的子串.
//
// key 键值
// start int, 子串的字节偏移;若 start 是负数, 则从字符串末尾算起.
// size int,可选, 子串的长度(字节数), 默认为到字符串最后一个字节;若 size 是负数, 则表示从字符串末尾算起, 忽略掉那么多字节(类似 PHP 的 substr())
// 返回 val，字符串的部分
// 返回 err，可能的错误，操作成功返回 nil
func (this *Client) Substr(key string, start int64, size ...int64) (val string, err error) {
var resp []string
if len(size) > 0 {
resp, err = this.Do("substr", key, start, size[0])
} else {
resp, err = this.Do("substr", key, start)
}
if err != nil {
return "", goerr.NewError(err, "Substr %s error", key)
}
if len(resp) > 1 && resp[0] == "ok" {
return resp[1], nil
}
return "", makeError(resp, key)
}
//批量获取 hashmap 中全部 对应的权重值.
//
// setName - hashmap 的名字.
// keys - 包含 key 的数组 .
// 返回 包含 key-value 的关联数组, 如果某个 key 不存在, 则它不会出现在返回数组中.
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) MultiHgetAll(setName string) (val map[string]Value, err error) {
resp, err := this.Do("hgetall", setName)
if err != nil {
return nil, goerr.NewError(err, "MultiHgetAll %s error", setName)
}
size := len(resp)
if size > 0 && resp[0] == "ok" {
val = make(map[string]Value)
for i := 1; i < size && i+1 < size; i += 2 {
val[resp[i]] = Value(resp[i+1])
}
return val, nil
}
return nil, makeError(resp)
}
//列出名字处于区间 (name_start, name_end] 的 hashmap. ("", ""] 表示整个区间.
//
// keyStart - 返回的起始 key(不包含), 空字符串表示 -inf.
// keyEnd - 返回的结束 key(包含), 空字符串表示 +inf.
// limit - 最多返回这么多个元素.
// 返回 包含名字的数组
// 返回 err，执行的错误，操作成功返回 nil
func (this *Client) Hlist(nameStart, nameEnd string, limit int64) ([]string, error) {
resp, err := this.Do("hlist", nameStart, nameEnd, this.encoding(limit, false))
if err != nil {
return nil, goerr.NewError(err, "Hlist %s %s %v error", nameStart, nameEnd, limit)
}
if len(resp) > 0 && resp[0] == "ok" {
size := len(resp)
keyList := make([]string, 0, size-1)
for i := 1; i < size; i += 1 {
keyList = append(keyList, resp[i])
}
return keyList, nil
}
return nil, makeError(resp, nameStart, nameEnd, limit)
}