redis

err := rdb.Do(ctx, "DEL", "pipeline_counter").Err()
if err != nil {
	panic(err)
}

pipe := rdb.Pipeline()

incr := pipe.Send("INCR", "pipeline_counter")
pipe.Send("EXPIRE", "pipeline_counter", 1*time.Minute)

// Execute
//
//	INCR pipeline_counter
//	EXPIRE pipeline_counts 60
//
// using one rdb-server roundtrip.
_, err = pipe.Exec(ctx)
if err != nil {
	panic(err)
}
fmt.Println(incr.Int())

Output:

1 <nil>

err := rdb.Do(ctx, "DEL", "pipelined_counter").Err()
if err != nil {
	panic(err)
}

var incr *redis.Result
_, err = rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
	incr = pipe.Send("INCR", "pipelined_counter")
	pipe.Send("EXPIRE", "pipelined_counter", 1*time.Minute)
	return nil
})
if err != nil {
	panic(err)
}
fmt.Println(incr.Int())

Output:

1 <nil>

err := rdb.Do(ctx, "DEL", "tx_pipeline_counter").Err()
if err != nil {
	panic(err)
}

pipe := rdb.TxPipeline()

incr := pipe.Send("INCR", "tx_pipeline_counter")
pipe.Send("EXPIRE", "tx_pipeline_counter", 1*time.Minute)

// Execute
//
//	MULTI
//	INCR tx_pipeline_counter
//	EXPIRE tx_pipeline_counter 60
//	EXEC
//
// using one rdb-server roundtrip.
_, err = pipe.Exec(ctx)
if err != nil {
	panic(err)
}
fmt.Println(incr.Int())

Output:

1 <nil>

err := rdb.Do(ctx, "DEL", "tx_pipelined_counter").Err()
if err != nil {
	panic(err)
}

var incr *redis.Result
_, err = rdb.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
	incr = pipe.Send("INCR", "tx_pipelined_counter")
	pipe.Send("EXPIRE", "tx_pipelined_counter", 1*time.Minute)
	return nil
})
if err != nil {
	panic(err)
}
fmt.Println(incr.Int())

Output:

1 <nil>

// Increment transactionally increments key using GET and SET commands.
increment := func(key string) error {
	// Transactional function.
	txf := func(tx *redis.Tx) error {
		// Get current value or zero.
		n, err := tx.Do(ctx, "GET", key).Int()
		if err != nil && redis.ErrNil != err {
			return err
		}

		// Actual opperation (local in optimistic lock).
		n++

		// Operation is committed only if the watched keys remain unchanged.
		_, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
			pipe.Send("SET", key, n)
			return nil
		})
		return err
	}

	const maxRetries = 10000
	for i := 0; i < maxRetries; i++ {
		switch err := rdb.Watch(ctx, txf, key); err {
		default:
			// Return any other error.
			return err
		case nil:
			// Success.
			return nil
		case redis.ErrNil:
			// Optimistic lock lost. Retry.
		}
	}
	return errors.New("increment reached maximum number of retries")
}

err := rdb.Do(ctx, "DEL", "counter3").Err()
if err != nil {
	panic(err)
}

var wg sync.WaitGroup
for i := 0; i < 100; i++ {
	wg.Add(1)
	go func() {
		defer wg.Done()

		if err := increment("counter3"); err != nil {
			fmt.Println("increment error:", err)
		}
	}()
}
wg.Wait()

n, err := rdb.Do(ctx, "GET", "counter3").Int()
fmt.Println("ended with", n, err)

Output:

ended with 100 <nil>

This example shows how receive pubsub notifications with cancelation.

package main

import (
	"context"
	"fmt"

	"github.com/weiwenchen2022/go-redis"
)

// listenPubSubChannels listens for messages on Redis pubsub channels. The
// onStart function is called after the channels are subscribed. The onMessage
// function is called for each message.
func listenPubSubChannels(ctx context.Context, rdb *redis.Client,
	onStart func() error,
	onMessage func(channel string, payload string) error,
	channels ...string,
) error {
	pubsub := rdb.Subscribe(ctx, channels...)

	done := make(chan error, 1)

	// Start a goroutine to receive notifications from the server.
	go func() {
		// Go channel which receives messages.
		ch := pubsub.ChannelWithSubscriptions()

		// Consume messages.
		for msgi := range ch {
			switch msg := msgi.(type) {
			case *redis.Message:
				if err := onMessage(msg.Channel, msg.Payload); err != nil {
					done <- err
					return
				}
			case *redis.Subscription:
				switch msg.Count {
				case len(channels):
					// Notify application when all channels are subscribed.
					if err := onStart(); err != nil {
						done <- err
						return
					}
				case 0:
					// Return from the goroutine when all channels are unsubscribed.
					done <- nil
					return
				}
			}
		}
	}()

loop:
	for {
		select {
		case <-ctx.Done():
			break loop
		case err := <-done:
			// Return error from the receive goroutine.
			return err
		}
	}

	// Signal the receiving goroutine to exit by unsubscribing from all channels.
	if err := pubsub.Unsubscribe(ctx); err != nil {
		return err
	}

	// Wait for goroutine to complete.
	return <-done
}

func publish(ctx context.Context, rdb *redis.Client) {
	if err := rdb.Do(ctx, "PUBLISH", "c1", "hello").Err(); err != nil {
		panic(err)
	}
	if err := rdb.Do(ctx, "PUBLISH", "c2", "world").Err(); err != nil {
		panic(err)
	}
	if err := rdb.Do(ctx, "PUBLISH", "c1", "goodbye").Err(); err != nil {
		panic(err)
	}
}

// This example shows how receive pubsub notifications with cancelation.
func main() {
	var (
		ctx, cancel = context.WithCancel(context.Background())
		rdb         = redis.NewClient(&redis.Options{
			Addr: "localhost:6379",
		})
	)

	err := listenPubSubChannels(ctx, rdb,
		func() error {
			// The start callback is a good place to backfill missed
			// notifications. For the purpose of this example, a goroutine is
			// started to send notifications.
			go publish(ctx, rdb)
			return nil
		},
		func(channel string, payload string) error {
			fmt.Println("received", payload, "from", channel)

			// For the purpose of this example, cancel the listener's context
			// after receiving last message sent by publish().
			if payload == "goodbye" {
				cancel()
			}
			return nil
		},
		"c1", "c2")
	if err != nil {
		panic(err)
	}

}

Output:

received hello from c1
received world from c2
received goodbye from c1

pubsub := rdb.Subscribe(ctx, "mychannel2")
defer pubsub.Close()

for i := 0; i < 2; i++ {
	// ReceiveTimeout is a low level API. Use ReceiveMessage instead.
	msgi, err := pubsub.ReceiveTimeout(1 * time.Second)
	if err != nil {
		panic(err)
	}

	switch msg := msgi.(type) {
	case *redis.Subscription:
		fmt.Println("subscribed to", msg.Channel)

		_, err := rdb.Do(ctx, "PUBLISH", "mychannel2", "hello").Int()
		if err != nil {
			panic(err)
		}
	case *redis.Message:
		fmt.Println("received", msg.Payload, "from", msg.Channel)
	default:
		panic("unreached")
	}
}

Output:

subscribed to mychannel2
received hello from mychannel2

err := rdb.Do(ctx, "SET", "foo", 1).Err()
if err != nil {
	panic(err)
}
exists, err := rdb.Do(ctx, "EXISTS", "foo").Bool()
if err != nil {
	panic(err)
}
fmt.Printf("%t\n", exists)

Output:

true

err := rdb.Do(ctx, "SET", "k1", 1).Err()
if err != nil {
	panic(err)
}

n, err := rdb.Do(ctx, "GET", "k1").Int()
if err != nil {
	panic(err)
}
fmt.Printf("%d\n", n)

n, err = rdb.Do(ctx, "INCR", "k1").Int()
if err != nil {
	panic(err)
}
fmt.Printf("%d\n", n)

Output:

1
2

err := rdb.Do(ctx, "SADD", "set_with_integers", 4, 5, 6).Err()
if err != nil {
	panic(err)
}
ints, err := rdb.Do(ctx, "SMEMBERS", "set_with_integers").Ints()
if err != nil {
	panic(err)
}
fmt.Printf("%v\n", ints)

Output:

[4 5 6]

err := rdb.Do(ctx, "DEL", "album:1", "album:2", "album:3", "albums").Err()
if err != nil {
	panic(err)
}

if _, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
	pipe.Send("HSET", "album:1", "title", "Red", "rating", 5)
	pipe.Send("HSET", "album:2", "title", "Earthbound", "rating", 1)
	pipe.Send("HSET", "album:3", "title", "Beat")
	pipe.Send("LPUSH", "albums", "1", "2", "3")
	return nil
}); err != nil {
	panic(err)
}

res := rdb.Do(ctx, "SORT", "albums",
	"BY", "album:*->rating",
	"GET", "album:*->title",
	"GET", "album:*->rating",
)
if err := res.Err(); err != nil {
	panic(err)
}

loop:
for {
	var title string
	rating := -1 // initialize to illegal value to detect nil.
	err = res.Scan(&title, &rating)
	switch err {
	default:
		panic(err)
	case redis.ErrValuesExhausted:
		break loop
	case nil:
	}

	if rating == -1 {
		fmt.Println(title, "not-rated")
	} else {
		fmt.Println(title, rating)
	}
}

Output:

Beat not-rated
Earthbound 1
Red 5

err := rdb.Do(ctx, "DEL", "album:1", "album:2", "album:3", "albums").Err()
if err != nil {
	panic(err)
}

if _, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
	pipe.Send("HSET", "album:1", "title", "Red", "rating", 5)
	pipe.Send("HSET", "album:2", "title", "Earthbound", "rating", 1)
	pipe.Send("HSET", "album:3", "title", "Beat", "rating", 4)
	pipe.Send("LPUSH", "albums", "1", "2", "3")
	return nil
}); err != nil {
	panic(err)
}

res := rdb.Do(ctx, "SORT", "albums",
	"BY", "album:*->rating",
	"GET", "album:*->title",
	"GET", "album:*->rating",
)
if err := res.Err(); err != nil {
	panic(err)
}

var albums []struct {
	Title  string
	Rating int
}
if err := res.ScanSlice(&albums); err != nil {
	panic(err)
}
fmt.Printf("%v\n", albums)

Output:

[{Earthbound 1} {Beat 4} {Red 5}]

err := rdb.Do(ctx, "DEL", "album:1").Err()
if err != nil {
	panic(err)
}
if err := rdb.Do(ctx, "HSET", "album:1",
	"title", "Electric Ladyland",
	"artist", "Jimi Hendrix",
	"price", 4.95,
	"likes", 8,
).Err(); err != nil {
	panic(err)
}

res := rdb.Do(ctx, "HGETALL", "album:1")
if err := res.Err(); err != nil {
	panic(err)
}

type Album struct {
	Title  string  `redis:"title"`
	Artist string  `redis:"artist"`
	Price  float64 `redis:"price"`
	Likes  int     `redis:"likes"`
}

ab := new(Album)
if err := res.ScanStruct(ab); err != nil {
	panic(err)
}
fmt.Printf("%+v\n", ab)

Output:

&{Title:Electric Ladyland Artist:Jimi Hendrix Price:4.95 Likes:8}

err := rdb.Do(ctx, "SET", "hello", "world").Err()
if err != nil {
	panic(err)
}
s, err := rdb.Do(ctx, "GET", "hello").String()
if err != nil {
	panic(err)
}
fmt.Printf("%s\n", s)

Output:

world