cmds_generic_test.go

Documentation: github.com/redis/go-redis/v9/doctests

     1  // EXAMPLE: cmds_generic
     2  // HIDE_START
     3  package example_commands_test
     4  
     5  import (
     6  	"context"
     7  	"fmt"
     8  	"math"
     9  	"time"
    10  
    11  	"github.com/redis/go-redis/v9"
    12  )
    13  
    14  // HIDE_END
    15  
    16  func ExampleClient_del_cmd() {
    17  	ctx := context.Background()
    18  
    19  	rdb := redis.NewClient(&redis.Options{
    20  		Addr:     "localhost:6379",
    21  		Password: "", // no password docs
    22  		DB:       0,  // use default DB
    23  	})
    24  
    25  	// REMOVE_START
    26  	// make sure we are working with fresh database
    27  	rdb.FlushDB(ctx)
    28  	rdb.Del(ctx, "key1", "key2", "key3")
    29  	// REMOVE_END
    30  
    31  	// STEP_START del
    32  	delResult1, err := rdb.Set(ctx, "key1", "Hello", 0).Result()
    33  
    34  	if err != nil {
    35  		panic(err)
    36  	}
    37  
    38  	fmt.Println(delResult1) // >>> OK
    39  
    40  	delResult2, err := rdb.Set(ctx, "key2", "World", 0).Result()
    41  
    42  	if err != nil {
    43  		panic(err)
    44  	}
    45  
    46  	fmt.Println(delResult2) // >>> OK
    47  
    48  	delResult3, err := rdb.Del(ctx, "key1", "key2", "key3").Result()
    49  
    50  	if err != nil {
    51  		panic(err)
    52  	}
    53  
    54  	fmt.Println(delResult3) // >>> 2
    55  	// STEP_END
    56  
    57  	// Output:
    58  	// OK
    59  	// OK
    60  	// 2
    61  }
    62  
    63  func ExampleClient_expire_cmd() {
    64  	ctx := context.Background()
    65  
    66  	rdb := redis.NewClient(&redis.Options{
    67  		Addr:     "localhost:6379",
    68  		Password: "", // no password docs
    69  		DB:       0,  // use default DB
    70  	})
    71  
    72  	// REMOVE_START
    73  	// start with fresh database
    74  	rdb.FlushDB(ctx)
    75  	rdb.Del(ctx, "mykey")
    76  	// REMOVE_END
    77  
    78  	// STEP_START expire
    79  	expireResult1, err := rdb.Set(ctx, "mykey", "Hello", 0).Result()
    80  
    81  	if err != nil {
    82  		panic(err)
    83  	}
    84  
    85  	fmt.Println(expireResult1) // >>> OK
    86  
    87  	expireResult2, err := rdb.Expire(ctx, "mykey", 10*time.Second).Result()
    88  
    89  	if err != nil {
    90  		panic(err)
    91  	}
    92  
    93  	fmt.Println(expireResult2) // >>> true
    94  
    95  	expireResult3, err := rdb.TTL(ctx, "mykey").Result()
    96  
    97  	if err != nil {
    98  		panic(err)
    99  	}
   100  
   101  	fmt.Println(math.Round(expireResult3.Seconds())) // >>> 10
   102  
   103  	expireResult4, err := rdb.Set(ctx, "mykey", "Hello World", 0).Result()
   104  
   105  	if err != nil {
   106  		panic(err)
   107  	}
   108  
   109  	fmt.Println(expireResult4) // >>> OK
   110  
   111  	expireResult5, err := rdb.TTL(ctx, "mykey").Result()
   112  
   113  	if err != nil {
   114  		panic(err)
   115  	}
   116  
   117  	fmt.Println(expireResult5) // >>> -1ns
   118  
   119  	expireResult6, err := rdb.ExpireXX(ctx, "mykey", 10*time.Second).Result()
   120  
   121  	if err != nil {
   122  		panic(err)
   123  	}
   124  
   125  	fmt.Println(expireResult6) // >>> false
   126  
   127  	expireResult7, err := rdb.TTL(ctx, "mykey").Result()
   128  
   129  	if err != nil {
   130  		panic(err)
   131  	}
   132  
   133  	fmt.Println(expireResult7) // >>> -1ns
   134  
   135  	expireResult8, err := rdb.ExpireNX(ctx, "mykey", 10*time.Second).Result()
   136  
   137  	if err != nil {
   138  		panic(err)
   139  	}
   140  
   141  	fmt.Println(expireResult8) // >>> true
   142  
   143  	expireResult9, err := rdb.TTL(ctx, "mykey").Result()
   144  
   145  	if err != nil {
   146  		panic(err)
   147  	}
   148  
   149  	fmt.Println(math.Round(expireResult9.Seconds())) // >>> 10
   150  	// STEP_END
   151  
   152  	// Output:
   153  	// OK
   154  	// true
   155  	// 10
   156  	// OK
   157  	// -1ns
   158  	// false
   159  	// -1ns
   160  	// true
   161  	// 10
   162  }
   163  
   164  func ExampleClient_ttl_cmd() {
   165  	ctx := context.Background()
   166  
   167  	rdb := redis.NewClient(&redis.Options{
   168  		Addr:     "localhost:6379",
   169  		Password: "", // no password docs
   170  		DB:       0,  // use default DB
   171  	})
   172  
   173  	// REMOVE_START
   174  	// start with fresh database
   175  	rdb.FlushDB(ctx)
   176  	rdb.Del(ctx, "mykey")
   177  	// REMOVE_END
   178  
   179  	// STEP_START ttl
   180  	ttlResult1, err := rdb.Set(ctx, "mykey", "Hello", 10*time.Second).Result()
   181  
   182  	if err != nil {
   183  		panic(err)
   184  	}
   185  
   186  	fmt.Println(ttlResult1) // >>> OK
   187  
   188  	ttlResult2, err := rdb.TTL(ctx, "mykey").Result()
   189  
   190  	if err != nil {
   191  		panic(err)
   192  	}
   193  
   194  	fmt.Println(math.Round(ttlResult2.Seconds())) // >>> 10
   195  	// STEP_END
   196  
   197  	// Output:
   198  	// OK
   199  	// 10
   200  }
   201
View as plain text