rueidis

package module
v0.0.100 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 15, 2023 License: Apache-2.0 Imports: 25 Imported by: 0

README

rueidis

Go Reference Build status Go Report Card codecov Maintainability

A fast Golang Redis client that does auto pipelining and supports client side caching.

Features

Getting Started

package main

import (
	"context"
	"github.com/rueian/rueidis"
)

func main() {
	client, err := rueidis.NewClient(rueidis.ClientOption{
		InitAddress: []string{"127.0.0.1:6379"},
	})
	if err != nil {
		panic(err)
	}
	defer client.Close()

	ctx := context.Background()
	// SET key val NX
	err = client.Do(ctx, client.B().Set().Key("key").Value("val").Nx().Build()).Error()
}

Developer friendly Command Builder

client.B() is the builder entrypoint to construct a redis command:

Developer friendly command builder
Recorded by @FZambia Improving Centrifugo Redis Engine throughput and allocation efficiency with Rueidis Go library

Once a command is built, use either client.Do() or client.DoMulti() to send it to redis.

Constructed commands will be recycled to underlying sync.Pool by default and you ❗️SHOULD NOT❗️ reuse them across multiple client.Do() or client.DoMulti() calls. To reuse a command, use Pin() after Build() and it will prevent the command being recycled.

Auto Pipelining

All concurrent non-blocking redis commands (such as GET, SET) are automatically pipelined through connections, which reduces the overall round trips and system calls, and gets higher throughput. You can easily get the benefit of pipelining technique by just calling client.Do() from multiple goroutines. For example:

func BenchmarkPipelining(b *testing.B, client rueidis.Client) {
	// the below client.Do() operations will be issued from
	// multiple goroutines and thus will be pipelined automatically.
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			client.Do(context.Background(), client.B().Get().Key("k").Build()).ToString()
		}
	})
}
Benchmark comparison with go-redis v9

Comparing to go-redis, Rueidis has higher throughput across 1, 8, and 64 parallelism settings.

It is even able to achieve ~14x throughput over go-redis in a local benchmark of Macbook Pro 16" M1 Pro 2021. (see parallelism(64)-key(16)-value(64)-10)

client_test_set

Benchmark source code: https://github.com/rueian/rueidis-benchmark

A benchmark result performed on two GCP n2-highcpu-2 machines also shows that rueidis can achieve higher throughput with lower latencies: https://github.com/rueian/rueidis/pull/93

Pipelining Bulk Operations Manually

Though all concurrent non-blocking commands are automatically pipelined, you can still pipeline commands manually with DoMulti():

cmds := make(rueidis.Commands, 0, 10)
for i := 0; i < 10; i++ {
    cmds = append(cmds, client.B().Set().Key("key").Value("value").Build())
}
for _, resp := range client.DoMulti(ctx, cmds...) {
    if err := resp.Error(); err != nil {
        panic(err)
    }
}

Client Side Caching

The opt-in mode of server-assisted client side caching is enabled by default, and can be used by calling DoCache() or DoMultiCache() with pairs of a readonly command and a client side TTL.

client.DoCache(ctx, client.B().Hmget().Key("myhash").Field("1", "2").Cache(), time.Minute).ToArray()
client.DoMultiCache(ctx,
    rueidis.CT(client.B().Get().Key("k1").Cache(), 1*time.Minute),
    rueidis.CT(client.B().Get().Key("k2").Cache(), 2*time.Minute))

Cached responses will be invalidated when being notified by redis or their client side ttl is reached.

Benchmark

Client Side Caching can boost read throughput just like having a redis replica right inside your application:

client_test_get

Benchmark source code: https://github.com/rueian/rueidis-benchmark

Client Side Caching Helpers

Use CacheTTL() to check the remaining client side TTL in seconds:

client.DoCache(ctx, client.B().Get().Key("k1").Cache(), time.Minute).CacheTTL() == 60

Use IsCacheHit() to verify that if the response came from the client side memory:

client.DoCache(ctx, client.B().Get().Key("k1").Cache(), time.Minute).IsCacheHit() == true

If the OpenTelemetry is enabled by the rueidisotel.WithClient(client), then there are also two metrics instrumented:

  • rueidis_do_cache_miss
  • rueidis_do_cache_hits
MGET/JSON.MGET Client Side Caching Helpers

rueidis.MGetCache and rueidis.JsonMGetCache are handy helpers fetching multiple keys across different slots through the client side caching. They will first group keys by slot to build MGET or JSON.MGET commands respectively and then send requests with only cache missed keys to redis nodes.

Broadcast Mode Client Side Caching

Although the default is opt-in mode, you can use broadcast mode by specifying your prefixes in ClientOption.ClientTrackingOptions:

client, err := rueidis.NewClient(rueidis.ClientOption{
	InitAddress:           []string{"127.0.0.1:6379"},
	ClientTrackingOptions: []string{"PREFIX", "prefix1:", "PREFIX", "prefix2:", "BCAST"},
})
if err != nil {
	panic(err)
}
client.DoCache(ctx, client.B().Get().Key("prefix1:1").Cache(), time.Minute).IsCacheHit() == false
client.DoCache(ctx, client.B().Get().Key("prefix1:1").Cache(), time.Minute).IsCacheHit() == true

Please make sure that commands passed to DoCache() and DoMultiCache() are covered by your prefixes. Otherwise, their client-side cache will not be invalidated by redis.

Disable Client Side Caching

Some Redis provider doesn't support client-side caching, ex. Google Cloud Memorystore. You can disable client-side caching by setting ClientOption.DisableCache to true. This will also fall back client.DoCache() and client.DoMultiCache() to client.Do() and client.DoMulti().

Context Cancellation

client.Do(), client.DoMulti(), client.DoCache() and client.DoMultiCache() can return early if the context is canceled or the deadline is reached.

ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
client.Do(ctx, client.B().Set().Key("key").Value("val").Nx().Build()).Error() == context.DeadlineExceeded

Please note that though operations can return early, the command is likely sent already.

Pub/Sub

To receive messages from channels, client.Receive() should be used. It supports SUBSCRIBE, PSUBSCRIBE and Redis 7.0's SSUBSCRIBE:

err = client.Receive(context.Background(), client.B().Subscribe().Channel("ch1", "ch2").Build(), func(msg rueidis.PubSubMessage) {
    // handle the msg
})

The provided handler will be called with received message.

It is important to note that client.Receive() will keep blocking and return only when the following cases:

  1. return nil when received any unsubscribe/punsubscribe message related to the provided subscribe command.
  2. return rueidis.ErrClosing when the client is closed manually.
  3. return ctx.Err() when the ctx is done.
  4. return non-nil err when the provided subscribe command failed.

While the client.Receive() call is blocking, the Client is still able to accept other concurrent requests, and they are sharing the same tcp connection. If your message handler may take some time to complete, it is recommended to use the client.Receive() inside a client.Dedicated() for not blocking other concurrent requests.

Alternative PubSub Hooks

The client.Receive() requires users to provide a subscription command in advance. There is an alternative Dedicatedclient.SetPubSubHooks() allows users to subscribe/unsubscribe channels later.

c, cancel := client.Dedicate()
defer cancel()

wait := c.SetPubSubHooks(rueidis.PubSubHooks{
	OnMessage: func(m rueidis.PubSubMessage) {
		// Handle message. This callback will be called sequentially, but in another goroutine.
	}
})
c.Do(ctx, c.B().Subscribe().Channel("ch").Build())
err := <-wait // disconnected with err

If the hooks are not nil, the above wait channel is guaranteed to be close when the hooks will not be called anymore, and produce at most one error describing the reason. Users can use this channel to detect disconnection.

CAS Pattern

To do a CAS operation (WATCH + MULTI + EXEC), a dedicated connection should be used, because there should be no unintentional write commands between WATCH and EXEC. Otherwise, the EXEC may not fail as expected.

client.Dedicated(func(c rueidis.DedicatedClient) error {
    // watch keys first
    c.Do(ctx, c.B().Watch().Key("k1", "k2").Build())
    // perform read here
    c.Do(ctx, c.B().Mget().Key("k1", "k2").Build())
    // perform write with MULTI EXEC
    c.DoMulti(
        ctx,
        c.B().Multi().Build(),
        c.B().Set().Key("k1").Value("1").Build(),
        c.B().Set().Key("k2").Value("2").Build(),
        c.B().Exec().Build(),
    )
    return nil
})

Or use Dedicate() and invoke cancel() when finished to put the connection back to the pool.

c, cancel := client.Dedicate()
defer cancel()

c.Do(ctx, c.B().Watch().Key("k1", "k2").Build())
// do the rest CAS operations with the `client` who occupying a connection

However, occupying a connection is not good in terms of throughput. It is better to use Lua script to perform optimistic locking instead.

Memory Consumption Consideration

Each underlying connection in rueidis allocates a ring buffer for pipelining. Its size is controlled by the ClientOption.RingScaleEachConn and the default value is 10 which results into each ring of size 2^10.

If you have many rueidis connections, you may find that they occupy quite amount of memory. In that case, you may consider reducing ClientOption.RingScaleEachConn to 8 or 9 at the cost of potential throughput degradation.

Lua Script

The NewLuaScript or NewLuaScriptReadOnly will create a script which is safe for concurrent usage.

When calling the script.Exec, it will try sending EVALSHA first and fallback to EVAL if the server returns NOSCRIPT.

script := rueidis.NewLuaScript("return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}")
// the script.Exec is safe for concurrent call
list, err := script.Exec(ctx, client, []string{"k1", "k2"}, []string{"a1", "a2"}).ToArray()

Redis Cluster, Single Redis and Sentinel

To connect to a redis cluster, the NewClient should be used:

client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"127.0.0.1:7001", "127.0.0.1:7002", "127.0.0.1:7003"},
    ShuffleInit: true,
})

To connect to a single redis node, still use the NewClient with one InitAddress

client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"127.0.0.1:6379"},
})

To connect to sentinels, specify the required master set name:

client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"127.0.0.1:26379", "127.0.0.1:26380", "127.0.0.1:26381"},
    Sentinel: rueidis.SentinelOption{
        MasterSet: "my_master",
    },
})

Arbitrary Command

If you want to construct commands that are absent from the command builder, you can use client.B().Arbitrary():

// This will result into [ANY CMD k1 k2 a1 a2]
client.B().Arbitrary("ANY", "CMD").Keys("k1", "k2").Args("a1", "a2").Build()

The command builder treats all the parameters as Redis strings, which are binary safe. This means that users can store []byte directly into Redis without conversion. And the rueidis.BinaryString helper can convert []byte to string without copy. For example:

client.B().Set().Key("b").Value(rueidis.BinaryString([]byte{...})).Build()

Treating all the parameters as Redis strings also means that the command builder doesn't do any quoting, conversion automatically for users.

When working with RedisJSON, users frequently need to prepare JSON string in Redis string. And rueidis.JSON can help:

client.B().JsonSet().Key("j").Path("$.myStrField").Value(rueidis.JSON("str")).Build()
// equivalent to
client.B().JsonSet().Key("j").Path("$.myStrField").Value(`"str"`).Build()

When working with vector similarity search, users can use rueidis.VectorString32 and rueidis.VectorString64 to build queries:

client.B().FtSearch().Index("idx").Query("*=>[KNN 5 @vec $V]").
    Params().Nargs(2).NameValue().NameValue("V", rueidis.VectorString64([]float64{...})).
    Dialect(2).Build()

Command Response Cheatsheet

It is hard to remember what message type is returned from redis and which parsing method should be used with. So, here is some common examples:

// GET
client.Do(ctx, client.B().Get().Key("k").Build()).ToString()
client.Do(ctx, client.B().Get().Key("k").Build()).AsInt64()
// MGET
client.Do(ctx, client.B().Mget().Key("k1", "k2").Build()).ToArray()
// SET
client.Do(ctx, client.B().Set().Key("k").Value("v").Build()).Error()
// INCR
client.Do(ctx, client.B().Incr().Key("k").Build()).AsInt64()
// HGET
client.Do(ctx, client.B().Hget().Key("k").Field("f").Build()).ToString()
// HMGET
client.Do(ctx, client.B().Hmget().Key("h").Field("a", "b").Build()).ToArray()
// HGETALL
client.Do(ctx, client.B().Hgetall().Key("h").Build()).AsStrMap()
// ZRANGE
client.Do(ctx, client.B().Zrange().Key("k").Min("1").Max("2").Build()).AsStrSlice()
// ZRANK
client.Do(ctx, client.B().Zrank().Key("k").Member("m").Build()).AsInt64()
// ZSCORE
client.Do(ctx, client.B().Zscore().Key("k").Member("m").Build()).AsFloat64()
// ZRANGE
client.Do(ctx, client.B().Zrange().Key("k").Min("0").Max("-1").Build()).AsStrSlice()
client.Do(ctx, client.B().Zrange().Key("k").Min("0").Max("-1").Withscores().Build()).AsZScores()
// ZPOPMIN
client.Do(ctx, client.B().Zpopmin().Key("k").Build()).AsZScore()
client.Do(ctx, client.B().Zpopmin().Key("myzset").Count(2).Build()).AsZScores()
// SCARD
client.Do(ctx, client.B().Scard().Key("k").Build()).AsInt64()
// SMEMBERS
client.Do(ctx, client.B().Smembers().Key("k").Build()).AsStrSlice()
// LINDEX
client.Do(ctx, client.B().Lindex().Key("k").Index(0).Build()).ToString()
// LPOP
client.Do(ctx, client.B().Lpop().Key("k").Build()).ToString()
client.Do(ctx, client.B().Lpop().Key("k").Count(2).Build()).AsStrSlice()

Supporting Go mod 1.18

To continuously support the old Go 1.18, there will be a special build tagged with -go1.18 for each release.

Such releases remove RedisResult.AsBytes() and other related functionalities provided by later go versions.

# go.mod
module mymodule

go 1.19

require github.com/rueian/rueidis v0.0.100-go1.18

Documentation

Overview

Package rueidis is a fast Golang Redis RESP3 client that does auto pipelining and supports client side caching.

Index

Examples

Constants

View Source 
const (
	// DefaultCacheBytes is the default value of ClientOption.CacheSizeEachConn, which is 128 MiB
	DefaultCacheBytes = 128 * (1 << 20)
	// DefaultRingScale is the default value of ClientOption.RingScaleEachConn, which results into having a ring of size 2^10 for each connection
	DefaultRingScale = 10
	// DefaultPoolSize is the default value of ClientOption.BlockingPoolSize
	DefaultPoolSize = 1000
	// DefaultDialTimeout is the default value of ClientOption.Dialer.Timeout
	DefaultDialTimeout = 5 * time.Second
	// DefaultTCPKeepAlive is the default value of ClientOption.Dialer.KeepAlive
	DefaultTCPKeepAlive = 1 * time.Second
	// DefaultReadBuffer is the default value of bufio.NewReaderSize for each connection, which is 0.5MiB
	DefaultReadBuffer = 1 << 19
	// DefaultWriteBuffer is the default value of bufio.NewWriterSize for each connection, which is 0.5MiB
	DefaultWriteBuffer = 1 << 19
)

Variables

View Source 
var (
	// ErrClosing means the Client.Close had been called
	ErrClosing = errors.New("rueidis client is closing or unable to connect redis")
	// ErrNoAddr means the ClientOption.InitAddress is empty
	ErrNoAddr = errors.New("no alive address in InitAddress")
	// ErrNoCache means your redis does not support client-side caching and must set ClientOption.DisableCache to true
	ErrNoCache = errors.New("ClientOption.DisableCache must be true for redis not supporting client-side caching or not supporting RESP3")
	// ErrRESP2PubSubMixed means your redis does not support RESP3 and rueidis can't handle SUBSCRIBE/PSUBSCRIBE/SSUBSCRIBE in mixed case
	ErrRESP2PubSubMixed = errors.New("rueidis does not support SUBSCRIBE/PSUBSCRIBE/SSUBSCRIBE mixed with other commands in RESP2")
	// ErrDoCacheAborted means redis abort EXEC request or connection closed
	ErrDoCacheAborted = errors.New("failed to fetch the cache because EXEC was aborted by redis or connection closed")
)
View Source 
var ErrMSetNXNotSet = errors.New("MSETNX: no key was set")

ErrMSetNXNotSet is used in the MSetNX helper when the underlying MSETNX response is 0. Ref: https://redis.io/commands/msetnx/

View Source 
var ErrNoSlot = errors.New("the slot has no redis node")

ErrNoSlot indicates that there is no redis node owns the key slot.

View Source 
var Nil = &RedisError{typ: '_'}

Nil represents a Redis Nil message

Functions

func BinaryString added in v0.0.36 

func BinaryString(bs []byte) string

BinaryString convert the provided []byte into a string without copy. It does what strings.Builder.String() does. Redis Strings are binary safe, this means that it is safe to store any []byte into Redis directly. Users can use this BinaryString helper to insert a []byte as the part of redis command. For example: 

client.B().Set().Key(rueidis.BinaryString([]byte{0})).Value(rueidis.BinaryString([]byte{0})).Build()

To read back the []byte of the string returned from the Redis, it is recommended to use the RedisMessage.AsReader.

func IsRedisNil 

func IsRedisNil(err error) bool

IsRedisNil is a handy method to check if error is redis nil response. All redis nil response returns as an error.

Example 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

_, err = client.Do(context.Background(), client.B().Get().Key("not_exists").Build()).ToString()
if err != nil && IsRedisNil(err) {
	fmt.Printf("it is a nil response")
}

Output:

func JSON added in v0.0.55 

func JSON(in any) string

JSON convert the provided parameter into a JSON string. Users can use this JSON helper to work with RedisJSON commands. For example: 

client.B().JsonSet().Key("a").Path("$.myField").Value(rueidis.JSON("str")).Build()

func JsonMGet added in v0.0.94 

func JsonMGet(client Client, ctx context.Context, keys []string, path string) (ret map[string]RedisMessage, err error)

JsonMGet is a helper that consults redis directly with multiple keys by grouping keys within same slot into JSON.MGETs

func JsonMGetCache added in v0.0.65 

func JsonMGetCache(client Client, ctx context.Context, ttl time.Duration, keys []string, path string) (ret map[string]RedisMessage, err error)

JsonMGetCache is a helper that consults the client-side caches with multiple keys by grouping keys within same slot into JSON.MGETs

func MGet added in v0.0.94 

func MGet(client Client, ctx context.Context, keys []string) (ret map[string]RedisMessage, err error)

MGet is a helper that consults the redis directly with multiple keys by grouping keys within same slot into MGETs

func MGetCache added in v0.0.65 

func MGetCache(client Client, ctx context.Context, ttl time.Duration, keys []string) (ret map[string]RedisMessage, err error)

MGetCache is a helper that consults the client-side caches with multiple keys by grouping keys within same slot into MGETs

func MSet added in v0.0.98 

func MSet(client Client, ctx context.Context, kvs map[string]string) map[string]error

MSet is a helper that consults the redis directly with multiple keys by grouping keys within same slot into MSETs

func MSetNX added in v0.0.98 

func MSetNX(client Client, ctx context.Context, kvs map[string]string) map[string]error

MSetNX is a helper that consults the redis directly with multiple keys by grouping keys within same slot into MSETNXs

func ToVector32 added in v0.0.97 

func ToVector32(s string) []float32

ToVector32 reverts VectorString32. User can use this to convert redis response back to []float32.

func ToVector64 added in v0.0.97 

func ToVector64(s string) []float64

ToVector64 reverts VectorString64. User can use this to convert redis response back to []float64.

func VectorString32 added in v0.0.97 

func VectorString32(v []float32) string

VectorString32 convert the provided []float32 into a string. Users can use this to build vector search queries: 

client.B().FtSearch().Index("idx").Query("*=>[KNN 5 @vec $V]").
    Params().Nargs(2).NameValue().NameValue("V", rueidis.VectorString32([]float32{1})).
    Dialect(2).Build()

func VectorString64 added in v0.0.97 

func VectorString64(v []float64) string

VectorString64 convert the provided []float64 into a string. Users can use this to build vector search queries: 

client.B().FtSearch().Index("idx").Query("*=>[KNN 5 @vec $V]").
    Params().Nargs(2).NameValue().NameValue("V", rueidis.VectorString64([]float64{1})).
    Dialect(2).Build()

Types

type Cacheable added in v0.0.99 

type Cacheable = cmds.Cacheable

Cacheable represents a completed Redis command which supports server-assisted client side caching, and it should be created by the Cache() of command builder.

type CacheableTTL added in v0.0.66 

type CacheableTTL struct {
	Cmd Cacheable
	TTL time.Duration
}

CacheableTTL is parameter container of DoMultiCache

func CT added in v0.0.66 

func CT(cmd Cacheable, ttl time.Duration) CacheableTTL

CT is a shorthand constructor for CacheableTTL

type Client added in v0.0.7 

type Client interface {
	// B is the getter function to the command builder for the client
	// If the client is a cluster client, the command builder also prohibits cross key slots in one command.
	B() cmds.Builder
	// Do is the method sending user's redis command building from the B() to a redis node.
	//  client.Do(ctx, client.B().Get().Key("k").Build()).ToString()
	// All concurrent non-blocking commands will be pipelined automatically and have better throughput.
	// Blocking commands will use another separated connection pool.
	// The cmd parameter is recycled after passing into Do() and should not be reused.
	Do(ctx context.Context, cmd Completed) (resp RedisResult)
	// DoMulti takes multiple redis commands and sends them together, reducing RTT from the user code.
	// The multi parameters are recycled after passing into DoMulti() and should not be reused.
	DoMulti(ctx context.Context, multi ...Completed) (resp []RedisResult)
	// DoCache is similar to Do, but it uses opt-in client side caching and requires a client side TTL.
	// The explicit client side TTL specifies the maximum TTL on the client side.
	// If the key's TTL on the server is smaller than the client side TTL, the client side TTL will be capped.
	//  client.Do(ctx, client.B().Get().Key("k").Cache(), time.Minute).ToString()
	// The above example will send the following command to redis if cache miss:
	//  CLIENT CACHING YES
	//  PTTL k
	//  GET k
	// The in-memory cache size is configured by ClientOption.CacheSizeEachConn.
	// The cmd parameter is recycled after passing into DoCache() and should not be reused.
	DoCache(ctx context.Context, cmd Cacheable, ttl time.Duration) (resp RedisResult)
	// DoMultiCache is similar to DoCache, but works with multiple cacheable commands across different slots.
	// It will first group commands by slots and will send only cache missed commands to redis.
	DoMultiCache(ctx context.Context, multi ...CacheableTTL) (resp []RedisResult)

	// Receive accepts SUBSCRIBE, SSUBSCRIBE, PSUBSCRIBE command and a message handler.
	// Receive will block and then return value only when the following cases:
	//   1. return nil when received any unsubscribe/punsubscribe message related to the provided `subscribe` command.
	//   2. return ErrClosing when the client is closed manually.
	//   3. return ctx.Err() when the `ctx` is done.
	//   4. return non-nil err when the provided `subscribe` command failed.
	Receive(ctx context.Context, subscribe Completed, fn func(msg PubSubMessage)) error

	// Dedicated acquire a connection from the blocking connection pool, no one else can use the connection
	// during Dedicated. The main usage of Dedicated is CAS operation, which is WATCH + MULTI + EXEC.
	// However, one should try to avoid CAS operation but use Lua script instead, because occupying a connection
	// is not good for performance.
	Dedicated(fn func(DedicatedClient) error) (err error)

	// Dedicate does the same as Dedicated, but it exposes DedicatedClient directly
	// and requires user to invoke cancel() manually to put connection back to the pool.
	Dedicate() (client DedicatedClient, cancel func())

	// Nodes returns each redis node this client known as rueidis.Client. This is useful if you want to
	// send commands to some specific redis nodes in the cluster.
	Nodes() map[string]Client

	// Close will make further calls to the client be rejected with ErrClosing,
	// and Close will wait until all pending calls finished.
	Close()
}

Client is the redis client interface for both single redis instance and redis cluster. It should be created from the NewClient()

Example (DedicateCAS) 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

c, cancel := client.Dedicate()
defer cancel()

ctx := context.Background()

// watch keys first
if err := c.Do(ctx, c.B().Watch().Key("k1", "k2").Build()).Error(); err != nil {
	panic(err)
}
// perform read here
values, err := c.Do(ctx, c.B().Mget().Key("k1", "k2").Build()).ToArray()
if err != nil {
	panic(err)
}
v1, _ := values[0].ToString()
v2, _ := values[1].ToString()
// perform write with MULTI EXEC
for _, resp := range c.DoMulti(
	ctx,
	c.B().Multi().Build(),
	c.B().Set().Key("k1").Value(v1+"1").Build(),
	c.B().Set().Key("k2").Value(v2+"2").Build(),
	c.B().Exec().Build(),
) {
	if err := resp.Error(); err != nil {
		panic(err)
	}
}

Output:
Example (DedicatedCAS) 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

ctx := context.Background()

client.Dedicated(func(client DedicatedClient) error {
	// watch keys first
	if err := client.Do(ctx, client.B().Watch().Key("k1", "k2").Build()).Error(); err != nil {
		return err
	}
	// perform read here
	values, err := client.Do(ctx, client.B().Mget().Key("k1", "k2").Build()).ToArray()
	if err != nil {
		return err
	}
	v1, _ := values[0].ToString()
	v2, _ := values[1].ToString()
	// perform write with MULTI EXEC
	for _, resp := range client.DoMulti(
		ctx,
		client.B().Multi().Build(),
		client.B().Set().Key("k1").Value(v1+"1").Build(),
		client.B().Set().Key("k2").Value(v2+"2").Build(),
		client.B().Exec().Build(),
	) {
		if err := resp.Error(); err != nil {
			return err
		}
	}
	return nil
})

Output:
Example (Do) 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

ctx := context.Background()

client.Do(ctx, client.B().Set().Key("k").Value("1").Build()).Error()

client.Do(ctx, client.B().Get().Key("k").Build()).ToString()

client.Do(ctx, client.B().Get().Key("k").Build()).AsInt64()

client.Do(ctx, client.B().Hmget().Key("h").Field("a", "b").Build()).ToArray()

client.Do(ctx, client.B().Scard().Key("s").Build()).ToInt64()

client.Do(ctx, client.B().Smembers().Key("s").Build()).AsStrSlice()

Output:
Example (DoCache) 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

ctx := context.Background()

client.DoCache(ctx, client.B().Get().Key("k").Cache(), time.Minute).ToString()

client.DoCache(ctx, client.B().Get().Key("k").Cache(), time.Minute).AsInt64()

client.DoCache(ctx, client.B().Hmget().Key("h").Field("a", "b").Cache(), time.Minute).ToArray()

client.DoCache(ctx, client.B().Scard().Key("s").Cache(), time.Minute).ToInt64()

client.DoCache(ctx, client.B().Smembers().Key("s").Cache(), time.Minute).AsStrSlice()

Output:
Example (Scan) 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

for _, c := range client.Nodes() { // loop over all your redis nodes
	var scan ScanEntry
	for more := true; more; more = scan.Cursor != 0 {
		if scan, err = c.Do(context.Background(), c.B().Scan().Cursor(scan.Cursor).Build()).AsScanEntry(); err != nil {
			panic(err)
		}
		fmt.Println(scan.Elements)
	}
}

Output:

func NewClient added in v0.0.7 

func NewClient(option ClientOption) (client Client, err error)

NewClient uses ClientOption to initialize the Client for both cluster client and single client. It will first try to connect as cluster client. If the len(ClientOption.InitAddress) == 1 and the address does not enable cluster mode, the NewClient() will use single client instead.

Example (Cluster) 
client, _ := NewClient(ClientOption{
	InitAddress: []string{"127.0.0.1:7001", "127.0.0.1:7002", "127.0.0.1:7003"},
	ShuffleInit: true,
})
defer client.Close()

Output:
Example (Sentinel) 
client, _ := NewClient(ClientOption{
	InitAddress: []string{"127.0.0.1:26379", "127.0.0.1:26380", "127.0.0.1:26381"},
	Sentinel: SentinelOption{
		MasterSet: "my_master",
	},
})
defer client.Close()

Output:
Example (Single) 
client, _ := NewClient(ClientOption{
	InitAddress: []string{"127.0.0.1:6379"},
})
defer client.Close()

Output:

type ClientOption added in v0.0.7 

type ClientOption struct {
	// TCP & TLS
	// Dialer can be used to customized how rueidis connect to a redis instance via TCP, including:
	// - Timeout, the default is DefaultDialTimeout
	// - KeepAlive, the default is DefaultTCPKeepAlive
	// The Dialer.KeepAlive interval is used to detect an unresponsive idle tcp connection.
	// OS takes at least (tcp_keepalive_probes+1)*Dialer.KeepAlive time to conclude an idle connection to be unresponsive.
	// For example: DefaultTCPKeepAlive = 1s and the default of tcp_keepalive_probes on Linux is 9.
	// Therefore, it takes at least 10s to kill an idle and unresponsive tcp connection on Linux by default.
	Dialer    net.Dialer
	TLSConfig *tls.Config

	// OnInvalidations is a callback function in case of client-side caching invalidation received.
	// Note that this function must be fast, otherwise other redis messages will be blocked.
	OnInvalidations func([]RedisMessage)

	// Sentinel options, including MasterSet and Auth options
	Sentinel SentinelOption

	// Redis AUTH parameters
	Username   string
	Password   string
	ClientName string

	// InitAddress point to redis nodes.
	// Rueidis will connect to them one by one and issue CLUSTER SLOT command to initialize the cluster client until success.
	// If len(InitAddress) == 1 and the address is not running in cluster mode, rueidis will fall back to the single client mode.
	// If ClientOption.Sentinel.MasterSet is set, then InitAddress will be used to connect sentinels
	InitAddress []string

	// ClientTrackingOptions will be appended to CLIENT TRACKING ON command when the connection is established.
	// The default is []string{"OPTIN"}
	ClientTrackingOptions []string

	SelectDB int

	// CacheSizeEachConn is redis client side cache size that bind to each TCP connection to a single redis instance.
	// The default is DefaultCacheBytes.
	CacheSizeEachConn int

	// RingScaleEachConn sets the size of the ring buffer in each connection to (2 ^ RingScaleEachConn).
	// The default is RingScaleEachConn, which results into having a ring of size 2^10 for each connection.
	// Reduce this value can reduce the memory consumption of each connection at the cost of potential throughput degradation.
	// Values smaller than 8 is typically not recommended.
	RingScaleEachConn int

	// ReadBufferEachConn is the size of the bufio.NewReaderSize for each connection, default to DefaultReadBuffer (0.5 MiB).
	ReadBufferEachConn int
	// WriteBufferEachConn is the size of the bufio.NewWriterSize for each connection, default to DefaultWriteBuffer (0.5 MiB).
	WriteBufferEachConn int

	// BlockingPoolSize is the size of the connection pool shared by blocking commands (ex BLPOP, XREAD with BLOCK).
	// The default is DefaultPoolSize.
	BlockingPoolSize int

	// PipelineMultiplex determines how many tcp connections used to pipeline commands to one redis instance.
	// The default for single and sentinel clients is 2, which means 4 connections (2^2).
	// The default for cluster client is 0, which means 1 connection (2^0).
	PipelineMultiplex int

	// ConnWriteTimeout is applied net.Conn.SetWriteDeadline and periodic PING to redis
	// Since the Dialer.KeepAlive will not be triggered if there is data in the outgoing buffer,
	// ConnWriteTimeout should be set in order to detect local congestion or unresponsive redis server.
	// This default is ClientOption.Dialer.KeepAlive * (9+1), where 9 is the default of tcp_keepalive_probes on Linux.
	ConnWriteTimeout time.Duration

	// MaxFlushDelay when greater than zero pauses pipeline write loop for some time (not larger than MaxFlushDelay)
	// after each flushing of data to the connection. This gives pipeline a chance to collect more commands to send
	// to Redis. Adding this delay increases latency, reduces throughput – but in most cases may significantly reduce
	// application and Redis CPU utilization due to less executed system calls. By default, Rueidis flushes data to the
	// connection without extra delays. Depending on network latency and application-specific conditions the value
	// of MaxFlushDelay may vary, sth like 20 microseconds should not affect latency/throughput a lot but still
	// produce notable CPU usage reduction under load. Ref: https://github.com/rueian/rueidis/issues/156
	MaxFlushDelay time.Duration

	// ShuffleInit is a handy flag that shuffles the InitAddress after passing to the NewClient() if it is true
	ShuffleInit bool
	// DisableRetry disables retrying read-only commands under network errors
	DisableRetry bool
	// DisableCache falls back Client.DoCache/Client.DoMultiCache to Client.Do/Client.DoMulti
	DisableCache bool
	// AlwaysPipelining makes rueidis.Client always pipeline redis commands even if they are not issued concurrently.
	AlwaysPipelining bool
	// AlwaysRESP2 makes rueidis.Client always uses RESP2, otherwise it will try using RESP3 first.
	AlwaysRESP2 bool
}

ClientOption should be passed to NewClient to construct a Client

type Commands added in v0.0.41 

type Commands []Completed

Commands is an exported alias to []Completed. This allows users to store commands for later usage, for example: 

c, release := client.Dedicate()
defer release()

cmds := make(rueidis.Commands, 0, 10)
for i := 0; i < 10; i++ {
    cmds = append(cmds, c.B().Set().Key(strconv.Itoa(i)).Value(strconv.Itoa(i)).Build())
}
for _, resp := range c.DoMulti(ctx, cmds...) {
    if err := resp.Error(); err != nil {
    panic(err)
}

However, please know that once commands are processed by the Do() or DoMulti(), they are recycled and should not be reused.

type Completed added in v0.0.99 

type Completed = cmds.Completed

Completed represents a completed Redis command, should be created by the Build() of command builder.

type DedicatedClient added in v0.0.7 

type DedicatedClient interface {
	// B is inherited from the Client
	B() cmds.Builder
	// Do is the same as Client's
	// The cmd parameter is recycled after passing into Do() and should not be reused.
	Do(ctx context.Context, cmd Completed) (resp RedisResult)
	// DoMulti takes multiple redis commands and sends them together, reducing RTT from the user code.
	// The multi parameters are recycled after passing into DoMulti() and should not be reused.
	DoMulti(ctx context.Context, multi ...Completed) (resp []RedisResult)
	// Receive is the same as Client's
	Receive(ctx context.Context, subscribe Completed, fn func(msg PubSubMessage)) error
	// SetPubSubHooks is an alternative way to processing Pub/Sub messages instead of using Receive.
	// SetPubSubHooks is non-blocking and allows users to subscribe/unsubscribe channels later.
	// Note that the hooks will be called sequentially but in another goroutine.
	// The return value will be either:
	//   1. an error channel, if the hooks passed in is not zero, or
	//   2. nil, if the hooks passed in is zero. (used for reset hooks)
	// In the former case, the error channel is guaranteed to be close when the hooks will not be called anymore,
	// and has at most one error describing the reason why the hooks will not be called anymore.
	// Users can use the error channel to detect disconnection.
	SetPubSubHooks(hooks PubSubHooks) <-chan error
	// Close closes the dedicated connection and prevent the connection be put back into the pool.
	Close()
}

DedicatedClient is obtained from Client.Dedicated() and it will be bound to single redis connection and no other commands can be pipelined in to this connection during Client.Dedicated(). If the DedicatedClient is obtained from cluster client, the first command to it must have a Key() to identify the redis node.

type FtSearchDoc added in v0.0.98 

type FtSearchDoc struct {
	Doc map[string]string
	Key string
}

type KeyValues added in v0.0.95 

type KeyValues struct {
	Key    string
	Values []string
}

type KeyZScores added in v0.0.95 

type KeyZScores struct {
	Key    string
	Values []ZScore
}

type Lua added in v0.0.3 

type Lua struct {
	// contains filtered or unexported fields
}

Lua represents a redis lua script. It should be created from the NewLuaScript() or NewLuaScriptReadOnly()

Example (Exec) 
client, err := NewClient(ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
if err != nil {
	panic(err)
}
defer client.Close()

ctx := context.Background()

script := NewLuaScript("return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}")

script.Exec(ctx, client, []string{"k1", "k2"}, []string{"a1", "a2"}).ToArray()

Output:

func NewLuaScript added in v0.0.7 

func NewLuaScript(script string) *Lua

NewLuaScript creates a Lua instance whose Lua.Exec uses EVALSHA and EVAL.

func NewLuaScriptReadOnly added in v0.0.7 

func NewLuaScriptReadOnly(script string) *Lua

NewLuaScriptReadOnly creates a Lua instance whose Lua.Exec uses EVALSHA_RO and EVAL_RO.

func (*Lua) Exec added in v0.0.3 

func (s *Lua) Exec(ctx context.Context, c Client, keys, args []string) (resp RedisResult)

Exec the script to the given Client. It will first try with the EVALSHA/EVALSHA_RO and then EVAL/EVAL_RO if first try failed. Cross slot keys are prohibited if the Client is a cluster client.

func (*Lua) ExecMulti added in v0.0.83 

func (s *Lua) ExecMulti(ctx context.Context, c Client, multi ...LuaExec) (resp []RedisResult)

ExecMulti exec the script multiple times by the provided LuaExec to the given Client. It will first try SCRIPT LOAD the script to all redis nodes and then exec it with the EVALSHA/EVALSHA_RO. Cross slot keys within single LuaExec are prohibited if the Client is a cluster client.

type LuaExec added in v0.0.83 

type LuaExec struct {
	Keys []string
	Args []string
}

LuaExec is a single execution unit of Lua.ExecMulti

type PubSubHooks added in v0.0.53 

type PubSubHooks struct {
	// OnMessage will be called when receiving "message" and "pmessage" event.
	OnMessage func(m PubSubMessage)
	// OnSubscription will be called when receiving "subscribe", "unsubscribe", "psubscribe" and "punsubscribe" event.
	OnSubscription func(s PubSubSubscription)
}

PubSubHooks can be registered into DedicatedClient to process pubsub messages without using Client.Receive

type PubSubMessage added in v0.0.35 

type PubSubMessage struct {
	// Pattern is only available with pmessage.
	Pattern string
	// Channel is the channel the message belongs to
	Channel string
	// Message is the message content
	Message string
}

PubSubMessage represent a pubsub message from redis

type PubSubSubscription added in v0.0.53 

type PubSubSubscription struct {
	// Kind is "subscribe", "unsubscribe", "psubscribe" or "punsubscribe"
	Kind string
	// Channel is the event subject.
	Channel string
	// Count is the current number of subscriptions for connection.
	Count int64
}

PubSubSubscription represent a pubsub "subscribe", "unsubscribe", "psubscribe" or "punsubscribe" event.

type RedirectMode added in v0.0.59 

type RedirectMode int
const (
	RedirectNone RedirectMode = iota
	RedirectMove
	RedirectAsk
	RedirectRetry
)

type RedisError added in v0.0.11 

type RedisError RedisMessage

RedisError is an error response or a nil message from redis instance

func (*RedisError) Error added in v0.0.11 

func (r *RedisError) Error() string

func (*RedisError) IsAsk added in v0.0.11 

func (r *RedisError) IsAsk() (addr string, ok bool)

IsAsk checks if it is a redis ASK message and returns ask address.

func (*RedisError) IsClusterDown added in v0.0.59 

func (r *RedisError) IsClusterDown() bool

IsClusterDown checks if it is a redis CLUSTERDOWN message and returns ask address.

func (*RedisError) IsMoved added in v0.0.11 

func (r *RedisError) IsMoved() (addr string, ok bool)

IsMoved checks if it is a redis MOVED message and returns moved address.

func (*RedisError) IsNil added in v0.0.11 

func (r *RedisError) IsNil() bool

IsNil checks if it is a redis nil message.

func (*RedisError) IsNoScript added in v0.0.11 

func (r *RedisError) IsNoScript() bool

IsNoScript checks if it is a redis NOSCRIPT message.

func (*RedisError) IsTryAgain added in v0.0.11 

func (r *RedisError) IsTryAgain() bool

IsTryAgain checks if it is a redis TRYAGAIN message and returns ask address.

type RedisMessage added in v0.0.11 

type RedisMessage struct {
	// contains filtered or unexported fields
}

RedisMessage is a redis response message, it may be a nil response

func (*RedisMessage) AsBool added in v0.0.44 

func (m *RedisMessage) AsBool() (val bool, err error)

AsBool checks if message is non-nil redis response, and parses it as bool

func (*RedisMessage) AsBytes added in v0.0.96 

func (m *RedisMessage) AsBytes() (bs []byte, err error)

AsBytes check if message is a redis string response and return it as an immutable []byte

func (*RedisMessage) AsFloat64 added in v0.0.17 

func (m *RedisMessage) AsFloat64() (val float64, err error)

AsFloat64 check if message is a redis string response, and parse it as float64

func (*RedisMessage) AsFloatSlice added in v0.0.44 

func (m *RedisMessage) AsFloatSlice() ([]float64, error)

AsFloatSlice check if message is a redis array/set response, and convert to []float64. redis nil element and other non float element will be present as zero.

func (*RedisMessage) AsFtSearch added in v0.0.98 

func (m *RedisMessage) AsFtSearch() (total int64, docs []FtSearchDoc, err error)

func (*RedisMessage) AsInt64 added in v0.0.15 

func (m *RedisMessage) AsInt64() (val int64, err error)

AsInt64 check if message is a redis string response, and parse it as int64

func (*RedisMessage) AsIntMap added in v0.0.44 

func (m *RedisMessage) AsIntMap() (map[string]int64, error)

AsIntMap check if message is a redis map/array/set response, and convert to map[string]int64. redis nil element and other non integer element will be present as zero.

func (*RedisMessage) AsIntSlice added in v0.0.44 

func (m *RedisMessage) AsIntSlice() ([]int64, error)

AsIntSlice check if message is a redis array/set response, and convert to []int64. redis nil element and other non integer element will be present as zero.

func (*RedisMessage) AsLMPop added in v0.0.95 

func (m *RedisMessage) AsLMPop() (kvs KeyValues, err error)

func (*RedisMessage) AsMap added in v0.0.16 

func (m *RedisMessage) AsMap() (map[string]RedisMessage, error)

AsMap check if message is a redis array/set response, and convert to map[string]RedisMessage

func (*RedisMessage) AsReader added in v0.0.32 

func (m *RedisMessage) AsReader() (reader io.Reader, err error)

AsReader check if message is a redis string response and wrap it with the strings.NewReader

func (*RedisMessage) AsScanEntry added in v0.0.91 

func (m *RedisMessage) AsScanEntry() (e ScanEntry, err error)

AsScanEntry check if message is a redis array/set response of length 2, and convert to ScanEntry.

func (*RedisMessage) AsStrMap added in v0.0.17 

func (m *RedisMessage) AsStrMap() (map[string]string, error)

AsStrMap check if message is a redis map/array/set response, and convert to map[string]string. redis nil element and other non string element will be present as zero.

func (*RedisMessage) AsStrSlice added in v0.0.17 

func (m *RedisMessage) AsStrSlice() ([]string, error)

AsStrSlice check if message is a redis array/set response, and convert to []string. redis nil element and other non string element will be present as zero.

func (*RedisMessage) AsUint64 added in v0.0.92 

func (m *RedisMessage) AsUint64() (val uint64, err error)

AsUint64 check if message is a redis string response, and parse it as uint64

func (*RedisMessage) AsXRange added in v0.0.44 

func (m *RedisMessage) AsXRange() ([]XRangeEntry, error)

AsXRange check if message is a redis array/set response, and convert to []XRangeEntry

func (*RedisMessage) AsXRangeEntry added in v0.0.77 

func (m *RedisMessage) AsXRangeEntry() (XRangeEntry, error)

AsXRangeEntry check if message is a redis array/set response of length 2, and convert to XRangeEntry

func (*RedisMessage) AsXRead added in v0.0.77 

func (m *RedisMessage) AsXRead() (ret map[string][]XRangeEntry, err error)

AsXRead converts XREAD/XREADGRUOP response to map[string][]XRangeEntry

func (*RedisMessage) AsZMPop added in v0.0.95 

func (m *RedisMessage) AsZMPop() (kvs KeyZScores, err error)

func (*RedisMessage) AsZScore added in v0.0.77 

func (m *RedisMessage) AsZScore() (s ZScore, err error)

AsZScore converts ZPOPMAX and ZPOPMIN command with count 1 response to a single ZScore

func (*RedisMessage) AsZScores added in v0.0.77 

func (m *RedisMessage) AsZScores() ([]ZScore, error)

AsZScores converts ZRANGE WITHSCROES, ZDIFF WITHSCROES and ZPOPMAX/ZPOPMIN command with count > 1 responses to []ZScore

func (*RedisMessage) CacheTTL added in v0.0.89 

func (m *RedisMessage) CacheTTL() int64

CacheTTL returns the remaining TTL in seconds of client side cache

func (*RedisMessage) DecodeJSON added in v0.0.32 

func (m *RedisMessage) DecodeJSON(v any) (err error)

DecodeJSON check if message is a redis string response and treat it as json, then unmarshal it into provided value

func (*RedisMessage) Error added in v0.0.11 

func (m *RedisMessage) Error() error

Error check if message is a redis error response, including nil response

func (*RedisMessage) IsArray added in v0.0.60 

func (m *RedisMessage) IsArray() bool

IsArray check if message is a redis array response

func (*RedisMessage) IsBool added in v0.0.60 

func (m *RedisMessage) IsBool() bool

IsBool check if message is a redis RESP3 bool response

func (*RedisMessage) IsCacheHit added in v0.0.19 

func (m *RedisMessage) IsCacheHit() bool

IsCacheHit check if message is from client side cache

func (*RedisMessage) IsFloat64 added in v0.0.60 

func (m *RedisMessage) IsFloat64() bool

IsFloat64 check if message is a redis RESP3 double response

func (*RedisMessage) IsInt64 added in v0.0.60 

func (m *RedisMessage) IsInt64() bool

IsInt64 check if message is a redis RESP3 int response

func (*RedisMessage) IsMap added in v0.0.60 

func (m *RedisMessage) IsMap() bool

IsMap check if message is a redis RESP3 map response

func (*RedisMessage) IsNil added in v0.0.11 

func (m *RedisMessage) IsNil() bool

IsNil check if message is a redis nil response

func (*RedisMessage) IsString added in v0.0.60 

func (m *RedisMessage) IsString() bool

IsString check if message is a redis string response

func (*RedisMessage) ToAny added in v0.0.44 

func (m *RedisMessage) ToAny() (any, error)

ToAny turns message into go any value

func (*RedisMessage) ToArray added in v0.0.11 

func (m *RedisMessage) ToArray() ([]RedisMessage, error)

ToArray check if message is a redis array/set response, and return it

func (*RedisMessage) ToBool added in v0.0.11 

func (m *RedisMessage) ToBool() (val bool, err error)

ToBool check if message is a redis RESP3 bool response, and return it

func (*RedisMessage) ToFloat64 added in v0.0.11 

func (m *RedisMessage) ToFloat64() (val float64, err error)

ToFloat64 check if message is a redis RESP3 double response, and return it

func (*RedisMessage) ToInt64 added in v0.0.11 

func (m *RedisMessage) ToInt64() (val int64, err error)

ToInt64 check if message is a redis RESP3 int response, and return it

func (*RedisMessage) ToMap added in v0.0.11 

func (m *RedisMessage) ToMap() (map[string]RedisMessage, error)

ToMap check if message is a redis RESP3 map response, and return it

func (*RedisMessage) ToString added in v0.0.11 

func (m *RedisMessage) ToString() (val string, err error)

ToString check if message is a redis string response, and return it

type RedisResult added in v0.0.11 

type RedisResult struct {
	// contains filtered or unexported fields
}

RedisResult is the return struct from Client.Do or Client.DoCache it contains either a redis response or an underlying error (ex. network timeout).

func (RedisResult) AsBool added in v0.0.44 

func (r RedisResult) AsBool() (v bool, err error)

AsBool delegates to RedisMessage.AsBool

func (RedisResult) AsBytes added in v0.0.96 

func (r RedisResult) AsBytes() (v []byte, err error)

AsBytes delegates to RedisMessage.AsBytes

func (RedisResult) AsFloat64 added in v0.0.17 

func (r RedisResult) AsFloat64() (v float64, err error)

AsFloat64 delegates to RedisMessage.AsFloat64

func (RedisResult) AsFloatSlice added in v0.0.44 

func (r RedisResult) AsFloatSlice() (v []float64, err error)

AsFloatSlice delegates to RedisMessage.AsFloatSlice

func (RedisResult) AsFtSearch added in v0.0.98 

func (r RedisResult) AsFtSearch() (total int64, docs []FtSearchDoc, err error)

func (RedisResult) AsInt64 added in v0.0.15 

func (r RedisResult) AsInt64() (v int64, err error)

AsInt64 delegates to RedisMessage.AsInt64

func (RedisResult) AsIntMap added in v0.0.44 

func (r RedisResult) AsIntMap() (v map[string]int64, err error)

AsIntMap delegates to RedisMessage.AsIntMap

func (RedisResult) AsIntSlice added in v0.0.44 

func (r RedisResult) AsIntSlice() (v []int64, err error)

AsIntSlice delegates to RedisMessage.AsIntSlice

func (RedisResult) AsLMPop added in v0.0.95 

func (r RedisResult) AsLMPop() (v KeyValues, err error)

func (RedisResult) AsMap added in v0.0.16 

func (r RedisResult) AsMap() (v map[string]RedisMessage, err error)

AsMap delegates to RedisMessage.AsMap

func (RedisResult) AsReader added in v0.0.32 

func (r RedisResult) AsReader() (v io.Reader, err error)

AsReader delegates to RedisMessage.AsReader

func (RedisResult) AsScanEntry added in v0.0.91 

func (r RedisResult) AsScanEntry() (v ScanEntry, err error)

AsScanEntry delegates to RedisMessage.AsScanEntry.

func (RedisResult) AsStrMap added in v0.0.17 

func (r RedisResult) AsStrMap() (v map[string]string, err error)

AsStrMap delegates to RedisMessage.AsStrMap

func (RedisResult) AsStrSlice added in v0.0.17 

func (r RedisResult) AsStrSlice() (v []string, err error)

AsStrSlice delegates to RedisMessage.AsStrSlice

func (RedisResult) AsUint64 added in v0.0.92 

func (r RedisResult) AsUint64() (v uint64, err error)

AsUint64 delegates to RedisMessage.AsUint64

func (RedisResult) AsXRange added in v0.0.44 

func (r RedisResult) AsXRange() (v []XRangeEntry, err error)

AsXRange delegates to RedisMessage.AsXRange

func (RedisResult) AsXRangeEntry added in v0.0.77 

func (r RedisResult) AsXRangeEntry() (v XRangeEntry, err error)

AsXRangeEntry delegates to RedisMessage.AsXRangeEntry

func (RedisResult) AsXRead added in v0.0.77 

func (r RedisResult) AsXRead() (v map[string][]XRangeEntry, err error)

AsXRead delegates to RedisMessage.AsXRead

func (RedisResult) AsZMPop added in v0.0.95 

func (r RedisResult) AsZMPop() (v KeyZScores, err error)

func (RedisResult) AsZScore added in v0.0.77 

func (r RedisResult) AsZScore() (v ZScore, err error)

AsZScore delegates to RedisMessage.AsZScore

func (RedisResult) AsZScores added in v0.0.77 

func (r RedisResult) AsZScores() (v []ZScore, err error)

AsZScores delegates to RedisMessage.AsZScores

func (RedisResult) CacheTTL added in v0.0.89 

func (r RedisResult) CacheTTL() int64

CacheTTL delegates to RedisMessage.CacheTTL

func (RedisResult) DecodeJSON added in v0.0.32 

func (r RedisResult) DecodeJSON(v any) (err error)

DecodeJSON delegates to RedisMessage.DecodeJSON

func (RedisResult) Error added in v0.0.11 

func (r RedisResult) Error() (err error)

Error returns either underlying error or redis error or nil

func (RedisResult) IsCacheHit added in v0.0.19 

func (r RedisResult) IsCacheHit() bool

IsCacheHit delegates to RedisMessage.IsCacheHit

func (RedisResult) NonRedisError added in v0.0.11 

func (r RedisResult) NonRedisError() error

NonRedisError can be used to check if there is an underlying error (ex. network timeout).

func (RedisResult) RedisError added in v0.0.11 

func (r RedisResult) RedisError() *RedisError

RedisError can be used to check if the redis response is an error message.

func (RedisResult) ToAny added in v0.0.44 

func (r RedisResult) ToAny() (v any, err error)

ToAny delegates to RedisMessage.ToAny

func (RedisResult) ToArray added in v0.0.11 

func (r RedisResult) ToArray() (v []RedisMessage, err error)

ToArray delegates to RedisMessage.ToArray

func (RedisResult) ToBool added in v0.0.11 

func (r RedisResult) ToBool() (v bool, err error)

ToBool delegates to RedisMessage.ToBool

func (RedisResult) ToFloat64 added in v0.0.11 

func (r RedisResult) ToFloat64() (v float64, err error)

ToFloat64 delegates to RedisMessage.ToFloat64

func (RedisResult) ToInt64 added in v0.0.11 

func (r RedisResult) ToInt64() (v int64, err error)

ToInt64 delegates to RedisMessage.ToInt64

func (RedisResult) ToMap added in v0.0.11 

func (r RedisResult) ToMap() (v map[string]RedisMessage, err error)

ToMap delegates to RedisMessage.ToMap

func (RedisResult) ToMessage added in v0.0.15 

func (r RedisResult) ToMessage() (v RedisMessage, err error)

ToMessage retrieves the RedisMessage

func (RedisResult) ToString added in v0.0.11 

func (r RedisResult) ToString() (v string, err error)

ToString delegates to RedisMessage.ToString

type ScanEntry added in v0.0.91 

type ScanEntry struct {
	Cursor   uint64
	Elements []string
}

ScanEntry is the element type of both SCAN, SSCAN, HSCAN and ZSCAN command response.

type SentinelOption added in v0.0.30 

type SentinelOption struct {
	// TCP & TLS, same as ClientOption but for connecting sentinel
	Dialer    net.Dialer
	TLSConfig *tls.Config

	// MasterSet is the redis master set name monitored by sentinel cluster.
	// If this field is set, then ClientOption.InitAddress will be used to connect to sentinel cluster.
	MasterSet string

	// Redis AUTH parameters for sentinel
	Username   string
	Password   string
	ClientName string
}

SentinelOption contains MasterSet,

type XRangeEntry added in v0.0.77 

type XRangeEntry struct {
	FieldValues map[string]string
	ID          string
}

XRangeEntry is the element type of both XRANGE and XREVRANGE command response array

type ZScore added in v0.0.77 

type ZScore struct {
	Member string
	Score  float64
}

ZScore is the element type of ZRANGE WITHSCORES, ZDIFF WITHSCORES and ZPOPMAX command response

Source Files

View all Source files

Directories

Path Synopsis
hack
cmds
internal
cmds
util

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.