cluster

package
v1.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 17, 2024 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Redis 

type Redis struct {
	Encode func(value interface{}) (result []byte, err error)
	Decode func(value []byte, result interface{}) (err error)
	// contains filtered or unexported fields
}

func NewSys 

func NewSys(RedisUrl []string, RedisPassword string, timeOut time.Duration,
	encode func(value interface{}) (result []byte, err error),
	decode func(value []byte, result interface{}) (err error),
) (sys *Redis, err error)

func (*Redis) Append 

func (this *Redis) Append(key string, value interface{}) (err error)

Redis Append 命令用于为指定的 key 追加值。 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。

func (*Redis) Close 

func (this *Redis) Close() (err error)

/事务

func (*Redis) Decr 

func (this *Redis) Decr(key string, value int) (err error)

Redis Decr 命令将 key 中储存的数字值减一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内

func (*Redis) DecrBy 

func (this *Redis) DecrBy(key string, value int) (err error)

Redis Decrby 命令将 key 所储存的值减去指定的减量值。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内

func (*Redis) Delete 

func (this *Redis) Delete(key string) (err error)

/删除redis key

func (*Redis) Do 

func (this *Redis) Do(ctx context.Context, args ...interface{}) *redis.Cmd

/ 命令接口

func (*Redis) ExistsKey 

func (this *Redis) ExistsKey(key string) (iskeep bool, err error)

/判断是否存在key

func (*Redis) ExpireKey 

func (this *Redis) ExpireKey(key string, expire int) (err error)

/设置key的过期时间 单位以秒级

func (*Redis) ExpireatKey 

func (this *Redis) ExpireatKey(key string, expire_unix int64) (err error)

/设置key的过期时间戳 秒级时间戳

func (*Redis) Get 

func (this *Redis) Get(key string, value interface{}) (err error)

命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型

func (*Redis) GetSet 

func (this *Redis) GetSet(key string, value interface{}, result interface{}) (err error)

设置指定 key 的值，并返回 key 的旧值

func (*Redis) HDel 

func (this *Redis) HDel(key string, fields ...string) (err error)

Redis Hdel 命令用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略

func (*Redis) HExists 

func (this *Redis) HExists(key string, field string) (result bool, err error)

Redis Hexists 命令用于查看哈希表的指定字段是否存在

func (*Redis) HGet 

func (this *Redis) HGet(key string, field string, value interface{}) (err error)

Redis Hget 命令用于返回哈希表中指定字段的值

func (*Redis) HGetAll 

func (this *Redis) HGetAll(key string, valuetype reflect.Type) (result []interface{}, err error)

Redis Hgetall 命令用于返回哈希表中，所有的字段和值。 在返回值里，紧跟每个字段名(field name)之后是字段的值(value)，所以返回值的长度是哈希表大小的两倍

func (*Redis) HIncrBy 

func (this *Redis) HIncrBy(key string, field string, value int) (err error)

Redis Hincrby 命令用于为哈希表中的字段值加上指定增量值。 增量也可以为负数，相当于对指定字段进行减法操作。 如果哈希表的 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。 如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0 。 对一个储存字符串值的字段执行 HINCRBY 命令将造成一个错误。 本操作的值被限制在 64 位(bit)有符号数字表示之内

func (*Redis) HIncrByFloat 

func (this *Redis) HIncrByFloat(key string, field string, value float32) (err error)

Redis Hincrbyfloat 命令用于为哈希表中的字段值加上指定浮点数增量值。 如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0

func (*Redis) HMGet 

func (this *Redis) HMGet(key string, valuetype reflect.Type, fields ...string) (result []interface{}, err error)

Redis Hmget 命令用于返回哈希表中，一个或多个给定字段的值。 如果指定的字段不存在于哈希表，那么返回一个 nil 值

func (*Redis) HMSet 

func (this *Redis) HMSet(key string, value map[string]interface{}) (err error)

Redis Hmset 命令用于同时将多个 field-value (字段-值)对设置到哈希表中。 此命令会覆盖哈希表中已存在的字段。 如果哈希表不存在，会创建一个空哈希表，并执行 HMSET 操作

func (*Redis) HSet 

func (this *Redis) HSet(key string, field string, value interface{}) (err error)

Redis Hset 命令用于为哈希表中的字段赋值 如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作 如果字段已经存在于哈希表中，旧值将被覆盖

func (*Redis) HSetNX 

func (this *Redis) HSetNX(key string, field string, value interface{}) (err error)

Redis Hsetnx 命令用于为哈希表中不存在的的字段赋值 如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作 如果字段已经存在于哈希表中，操作无效 如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令

func (*Redis) Hkeys 

func (this *Redis) Hkeys(key string) (result []string, err error)

Redis Hkeys 命令用于获取哈希表中的所有域(field)

func (*Redis) Hlen 

func (this *Redis) Hlen(key string) (result int, err error)

Redis Hlen 命令用于获取哈希表中字段的数量

func (*Redis) INCRBY 

func (this *Redis) INCRBY(key string, amount int64) (result int64, err error)

/判断是否存在key pattern:key*

func (*Redis) Incr 

func (this *Redis) Incr(key string) (err error)

Redis Incr 命令将 key 中储存的数字值增一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。

func (*Redis) IncrBY 

func (this *Redis) IncrBY(key string, value int) (err error)

Redis Incrby 命令将 key 中储存的数字加上指定的增量值。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内

func (*Redis) Incrbyfloat 

func (this *Redis) Incrbyfloat(key string, value float32) (err error)

Redis Incrbyfloat 命令为 key 中所储存的值加上指定的浮点数增量值。 如果 key 不存在，那么 INCRBYFLOAT 会先将 key 的值设为 0 ，再执行加法操作

func (*Redis) Keys 

func (this *Redis) Keys(pattern string) (keys []string, err error)

/判断是否存在key pattern:key*

func (*Redis) LPop 

func (this *Redis) LPop(key string, value interface{}) (err error)

Redis Lpop 命令用于移除并返回列表的第一个元素

func (*Redis) LPush 

func (this *Redis) LPush(key string, values ...interface{}) (err error)

Redis Lpush 命令将一个或多个值插入到列表头部。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误

func (*Redis) LPushX 

func (this *Redis) LPushX(key string, values ...interface{}) (err error)

Redis Lpushx 将一个值插入到已存在的列表头部，列表不存在时操作无效

func (*Redis) LRange 

func (this *Redis) LRange(key string, start, end int, valuetype reflect.Type) (result []interface{}, err error)

Redis Lrange 返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素， 以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推

func (*Redis) LRem 

func (this *Redis) LRem(key string, count int, target interface{}) (err error)

Redis Lrem 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。 COUNT 的值可以是以下几种： count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。 count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。 count = 0 : 移除表中所有与 VALUE 相等的值

func (*Redis) LSet 

func (this *Redis) LSet(key string, index int, value interface{}) (err error)

Redis Lset 通过索引来设置元素的值。 当索引参数超出范围，或对一个空列表进行 LSET 时，返回一个错误

func (*Redis) Lindex 

func (this *Redis) Lindex(key string, value interface{}) (err error)

Redis Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推

func (*Redis) Linsert 

func (this *Redis) Linsert(key string, isbefore bool, tager interface{}, value interface{}) (err error)

Redis Linsert 命令用于在列表的元素前或者后插入元素。当指定元素不存在于列表中时，不执行任何操作。 当列表不存在时，被视为空列表，不执行任何操作。 如果 key 不是列表类型，返回一个错误

func (*Redis) Llen 

func (this *Redis) Llen(key string) (result int, err error)

Redis Llen 命令用于返回列表的长度。 如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。 如果 key 不是列表类型，返回一个错误

func (*Redis) Lock 

func (this *Redis) Lock(key string, outTime int) (result bool, err error)

锁

func (*Redis) Ltrim 

func (this *Redis) Ltrim(key string, start, stop int) (err error)

Redis Ltrim 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。 下标 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标， 以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推

func (*Redis) MGet 

func (this *Redis) MGet(keys ...string) (result []string, err error)

返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil

func (*Redis) MSet 

func (this *Redis) MSet(keyvalues map[string]interface{}) (err error)

同时设置一个或多个 key-value 对

func (*Redis) MSetNX 

func (this *Redis) MSetNX(keyvalues map[string]interface{}) (err error)

命令用于所有给定 key 都不存在时，同时设置一个或多个 key-value 对

func (*Redis) PersistKey 

func (this *Redis) PersistKey(key string) (err error)

/移除Key的过期时间

func (*Redis) PexpireatKey 

func (this *Redis) PexpireatKey(key string, expire_unix int64) (err error)

/设置key的过期时间戳 单位以豪秒级

func (*Redis) Pexpirekey 

func (this *Redis) Pexpirekey(key string, expire int) (err error)

/设置key的过期时间 单位以毫秒级

func (*Redis) Ping 

func (this *Redis) Ping() (string, error)

/ Ping

func (*Redis) Pipeline 

func (this *Redis) Pipeline(ctx context.Context, fn func(pipe redis.Pipeliner) error) (err error)

/批处理

func (*Redis) PttlKey 

func (this *Redis) PttlKey(key string) (leftexpire int64, err error)

/获取key剩余过期时间 单位毫秒

func (*Redis) RPopLPush 

func (this *Redis) RPopLPush(oldkey string, newkey string, value interface{}) (err error)

Redis Rpoplpush 命令用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回

func (*Redis) RPush 

func (this *Redis) RPush(key string, values ...interface{}) (err error)

Redis Rpush 命令用于将一个或多个值插入到列表的尾部(最右边)。 如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。 注意：在 Redis 2.4 版本以前的 RPUSH 命令，都只接受单个 value 值

func (*Redis) RPushX 

func (this *Redis) RPushX(key string, values ...interface{}) (err error)

Redis Rpushx 命令用于将一个值插入到已存在的列表尾部(最右边)。如果列表不存在，操作无效

func (*Redis) RenameKye 

func (this *Redis) RenameKye(oldkey string, newkey string) (err error)

/重命名Key

func (*Redis) RenamenxKey 

func (this *Redis) RenamenxKey(oldkey string, newkey string) (err error)

/重命名key 在新的 key 不存在时修改 key 的名称

func (*Redis) Rpop 

func (this *Redis) Rpop(key string, value interface{}) (err error)

Redis Rpop 命令用于移除列表的最后一个元素，返回值为移除的元素

func (*Redis) SAdd 

func (this *Redis) SAdd(key string, values ...interface{}) (err error)

Redis Sadd 命令将一个或多个成员元素加入到集合中，已经存在于集合的成员元素将被忽略。 假如集合 key 不存在，则创建一个只包含添加的元素作成员的集合。 当集合 key 不是集合类型时，返回一个错误。

func (*Redis) SCard 

func (this *Redis) SCard(key string) (result int64, err error)

Redis Scard 命令返回集合中元素的数量

func (*Redis) SDiff 

func (this *Redis) SDiff(valuetype reflect.Type, keys ...string) (result []interface{}, err error)

Redis Sdiff 命令返回第一个集合与其他集合之间的差异，也可以认为说第一个集合中独有的元素。不存在的集合 key 将视为空集。 差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1，也不是整个 FIRST_KEY OTHER_KEY1..OTHER_KEYN 的差集。 实例:

func (*Redis) SDiffStore 

func (this *Redis) SDiffStore(destination string, keys ...string) (result int64, err error)

Redis Sdiffstore 命令将给定集合之间的差集合存储在指定的集合中。

func (*Redis) SInter 

func (this *Redis) SInter(valuetype reflect.Type, keys ...string) (result []interface{}, err error)

Redis Sismember 命令返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

func (*Redis) SInterStore 

func (this *Redis) SInterStore(destination string, keys ...string) (result int64, err error)

Redis Sinterstore 决定将给定集合之间的交集在指定的集合中。如果指定的集合已经存在，则将其覆盖

func (*Redis) SMembers 

func (this *Redis) SMembers(valuetype reflect.Type, key string) (result []interface{}, err error)

Redis Smembers 号召返回集合中的所有成员。

func (*Redis) SMove 

func (this *Redis) SMove(source string, destination string, member interface{}) (result bool, err error)

Redis Smove 命令将指定成员 member 元素从 source 集合移动到 destination 集合。 SMOVE 是原子性操作。 如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。 当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。 当 source 或 destination 不是集合类型时，返回一个错误。

func (*Redis) SRem 

func (this *Redis) SRem(key string, members ...interface{}) (result int64, err error)

Redis Srem 呼吁用于移除集合中的一个或多个元素元素，不存在的元素元素会被忽略。 当键不是集合类型，返回一个错误。 在 Redis 2.4 版本以前，SREM 只接受个别成员值。

func (*Redis) SUnion 

func (this *Redis) SUnion(valuetype reflect.Type, keys ...string) (result []interface{}, err error)

Redis Sunion 命令返回给定集合的并集。

func (*Redis) Set 

func (this *Redis) Set(key string, value interface{}, expiration time.Duration) (err error)
String ******************************************************************************

命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。

func (*Redis) SetNX 

func (this *Redis) SetNX(key string, value interface{}) (result int64, err error)

指定的 key 不存在时，为 key 设置指定的值

func (*Redis) Sismember 

func (this *Redis) Sismember(key string, value interface{}) (iskeep bool, err error)

Redis Sismember 命令判断成员元素是否是集合的成员

func (*Redis) Spop 

func (this *Redis) Spop(key string) (result string, err error)

Redis Spop命令用于移除集合中的指定键的一个或多个随机元素，移除后会返回移除的元素。 该命令类似于Srandmember命令，但SPOP将随机元素从集合中移除并返回，而Srandmember则返回元素，而不是对集合进行任何改动。

func (*Redis) Srandmember 

func (this *Redis) Srandmember(key string) (result string, err error)

Redis Srandmember 命令用于返回集合中的一个随机元素。 从 Redis 2.6 版本开始， Srandmember 命令接受可选的 count 参数： 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。 该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 Srandmember 则仅仅返回随机元素，而不对集合进行任何改动。

func (*Redis) Sscan 

func (this *Redis) Sscan(key string, _cursor uint64, match string, count int64) (keys []string, cursor uint64, err error)

Redis Sscan 用于继承集合中键的元素，Sscan 继承自Scan。

func (*Redis) Sunionstore 

func (this *Redis) Sunionstore(destination string, keys ...string) (result int64, err error)

Redis Sunionstore 命令将给定集合的并集存储在指定的集合 destination 中。如果 destination 已经存在，则将其覆盖。

func (*Redis) TtlKey 

func (this *Redis) TtlKey(key string) (leftexpire int64, err error)

/获取key剩余过期时间 单位秒

func (*Redis) TxPipelined 

func (this *Redis) TxPipelined(ctx context.Context, fn func(pipe redis.Pipeliner) error) (err error)

/事务

func (*Redis) Type 

func (this *Redis) Type(key string) (ty string, err error)

/获取键类型

func (*Redis) UnLock 

func (this *Redis) UnLock(key string) (err error)

锁

func (*Redis) Watch 

func (this *Redis) Watch(ctx context.Context, fn func(*redis.Tx) error, keys ...string) (err error)

/监控

func (*Redis) ZAdd 

func (this *Redis) ZAdd(key string, members ...*redis.Z) (err error)

Redis ZAdd 向有序集合添加一个或多个成员，或者更新已存在成员的分数

func (*Redis) ZCard 

func (this *Redis) ZCard(key string) (result int64, err error)

Redis Zcard 用于计算集合中元素的数量。

func (*Redis) ZCount 

func (this *Redis) ZCount(key string, min string, max string) (result int64, err error)

Redis ZCount 用于计算集合中指定的范围内的数量

func (*Redis) ZIncrBy 

func (this *Redis) ZIncrBy(key string, increment float64, member string) (result float64, err error)

Redis ZIncrBy 有序集合中对指定成员的分数加上增量 increment

func (*Redis) ZInterStore 

func (this *Redis) ZInterStore(destination string, store *redis.ZStore) (result int64, err error)

Redis ZInterStore 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中

func (*Redis) ZLexCount 

func (this *Redis) ZLexCount(key string, min string, max string) (result int64, err error)

Redis ZLexCount 在有序集合中计算指定字典区间内成员数量

func (*Redis) ZRange 

func (this *Redis) ZRange(valuetype reflect.Type, key string, start int64, stop int64) (result []interface{}, err error)

Redis ZRange 通过索引区间返回有序集合指定区间内的成员

func (*Redis) ZRangeByLex 

func (this *Redis) ZRangeByLex(valuetype reflect.Type, key string, opt *redis.ZRangeBy) (result []interface{}, err error)

Redis ZRangeByLex 通过字典区间返回有序集合的成员

func (*Redis) ZRangeByScore 

func (this *Redis) ZRangeByScore(valuetype reflect.Type, key string, opt *redis.ZRangeBy) (result []interface{}, err error)

Redis ZRangeByScore 通过分数返回有序集合指定区间内的成员

func (*Redis) ZRank 

func (this *Redis) ZRank(key string, member string) (result int64, err error)

Redis ZRank 返回有序集合中指定成员的索引

func (*Redis) ZRem 

func (this *Redis) ZRem(key string, members ...interface{}) (result int64, err error)

Redis ZRem 移除有序集合中的一个或多个成员

func (*Redis) ZRemRangeByLex 

func (this *Redis) ZRemRangeByLex(key string, min string, max string) (result int64, err error)

Redis ZRemRangeByLex 移除有序集合中给定的字典区间的所有成员

func (*Redis) ZRemRangeByRank 

func (this *Redis) ZRemRangeByRank(key string, start int64, stop int64) (result int64, err error)

Redis ZRemRangeByRank 移除有序集合中给定的排名区间的所有成员

func (*Redis) ZRemRangeByScore 

func (this *Redis) ZRemRangeByScore(key string, min string, max string) (result int64, err error)

Redis ZRemRangeByScore 移除有序集合中给定的分数区间的所有成员

func (*Redis) ZRevRange 

func (this *Redis) ZRevRange(valuetype reflect.Type, key string, start int64, stop int64) (result []interface{}, err error)

Redis ZRevRange 返回有序集中指定区间内的成员，通过索引，分数从高到低 ZREVRANGE

func (*Redis) ZRevRangeByScore 

func (this *Redis) ZRevRangeByScore(valuetype reflect.Type, key string, opt *redis.ZRangeBy) (result []interface{}, err error)

Redis ZRevRangeByScore 返回有序集中指定分数区间内的成员，分数从高到低排序

func (*Redis) ZRevRank 

func (this *Redis) ZRevRank(key string, member string) (result int64, err error)

Redis ZRevRank 返回有序集中指定分数区间内的成员，分数从高到低排序

func (*Redis) ZScan 

func (this *Redis) ZScan(key string, _cursor uint64, match string, count int64) (keys []string, cursor uint64, err error)

Redis ZScan 迭代有序集合中的元素（包括元素成员和元素分值）

func (*Redis) ZScore 

func (this *Redis) ZScore(key string, member string) (result float64, err error)

Redis ZScore 返回有序集中指定分数区间内的成员，分数从高到低排序

func (*Redis) ZUnionStore 

func (this *Redis) ZUnionStore(dest string, store *redis.ZStore) (result int64, err error)

Redis ZScore 返回有序集中指定分数区间内的成员，分数从高到低排序 ZUNIONSTORE

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.