Is there a possible to get raw RESP response stream?

[stamaimer]

import (
    "context"
    "github.com/go-redis/redis/v8"
)

var ctx = context.Background()

func ExampleClient() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    res, err := rdb.Do(ctx, "set", "key", "value").Result()
}

After execute res, err := rdb.Do(ctx, "set", "key", "value").Result(), Is there a method to get raw RESP response? Like $6\r\nfoobar\r\n

[monkey92t]

The RESP response cannot be obtained directly. Do you have any scenarios where the RESP response value is required?

[stamaimer]

I use go-redis develop a redis cluster proxy for services which don't support access redis cluster directly.

[vmihailenco]

You can check https://github.com/bsm/redeo

[stamaimer]

I use Writer in go-redis to parse result as follows:

import (
    "context"
    "github.com/go-redis/redis/v8"
)

var ctx = context.Background()

func ExampleClient() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    res, err := rdb.Do(ctx, "set", "key", "value").Result()

    buffer := new(bytes.Buffer)
    writer := proto.NewWriter(buffer)

    switch t := result.(type) {
    case []interface{}:
        writer.WriteArgs(result.([]interface{}))
    case interface{}:
        writer.WriteArgs([]interface{}{result})
    default:
        log.Debugf("result: %+v", t)
    }

    log.Debugf("resp buff: %s", buffer.String())

}

It seems like the writer can't parse Nested Result Array like result returned by COMMAND

[monkey92t]

I have the same question and the same problem.
My case is I strongly want to get the output of .Del() method, for example. Because Redis returns the amount of really deleted keys from multiple keys requested to delete. And it's very important data.
But val, err := client.Del(ctx, keys...) making delete, leaving err as nil, and val is empty, even if some amount of keys really has been deleted.
I guess it's just an error.

you can try: n, err := client.Del(ctx, key...).Result()
n -> number

[justewg]

the same, n returns 0, but amount of deleted keys isn't 0

[justewg]

The full case is that I using pipelined-schema and pipelines-method Del()

	chunkSize := 5000
	chunksInterface := xslice.SplitToChunks(keys, chunkSize)
	chunks := chunksInterface.([][]string)
	result, err := c.client.Pipelined(ctx, func(p redis.Pipeliner) error {
		for i, chunk := range chunks {
			_, err := p.Del(c.ctx, chunk...).Result()
			if err != nil {
				logger.Logger.Debugw("Error deleting Redis cache", "chunk N", i, "err", err)
				return err
			}
			logger.Logger.Infow("Deleting Redis cache", "keys", chunk, "results", res)
		}
		return nil
	})

And I see {"results": 0}

[monkey92t]

For the pipeline, go-redis returns []redis.Cmder(interface), Cmder seems to need to support the method of obtaining the return value, instead of performing cmd.(*Intcmd) similar operations every time

[monkey92t]

cmds, _ := client.Pipelined(ctx, func(p redis.Pipeliner) error {
		p.Del(ctx, "key1")
		p.Del(ctx, "key2")
		p.Del(ctx, "key3")

		return nil
	})

	for _, cmd := range cmds {
		fmt.Println(cmd.(*redis.IntCmd).Result())
	}