forked from mirror/redis
134 lines
3.2 KiB
Go
134 lines
3.2 KiB
Go
/*
|
|
Package github.com/vmihailenco/redis implements a Redis client.
|
|
|
|
Let's start with connecting to Redis using TCP:
|
|
|
|
password := "" // no password set
|
|
db := int64(-1) // use default DB
|
|
client := redis.NewTCPClient("localhost:6379", password, db)
|
|
defer client.Close()
|
|
|
|
ping := client.Ping()
|
|
fmt.Println(ping.Err(), ping.Val())
|
|
// Output: <nil> PONG
|
|
|
|
or using Unix socket:
|
|
|
|
client := redis.NewUnixClient("/tmp/redis.sock", "", -1)
|
|
defer client.Close()
|
|
|
|
ping := client.Ping()
|
|
fmt.Println(ping.Err(), ping.Val())
|
|
// Output: <nil> PONG
|
|
|
|
Then we can start sending commands:
|
|
|
|
set := client.Set("foo", "bar")
|
|
fmt.Println(set.Err(), set.Val())
|
|
|
|
get := client.Get("foo")
|
|
fmt.Println(get.Err(), get.Val())
|
|
|
|
// Output: <nil> OK
|
|
// <nil> bar
|
|
|
|
We can also pipeline two commands together:
|
|
|
|
var set *redis.StatusReq
|
|
var get *redis.StringReq
|
|
reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
|
|
set = c.Set("key1", "hello1")
|
|
get = c.Get("key2")
|
|
})
|
|
fmt.Println(err, reqs)
|
|
fmt.Println(set)
|
|
fmt.Println(get)
|
|
// Output: <nil> [SET key1 hello1: OK GET key2: (nil)]
|
|
// SET key1 hello1: OK
|
|
// GET key2: (nil)
|
|
|
|
or:
|
|
|
|
var set *redis.StatusReq
|
|
var get *redis.StringReq
|
|
reqs, err := client.Pipelined(func(c *redis.PipelineClient) {
|
|
set = c.Set("key1", "hello1")
|
|
get = c.Get("key2")
|
|
})
|
|
fmt.Println(err, reqs)
|
|
fmt.Println(set)
|
|
fmt.Println(get)
|
|
// Output: <nil> [SET key1 hello1 GET key2]
|
|
// SET key1 hello1
|
|
// GET key2
|
|
|
|
We can also send several commands in transaction:
|
|
|
|
func transaction(multi *redis.MultiClient) ([]redis.Req, error) {
|
|
get := multi.Get("key")
|
|
if err := get.Err(); err != nil && err != redis.Nil {
|
|
return nil, err
|
|
}
|
|
|
|
val, _ := strconv.ParseInt(get.Val(), 10, 64)
|
|
|
|
reqs, err := multi.Exec(func() {
|
|
multi.Set("key", strconv.FormatInt(val+1, 10))
|
|
})
|
|
// Transaction failed. Repeat.
|
|
if err == redis.Nil {
|
|
return transaction(multi)
|
|
}
|
|
return reqs, err
|
|
}
|
|
|
|
multi, err := client.MultiClient()
|
|
_ = err
|
|
defer multi.Close()
|
|
|
|
watch := multi.Watch("key")
|
|
_ = watch.Err()
|
|
|
|
reqs, err := transaction(multi)
|
|
fmt.Println(err, reqs)
|
|
|
|
// Output: <nil> [SET key 1: OK]
|
|
|
|
To subscribe to the channel:
|
|
|
|
pubsub, err := client.PubSubClient()
|
|
defer pubsub.Close()
|
|
|
|
ch, err := pubsub.Subscribe("mychannel")
|
|
_ = err
|
|
|
|
subscribeMsg := <-ch
|
|
fmt.Println(subscribeMsg.Err, subscribeMsg.Name)
|
|
|
|
pub := client.Publish("mychannel", "hello")
|
|
_ = pub.Err()
|
|
|
|
msg := <-ch
|
|
fmt.Println(msg.Err, msg.Message)
|
|
|
|
// Output: <nil> subscribe
|
|
// <nil> hello
|
|
|
|
You can also write custom commands:
|
|
|
|
func Get(client *redis.Client, key string) *redis.StringReq {
|
|
req := redis.NewStringReq("GET", key)
|
|
client.Process(req)
|
|
return req
|
|
}
|
|
|
|
get := Get(client, "key_does_not_exist")
|
|
fmt.Println(get.Err(), get.Val())
|
|
// Output: (nil)
|
|
|
|
Client uses connection pool to send commands. You can change maximum number of connections with:
|
|
|
|
client.ConnPool.(*redis.MultiConnPool).MaxCap = 1
|
|
*/
|
|
package redis
|