feat: RedisResult.AsBytes without copy

Author: rueian

binary.go

@@ -8,15 +8,18 @@ import (
 // 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()
+//
+//	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 BinaryString(bs []byte) string {
-	return *(*string)(unsafe.Pointer(&bs))
+	return unsafe.String(unsafe.SliceData(bs), len(bs))
 }
 
 // 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()
+//
+//	client.B().JsonSet().Key("a").Path("$.myField").Value(rueidis.JSON("str")).Build()
 func JSON(in any) string {
 	bs, err := json.Marshal(in)
 	if err != nil {

message.go

@@ -165,6 +165,16 @@ func (r RedisResult) AsReader() (v io.Reader, err error) {
 	return
 }
 
+// AsBytes delegates to RedisMessage.AsBytes
+func (r RedisResult) AsBytes() (v []byte, err error) {
+	if r.err != nil {
+		err = r.err
+	} else {
+		v, err = r.val.AsBytes()
+	}
+	return
+}
+
 // DecodeJSON delegates to RedisMessage.DecodeJSON
 func (r RedisResult) DecodeJSON(v any) (err error) {
 	if r.err != nil {
@@ -473,6 +483,15 @@ func (m *RedisMessage) AsReader() (reader io.Reader, err error) {
 	return strings.NewReader(str), nil
 }
 
+// AsBytes check if message is a redis string response and return it as an immutable []byte
+func (m *RedisMessage) AsBytes() (bs []byte, err error) {
+	str, err := m.ToString()
+	if err != nil {
+		return nil, err
+	}
+	return unsafe.Slice(unsafe.StringData(str), len(str)), nil
+}
+
 // DecodeJSON check if message is a redis string response and treat it as json, then unmarshal it into provided value
 func (m *RedisMessage) DecodeJSON(v any) (err error) {
 	str, err := m.ToString()

message_test.go

@@ -108,16 +108,29 @@ func TestRedisResult(t *testing.T) {
 		}
 	})
 
+	t.Run("AsBytes", func(t *testing.T) {
+		if _, err := (RedisResult{err: errors.New("other")}).AsBytes(); err == nil {
+			t.Fatal("AsBytes not failed as expected")
+		}
+		if _, err := (RedisResult{val: RedisMessage{typ: '-'}}).AsBytes(); err == nil {
+			t.Fatal("AsBytes not failed as expected")
+		}
+		bs, _ := (RedisResult{val: RedisMessage{typ: '+', string: "0.1"}}).AsBytes()
+		if !bytes.Equal(bs, []byte("0.1")) {
+			t.Fatalf("AsBytes not get value as expected %v", bs)
+		}
+	})
+
 	t.Run("DecodeJSON", func(t *testing.T) {
 		v := map[string]string{}
 		if err := (RedisResult{err: errors.New("other")}).DecodeJSON(&v); err == nil {
-			t.Fatal("AsReader not failed as expected")
+			t.Fatal("DecodeJSON not failed as expected")
 		}
 		if err := (RedisResult{val: RedisMessage{typ: '-'}}).DecodeJSON(&v); err == nil {
-			t.Fatal("AsReader not failed as expected")
+			t.Fatal("DecodeJSON not failed as expected")
 		}
 		if _ = (RedisResult{val: RedisMessage{typ: '+', string: `{"k":"v"}`}}).DecodeJSON(&v); v["k"] != "v" {
-			t.Fatalf("AsReader not get value as expected %v", v)
+			t.Fatalf("DecodeJSON not get value as expected %v", v)
 		}
 	})
 
@@ -629,6 +642,19 @@ func TestRedisMessage(t *testing.T) {
 		(&RedisMessage{typ: ':'}).AsReader()
 	})
 
+	t.Run("AsBytes", func(t *testing.T) {
+		if _, err := (&RedisMessage{typ: '_'}).AsBytes(); err == nil {
+			t.Fatal("AsBytes not failed as expected")
+		}
+
+		defer func() {
+			if !strings.Contains(recover().(string), "redis message type : is not a string") {
+				t.Fatal("AsBytes not panic as expected")
+			}
+		}()
+		(&RedisMessage{typ: ':'}).AsBytes()
+	})
+
 	t.Run("DecodeJSON", func(t *testing.T) {
 		if err := (&RedisMessage{typ: '_'}).DecodeJSON(nil); err == nil {
 			t.Fatal("DecodeJSON not failed as expected")

om/conv.go

@@ -4,7 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"strconv"
-	"unsafe"
+
+	"github.com/rueian/rueidis"
 )
 
 func newHashConvFactory(t reflect.Type, schema schema) *hashConvFactory {
@@ -164,7 +165,7 @@ var converters = struct {
 				if !ok {
 					return "", false
 				}
-				return *(*string)(unsafe.Pointer(&buf)), true
+				return rueidis.BinaryString(buf), true
 			},
 			StringToValue: func(value string) (reflect.Value, error) {
 				buf := []byte(value)

resp.go

@@ -6,7 +6,6 @@ import (
 	"io"
 	"strconv"
 	"strings"
-	"unsafe"
 )
 
 var errChunked = errors.New("unbounded redis message")
@@ -122,7 +121,7 @@ func readS(i *bufio.Reader) (string, error) {
 	} else {
 		bs = bs[:trim]
 	}
-	return *(*string)(unsafe.Pointer(&bs)), nil
+	return BinaryString(bs), nil
 }
 
 func readI(i *bufio.Reader) (int64, error) {
@@ -170,7 +169,7 @@ func readB(i *bufio.Reader) (string, error) {
 	if _, err = i.Discard(2); err != nil {
 		return "", err
 	}
-	return *(*string)(unsafe.Pointer(&bs)), nil
+	return BinaryString(bs), nil
 }
 
 func readE(i *bufio.Reader) ([]RedisMessage, error) {