summaryrefslogtreecommitdiffstats
path: root/dependencies/pkg/mod/github.com/go-redis/redis/v8@v8.11.5/example_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'dependencies/pkg/mod/github.com/go-redis/redis/v8@v8.11.5/example_test.go')
-rw-r--r--dependencies/pkg/mod/github.com/go-redis/redis/v8@v8.11.5/example_test.go634
1 files changed, 634 insertions, 0 deletions
diff --git a/dependencies/pkg/mod/github.com/go-redis/redis/v8@v8.11.5/example_test.go b/dependencies/pkg/mod/github.com/go-redis/redis/v8@v8.11.5/example_test.go
new file mode 100644
index 0000000..f015809
--- /dev/null
+++ b/dependencies/pkg/mod/github.com/go-redis/redis/v8@v8.11.5/example_test.go
@@ -0,0 +1,634 @@
+package redis_test
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "sync"
+ "time"
+
+ "github.com/go-redis/redis/v8"
+)
+
+var (
+ ctx = context.Background()
+ rdb *redis.Client
+)
+
+func init() {
+ rdb = redis.NewClient(&redis.Options{
+ Addr: ":6379",
+ DialTimeout: 10 * time.Second,
+ ReadTimeout: 30 * time.Second,
+ WriteTimeout: 30 * time.Second,
+ PoolSize: 10,
+ PoolTimeout: 30 * time.Second,
+ })
+}
+
+func ExampleNewClient() {
+ rdb := redis.NewClient(&redis.Options{
+ Addr: "localhost:6379", // use default Addr
+ Password: "", // no password set
+ DB: 0, // use default DB
+ })
+
+ pong, err := rdb.Ping(ctx).Result()
+ fmt.Println(pong, err)
+ // Output: PONG <nil>
+}
+
+func ExampleParseURL() {
+ opt, err := redis.ParseURL("redis://:qwerty@localhost:6379/1?dial_timeout=5s")
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("addr is", opt.Addr)
+ fmt.Println("db is", opt.DB)
+ fmt.Println("password is", opt.Password)
+ fmt.Println("dial timeout is", opt.DialTimeout)
+
+ // Create client as usually.
+ _ = redis.NewClient(opt)
+
+ // Output: addr is localhost:6379
+ // db is 1
+ // password is qwerty
+ // dial timeout is 5s
+}
+
+func ExampleNewFailoverClient() {
+ // See http://redis.io/topics/sentinel for instructions how to
+ // setup Redis Sentinel.
+ rdb := redis.NewFailoverClient(&redis.FailoverOptions{
+ MasterName: "master",
+ SentinelAddrs: []string{":26379"},
+ })
+ rdb.Ping(ctx)
+}
+
+func ExampleNewClusterClient() {
+ // See http://redis.io/topics/cluster-tutorial for instructions
+ // how to setup Redis Cluster.
+ rdb := redis.NewClusterClient(&redis.ClusterOptions{
+ Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
+ })
+ rdb.Ping(ctx)
+}
+
+// Following example creates a cluster from 2 master nodes and 2 slave nodes
+// without using cluster mode or Redis Sentinel.
+func ExampleNewClusterClient_manualSetup() {
+ // clusterSlots returns cluster slots information.
+ // It can use service like ZooKeeper to maintain configuration information
+ // and Cluster.ReloadState to manually trigger state reloading.
+ clusterSlots := func(ctx context.Context) ([]redis.ClusterSlot, error) {
+ slots := []redis.ClusterSlot{
+ // First node with 1 master and 1 slave.
+ {
+ Start: 0,
+ End: 8191,
+ Nodes: []redis.ClusterNode{{
+ Addr: ":7000", // master
+ }, {
+ Addr: ":8000", // 1st slave
+ }},
+ },
+ // Second node with 1 master and 1 slave.
+ {
+ Start: 8192,
+ End: 16383,
+ Nodes: []redis.ClusterNode{{
+ Addr: ":7001", // master
+ }, {
+ Addr: ":8001", // 1st slave
+ }},
+ },
+ }
+ return slots, nil
+ }
+
+ rdb := redis.NewClusterClient(&redis.ClusterOptions{
+ ClusterSlots: clusterSlots,
+ RouteRandomly: true,
+ })
+ rdb.Ping(ctx)
+
+ // ReloadState reloads cluster state. It calls ClusterSlots func
+ // to get cluster slots information.
+ rdb.ReloadState(ctx)
+}
+
+func ExampleNewRing() {
+ rdb := redis.NewRing(&redis.RingOptions{
+ Addrs: map[string]string{
+ "shard1": ":7000",
+ "shard2": ":7001",
+ "shard3": ":7002",
+ },
+ })
+ rdb.Ping(ctx)
+}
+
+func ExampleClient() {
+ err := rdb.Set(ctx, "key", "value", 0).Err()
+ if err != nil {
+ panic(err)
+ }
+
+ val, err := rdb.Get(ctx, "key").Result()
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println("key", val)
+
+ val2, err := rdb.Get(ctx, "missing_key").Result()
+ if err == redis.Nil {
+ fmt.Println("missing_key does not exist")
+ } else if err != nil {
+ panic(err)
+ } else {
+ fmt.Println("missing_key", val2)
+ }
+ // Output: key value
+ // missing_key does not exist
+}
+
+func ExampleConn() {
+ conn := rdb.Conn(context.Background())
+
+ err := conn.ClientSetName(ctx, "foobar").Err()
+ if err != nil {
+ panic(err)
+ }
+
+ // Open other connections.
+ for i := 0; i < 10; i++ {
+ go rdb.Ping(ctx)
+ }
+
+ s, err := conn.ClientGetName(ctx).Result()
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(s)
+ // Output: foobar
+}
+
+func ExampleClient_Set() {
+ // Last argument is expiration. Zero means the key has no
+ // expiration time.
+ err := rdb.Set(ctx, "key", "value", 0).Err()
+ if err != nil {
+ panic(err)
+ }
+
+ // key2 will expire in an hour.
+ err = rdb.Set(ctx, "key2", "value", time.Hour).Err()
+ if err != nil {
+ panic(err)
+ }
+}
+
+func ExampleClient_SetEX() {
+ err := rdb.SetEX(ctx, "key", "value", time.Hour).Err()
+ if err != nil {
+ panic(err)
+ }
+}
+
+func ExampleClient_Incr() {
+ result, err := rdb.Incr(ctx, "counter").Result()
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(result)
+ // Output: 1
+}
+
+func ExampleClient_BLPop() {
+ if err := rdb.RPush(ctx, "queue", "message").Err(); err != nil {
+ panic(err)
+ }
+
+ // use `rdb.BLPop(0, "queue")` for infinite waiting time
+ result, err := rdb.BLPop(ctx, 1*time.Second, "queue").Result()
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(result[0], result[1])
+ // Output: queue message
+}
+
+func ExampleClient_Scan() {
+ rdb.FlushDB(ctx)
+ for i := 0; i < 33; i++ {
+ err := rdb.Set(ctx, fmt.Sprintf("key%d", i), "value", 0).Err()
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ var cursor uint64
+ var n int
+ for {
+ var keys []string
+ var err error
+ keys, cursor, err = rdb.Scan(ctx, cursor, "key*", 10).Result()
+ if err != nil {
+ panic(err)
+ }
+ n += len(keys)
+ if cursor == 0 {
+ break
+ }
+ }
+
+ fmt.Printf("found %d keys\n", n)
+ // Output: found 33 keys
+}
+
+func ExampleClient_ScanType() {
+ rdb.FlushDB(ctx)
+ for i := 0; i < 33; i++ {
+ err := rdb.Set(ctx, fmt.Sprintf("key%d", i), "value", 0).Err()
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ var cursor uint64
+ var n int
+ for {
+ var keys []string
+ var err error
+ keys, cursor, err = rdb.ScanType(ctx, cursor, "key*", 10, "string").Result()
+ if err != nil {
+ panic(err)
+ }
+ n += len(keys)
+ if cursor == 0 {
+ break
+ }
+ }
+
+ fmt.Printf("found %d keys\n", n)
+ // Output: found 33 keys
+}
+
+// ExampleStringStringMapCmd_Scan shows how to scan the results of a map fetch
+// into a struct.
+func ExampleStringStringMapCmd_Scan() {
+ rdb.FlushDB(ctx)
+ err := rdb.HMSet(ctx, "map",
+ "name", "hello",
+ "count", 123,
+ "correct", true).Err()
+ if err != nil {
+ panic(err)
+ }
+
+ // Get the map. The same approach works for HmGet().
+ res := rdb.HGetAll(ctx, "map")
+ if res.Err() != nil {
+ panic(err)
+ }
+
+ type data struct {
+ Name string `redis:"name"`
+ Count int `redis:"count"`
+ Correct bool `redis:"correct"`
+ }
+
+ // Scan the results into the struct.
+ var d data
+ if err := res.Scan(&d); err != nil {
+ panic(err)
+ }
+
+ fmt.Println(d)
+ // Output: {hello 123 true}
+}
+
+// ExampleSliceCmd_Scan shows how to scan the results of a multi key fetch
+// into a struct.
+func ExampleSliceCmd_Scan() {
+ rdb.FlushDB(ctx)
+ err := rdb.MSet(ctx,
+ "name", "hello",
+ "count", 123,
+ "correct", true).Err()
+ if err != nil {
+ panic(err)
+ }
+
+ res := rdb.MGet(ctx, "name", "count", "empty", "correct")
+ if res.Err() != nil {
+ panic(err)
+ }
+
+ type data struct {
+ Name string `redis:"name"`
+ Count int `redis:"count"`
+ Correct bool `redis:"correct"`
+ }
+
+ // Scan the results into the struct.
+ var d data
+ if err := res.Scan(&d); err != nil {
+ panic(err)
+ }
+
+ fmt.Println(d)
+ // Output: {hello 123 true}
+}
+
+func ExampleClient_Pipelined() {
+ var incr *redis.IntCmd
+ _, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
+ incr = pipe.Incr(ctx, "pipelined_counter")
+ pipe.Expire(ctx, "pipelined_counter", time.Hour)
+ return nil
+ })
+ fmt.Println(incr.Val(), err)
+ // Output: 1 <nil>
+}
+
+func ExampleClient_Pipeline() {
+ pipe := rdb.Pipeline()
+
+ incr := pipe.Incr(ctx, "pipeline_counter")
+ pipe.Expire(ctx, "pipeline_counter", time.Hour)
+
+ // Execute
+ //
+ // INCR pipeline_counter
+ // EXPIRE pipeline_counts 3600
+ //
+ // using one rdb-server roundtrip.
+ _, err := pipe.Exec(ctx)
+ fmt.Println(incr.Val(), err)
+ // Output: 1 <nil>
+}
+
+func ExampleClient_TxPipelined() {
+ var incr *redis.IntCmd
+ _, err := rdb.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
+ incr = pipe.Incr(ctx, "tx_pipelined_counter")
+ pipe.Expire(ctx, "tx_pipelined_counter", time.Hour)
+ return nil
+ })
+ fmt.Println(incr.Val(), err)
+ // Output: 1 <nil>
+}
+
+func ExampleClient_TxPipeline() {
+ pipe := rdb.TxPipeline()
+
+ incr := pipe.Incr(ctx, "tx_pipeline_counter")
+ pipe.Expire(ctx, "tx_pipeline_counter", time.Hour)
+
+ // Execute
+ //
+ // MULTI
+ // INCR pipeline_counter
+ // EXPIRE pipeline_counts 3600
+ // EXEC
+ //
+ // using one rdb-server roundtrip.
+ _, err := pipe.Exec(ctx)
+ fmt.Println(incr.Val(), err)
+ // Output: 1 <nil>
+}
+
+func ExampleClient_Watch() {
+ const maxRetries = 1000
+
+ // Increment transactionally increments key using GET and SET commands.
+ increment := func(key string) error {
+ // Transactional function.
+ txf := func(tx *redis.Tx) error {
+ // Get current value or zero.
+ n, err := tx.Get(ctx, key).Int()
+ if err != nil && err != redis.Nil {
+ return err
+ }
+
+ // Actual opperation (local in optimistic lock).
+ n++
+
+ // Operation is committed only if the watched keys remain unchanged.
+ _, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
+ pipe.Set(ctx, key, n, 0)
+ return nil
+ })
+ return err
+ }
+
+ for i := 0; i < maxRetries; i++ {
+ err := rdb.Watch(ctx, txf, key)
+ if err == nil {
+ // Success.
+ return nil
+ }
+ if err == redis.TxFailedErr {
+ // Optimistic lock lost. Retry.
+ continue
+ }
+ // Return any other error.
+ return err
+ }
+
+ return errors.New("increment reached maximum number of retries")
+ }
+
+ var wg sync.WaitGroup
+ for i := 0; i < 100; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+
+ if err := increment("counter3"); err != nil {
+ fmt.Println("increment error:", err)
+ }
+ }()
+ }
+ wg.Wait()
+
+ n, err := rdb.Get(ctx, "counter3").Int()
+ fmt.Println("ended with", n, err)
+ // Output: ended with 100 <nil>
+}
+
+func ExamplePubSub() {
+ pubsub := rdb.Subscribe(ctx, "mychannel1")
+
+ // Wait for confirmation that subscription is created before publishing anything.
+ _, err := pubsub.Receive(ctx)
+ if err != nil {
+ panic(err)
+ }
+
+ // Go channel which receives messages.
+ ch := pubsub.Channel()
+
+ // Publish a message.
+ err = rdb.Publish(ctx, "mychannel1", "hello").Err()
+ if err != nil {
+ panic(err)
+ }
+
+ time.AfterFunc(time.Second, func() {
+ // When pubsub is closed channel is closed too.
+ _ = pubsub.Close()
+ })
+
+ // Consume messages.
+ for msg := range ch {
+ fmt.Println(msg.Channel, msg.Payload)
+ }
+
+ // Output: mychannel1 hello
+}
+
+func ExamplePubSub_Receive() {
+ pubsub := rdb.Subscribe(ctx, "mychannel2")
+ defer pubsub.Close()
+
+ for i := 0; i < 2; i++ {
+ // ReceiveTimeout is a low level API. Use ReceiveMessage instead.
+ msgi, err := pubsub.ReceiveTimeout(ctx, time.Second)
+ if err != nil {
+ break
+ }
+
+ switch msg := msgi.(type) {
+ case *redis.Subscription:
+ fmt.Println("subscribed to", msg.Channel)
+
+ _, err := rdb.Publish(ctx, "mychannel2", "hello").Result()
+ if err != nil {
+ panic(err)
+ }
+ case *redis.Message:
+ fmt.Println("received", msg.Payload, "from", msg.Channel)
+ default:
+ panic("unreached")
+ }
+ }
+
+ // sent message to 1 rdb
+ // received hello from mychannel2
+}
+
+func ExampleScript() {
+ IncrByXX := redis.NewScript(`
+ if redis.call("GET", KEYS[1]) ~= false then
+ return redis.call("INCRBY", KEYS[1], ARGV[1])
+ end
+ return false
+ `)
+
+ n, err := IncrByXX.Run(ctx, rdb, []string{"xx_counter"}, 2).Result()
+ fmt.Println(n, err)
+
+ err = rdb.Set(ctx, "xx_counter", "40", 0).Err()
+ if err != nil {
+ panic(err)
+ }
+
+ n, err = IncrByXX.Run(ctx, rdb, []string{"xx_counter"}, 2).Result()
+ fmt.Println(n, err)
+
+ // Output: <nil> redis: nil
+ // 42 <nil>
+}
+
+func Example_customCommand() {
+ Get := func(ctx context.Context, rdb *redis.Client, key string) *redis.StringCmd {
+ cmd := redis.NewStringCmd(ctx, "get", key)
+ rdb.Process(ctx, cmd)
+ return cmd
+ }
+
+ v, err := Get(ctx, rdb, "key_does_not_exist").Result()
+ fmt.Printf("%q %s", v, err)
+ // Output: "" redis: nil
+}
+
+func Example_customCommand2() {
+ v, err := rdb.Do(ctx, "get", "key_does_not_exist").Text()
+ fmt.Printf("%q %s", v, err)
+ // Output: "" redis: nil
+}
+
+func ExampleScanIterator() {
+ iter := rdb.Scan(ctx, 0, "", 0).Iterator()
+ for iter.Next(ctx) {
+ fmt.Println(iter.Val())
+ }
+ if err := iter.Err(); err != nil {
+ panic(err)
+ }
+}
+
+func ExampleScanCmd_Iterator() {
+ iter := rdb.Scan(ctx, 0, "", 0).Iterator()
+ for iter.Next(ctx) {
+ fmt.Println(iter.Val())
+ }
+ if err := iter.Err(); err != nil {
+ panic(err)
+ }
+}
+
+func ExampleNewUniversalClient_simple() {
+ rdb := redis.NewUniversalClient(&redis.UniversalOptions{
+ Addrs: []string{":6379"},
+ })
+ defer rdb.Close()
+
+ rdb.Ping(ctx)
+}
+
+func ExampleNewUniversalClient_failover() {
+ rdb := redis.NewUniversalClient(&redis.UniversalOptions{
+ MasterName: "master",
+ Addrs: []string{":26379"},
+ })
+ defer rdb.Close()
+
+ rdb.Ping(ctx)
+}
+
+func ExampleNewUniversalClient_cluster() {
+ rdb := redis.NewUniversalClient(&redis.UniversalOptions{
+ Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
+ })
+ defer rdb.Close()
+
+ rdb.Ping(ctx)
+}
+
+func ExampleClient_SlowLogGet() {
+ const key = "slowlog-log-slower-than"
+
+ old := rdb.ConfigGet(ctx, key).Val()
+ rdb.ConfigSet(ctx, key, "0")
+ defer rdb.ConfigSet(ctx, key, old[1].(string))
+
+ if err := rdb.Do(ctx, "slowlog", "reset").Err(); err != nil {
+ panic(err)
+ }
+
+ rdb.Set(ctx, "test", "true", 0)
+
+ result, err := rdb.SlowLogGet(ctx, -1).Result()
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(len(result))
+ // Output: 2
+}