feat(scan): scan time.Time uses UnmarshalText(RFC3339) interface decoding by default

Signed-off-by: monkey92t <[email protected]>

Author: monkey92t

commands_test.go

@@ -1841,6 +1841,25 @@ var _ = Describe("Commands", func() {
 				Key2: 123,
 				Time: TimeValue{Time: time.Time{}},
 			}))
+
+			type data2 struct {
+				Key1 string    `redis:"key1"`
+				Key2 int       `redis:"key2"`
+				Time time.Time `redis:"time"`
+			}
+			err = client.HSet(ctx, "hash", &data2{
+				Key1: "hello2",
+				Key2: 200,
+				Time: now,
+			}).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			var d2 data2
+			err = client.HMGet(ctx, "hash", "key1", "key2", "time").Scan(&d2)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(d2.Key1).To(Equal("hello2"))
+			Expect(d2.Key2).To(Equal(200))
+			Expect(d2.Time.Unix()).To(Equal(now.Unix()))
 		})
 
 		It("should HIncrBy", func() {

internal/hscan/hscan.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"reflect"
 	"strconv"
+	"time"
 )
 
 // decoderFunc represents decoding functions for default built-in types.
@@ -42,7 +43,7 @@ var (
 		reflect.Ptr:           decodeUnsupported,
 		reflect.Slice:         decodeSlice,
 		reflect.String:        decodeString,
-		reflect.Struct:        decodeUnsupported,
+		reflect.Struct:        decodeStruct,
 		reflect.UnsafePointer: decodeUnsupported,
 	}
 
@@ -202,6 +203,20 @@ func decodeSlice(f reflect.Value, s string) error {
 	return nil
 }
 
+func decodeStruct(f reflect.Value, s string) error {
+	// handle time.Time here.
+	// time.Time CanSet() == false
+	if f.CanAddr() {
+		p := f.Addr()
+		if p.CanInterface() {
+			if v, ok := p.Interface().(*time.Time); ok {
+				return v.UnmarshalText([]byte(s))
+			}
+		}
+	}
+	return decodeUnsupported(f, s)
+}
+
 func decodeUnsupported(v reflect.Value, s string) error {
 	return fmt.Errorf("redis.Scan(unsupported %s)", v.Type())
 }

internal/hscan/hscan_test.go

@@ -200,4 +200,16 @@ var _ = Describe("Scan", func() {
 		Expect(td.Time.UnixNano()).To(Equal(now.UnixNano()))
 		Expect(td.Time.Format(time.RFC3339Nano)).To(Equal(now.Format(time.RFC3339Nano)))
 	})
+
+	It("should time.Time RFC3339Nano", func() {
+		type TimeTime struct {
+			Time time.Time `redis:"time"`
+		}
+
+		now := time.Now()
+
+		var tt TimeTime
+		Expect(Scan(&tt, i{"time"}, i{now.Format(time.RFC3339Nano)})).NotTo(HaveOccurred())
+		Expect(now.Unix()).To(Equal(tt.Time.Unix()))
+	})
 })

internal/proto/writer.go

@@ -101,15 +101,16 @@ func (w *Writer) WriteArg(v interface{}) error {
 		return w.bytes(w.numBuf)
 	case time.Duration:
 		return w.int(v.Nanoseconds())
-	case encoding.BinaryMarshaler:
-		b, err := v.MarshalBinary()
-		if err != nil {
-			return err
-		}
-		return w.bytes(b)
 	case net.IP:
 		return w.bytes(v)
 	default:
+		if m, ok := v.(encoding.BinaryMarshaler); ok {
+			b, err := m.MarshalBinary()
+			if err != nil {
+				return err
+			}
+			return w.bytes(b)
+		}
 		return fmt.Errorf(
 			"redis: can't marshal %T (implement encoding.BinaryMarshaler)", v)
 	}