fix(spanner): pointer type custom struct decoder (#12496)

0daryo · web-flow · commit ac3cafbac435 · 2025-06-27T19:04:27.000+05:30
diff --git a/spanner/row_test.go b/spanner/row_test.go
@@ -2279,6 +2279,7 @@ func TestSelectAll(t *testing.T) {
 		Col1 int64
 		COL2 float64
 		Col3 CustomType[string]
+		Col4 *CustomType[string]
 	}
 
 	type testStructWithTag struct {
@@ -2451,7 +2452,7 @@ func TestSelectAll(t *testing.T) {
 			},
 		},
 		{
-			name: "success: using destination with custom type with custom decoder with some null columns",
+			name: "success: using destination with custom type with custom decoder with some null columns and pointer decoder",
 			args: args{
 				destination: &[]*testStructWithCustom{},
 				mock: newMockIterator(
@@ -2460,32 +2461,35 @@ func TestSelectAll(t *testing.T) {
 							{Name: "Col1", Type: intType()},
 							{Name: "Col2", Type: floatType()},
 							{Name: "Col3", Type: stringType()},
+							{Name: "Col4", Type: stringType()},
 						},
-						[]*proto3.Value{intProto(3), floatProto(3.3), stringProto("value3")},
+						[]*proto3.Value{intProto(3), floatProto(3.3), stringProto("value3"), stringProto("test3")},
 					},
 					&Row{
 						[]*sppb.StructType_Field{
 							{Name: "Col1", Type: intType()},
 							{Name: "Col2", Type: floatType()},
 							{Name: "Col3", Type: stringType()},
+							{Name: "Col4", Type: stringType()},
 						},
-						[]*proto3.Value{intProto(1), floatProto(1.1), nullProto()},
+						[]*proto3.Value{intProto(1), floatProto(1.1), nullProto(), nullProto()},
 					},
 					&Row{
 						[]*sppb.StructType_Field{
 							{Name: "Col1", Type: intType()},
 							{Name: "Col2", Type: floatType()},
 							{Name: "Col3", Type: stringType()},
+							{Name: "Col4", Type: stringType()},
 						},
-						[]*proto3.Value{intProto(2), floatProto(2.2), stringProto("value2")},
+						[]*proto3.Value{intProto(2), floatProto(2.2), stringProto("value2"), stringProto("test2")},
 					},
 					iterator.Done,
 				),
 			},
 			want: &[]*testStructWithCustom{
-				{Col1: 3, COL2: 3.3, Col3: CustomType[string]{"value3"}},
-				{Col1: 1, COL2: 1.1, Col3: CustomType[string]{}},
-				{Col1: 2, COL2: 2.2, Col3: CustomType[string]{"value2"}},
+				{Col1: 3, COL2: 3.3, Col3: CustomType[string]{"value3"}, Col4: &CustomType[string]{"test3"}},
+				{Col1: 1, COL2: 1.1, Col3: CustomType[string]{}, Col4: nil},
+				{Col1: 2, COL2: 2.2, Col3: CustomType[string]{"value2"}, Col4: &CustomType[string]{"test2"}},
 			},
 		},
 		{
diff --git a/spanner/value.go b/spanner/value.go
@@ -1416,6 +1416,41 @@ func parseNullTime(v *proto3.Value, p *NullTime, code sppb.TypeCode, isNull bool
 	return nil
 }
 
+// tryDecodePointerToDecoder attempts to decode a **T where *T implements Decoder
+// Returns (handled, error) - handled=true if this case was processed
+func tryDecodePointerToDecoder(ptr interface{}, t *sppb.Type, v *proto3.Value, isNull bool) (bool, error) {
+	rv := reflect.ValueOf(ptr)
+	if rv.Kind() != reflect.Ptr || rv.Type().Elem().Kind() != reflect.Ptr {
+		return false, nil
+	}
+
+	elemType := rv.Type().Elem().Elem()
+	if !reflect.PointerTo(elemType).Implements(reflect.TypeOf((*Decoder)(nil)).Elem()) {
+		return false, nil
+	}
+
+	if isNull {
+		rv.Elem().Set(reflect.Zero(rv.Elem().Type()))
+		return true, nil
+	}
+
+	// Create a new instance of the underlying type
+	newInstance := reflect.New(elemType)
+	if decodedVal, ok := newInstance.Interface().(Decoder); ok {
+		x, err := getGenericValue(t, v)
+		if err != nil {
+			return true, err
+		}
+		if err := decodedVal.DecodeSpanner(x); err != nil {
+			return true, err
+		}
+		rv.Elem().Set(newInstance)
+		return true, nil
+	}
+
+	return false, nil
+}
+
 // decodeValue decodes a protobuf Value into a pointer to a Go value, as
 // specified by sppb.Type.
 func decodeValue(v *proto3.Value, t *sppb.Type, ptr interface{}, opts ...DecodeOptions) error {
@@ -2470,6 +2505,10 @@ func decodeValue(v *proto3.Value, t *sppb.Type, ptr interface{}, opts ...DecodeO
 			}
 			return decodedVal.DecodeSpanner(x)
 		}
+		// Check if the pointer is a pointer to a pointer, and if the underlying type implements Decoder
+		if handled, err := tryDecodePointerToDecoder(ptr, t, v, isNull); handled {
+			return err
+		}
 		if p == nil {
 			return errNilDst(p)
 		}
@@ -2721,6 +2760,10 @@ func decodeValue(v *proto3.Value, t *sppb.Type, ptr interface{}, opts ...DecodeO
 			}
 			return decodedVal.DecodeSpanner(x)
 		}
+		// Check if the pointer is a pointer to a pointer, and if the underlying type implements Decoder
+		if handled, err := tryDecodePointerToDecoder(ptr, t, v, isNull); handled {
+			return err
+		}
 
 		// Check if the pointer is a variant of a base type.
 		decodableType := getDecodableSpannerType(ptr, true)
