ss_tutorial_test.go

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

     1  // EXAMPLE: ss_tutorial
     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  func ExampleClient_zadd() {
    14  	ctx := context.Background()
    15  
    16  	rdb := redis.NewClient(&redis.Options{
    17  		Addr:     "localhost:6379",
    18  		Password: "", // no password docs
    19  		DB:       0,  // use default DB
    20  	})
    21  
    22  	// REMOVE_START
    23  	// start with fresh database
    24  	rdb.FlushDB(ctx)
    25  	rdb.Del(ctx, "racer_scores")
    26  	// REMOVE_END
    27  
    28  	// STEP_START zadd
    29  	res1, err := rdb.ZAdd(ctx, "racer_scores",
    30  		redis.Z{Member: "Norem", Score: 10},
    31  	).Result()
    32  
    33  	if err != nil {
    34  		panic(err)
    35  	}
    36  
    37  	fmt.Println(res1) // >>> 1
    38  
    39  	res2, err := rdb.ZAdd(ctx, "racer_scores",
    40  		redis.Z{Member: "Castilla", Score: 12},
    41  	).Result()
    42  
    43  	if err != nil {
    44  		panic(err)
    45  	}
    46  
    47  	fmt.Println(res2) // >>> 1
    48  
    49  	res3, err := rdb.ZAdd(ctx, "racer_scores",
    50  		redis.Z{Member: "Norem", Score: 10},
    51  		redis.Z{Member: "Sam-Bodden", Score: 8},
    52  		redis.Z{Member: "Royce", Score: 10},
    53  		redis.Z{Member: "Ford", Score: 6},
    54  		redis.Z{Member: "Prickett", Score: 14},
    55  		redis.Z{Member: "Castilla", Score: 12},
    56  	).Result()
    57  
    58  	if err != nil {
    59  		panic(err)
    60  	}
    61  
    62  	fmt.Println(res3) // >>> 4
    63  	// STEP_END
    64  
    65  	// Output:
    66  	// 1
    67  	// 1
    68  	// 4
    69  }
    70  
    71  func ExampleClient_zrange() {
    72  	ctx := context.Background()
    73  
    74  	rdb := redis.NewClient(&redis.Options{
    75  		Addr:     "localhost:6379",
    76  		Password: "", // no password docs
    77  		DB:       0,  // use default DB
    78  	})
    79  
    80  	// REMOVE_START
    81  	// start with fresh database
    82  	rdb.FlushDB(ctx)
    83  	rdb.Del(ctx, "racer_scores")
    84  	// REMOVE_END
    85  
    86  	_, err := rdb.ZAdd(ctx, "racer_scores",
    87  		redis.Z{Member: "Norem", Score: 10},
    88  		redis.Z{Member: "Sam-Bodden", Score: 8},
    89  		redis.Z{Member: "Royce", Score: 10},
    90  		redis.Z{Member: "Ford", Score: 6},
    91  		redis.Z{Member: "Prickett", Score: 14},
    92  		redis.Z{Member: "Castilla", Score: 12},
    93  	).Result()
    94  
    95  	if err != nil {
    96  		panic(err)
    97  	}
    98  
    99  	// STEP_START zrange
   100  	res4, err := rdb.ZRange(ctx, "racer_scores", 0, -1).Result()
   101  
   102  	if err != nil {
   103  		panic(err)
   104  	}
   105  
   106  	fmt.Println(res4)
   107  	// >>> [Ford Sam-Bodden Norem Royce Castilla Prickett]
   108  
   109  	res5, err := rdb.ZRevRange(ctx, "racer_scores", 0, -1).Result()
   110  
   111  	if err != nil {
   112  		panic(err)
   113  	}
   114  
   115  	fmt.Println(res5)
   116  	// >>> [Prickett Castilla Royce Norem Sam-Bodden Ford]
   117  	// STEP_END
   118  
   119  	// Output:
   120  	// [Ford Sam-Bodden Norem Royce Castilla Prickett]
   121  	// [Prickett Castilla Royce Norem Sam-Bodden Ford]
   122  }
   123  
   124  func ExampleClient_zrangewithscores() {
   125  	ctx := context.Background()
   126  
   127  	rdb := redis.NewClient(&redis.Options{
   128  		Addr:     "localhost:6379",
   129  		Password: "", // no password docs
   130  		DB:       0,  // use default DB
   131  	})
   132  
   133  	// REMOVE_START
   134  	// start with fresh database
   135  	rdb.FlushDB(ctx)
   136  	rdb.Del(ctx, "racer_scores")
   137  	// REMOVE_END
   138  
   139  	_, err := rdb.ZAdd(ctx, "racer_scores",
   140  		redis.Z{Member: "Norem", Score: 10},
   141  		redis.Z{Member: "Sam-Bodden", Score: 8},
   142  		redis.Z{Member: "Royce", Score: 10},
   143  		redis.Z{Member: "Ford", Score: 6},
   144  		redis.Z{Member: "Prickett", Score: 14},
   145  		redis.Z{Member: "Castilla", Score: 12},
   146  	).Result()
   147  
   148  	if err != nil {
   149  		panic(err)
   150  	}
   151  
   152  	// STEP_START zrange_withscores
   153  	res6, err := rdb.ZRangeWithScores(ctx, "racer_scores", 0, -1).Result()
   154  
   155  	if err != nil {
   156  		panic(err)
   157  	}
   158  
   159  	fmt.Println(res6)
   160  	// >>> [{6 Ford} {8 Sam-Bodden} {10 Norem} {10 Royce} {12 Castilla} {14 Prickett}]
   161  	// STEP_END
   162  
   163  	// Output:
   164  	// [{6 Ford} {8 Sam-Bodden} {10 Norem} {10 Royce} {12 Castilla} {14 Prickett}]
   165  }
   166  
   167  func ExampleClient_zrangebyscore() {
   168  	ctx := context.Background()
   169  
   170  	rdb := redis.NewClient(&redis.Options{
   171  		Addr:     "localhost:6379",
   172  		Password: "", // no password docs
   173  		DB:       0,  // use default DB
   174  	})
   175  
   176  	// REMOVE_START
   177  	// start with fresh database
   178  	rdb.FlushDB(ctx)
   179  	rdb.Del(ctx, "racer_scores")
   180  	// REMOVE_END
   181  
   182  	_, err := rdb.ZAdd(ctx, "racer_scores",
   183  		redis.Z{Member: "Norem", Score: 10},
   184  		redis.Z{Member: "Sam-Bodden", Score: 8},
   185  		redis.Z{Member: "Royce", Score: 10},
   186  		redis.Z{Member: "Ford", Score: 6},
   187  		redis.Z{Member: "Prickett", Score: 14},
   188  		redis.Z{Member: "Castilla", Score: 12},
   189  	).Result()
   190  
   191  	if err != nil {
   192  		panic(err)
   193  	}
   194  
   195  	// STEP_START zrangebyscore
   196  	res7, err := rdb.ZRangeByScore(ctx, "racer_scores",
   197  		&redis.ZRangeBy{Min: "-inf", Max: "10"},
   198  	).Result()
   199  
   200  	if err != nil {
   201  		panic(err)
   202  	}
   203  
   204  	fmt.Println(res7)
   205  	// >>> [Ford Sam-Bodden Norem Royce]
   206  	// STEP_END
   207  
   208  	// Output:
   209  	// [Ford Sam-Bodden Norem Royce]
   210  }
   211  
   212  func ExampleClient_zremrangebyscore() {
   213  	ctx := context.Background()
   214  
   215  	rdb := redis.NewClient(&redis.Options{
   216  		Addr:     "localhost:6379",
   217  		Password: "", // no password docs
   218  		DB:       0,  // use default DB
   219  	})
   220  
   221  	// REMOVE_START
   222  	// start with fresh database
   223  	rdb.FlushDB(ctx)
   224  	rdb.Del(ctx, "racer_scores")
   225  	// REMOVE_END
   226  
   227  	_, err := rdb.ZAdd(ctx, "racer_scores",
   228  		redis.Z{Member: "Norem", Score: 10},
   229  		redis.Z{Member: "Sam-Bodden", Score: 8},
   230  		redis.Z{Member: "Royce", Score: 10},
   231  		redis.Z{Member: "Ford", Score: 6},
   232  		redis.Z{Member: "Prickett", Score: 14},
   233  		redis.Z{Member: "Castilla", Score: 12},
   234  	).Result()
   235  
   236  	if err != nil {
   237  		panic(err)
   238  	}
   239  
   240  	// STEP_START zremrangebyscore
   241  	res8, err := rdb.ZRem(ctx, "racer_scores", "Castilla").Result()
   242  
   243  	if err != nil {
   244  		panic(err)
   245  	}
   246  
   247  	fmt.Println(res8) // >>> 1
   248  
   249  	res9, err := rdb.ZRemRangeByScore(ctx, "racer_scores", "-inf", "9").Result()
   250  
   251  	if err != nil {
   252  		panic(err)
   253  	}
   254  
   255  	fmt.Println(res9) // >>> 2
   256  
   257  	res10, err := rdb.ZRange(ctx, "racer_scores", 0, -1).Result()
   258  
   259  	if err != nil {
   260  		panic(err)
   261  	}
   262  
   263  	fmt.Println(res10)
   264  	// >>> [Norem Royce Prickett]
   265  	// STEP_END
   266  
   267  	// Output:
   268  	// 1
   269  	// 2
   270  	// [Norem Royce Prickett]
   271  }
   272  
   273  func ExampleClient_zrank() {
   274  	ctx := context.Background()
   275  
   276  	rdb := redis.NewClient(&redis.Options{
   277  		Addr:     "localhost:6379",
   278  		Password: "", // no password docs
   279  		DB:       0,  // use default DB
   280  	})
   281  
   282  	// REMOVE_START
   283  	// start with fresh database
   284  	rdb.FlushDB(ctx)
   285  	rdb.Del(ctx, "racer_scores")
   286  	// REMOVE_END
   287  
   288  	_, err := rdb.ZAdd(ctx, "racer_scores",
   289  		redis.Z{Member: "Norem", Score: 10},
   290  		redis.Z{Member: "Royce", Score: 10},
   291  		redis.Z{Member: "Prickett", Score: 14},
   292  	).Result()
   293  
   294  	if err != nil {
   295  		panic(err)
   296  	}
   297  
   298  	// STEP_START zrank
   299  	res11, err := rdb.ZRank(ctx, "racer_scores", "Norem").Result()
   300  
   301  	if err != nil {
   302  		panic(err)
   303  	}
   304  
   305  	fmt.Println(res11) // >>> 0
   306  
   307  	res12, err := rdb.ZRevRank(ctx, "racer_scores", "Norem").Result()
   308  
   309  	if err != nil {
   310  		panic(err)
   311  	}
   312  
   313  	fmt.Println(res12) // >>> 2
   314  	// STEP_END
   315  
   316  	// Output:
   317  	// 0
   318  	// 2
   319  }
   320  
   321  func ExampleClient_zaddlex() {
   322  	ctx := context.Background()
   323  
   324  	rdb := redis.NewClient(&redis.Options{
   325  		Addr:     "localhost:6379",
   326  		Password: "", // no password docs
   327  		DB:       0,  // use default DB
   328  	})
   329  
   330  	// REMOVE_START
   331  	// start with fresh database
   332  	rdb.FlushDB(ctx)
   333  	rdb.Del(ctx, "racer_scores")
   334  	// REMOVE_END
   335  
   336  	_, err := rdb.ZAdd(ctx, "racer_scores",
   337  		redis.Z{Member: "Norem", Score: 0},
   338  		redis.Z{Member: "Royce", Score: 0},
   339  		redis.Z{Member: "Prickett", Score: 0},
   340  	).Result()
   341  
   342  	// STEP_START zadd_lex
   343  	res13, err := rdb.ZAdd(ctx, "racer_scores",
   344  		redis.Z{Member: "Norem", Score: 0},
   345  		redis.Z{Member: "Sam-Bodden", Score: 0},
   346  		redis.Z{Member: "Royce", Score: 0},
   347  		redis.Z{Member: "Ford", Score: 0},
   348  		redis.Z{Member: "Prickett", Score: 0},
   349  		redis.Z{Member: "Castilla", Score: 0},
   350  	).Result()
   351  
   352  	if err != nil {
   353  		panic(err)
   354  	}
   355  
   356  	fmt.Println(res13) // >>> 3
   357  
   358  	res14, err := rdb.ZRange(ctx, "racer_scores", 0, -1).Result()
   359  
   360  	if err != nil {
   361  		panic(err)
   362  	}
   363  
   364  	fmt.Println(res14)
   365  	// >>> [Castilla Ford Norem Prickett Royce Sam-Bodden]
   366  
   367  	res15, err := rdb.ZRangeByLex(ctx, "racer_scores", &redis.ZRangeBy{
   368  		Min: "[A", Max: "[L",
   369  	}).Result()
   370  
   371  	if err != nil {
   372  		panic(err)
   373  	}
   374  
   375  	fmt.Println(res15) // >>> [Castilla Ford]
   376  	// STEP_END
   377  
   378  	// Output:
   379  	// 3
   380  	// [Castilla Ford Norem Prickett Royce Sam-Bodden]
   381  	// [Castilla Ford]
   382  }
   383  
   384  func ExampleClient_leaderboard() {
   385  	ctx := context.Background()
   386  
   387  	rdb := redis.NewClient(&redis.Options{
   388  		Addr:     "localhost:6379",
   389  		Password: "", // no password docs
   390  		DB:       0,  // use default DB
   391  	})
   392  
   393  	// REMOVE_START
   394  	// start with fresh database
   395  	rdb.FlushDB(ctx)
   396  	rdb.Del(ctx, "racer_scores")
   397  	// REMOVE_END
   398  
   399  	// STEP_START leaderboard
   400  	res16, err := rdb.ZAdd(ctx, "racer_scores",
   401  		redis.Z{Member: "Wood", Score: 100},
   402  	).Result()
   403  
   404  	if err != nil {
   405  		panic(err)
   406  	}
   407  
   408  	fmt.Println(res16) // >>> 1
   409  
   410  	res17, err := rdb.ZAdd(ctx, "racer_scores",
   411  		redis.Z{Member: "Henshaw", Score: 100},
   412  	).Result()
   413  
   414  	if err != nil {
   415  		panic(err)
   416  	}
   417  
   418  	fmt.Println(res17) // >>> 1
   419  
   420  	res18, err := rdb.ZAdd(ctx, "racer_scores",
   421  		redis.Z{Member: "Henshaw", Score: 150},
   422  	).Result()
   423  
   424  	if err != nil {
   425  		panic(err)
   426  	}
   427  
   428  	fmt.Println(res18) // >>> 0
   429  
   430  	res19, err := rdb.ZIncrBy(ctx, "racer_scores", 50, "Wood").Result()
   431  
   432  	if err != nil {
   433  		panic(err)
   434  	}
   435  
   436  	fmt.Println(res19) // >>> 150
   437  
   438  	res20, err := rdb.ZIncrBy(ctx, "racer_scores", 50, "Henshaw").Result()
   439  
   440  	if err != nil {
   441  		panic(err)
   442  	}
   443  
   444  	fmt.Println(res20) // >>> 200
   445  	// STEP_END
   446  
   447  	// Output:
   448  	// 1
   449  	// 1
   450  	// 0
   451  	// 150
   452  	// 200
   453  }
   454
View as plain text