Rueidis

https://pkg.go.dev/github.com/redis/rueidis
Admin
Rueidis is a fast Golang Redis client that does auto pipelining and supports server-assisted...
Tokens:278,693
Snippets:2,025
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get Command Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for constructing a GET command.

```go
type Get Incomplete
```

```go
func (c Get) Key(key string) GetKey
```

```go
type GetKey Incomplete
```

```go
func (c GetKey) Build() Completed
```

```go
func (c GetKey) Cache() Cacheable
```

--------------------------------

### Install rueidislimiter

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidislimiter

Command to install the module via Go modules.

```bash
go get github.com/redis/rueidis/rueidislimiter
```

--------------------------------

### ArgrepKey Start Method

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Sets the start string for an ArgrepKey operation.

```go
func (c ArgrepKey) Start(start string) ArgrepStart
```

--------------------------------

### Start Valkey Server with RDMA

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidisrdma

Launch the Valkey server loading the RDMA module and binding to the RDMA interface.

```bash
./src/valkey-server --loadmodule ./src/valkey-rdma.so --rdma-bind <server ip on the rdma netdev> --rdma-port 6378
```

--------------------------------

### Create Rate Limiter Instance

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidislimiter

Example of creating a new rate limiter instance with specific configuration options.

```go
limiter, err := rueidislimiter.NewRateLimiter(rueidislimiter.RateLimiterOption{
	ClientOption: rueidis.ClientOption{InitAddress: []string{"localhost:6379"}},
	KeyPrefix:    "api_rate_limit",
	Limit:        5,
	Window:       time.Second,
})
```

--------------------------------

### Build Valkey with RDMA Module

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidisrdma

Commands to install dependencies and build the Valkey server with the RDMA module enabled.

```bash
sudo apt install -y build-essential pkg-config libjemalloc-dev
sudo apt install -y librdmacm-dev rdma-core rdmacm-utils
wget https://github.com/valkey-io/valkey/archive/refs/tags/9.0.1.tar.gz
tar -zxvf 9.0.1.tar.gz && rm 9.0.1.tar.gz
cd valkey-9.0.1

BUILD_RDMA=module make
```

--------------------------------

### Suggestion Get Command Builder

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Fluent API for building FT.SUGGET commands.

```go
type FtSugget Incomplete
```

```go
func (c FtSugget) Key(key string) FtSuggetKey
```

```go
type FtSuggetFuzzy Incomplete
```

```go
func (c FtSuggetFuzzy) Build() Completed
```

```go
func (c FtSuggetFuzzy) Max(max int64) FtSuggetMax
```

```go
func (c FtSuggetFuzzy) Withpayloads() FtSuggetWithpayloads
```

```go
func (c FtSuggetFuzzy) Withscores() FtSuggetWithscores
```

```go
type FtSuggetKey Incomplete
```

```go
func (c FtSuggetKey) Prefix(prefix string) FtSuggetPrefix
```

```go
type FtSuggetMax Incomplete
```

```go
func (c FtSuggetMax) Build() Completed
```

```go
type FtSuggetPrefix Incomplete
```

```go
func (c FtSuggetPrefix) Build() Completed
```

```go
func (c FtSuggetPrefix) Fuzzy() FtSuggetFuzzy
```

```go
func (c FtSuggetPrefix) Max(max int64) FtSuggetMax
```

```go
func (c FtSuggetPrefix) Withpayloads() FtSuggetWithpayloads
```

```go
func (c FtSuggetPrefix) Withscores() FtSuggetWithscores
```

```go
type FtSuggetWithpayloads Incomplete
```

```go
func (c FtSuggetWithpayloads) Build() Completed
```

```go
func (c FtSuggetWithpayloads) Max(max int64) FtSuggetMax
```

```go
type FtSuggetWithscores Incomplete
```

```go
func (c FtSuggetWithscores) Build() Completed
```

```go
func (c FtSuggetWithscores) Max(max int64) FtSuggetMax
```

```go
func (c FtSuggetWithscores) Withpayloads() FtSuggetWithpayloads
```

--------------------------------

### Configuration Pipeline Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Methods for getting and setting Redis server configuration parameters.

```go
func (c *Pipeline) ConfigGet(ctx context.Context, parameter string) *StringStringMapCmd
```

```go
func (c *Pipeline) ConfigResetStat(ctx context.Context) *StatusCmd
```

```go
func (c *Pipeline) ConfigRewrite(ctx context.Context) *StatusCmd
```

```go
func (c *Pipeline) ConfigSet(ctx context.Context, parameter, value string) *StatusCmd
```

--------------------------------

### Build Vector Search Queries

Source: https://pkg.go.dev/github.com/redis/rueidis

Examples of using vector string conversion functions within a search query builder.

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

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

--------------------------------

### Instantiate Redis Client with Various Topologies

Source: https://pkg.go.dev/github.com/redis/rueidis

Demonstrates creating a new Redis client using different connection configurations such as single node, cluster, sentinel, and unix sockets.

```go
// Connect to a single redis node:
client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"127.0.0.1:6379"},
})

// Connect to a standalone redis with replicas
client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"127.0.0.1:6379"},
    Standalone: rueidis.StandaloneOption{
        // Note that these addresses must be online and cannot be promoted.
        // An example use case is the reader endpoint provided by cloud vendors.
        ReplicaAddress: []string{"reader_endpoint:port"},
    },
    SendToReplicas: func(cmd rueidis.Completed) bool {
        return cmd.IsReadOnly()
    },
})

// Connect to a redis cluster
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,
})

// Connect to a redis cluster and use replicas for read operations
client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"127.0.0.1:7001", "127.0.0.1:7002", "127.0.0.1:7003"},
    SendToReplicas: func(cmd rueidis.Completed) bool {
        return cmd.IsReadOnly()
    },
})

// Connect to sentinels
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",
    },
})
// connect to redis node through unix socket
client, err := rueidis.NewClient(rueidis.ClientOption{
    InitAddress: []string{"/run/valkey.sock"},
    DialCtxFn: func(ctx context.Context, s string, d *net.Dialer, c *tls.Config) (conn net.Conn, err error) {
        return d.DialContext(ctx, "unix", s)
    },
})
```

--------------------------------

### Initialize and Execute Commands with rueidis

Source: https://pkg.go.dev/github.com/redis/rueidis

Demonstrates how to create a new client instance and execute basic Redis commands using the builder pattern.

```go
package main

import (
  "context"
  "github.com/redis/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()
  // HGETALL hm
  hm, err := client.Do(ctx, client.B().Hgetall().Key("hm").Build()).AsStrMap()
}
```

--------------------------------

### HotkeysStartSample Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring sampling parameters.

```go
type HotkeysStartSample Incomplete
```

```go
func (c HotkeysStartSample) Build() Completed
```

```go
func (c HotkeysStartSample) Slots() HotkeysStartSlotsSlots
```

--------------------------------

### ArgetrangeKey Start Method

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Sets the start index for an ArgetrangeKey operation.

```go
func (c ArgetrangeKey) Start(start int64) ArgetrangeStart
```

--------------------------------

### HKeys

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets all keys in a hash.

```go
func (c *Compat) HKeys(ctx context.Context, key string) *StringSliceCmd
```

--------------------------------

### Blpop Key Method

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Initializes the Blpop command with a key.

```go
type Blpop Incomplete
```

```go
func (c Blpop) Key(key ...string) BlpopKey
```

--------------------------------

### Hello Command Builder

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for building the HELLO command with authentication and protocol versioning.

```go
type Hello Incomplete
```

```go
func (c Hello) Build() Completed
```

```go
func (c Hello) Protover(protover int64) HelloArgumentsProtover
```

```go
type HelloArgumentsAuth Incomplete
```

```go
func (c HelloArgumentsAuth) Build() Completed
```

```go
func (c HelloArgumentsAuth) Setname(clientname string) HelloArgumentsSetname
```

```go
type HelloArgumentsProtover Incomplete
```

```go
func (c HelloArgumentsProtover) Auth(username string, password string) HelloArgumentsAuth
```

```go
func (c HelloArgumentsProtover) Build() Completed
```

```go
func (c HelloArgumentsProtover) Setname(clientname string) HelloArgumentsSetname
```

```go
type HelloArgumentsSetname Incomplete
```

```go
func (c HelloArgumentsSetname) Build() Completed
```

--------------------------------

### HRandField

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets random fields from a hash.

```go
func (c *Compat) HRandField(ctx context.Context, key string, count int64) *StringSliceCmd
```

--------------------------------

### Initialize and Use Rate Limiter

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidislimiter

Demonstrates initializing the limiter and performing check, allow, and batch allow operations.

```go
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/redis/rueidis"
	"github.com/redis/rueidis/rueidislimiter"
)

func main() {
	// Initialize a new rate limiter with a limit of 5 requests per minute
	limiter, err := rueidislimiter.NewRateLimiter(rueidislimiter.RateLimiterOption{
		ClientOption: rueidis.ClientOption{InitAddress: []string{"localhost:6379"}},
		KeyPrefix:    "api_rate_limit",
		Limit:        5,
		Window:       time.Minute,
	})
	if err != nil {
		panic(err)
	}

	identifier := "user_123"

	// Check if a request is allowed
	result, err := limiter.Check(context.Background(), identifier)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Allowed: %v, Remaining: %d, RetryAfter: %v\n", result.Allowed, result.Remaining, result.RetryAfter)

	// Allow a request
	result, err = limiter.Allow(context.Background(), identifier)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Allowed: %v, Remaining: %d, RetryAfter: %v\n", result.Allowed, result.Remaining, result.RetryAfter)

	// Allow multiple requests
	result, err = limiter.AllowN(context.Background(), identifier, 3)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Allowed: %v, Remaining: %d, RetryAfter: %v\n", result.Allowed, result.Remaining, result.RetryAfter)
}
```

--------------------------------

### HLen

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets the number of fields in a hash.

```go
func (c *Compat) HLen(ctx context.Context, key string) *IntCmd
```

--------------------------------

### HGetEX

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets hash fields with expiration.

```go
func (c *Compat) HGetEX(ctx context.Context, key string, fields ...string) *StringSliceCmd
```

--------------------------------

### Configure AiModelstoreDeviceCpu

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builder methods for CPU-based model store configuration.

```go
type AiModelstoreDeviceCpu Incomplete
```

```go
func (c AiModelstoreDeviceCpu) Batchsize(batchsize int64) AiModelstoreBatchsize
```

```go
func (c AiModelstoreDeviceCpu) Blob(blob string) AiModelstoreBlob
```

```go
func (c AiModelstoreDeviceCpu) Build() Completed
```

```go
func (c AiModelstoreDeviceCpu) Inputs(inputCount int64) AiModelstoreInputsInputs
```

```go
func (c AiModelstoreDeviceCpu) Minbatchsize(minbatchsize int64) AiModelstoreMinbatchsize
```

```go
func (c AiModelstoreDeviceCpu) Minbatchtimeout(minbatchtimeout int64) AiModelstoreMinbatchtimeout
```

```go
func (c AiModelstoreDeviceCpu) Outputs(outputCount int64) AiModelstoreOutputsOutputs
```

```go
func (c AiModelstoreDeviceCpu) Tag(tag string) AiModelstoreTag
```

--------------------------------

### HGetDel

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets and deletes hash fields.

```go
func (c *Compat) HGetDel(ctx context.Context, key string, fields ...string) *StringSliceCmd
```

--------------------------------

### Command Type and Build Method

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Basic command structure and build method.

```go
type Command Incomplete
```

```go
func (c Command) Build() Completed
```

--------------------------------

### HotkeysStartMetricsCpu Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring CPU-related metrics.

```go
type HotkeysStartMetricsCpu Incomplete
```

```go
func (c HotkeysStartMetricsCpu) Build() Completed
```

```go
func (c HotkeysStartMetricsCpu) Count(k int64) HotkeysStartCount
```

```go
func (c HotkeysStartMetricsCpu) Duration(seconds int64) HotkeysStartDuration
```

```go
func (c HotkeysStartMetricsCpu) Net() HotkeysStartMetricsNet
```

```go
func (c HotkeysStartMetricsCpu) Sample(ratio int64) HotkeysStartSample
```

```go
func (c HotkeysStartMetricsCpu) Slots() HotkeysStartSlotsSlots
```

--------------------------------

### HGetAll

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets all fields and values in a hash.

```go
func (c *Compat) HGetAll(ctx context.Context, key string) *StringStringMapCmd
```

--------------------------------

### Create New Index

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Initializes a new index with provided options and schema.

```go
func (c *Compat) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd
```

--------------------------------

### HGet

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets the value of a hash field.

```go
func (c *Compat) HGet(ctx context.Context, key, field string) *StringCmd
```

--------------------------------

### ClientOption Configuration

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidisaside

Configuration options for initializing the cache-aside client.

```go
type ClientOption struct {
	// ClientBuilder can be used to modify rueidis.Client used by Locker
	ClientBuilder func(option rueidis.ClientOption) (rueidis.Client, error)
	ClientOption  rueidis.ClientOption
	ClientTTL     time.Duration // TTL for the client marker, refreshed every 1/2 TTL. Defaults to 10s. The marker allows other clients to know if this client is still alive.
	UseLuaLock    bool
}
```

--------------------------------

### TSGet

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets the last sample of a time-series key.

```APIDOC
func (c *Compat) TSGet(ctx context.Context, key string) *TSTimestampValueCmd
```

--------------------------------

### HRandFieldWithValues

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets random fields and values from a hash.

```go
func (c *Compat) HRandFieldWithValues(ctx context.Context, key string, count int64) *KeyValueSliceCmd
```

--------------------------------

### Configure AiModelstoreKey

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for selecting the AI model backend.

```go
type AiModelstoreKey Incomplete
```

```go
func (c AiModelstoreKey) Onnx() AiModelstoreBackendOnnx
```

```go
func (c AiModelstoreKey) Tf() AiModelstoreBackendTf
```

```go
func (c AiModelstoreKey) Torch() AiModelstoreBackendTorch
```

--------------------------------

### Initialize and Use an OM Repository

Source: https://pkg.go.dev/github.com/redis/rueidis/om

Demonstrates defining a struct with Redis tags and performing basic CRUD operations using a repository.

```go
package main

import (
    "context"
    "fmt"
    "time"

    "github.com/redis/rueidis"
    "github.com/redis/rueidis/om"
)

type Example struct {
    Key  string    `json:"key" redis:",key"`   // the redis:",key" is required to indicate which field is the ULID key
    Ver  int64     `json:"ver" redis:",ver"`   // the redis:",ver" is optional for optimistic locking to prevent lost update
    ExAt time.Time `json:"exat" redis:",exat"` // the redis:",exat" is optional for setting record expiry with unix timestamp
    Str  string    `json:"str"`                // both NewHashRepository and NewJSONRepository use json tag as field name
}

func main() {
    ctx := context.Background()
    c, err := rueidis.NewClient(rueidis.ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
    if err != nil {
        panic(err)
    }
    // create the repo with NewHashRepository or NewJSONRepository
    repo := om.NewHashRepository("my_prefix", Example{}, c)

    exp := repo.NewEntity()
    exp.Str = "mystr"
    exp.ExAt = time.Now().Add(time.Hour)
    fmt.Println(exp.Key) // output 01FNH4FCXV9JTB9WTVFAAKGSYB
    repo.Save(ctx, exp) // success

    // lookup "my_prefix:01FNH4FCXV9JTB9WTVFAAKGSYB" through client side caching
    exp2, _ := repo.FetchCache(ctx, exp.Key, time.Second*5)
    fmt.Println(exp2.Str) // output "mystr", which is equal to exp.Str

    exp2.Ver = 0         // if someone changes the version during your GET then SET operation,
    repo.Save(ctx, exp2) // the save will fail with ErrVersionMismatch.
}
```

--------------------------------

### HPTTL

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets TTL of hash fields in milliseconds.

```go
func (c *Compat) HPTTL(ctx context.Context, key string, fields ...string) *IntSliceCmd
```

--------------------------------

### HMGet

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets values of multiple hash fields.

```go
func (c *Compat) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd
```

--------------------------------

### Configure AiModelstoreDeviceGpu

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builder methods for GPU-based model store configuration.

```go
type AiModelstoreDeviceGpu Incomplete
```

```go
func (c AiModelstoreDeviceGpu) Batchsize(batchsize int64) AiModelstoreBatchsize
```

```go
func (c AiModelstoreDeviceGpu) Blob(blob string) AiModelstoreBlob
```

```go
func (c AiModelstoreDeviceGpu) Build() Completed
```

```go
func (c AiModelstoreDeviceGpu) Inputs(inputCount int64) AiModelstoreInputsInputs
```

```go
func (c AiModelstoreDeviceGpu) Minbatchsize(minbatchsize int64) AiModelstoreMinbatchsize
```

```go
func (c AiModelstoreDeviceGpu) Minbatchtimeout(minbatchtimeout int64) AiModelstoreMinbatchtimeout
```

```go
func (c AiModelstoreDeviceGpu) Outputs(outputCount int64) AiModelstoreOutputsOutputs
```

```go
func (c AiModelstoreDeviceGpu) Tag(tag string) AiModelstoreTag
```

--------------------------------

### HotkeysStartMetricsNet Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring network-related metrics.

```go
type HotkeysStartMetricsNet Incomplete
```

```go
func (c HotkeysStartMetricsNet) Build() Completed
```

```go
func (c HotkeysStartMetricsNet) Count(k int64) HotkeysStartCount
```

```go
func (c HotkeysStartMetricsNet) Duration(seconds int64) HotkeysStartDuration
```

```go
func (c HotkeysStartMetricsNet) Sample(ratio int64) HotkeysStartSample
```

```go
func (c HotkeysStartMetricsNet) Slots() HotkeysStartSlotsSlots
```

--------------------------------

### HGetEXWithArgs

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets hash fields with expiration and options.

```go
func (c *Compat) HGetEXWithArgs(ctx context.Context, key string, options *HGetEXOptions, fields ...string) *StringSliceCmd
```

--------------------------------

### FtCreateIndex Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for initializing index creation.

```go
type FtCreateIndex Incomplete
```

```go
func (c FtCreateIndex) Filter(filter string) FtCreateFilter
```

```go
func (c FtCreateIndex) Language(defaultLang string) FtCreateLanguage
```

```go
func (c FtCreateIndex) LanguageField(langAttribute string) FtCreateLanguageField
```

--------------------------------

### HExpireTime

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets expiration time of hash fields.

```go
func (c *Compat) HExpireTime(ctx context.Context, key string, fields ...string) *IntSliceCmd
```

--------------------------------

### AiTensorgetKey Meta

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Retrieves metadata for a tensor get key.

```go
func (c AiTensorgetKey) Meta() AiTensorgetMeta
```

--------------------------------

### Adapter Configuration

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Options for configuring the adapter.

```go
type AdapterOption func(c *Compat)
```

```go
func WithNodeScaleoutLimit(limit int) AdapterOption
```

--------------------------------

### AiTensorget Key

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Initializes a tensor get operation with a key.

```go
func (c AiTensorget) Key(key string) AiTensorgetKey
```

--------------------------------

### HotkeysStartSlotsSlot Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring specific slots.

```go
type HotkeysStartSlotsSlot Incomplete
```

```go
func (c HotkeysStartSlotsSlot) Build() Completed
```

```go
func (c HotkeysStartSlotsSlot) Slot(slot ...int64) HotkeysStartSlotsSlot
```

--------------------------------

### Time Pipeline Command

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets the current server time.

```go
func (c *Pipeline) Time(ctx context.Context) *TimeCmd
```

--------------------------------

### HotkeysStartMetricsMetrics Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring general metrics.

```go
type HotkeysStartMetricsMetrics Incomplete
```

```go
func (c HotkeysStartMetricsMetrics) Count(count int64) HotkeysStartMetricsCount
```

--------------------------------

### TTL Pipeline Command

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets the time to live for a key.

```go
func (c *Pipeline) TTL(ctx context.Context, key string) *DurationCmd
```

--------------------------------

### Build Client Tracking Info

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builds the client tracking info command.

```go
type ClientTrackinginfo Incomplete
func (c ClientTrackinginfo) Build() Completed
```

--------------------------------

### HPExpireTime

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets expiration time of hash fields in milliseconds.

```go
func (c *Compat) HPExpireTime(ctx context.Context, key string, fields ...string) *IntSliceCmd
```

--------------------------------

### Bulk Operations

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Methods for performing bulk get and set operations.

```go
func (c *Pipeline) MGet(ctx context.Context, keys ...string) *SliceCmd
```

```go
func (c *Pipeline) MSet(ctx context.Context, values ...any) *StatusCmd
```

```go
func (c *Pipeline) MSetNX(ctx context.Context, values ...any) *BoolCmd
```

--------------------------------

### SortRoGet Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring the GET clause in a read-only SORT command.

```go
func (c SortRoGet) Asc() SortRoOrderAsc
```

```go
func (c SortRoGet) Build() Completed
```

```go
func (c SortRoGet) Cache() Cacheable
```

```go
func (c SortRoGet) Desc() SortRoOrderDesc
```

```go
func (c SortRoGet) Get(pattern string) SortRoGet
```

--------------------------------

### LcsWithmatchlen Build

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builds the LcsWithmatchlen command.

```go
type LcsWithmatchlen Incomplete
```

```go
func (c LcsWithmatchlen) Build() Completed
```

--------------------------------

### SetGet Builder Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builder methods for the SET GET command variant.

```go
type SetGet Incomplete
```

```go
func (c SetGet) Build() Completed
```

```go
func (c SetGet) Ex(duration time.Duration) SetExpirationExSecTyped
```

```go
func (c SetGet) ExSeconds(seconds int64) SetExpirationExSeconds
```

```go
func (c SetGet) Exat(timestamp time.Time) SetExpirationExatTimestampTyped
```

```go
func (c SetGet) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp
```

```go
func (c SetGet) Keepttl() SetExpirationKeepttl
```

```go
func (c SetGet) Px(duration time.Duration) SetExpirationPxMsTyped
```

```go
func (c SetGet) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds
```

```go
func (c SetGet) Pxat(timestamp time.Time) SetExpirationPxatMsTimestampTyped
```

```go
func (c SetGet) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp
```

--------------------------------

### Mock client.Do

Source: https://pkg.go.dev/github.com/redis/rueidis/mock

Demonstrates how to mock Do and DoMulti methods using mock.Match and mock.Result to simulate Redis responses.

```go
package main

import (
	"context"
	"testing"

	"go.uber.org/mock/gomock"
	"github.com/redis/rueidis/mock"
)

func TestWithRueidis(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	ctx := context.Background()
	client := mock.NewClient(ctrl)

	client.EXPECT().Do(ctx, mock.Match("GET", "key")).Return(mock.Result(mock.RedisString("val")))
	if v, _ := client.Do(ctx, client.B().Get().Key("key").Build()).ToString(); v != "val" {
		t.Fatalf("unexpected val %v", v)
	}
	client.EXPECT().DoMulti(ctx, mock.Match("GET", "c"), mock.Match("GET", "d")).Return([]rueidis.RedisResult{
		mock.Result(mock.RedisNil()),
		mock.Result(mock.RedisNil()),
	})
	for _, resp := range client.DoMulti(ctx, client.B().Get().Key("c").Build(), client.B().Get().Key("d").Build()) {
		if err := resp.Error(); !rueidis.IsRedisNil(err) {
			t.Fatalf("unexpected err %v", err)
		}
	}
}
```

--------------------------------

### Explain Query Execution

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Returns the execution plan for a search query, with optional dialect configuration.

```go
func (c *Compat) FTExplain(ctx context.Context, index string, query string) *StringCmd
```

```go
func (c *Compat) FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd
```

--------------------------------

### AiTensorgetFormatValues Operations

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builds or caches a values format tensor get operation.

```go
func (c AiTensorgetFormatValues) Build() Completed
```

```go
func (c AiTensorgetFormatValues) Cache() Cacheable
```

--------------------------------

### AiTensorgetFormatBlob Operations

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Builds or caches a blob format tensor get operation.

```go
func (c AiTensorgetFormatBlob) Build() Completed
```

```go
func (c AiTensorgetFormatBlob) Cache() Cacheable
```

--------------------------------

### FtConfigHelpOption Command Builder

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Defines the structure for configuration help options.

```go
type FtConfigHelpOption Incomplete
```

```go
func (c FtConfigHelpOption) Build() Completed
```

--------------------------------

### Initialize NewClient

Source: https://pkg.go.dev/github.com/redis/rueidis

Creates a new Redis client instance using the provided configuration options.

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

--------------------------------

### JSON Configuration Arguments

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Structures for configuring JSON get and set operations.

```go
type JSONGetArgs struct {
	Indent  string
	Newline string
	Space   string
}
```

```go
type JSONSetArgs struct {
	Value interface{}
	Key   string
	Path  string
}
```

--------------------------------

### Initialize and use a distributed lock

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidislock

Demonstrates creating a new locker instance and acquiring a lock with a context that is automatically canceled if the lock is lost.

```go
package main

import (
	"context"
	"github.com/redis/rueidis"
	"github.com/redis/rueidis/rueidislock"
)

func main() {
	locker, err := rueidislock.NewLocker(rueidislock.LockerOption{
		ClientOption:   rueidis.ClientOption{InitAddress: []string{"localhost:6379"}},
		KeyMajority:    1,    // Use KeyMajority=1 if you have only one Redis instance. Also make sure that all your `Locker`s share the same KeyMajority.
		NoLoopTracking: true, // Enable this to have better performance if all your Redis are >= 7.0.5.
	})
	if err != nil {
		panic(err)
	}
	defer locker.Close()

	// acquire the lock "my_lock"
	ctx, cancel, err := locker.WithContext(context.Background(), "my_lock")
	if err != nil {
		panic(err)
	}

	// "my_lock" is acquired. use the ctx as normal.
	doSomething(ctx)

	// invoke cancel() to release the lock.
	cancel()
}
```

--------------------------------

### Get RediSearch Configuration

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Retrieves a specific RediSearch configuration parameter value.

```go
func (c *Compat) FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd
```

--------------------------------

### Pipeline

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Creates a new pipeline.

```go
func (c *Compat) Pipeline() Pipeliner
```

--------------------------------

### Cluster Delslotsrange StartSlotEndSlot

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Sets the start and end slots for the delslotsrange command.

```go
func (c ClusterDelslotsrangeStartSlotEndSlot) StartSlotEndSlot(startSlot int64, endSlot int64) ClusterDelslotsrangeStartSlotEndSlot
```

--------------------------------

### TSMGet Pipeline Command

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Gets the last samples for time series matching filters.

```go
func (c *Pipeline) TSMGet(ctx context.Context, filters []string) *MapStringSliceInterfaceCmd
```

```go
func (c *Pipeline) TSMGetWithArgs(ctx context.Context, filters []string, options *TSMGetOptions) *MapStringSliceInterfaceCmd
```

--------------------------------

### HotkeysStartDuration Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring duration-based hotkeys parameters.

```go
type HotkeysStartDuration Incomplete
```

```go
func (c HotkeysStartDuration) Build() Completed
```

```go
func (c HotkeysStartDuration) Sample(ratio int64) HotkeysStartSample
```

```go
func (c HotkeysStartDuration) Slots() HotkeysStartSlotsSlots
```

--------------------------------

### Get Index Information

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Retrieves metadata and status information for a specific search index.

```go
func (c *Compat) FTInfo(ctx context.Context, index string) *FTInfoCmd
```

--------------------------------

### HotkeysStartCount Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring count-based hotkeys parameters.

```go
func (c HotkeysStartCount) Duration(seconds int64) HotkeysStartDuration
```

```go
func (c HotkeysStartCount) Sample(ratio int64) HotkeysStartSample
```

```go
func (c HotkeysStartCount) Slots() HotkeysStartSlotsSlots
```

--------------------------------

### Set Fromtimestamp for TsRangeKey

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Defines the starting timestamp for a time series range key.

```go
func (c TsRangeKey) Fromtimestamp(fromtimestamp string) TsRangeFromtimestamp
```

--------------------------------

### GeoradiusKey and Longitude

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Defines the starting point for a GEORADIUS command by specifying the key and longitude.

```go
type GeoradiusKey Incomplete
```

```go
func (c GeoradiusKey) Longitude(longitude float64) GeoradiusLongitude
```

--------------------------------

### Create and Search RediSearch Indexes

Source: https://pkg.go.dev/github.com/redis/rueidis/om

Shows how to create indexes for Hash or JSON repositories and perform searches using parameterized queries.

```go
if _, ok := repo.(*om.HashRepository[Example]); ok {
    repo.CreateIndex(ctx, func(schema om.FtCreateSchema) rueidis.Completed {
        return schema.FieldName("str").Tag().Build() // Note that the Example.Str field is mapped to str on redis by its json tag
    })
}

if _, ok := repo.(*om.JSONRepository[Example]); ok {
    repo.CreateIndex(ctx, func(schema om.FtCreateSchema) rueidis.Completed {
        return schema.FieldName("$.str").As("str").Tag().Build() // the FieldName of a JSON index should be a JSON path syntax
    })
}

exp := repo.NewEntity()
exp.Str = "special_chars:[$.-]"
repo.Save(ctx, exp)

n, records, _ := repo.Search(ctx, func(search om.FtSearchIndex) rueidis.Completed {
    // Note that by using the named parameters with DIALECT >= 2, you won't have to escape chars for building queries.
    return search.Query("@str:{$v}").Params().Nargs(2).NameValue().NameValue("v", exp.Str).Dialect(2).Build()
})

fmt.Println("total", n) // n is the total number of results matched in redis, which is >= len(records)

for _, v := range records {
    fmt.Println(v.Str) // print "special_chars:[$.-]"
}
```

--------------------------------

### MGet

Source: https://pkg.go.dev/github.com/redis/rueidis

Consults Redis directly with multiple keys by grouping them into MGET or multiple GET commands.

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

### Description
Consults the redis directly with multiple keys by grouping keys within the same slot into MGET or multiple GETs.

### Parameters
- **client** (Client) - Required - The Redis client instance.
- **ctx** (context.Context) - Required - The context for the operation.
- **keys** ([]string) - Required - The list of keys to retrieve.
```

--------------------------------

### FtConfigHelp Command Builder

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Defines the structure for retrieving search configuration help.

```go
type FtConfigHelp Incomplete
```

```go
func (c FtConfigHelp) Option(option string) FtConfigHelpOption
```

--------------------------------

### XinfoHelp Build Method

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Finalizes the XINFO HELP command.

```go
func (c XinfoHelp) Build() Completed
```

--------------------------------

### FtAggregateOpGroupbyReduceOrderDesc Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for configuring aggregation operations starting from a descending order group-by state.

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Groupby(nargs int64) FtAggregateOpGroupbyGroupby
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Limit() FtAggregateOpLimitLimit
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Load(count int64) FtAggregateOpLoadLoad
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) LoadAll() FtAggregateOpLoadallLoadAll
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Params() FtAggregateParamsParams
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Reduce(function string) FtAggregateOpGroupbyReduceReduce
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Sortby(nargs int64) FtAggregateOpSortbySortby
```

```go
func (c FtAggregateOpGroupbyReduceOrderDesc) Withcursor() FtAggregateCursorWithcursor
```

--------------------------------

### General utility methods

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Methods for basic key and database operations.

```go
func (c *Compat) Copy(ctx context.Context, source string, destination string, db int64, replace bool) *IntCmd
```

```go
func (c *Compat) DBSize(ctx context.Context) *IntCmd
```

```go
func (c *Compat) DebugObject(ctx context.Context, key string) *StringCmd
```

```go
func (c *Compat) Decr(ctx context.Context, key string) *IntCmd
```

```go
func (c *Compat) DecrBy(ctx context.Context, key string, decrement int64) *IntCmd
```

```go
func (c *Compat) Del(ctx context.Context, keys ...string) *IntCmd
```

```go
func (c *Compat) Dump(ctx context.Context, key string) *StringCmd
```

```go
func (c *Compat) Echo(ctx context.Context, message any) *StringCmd
```

```go
func (c *Compat) Exists(ctx context.Context, keys ...string) *IntCmd
```

--------------------------------

### Define Cluster Slot Migration Range

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Sets the start and end slots for a migration operation.

```go
func (c ClusterMigrateslotsSlotMigrationSpecSlotsrange) Slotsrange(startSlot int64, endSlot int64) ClusterMigrateslotsSlotMigrationSpecSlotsrange
```

--------------------------------

### Pipeline Server and Utility Commands

Source: https://pkg.go.dev/github.com/redis/rueidis/rueidiscompat

Miscellaneous commands for server management, logging, and pub/sub.

```go
func (c *Pipeline) SlaveOf(ctx context.Context, host, port string) *StatusCmd
```

```go
func (c *Pipeline) SlowLogGet(ctx context.Context, num int64) *SlowLogCmd
```

```go
func (c *Pipeline) SlowLogReset(ctx context.Context) *StatusCmd
```

```go
func (c *Pipeline) StrLen(ctx context.Context, key string) *IntCmd
```

```go
func (c *Pipeline) Subscribe(_ context.Context, _ ...string) PubSub
```

--------------------------------

### ClientKillName Builder Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for building a CLIENT KILL command starting from a Name filter.

```go
type ClientKillName Incomplete
```

```go
func (c ClientKillName) Build() Completed
```

```go
func (c ClientKillName) Capa(capa string) ClientKillCapa
```

```go
func (c ClientKillName) Db(db int64) ClientKillDb
```

```go
func (c ClientKillName) Flags(flags string) ClientKillFlags
```

```go
func (c ClientKillName) Idle(idle int64) ClientKillIdle
```

```go
func (c ClientKillName) Ip(ip string) ClientKillIp
```

```go
func (c ClientKillName) LibName(libName string) ClientKillLibName
```

```go
func (c ClientKillName) LibVer(libVer string) ClientKillLibVer
```

```go
func (c ClientKillName) NotAddr(notAddr string) ClientKillNotAddr
```

```go
func (c ClientKillName) NotCapa(notCapa string) ClientKillNotCapa
```

```go
func (c ClientKillName) NotDb(notDb int64) ClientKillNotDb
```

```go
func (c ClientKillName) NotFlags(notFlags string) ClientKillNotFlags
```

--------------------------------

### ClientKillMaxage Builder Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for building a CLIENT KILL command starting from a Maxage filter.

```go
func (c ClientKillMaxage) Build() Completed
```

```go
func (c ClientKillMaxage) Capa(capa string) ClientKillCapa
```

```go
func (c ClientKillMaxage) Db(db int64) ClientKillDb
```

```go
func (c ClientKillMaxage) Flags(flags string) ClientKillFlags
```

```go
func (c ClientKillMaxage) Idle(idle int64) ClientKillIdle
```

```go
func (c ClientKillMaxage) Ip(ip string) ClientKillIp
```

```go
func (c ClientKillMaxage) LibName(libName string) ClientKillLibName
```

```go
func (c ClientKillMaxage) LibVer(libVer string) ClientKillLibVer
```

```go
func (c ClientKillMaxage) Name(name string) ClientKillName
```

```go
func (c ClientKillMaxage) NotAddr(notAddr string) ClientKillNotAddr
```

```go
func (c ClientKillMaxage) NotCapa(notCapa string) ClientKillNotCapa
```

```go
func (c ClientKillMaxage) NotDb(notDb int64) ClientKillNotDb
```

```go
func (c ClientKillMaxage) NotFlags(notFlags string) ClientKillNotFlags
```

```go
func (c ClientKillMaxage) NotId() ClientKillNotIdNotId
```

```go
func (c ClientKillMaxage) NotIp(notIp string) ClientKillNotIp
```

```go
func (c ClientKillMaxage) NotLaddr(notLaddr string) ClientKillNotLaddr
```

```go
func (c ClientKillMaxage) NotLibName(notLibName string) ClientKillNotLibName
```

```go
func (c ClientKillMaxage) NotLibVer(notLibVer string) ClientKillNotLibVer
```

```go
func (c ClientKillMaxage) NotName(notName string) ClientKillNotName
```

```go
func (c ClientKillMaxage) NotTypeMaster() ClientKillNotTypeMaster
```

```go
func (c ClientKillMaxage) NotTypeNormal() ClientKillNotTypeNormal
```

```go
func (c ClientKillMaxage) NotTypePrimary() ClientKillNotTypePrimary
```

```go
func (c ClientKillMaxage) NotTypePubsub() ClientKillNotTypePubsub
```

```go
func (c ClientKillMaxage) NotTypeReplica() ClientKillNotTypeReplica
```

```go
func (c ClientKillMaxage) NotTypeSlave() ClientKillNotTypeSlave
```

```go
func (c ClientKillMaxage) NotUser(notUsername string) ClientKillNotUser
```

--------------------------------

### Memory and Module Command Builder Methods

Source: https://pkg.go.dev/github.com/redis/rueidis/internal/cmds

Methods for memory management and module administration.

```go
func (b Builder) MemoryDoctor() (c MemoryDoctor)
```

```go
func (b Builder) MemoryHelp() (c MemoryHelp)
```

```go
func (b Builder) MemoryMallocStats() (c MemoryMallocStats)
```

```go
func (b Builder) MemoryPurge() (c MemoryPurge)
```

```go
func (b Builder) MemoryStats() (c MemoryStats)
```

```go
func (b Builder) MemoryUsage() (c MemoryUsage)
```

```go
func (b Builder) Mget() (c Mget)
```

```go
func (b Builder) Migrate() (c Migrate)
```

```go
func (b Builder) ModuleList() (c ModuleList)
```

```go
func (b Builder) ModuleLoad() (c ModuleLoad)
```

```go
func (b Builder) ModuleLoadex() (c ModuleLoadex)
```

--------------------------------

### Initialize a JSON Repository

Source: https://pkg.go.dev/github.com/redis/rueidis/om

Creates a new JSONRepository instance with a specified key prefix and schema. The schema must be a struct with fields tagged with redis:"key".

```go
func NewJSONRepository[T any](prefix string, schema T, client rueidis.Client, opts ...RepositoryOption) Repository[T]
```
Tokens:
Raw