cmds_sorted_set_test.go

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

     1  // EXAMPLE: cmds_sorted_set
     2  // HIDE_START
     3  package example_commands_test
     4  
     5  import (
     6  	"context"
     7  	"fmt"
     8  
     9  	"github.com/redis/go-redis/v9"
    10  )
    11  
    12  // HIDE_END
    13  
    14  func ExampleClient_zadd_cmd() {
    15  	ctx := context.Background()
    16  
    17  	rdb := redis.NewClient(&redis.Options{
    18  		Addr:     "localhost:6379",
    19  		Password: "", // no password docs
    20  		DB:       0,  // use default DB
    21  	})
    22  
    23  	// REMOVE_START
    24  	// make sure we are working with fresh database
    25  	rdb.FlushDB(ctx)
    26  	rdb.Del(ctx, "myzset")
    27  	// REMOVE_END
    28  
    29  	// STEP_START zadd
    30  	zAddResult1, err := rdb.ZAdd(ctx, "myzset",
    31  		redis.Z{Member: "one", Score: 1},
    32  	).Result()
    33  
    34  	if err != nil {
    35  		panic(err)
    36  	}
    37  
    38  	fmt.Println(zAddResult1) // >>> 1
    39  
    40  	zAddResult2, err := rdb.ZAdd(ctx, "myzset",
    41  		redis.Z{Member: "uno", Score: 1},
    42  	).Result()
    43  
    44  	if err != nil {
    45  		panic(err)
    46  	}
    47  
    48  	fmt.Println(zAddResult2)
    49  
    50  	zAddResult3, err := rdb.ZAdd(ctx, "myzset",
    51  		redis.Z{Member: "two", Score: 2},
    52  		redis.Z{Member: "three", Score: 3},
    53  	).Result()
    54  
    55  	if err != nil {
    56  		panic(err)
    57  	}
    58  
    59  	fmt.Println(zAddResult3) // >>> 2
    60  
    61  	zAddResult4, err := rdb.ZRangeWithScores(ctx, "myzset", 0, -1).Result()
    62  
    63  	if err != nil {
    64  		panic(err)
    65  	}
    66  
    67  	fmt.Println(zAddResult4) // >>> [{1 one} {1 uno} {2 two} {3 three}]
    68  	// STEP_END
    69  
    70  	// Output:
    71  	// 1
    72  	// 1
    73  	// 2
    74  	// [{1 one} {1 uno} {2 two} {3 three}]
    75  }
    76  
    77  func ExampleClient_zrange1() {
    78  	ctx := context.Background()
    79  
    80  	rdb := redis.NewClient(&redis.Options{
    81  		Addr:     "localhost:6379",
    82  		Password: "", // no password docs
    83  		DB:       0,  // use default DB
    84  	})
    85  
    86  	// REMOVE_START
    87  	// start with fresh database
    88  	rdb.FlushDB(ctx)
    89  	rdb.Del(ctx, "myzset")
    90  	// REMOVE_END
    91  
    92  	// STEP_START zrange1
    93  	zrangeResult1, err := rdb.ZAdd(ctx, "myzset",
    94  		redis.Z{Member: "one", Score: 1},
    95  		redis.Z{Member: "two", Score: 2},
    96  		redis.Z{Member: "three", Score: 3},
    97  	).Result()
    98  
    99  	if err != nil {
   100  		panic(err)
   101  	}
   102  
   103  	fmt.Println(zrangeResult1) // >>> 3
   104  
   105  	zrangeResult2, err := rdb.ZRange(ctx, "myzset", 0, -1).Result()
   106  
   107  	if err != nil {
   108  		panic(err)
   109  	}
   110  
   111  	fmt.Println(zrangeResult2) // >>> [one two three]
   112  
   113  	zrangeResult3, err := rdb.ZRange(ctx, "myzset", 2, 3).Result()
   114  
   115  	if err != nil {
   116  		panic(err)
   117  	}
   118  
   119  	fmt.Println(zrangeResult3) // >>> [three]
   120  
   121  	zrangeResult4, err := rdb.ZRange(ctx, "myzset", -2, -1).Result()
   122  
   123  	if err != nil {
   124  		panic(err)
   125  	}
   126  
   127  	fmt.Println(zrangeResult4) // >>> [two three]
   128  	// STEP_END
   129  
   130  	// Output:
   131  	// 3
   132  	// [one two three]
   133  	// [three]
   134  	// [two three]
   135  }
   136  
   137  func ExampleClient_zrange2() {
   138  	ctx := context.Background()
   139  
   140  	rdb := redis.NewClient(&redis.Options{
   141  		Addr:     "localhost:6379",
   142  		Password: "", // no password docs
   143  		DB:       0,  // use default DB
   144  	})
   145  
   146  	// REMOVE_START
   147  	// start with fresh database
   148  	rdb.FlushDB(ctx)
   149  	rdb.Del(ctx, "myzset")
   150  	// REMOVE_END
   151  
   152  	// STEP_START zrange2
   153  	zRangeResult5, err := rdb.ZAdd(ctx, "myzset",
   154  		redis.Z{Member: "one", Score: 1},
   155  		redis.Z{Member: "two", Score: 2},
   156  		redis.Z{Member: "three", Score: 3},
   157  	).Result()
   158  
   159  	if err != nil {
   160  		panic(err)
   161  	}
   162  
   163  	fmt.Println(zRangeResult5) // >>> 3
   164  
   165  	zRangeResult6, err := rdb.ZRangeWithScores(ctx, "myzset", 0, 1).Result()
   166  
   167  	if err != nil {
   168  		panic(err)
   169  	}
   170  
   171  	fmt.Println(zRangeResult6) // >>> [{1 one} {2 two}]
   172  	// STEP_END
   173  
   174  	// Output:
   175  	// 3
   176  	// [{1 one} {2 two}]
   177  }
   178  
   179  func ExampleClient_zrange3() {
   180  	ctx := context.Background()
   181  
   182  	rdb := redis.NewClient(&redis.Options{
   183  		Addr:     "localhost:6379",
   184  		Password: "", // no password docs
   185  		DB:       0,  // use default DB
   186  	})
   187  
   188  	// REMOVE_START
   189  	// start with fresh database
   190  	rdb.FlushDB(ctx)
   191  	rdb.Del(ctx, "myzset")
   192  	// REMOVE_END
   193  
   194  	// STEP_START zrange3
   195  	zRangeResult7, err := rdb.ZAdd(ctx, "myzset",
   196  		redis.Z{Member: "one", Score: 1},
   197  		redis.Z{Member: "two", Score: 2},
   198  		redis.Z{Member: "three", Score: 3},
   199  	).Result()
   200  
   201  	if err != nil {
   202  		panic(err)
   203  	}
   204  
   205  	fmt.Println(zRangeResult7) // >>> 3
   206  
   207  	zRangeResult8, err := rdb.ZRangeArgs(ctx,
   208  		redis.ZRangeArgs{
   209  			Key:     "myzset",
   210  			ByScore: true,
   211  			Start:   "(1",
   212  			Stop:    "+inf",
   213  			Offset:  1,
   214  			Count:   1,
   215  		},
   216  	).Result()
   217  
   218  	if err != nil {
   219  		panic(err)
   220  	}
   221  
   222  	fmt.Println(zRangeResult8) // >>> [three]
   223  	// STEP_END
   224  
   225  	// Output:
   226  	// 3
   227  	// [three]
   228  }
   229
View as plain text