예제 #1
0
파일: queue.go 프로젝트: lunny/gossdb
//返回下标处于区域 [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)
}
예제 #2
0
파일: set.go 프로젝트: lunny/gossdb
//设置过期
//
//  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)
}
예제 #3
0
파일: set.go 프로젝트: lunny/gossdb
//更新 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)
}
예제 #4
0
파일: queue.go 프로젝트: lunny/gossdb
//返回队列的最后一个元素.
//
//  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)
}
예제 #5
0
파일: queue.go 프로젝트: lunny/gossdb
//返回指定位置的元素. 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)
}
예제 #6
0
파일: hset.go 프로젝트: lunny/gossdb
//获取 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)
}
예제 #7
0
파일: hset.go 프로젝트: lunny/gossdb
//删除 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)
}
예제 #8
0
파일: zset.go 프로젝트: lunny/gossdb
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)
}
예제 #9
0
파일: set.go 프로젝트: lunny/gossdb
//当 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)
}
예제 #10
0
파일: queue.go 프로젝트: lunny/gossdb
//返回队列的长度.
//
//  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)
}
예제 #11
0
파일: hset.go 프로젝트: lunny/gossdb
//删除 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)
}
예제 #12
0
파일: zset.go 프로젝트: lunny/gossdb
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)
}
예제 #13
0
파일: hset.go 프로젝트: lunny/gossdb
//判断指定的 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)
}
예제 #14
0
파일: hset.go 프로젝트: lunny/gossdb
//设置 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)
}
예제 #15
0
파일: set.go 프로젝트: lunny/gossdb
//返回 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)
}
예제 #16
0
파일: zset.go 프로젝트: lunny/gossdb
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)

}
예제 #17
0
파일: set.go 프로젝트: lunny/gossdb
//计算字符串的长度(字节数).
//
//  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)
}
예제 #18
0
파일: set.go 프로젝트: lunny/gossdb
//列出处于区间 (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)
}
예제 #19
0
파일: set.go 프로젝트: lunny/gossdb
//删除指定 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)
}
예제 #20
0
파일: hset.go 프로젝트: lunny/gossdb
//设置 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)
}
예제 #21
0
파일: queue.go 프로젝트: lunny/gossdb
//更新位于 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)
}
예제 #22
0
파일: queue.go 프로젝트: lunny/gossdb
//从队列头部删除多个元素.
//
//  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)
}
예제 #23
0
파일: queue.go 프로젝트: lunny/gossdb
//从队列首部弹出最后一个元素.
//
//  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)
}
예제 #24
0
파일: zset.go 프로젝트: lunny/gossdb
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)
}
예제 #25
0
파일: hset.go 프로젝트: lunny/gossdb
//批量删除 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)
}
예제 #26
0
파일: set.go 프로젝트: lunny/gossdb
//批量删除一批 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)
}
예제 #27
0
파일: set.go 프로젝트: lunny/gossdb
//设置指定 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)
}
예제 #28
0
파일: set.go 프로젝트: lunny/gossdb
//	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)
}
예제 #29
0
파일: hset.go 프로젝트: lunny/gossdb
//批量获取 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)
}
예제 #30
0
파일: hset.go 프로젝트: lunny/gossdb
//列出名字处于区间 (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)
}