//ZINTERSTORE destination numkeys key
func (r *RedisType) ZInterStore(destination, key string, numkeys int, weight ...interface{}) (int, error) {
if len(weight) > 0 {
row, err := redis.Int(r.RedisConn.Do("ZINTERSTORE", destination, key, numkeys, weight))
return row, err
}
row, err := redis.Int(r.RedisConn.Do("ZINTERSTORE", destination, key, numkeys))
return row, err
}
func (r *RedisType) BitPos(key string, bit int, borders ...int) (int, error) {
if len(borders) > 0 {
if len(borders) > 1 {
return 0, errors.New("Too many borders")
}
row, err := redis.Int(r.RedisConn.Do("BITPOS", key, bit, borders[0], borders[1]))
return row, err
} else {
row, err := redis.Int(r.RedisConn.Do("BITPOS", key, bit))
return row, err
}
}
func (r *RedisType) ZRevRank(key, member string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZREVRANK", key, member))
if err == redis.ErrNil {
return 0, nil
}
return row, err
}
func (r *RedisType) ZCard(key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZCARD", key))
if err == redis.ErrNil {
return 0, nil
}
return row, err
}
func (r *RedisType) ZCount(key string, min, max int) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZCOUNT", key, min, max))
if err == redis.ErrNil {
return 0, nil
}
return row, err
}
func (r *RedisType) Ttl(key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("TTL", key))
if row < 0 {
row = 0
}
return row, err
}
func (r *RedisType) SRem(key string, members ...interface{}) (int, error) {
params := make([]interface{}, 0)
params = append(params, key)
for _, v := range members {
params = append(params, v)
}
row, err := redis.Int(r.RedisConn.Do("SREM", params...))
return row, err
}
func (r *RedisType) PfAdd(key string, element ...interface{}) (int, error) {
params := make([]interface{}, 0)
params = append(params, key)
for _, v := range element {
params = append(params, v)
}
row, err := redis.Int(r.RedisConn.Do("PFADD", params))
return row, err
}
func (r *RedisType) ZScore(key, member string) (interface{}, error) {
params := make([]interface{}, 0)
params = append(params, key)
params = append(params, member)
row, err := redis.Int(r.RedisConn.Do("ZSCORE", params...))
if err == redis.ErrNil {
return nil, nil
}
return row, err
}
func (r *RedisType) ZUnionStore(destination string, numkeys int, key interface{}, weights ...interface{}) (interface{}, error) {
params := make([]interface{}, 0)
params = append(params, destination)
params = append(params, numkeys)
switch key.(type) {
case string:
params = append(params, key)
case []string:
for _, v := range key.([]string) {
params = append(params, v)
}
}
if len(weights) > 0 {
for _, v := range weights {
params = append(params, v)
}
}
row, err := redis.Int(r.RedisConn.Do("ZUNIONSTORE", params...))
if err == redis.ErrNil {
return nil, nil
}
return row, err
}
func (r *RedisType) SMove(source, destination string, member interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("SMOVE", source, destination, member))
return row, err
}
func (r *RedisType) SInterScore(destination string, key ...interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("SINTERSTORE", destination, key))
return row, err
}
func (r *RedisType) SCard(key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("SCARD", key))
return row, err
}
//zlexcount key min max
func (r *RedisType) ZLexCount(key string, min, max int) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZLEXCOUNT", key, min, max))
return row, err
}
func (r *RedisType) DecrBy(key string, decrement interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("DECRBY", key, decrement))
return row, err
}
func (r *RedisType) Publish(channel string, message interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("PUBLISH", channel, message))
return row, err
}
func (r *RedisType) Expire(key string, seconds uint32) (int, error) {
row, err := redis.Int(r.RedisConn.Do("EXPIRE", key, seconds))
return row, err
}
func (r *RedisType) Append(key string, value interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("APPEND", key, value))
return row, err
}
func (r *RedisType) StrLen(key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("STRLEN", key))
return row, err
}
func (r *RedisType) ExpireAt(key string, timestamp uint32) (int, error) {
row, err := redis.Int(r.RedisConn.Do("EXPIREAT", key, timestamp))
return row, err
}
func (r *RedisType) Incr(key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("INCR", key))
return row, err
}
func (r *RedisType) ZRemRangeByScore(key string, min, max int) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZREMRANGEBYSCORE", key, min, max))
return row, err
}
func (r *RedisType) ZRemRangeByRank(key string, start, stop int) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZREMRANGEBYRANK", key, start, stop))
return row, err
}
func (r *RedisType) BitOp(operation, destkey, key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("BITOP", operation, destkey, key))
return row, err
}
func (r *RedisType) SUnionStore(destination, key string) (int, error) {
row, err := redis.Int(r.RedisConn.Do("SUNIONSTORE", destination, key))
return row, err
}
func (r *RedisType) GetBit(key string, offset interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("GETBIT", key, offset))
return row, err
}
func (r *RedisType) ZIncrBy(key string, member interface{}, increment interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("ZINCRBY", key, increment, member))
return row, err
}
func (r *RedisType) PfCount(key ...interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("PFCOUNT", key))
return row, err
}
func (r *RedisType) Move(key string, db int) (int, error) {
row, err := redis.Int(r.RedisConn.Do("MOVE", key, db))
return row, err
}
func (r *RedisType) SetRange(key string, offset interface{}, value interface{}) (int, error) {
row, err := redis.Int(r.RedisConn.Do("SETRANGE", key, offset, value))
return row, err
}