redis

package
v0.0.0-...-273cdd3 Latest Latest
Warning

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

 Go to latest Published: Dec 3, 2020 License: BSD-3-Clause Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	OK   = "OK"
	PING = "PING"
	PONG = "PONG"

	// key
	DEL    = "DEL"
	EXISTS = "EXISTS"
	INCRBY = "INCRBY"

	// string
	SET = "SET"
	NX  = "NX"
	EX  = "EX"
	GET = "GET"

	// hash
	HDEL    = "HDEL"
	HSET    = "HSET"
	HGET    = "HGET"
	HMGET   = "HMGET"
	HGETALL = "HGETALL"
	HINCRBY = "HINCRBY"
	HEXISTS = "HEXISTS"

	// set
	SADD      = "SADD"
	SREM      = "SREM"
	SMEMBERS  = "SMEMBERS"
	SISMEMBER = "SISMEMBER"

	// sorted set
	ZINCRBY    = "ZINCRBY"
	ZREVRANGE  = "ZREVRANGE"
	ZSCORE     = "ZSCORE"
	ZREVRANK   = "ZREVRANK"
	WITHSCORES = "WITHSCORES"
)

Variables

View Source 
var (
	ErrAtomicLockFailed   = errors.New("lock failed")
	ErrAtomicUnlockFailed = errors.New("unlock failed")
)

Functions

This section is empty.

Types

type Atomic 

type Atomic struct {
	// contains filtered or unexported fields
}

func (*Atomic) Exec 

func (atomic *Atomic) Exec(handler func()) (ok bool, err error)

func (*Atomic) Expired 

func (atomic *Atomic) Expired(duration time.Duration) *Atomic

func (*Atomic) Lock 

func (atomic *Atomic) Lock() error

func (*Atomic) Ticker 

func (atomic *Atomic) Ticker(duration time.Duration) *Atomic

func (*Atomic) Timeout 

func (atomic *Atomic) Timeout(duration time.Duration) *Atomic

func (*Atomic) Unlock 

func (atomic *Atomic) Unlock() error

type Client 

type Client struct {
	// contains filtered or unexported fields
}

func New 

func New(option Option) (*Client, error)

func (*Client) Atomic 

func (client *Client) Atomic(key string) *Atomic

func (*Client) Eval 

func (client *Client) Eval(script *Script) *Eval

func (*Client) Exec 

func (client *Client) Exec(cmd string, args ...interface{}) (interface{}, error)

func (*Client) Hash 

func (client *Client) Hash(key string) *Hash

func (*Client) Key 

func (client *Client) Key() *Key

func (*Client) Set 

func (client *Client) Set(key string) *Set

func (*Client) Singleton 

func (client *Client) Singleton(key string) *Singleton

func (*Client) ZOrder 

func (client *Client) ZOrder(key string) *ZOrder

type Eval 

type Eval struct {
	// contains filtered or unexported fields
}

func (*Eval) Do 

func (eval *Eval) Do(args ...interface{}) (interface{}, error)

func (*Eval) Exec 

func (eval *Eval) Exec(value interface{}, args ...interface{}) error

func (*Eval) Load 

func (eval *Eval) Load() error

type EvalLog 

type EvalLog struct {
	Name     string
	Request  []interface{}
	Response interface{}
	Error    error
}

func (*EvalLog) String 

func (log *EvalLog) String() string

type ExecLog 

type ExecLog struct {
	Command  string
	Request  []interface{}
	Response interface{}
	Error    error
}

func (*ExecLog) String 

func (log *ExecLog) String() string

type Hash 

type Hash struct {
	// contains filtered or unexported fields
}

func (*Hash) Consume 

func (hash *Hash) Consume(field interface{}, increment int64) (int64, bool, error)

func (*Hash) Delete 

func (hash *Hash) Delete(fields ...interface{}) error

HDEL key field [field ...]

删除哈希表 key 中的一个或多个指定域, 不存在的域将被忽略.

可用版本: >= 2.0.0 时间复杂度: O(N), N 为要删除的域的数量.

返回值: 

被成功移除的域的数量, 不包括被忽略的域.

func (*Hash) Get 

func (hash *Hash) Get(field, value interface{}) (bool, error)

HGET key field

返回哈希表 key 中给定域 field 的值。

可用版本: >= 2.0.0 时间复杂度: O(1)

返回值: 

给定域的值.
当给定域不存在或是给定 key 不存在时, 返回 nil .

func (*Hash) GetAll 

func (hash *Hash) GetAll(value interface{}) error

HGETALL key

返回哈希表 key 中, 所有的域和值. 在返回值里, 紧跟每个域名(field name)之后是域的值(value), 所以返回值的长度是哈希表大小的两倍.

可用版本: >= 2.0.0 时间复杂度: O(N), N 为哈希表的大小.

返回值: 

以列表形式返回哈希表的域和域的值.
若 key 不存在, 返回空列表.

func (*Hash) Gets 

func (hash *Hash) Gets(value interface{}, fields ...interface{}) error

HMGET key field [field ...]

返回哈希表 key 中, 一个或多个给定域的值. 如果给定的域不存在于哈希表, 那么返回一个 nil 值. 因为不存在的 key 被当作一个空哈希表来处理, 所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表.

可用版本: >= 2.0.0 时间复杂度: O(N), N 为给定域的数量.

返回值: 

一个包含多个给定域的关联值的表, 表值的排列顺序和给定域参数的请求顺序一样.

func (*Hash) Increase 

func (hash *Hash) Increase(field interface{}, increment int64) (int64, error)

HINCRBY key field increment

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

可用版本: >= 2.0.0 时间复杂度: O(1) 返回值: 

执行 HINCRBY 命令之后, 哈希表 key 中域 field 的值.

func (*Hash) Set 

func (hash *Hash) Set(field, value interface{}) error

HSET key field value

将哈希表 key 中的域 field 的值设为 value . 如果 key 不存在, 一个新的哈希表被创建并进行 HSET 操作. 如果域 field 已经存在于哈希表中, 旧值将被覆盖.

可用版本: >= 2.0.0 时间复杂度: O(1)

返回值: 

如果 field 是哈希表中的一个新建域, 并且值设置成功, 返回 1 .
如果哈希表中域 field 已经存在且旧值已被新值覆盖, 返回 0 .

type Key 

type Key struct {
	// contains filtered or unexported fields
}

func (*Key) Delete 

func (k *Key) Delete(keys ...interface{}) error

DEL key [key ...]

删除给定的一个或多个 key . 不存在的 key 会被忽略.

可用版本: >= 1.0.0 时间复杂度: 

O(N), N 为被删除的 key 的数量.
删除单个字符串类型的 key , 时间复杂度为O(1).
删除单个列表、集合、有序集合或哈希表类型的 key , 时间复杂度为O(M) , M 为以上数据结构内的元素数量.

返回值: 

被删除 key 的数量.

func (*Key) Exist 

func (k *Key) Exist(key interface{}) (bool, error)

EXISTS key

检查给定 key 是否存在.

可用版本: >= 1.0.0 时间复杂度: O(1)

返回值: 

若 key 存在, 返回 1 , 否则返回 0 .

func (*Key) Get 

func (k *Key) Get(key, value interface{}) (bool, error)

GET key

返回 key 所关联的字符串值. 如果 key 不存在那么返回特殊值 nil . 假如 key 储存的值不是字符串类型, 返回一个错误, 因为 GET 只能用于处理字符串值.

可用版本: >= 1.0.0 时间复杂度: O(1) 返回值: 

当 key 不存在时, 返回 nil , 否则，返回 key 的值.
如果 key 不是字符串类型, 那么返回一个错误.

func (*Key) Incr 

func (k *Key) Incr(key interface{}, increment int64) (int64, error)

INCRBY key increment

将 key 所储存的值加上增量 increment . 如果 key 不存在, 那么 key 的值会先被初始化为 0 , 然后再执行 INCRBY 命令. 如果值包含错误的类型, 或字符串类型的值不能表示为数字, 那么返回一个错误. 本操作的值限制在 64 位(bit)有符号数字表示之内. 关于递增(increment) / 递减(decrement)操作的更多信息, 参见 INCR 命令.

可用版本: >= 1.0.0 时间复杂度: O(1)

返回值: 

加上 increment 之后 key 的值.

func (*Key) Set 

func (k *Key) Set(key, value interface{}) error

SET key value [EX seconds] [PX milliseconds] [NX|XX]

将字符串值 value 关联到 key . 如果 key 已经持有其他值, SET 就覆写旧值, 无视类型. 对于某个原本带有生存时间(TTL)的键来说, 当 SET 命令成功在这个键上执行时, 这个键原有的 TTL 将被清除.

可选参数: 

EX second: 设置键的过期时间为 second 秒.
PX millisecond: 设置键的过期时间为 millisecond 毫秒.
NX: 只在键不存在时, 才对键进行设置操作.
XX: 只在键已经存在时, 才对键进行设置操作.

可用版本: >= 2.6.12 时间复杂度: O(1)

返回值： 

SET 在设置操作成功完成时, 才返回 OK .
如果设置了 NX 或者 XX , 但因为条件没达到而造成设置操作未执行, 那么命令返回空批量回复(NULL Bulk Reply).

func (*Key) SetEX 

func (k *Key) SetEX(key, value interface{}, second int64) error

func (*Key) SetNEX 

func (k *Key) SetNEX(key, value interface{}, second int64) (bool, error)

func (*Key) SetNX 

func (k *Key) SetNX(key, value interface{}) (bool, error)

type Option 

type Option struct {
	Network   string     // 网络类型
	Address   string     // 地址
	Password  string     // 密码
	Database  int        // 数据库
	MaxIdle   int        // 最大空闲连接数
	MaxActive int        // 最大活跃连接数
	Logger    log.Logger // 日志接口
}

type Script 

type Script struct {
	Name   string
	Script *redis.Script
}

func NewScript 

func NewScript(name string, keys int, src string) *Script

type Set 

type Set struct {
	// contains filtered or unexported fields
}

func (*Set) Add 

func (set *Set) Add(members ...interface{}) error

SADD key member [member ...]

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

可用版本: >= 1.0.0 时间复杂度: O(N), N 为被添加的元素的数量.

返回值: 

被添加到集合中的新元素的数量, 不包括被忽略的元素.

func (*Set) Keys 

func (set *Set) Keys(value interface{}) error

SMEMBERS key

返回集合 key 中的所有成员. 不存在的 key 被视为空集合.

可用版本: >= 1.0.0 时间复杂度: O(N), N 为集合的基数.

返回值: 

集合中的所有成员.

func (*Set) Remove 

func (set *Set) Remove(members ...interface{}) error

SREM key member [member ...]

移除集合 key 中的一个或多个 member 元素, 不存在的 member 元素会被忽略. 当 key 不是集合类型, 返回一个错误.

可用版本: >= 1.0.0 时间复杂度: O(N), N 为给定 member 元素的数量.

返回值: 

被成功移除的元素的数量, 不包括被忽略的元素.

type Singleton 

type Singleton struct {
	// contains filtered or unexported fields
}

func (*Singleton) Exec 

func (singleton *Singleton) Exec(handler func()) (bool, error)

type ZOrder 

type ZOrder struct {
	// contains filtered or unexported fields
}

func (*ZOrder) Incr 

func (order *ZOrder) Incr(member interface{}, increment int64) (int64, error)

func (*ZOrder) Range 

func (order *ZOrder) Range(value interface{}, start, stop int) error

ZREVRANGE key start stop WITHSCORES

返回有序集 key 中, 指定区间内的成员. 其中成员的位置按 score 值递增(从大到小)来排序. 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)来排列. 如果你需要成员按 score 值递减(从小到大)来排列, 请使用 ZRANGE 命令.

下标参数 start 和 stop 都以 0 为底, 以 0 表示有序集第一个成员, 以 1 表示有序集第二个成员, 以此类推. 也可以使用负数下标, 以 -1 表示最后一个成员, -2 表示倒数第二个成员, 以此类推.

超出范围的下标并不会引起错误. 当 start 的值比有序集的最大下标还要大, 或是 start > stop 时, ZRANGE 命令只是简单地返回一个空列表. 假如 stop 参数的值比有序集的最大下标还要大, 那么 Redis 将 stop 当作最大下标来处理. 可以通过使用 WITHSCORES 选项, 来让成员和它的 score 值一并返回, 返回列表以 value1,score1, ..., valueN,scoreN 的格式表示.

可用版本: >= 1.2.0 时间复杂度: O(log(N)+M), N 为有序集的基数, 而 M 为结果集的基数.

返回值: 

指定区间内, 带有 score 值(可选)的有序集成员的列表.

func (*ZOrder) Rank 

func (order *ZOrder) Rank(member interface{}) (int64, bool, error)

ZREVRANK key member

返回有序集 key 中成员 member 的排名. 其中有序集成员按 score 值递减(从大到小)排序. 排名以 0 开始, 也就是说, score 值最大的成员排名为 0. 使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名.

可用版本: >= 2.0.0 时间复杂度: O(log(N))

返回值: 

如果 member 是有序集 key 的成员, 返回 member 的排名.
如果 member 不是有序集 key 的成员, 返回 nil.

func (*ZOrder) Score 

func (order *ZOrder) Score(member interface{}) (int64, bool, error)

ZSCORE key member

返回有序集 key 中, 成员 member 的 score 值. 如果 member 元素不是有序集 key 的成员, 或 key 不存在, 返回 nil .

可用版本: >= 1.2.0 时间复杂度: O(1)

返回值: 

member 成员的 score 值, 以字符串形式表示.

Source Files

View all Source files

Directories

Path Synopsis

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.