feat(spanner): allow string values for Scan functions (#11898)

Support scanning string values for the various
spanner.NullTypes.

Use the Scan implementation of the underlying data type for
spanner.NullDate, as civil.Date now implements the sql.Scanner
interface.

The Scan implementations are used by the database/sql driver
and applications that depend on the database/sql driver.

Co-authored-by: rahul2393 <irahul@google.com>

Author: olavloite

spanner/value.go

@@ -268,6 +268,20 @@ func (n *NullInt64) Scan(value interface{}) error {
 	case NullInt64:
 		n.Int64 = p.Int64
 		n.Valid = p.Valid
+	case string:
+		i64, err := strconv.ParseInt(p, 10, 64)
+		if err != nil {
+			return err
+		}
+		n.Int64 = i64
+		n.Valid = true
+	case *string:
+		i64, err := strconv.ParseInt(*p, 10, 64)
+		if err != nil {
+			return err
+		}
+		n.Int64 = i64
+		n.Valid = true
 	}
 	return nil
 }
@@ -433,6 +447,20 @@ func (n *NullFloat64) Scan(value interface{}) error {
 	case NullFloat64:
 		n.Float64 = p.Float64
 		n.Valid = p.Valid
+	case string:
+		f, err := strconv.ParseFloat(p, 64)
+		if err != nil {
+			return err
+		}
+		n.Float64 = f
+		n.Valid = true
+	case *string:
+		f, err := strconv.ParseFloat(*p, 64)
+		if err != nil {
+			return err
+		}
+		n.Float64 = f
+		n.Valid = true
 	}
 	return nil
 }
@@ -513,6 +541,20 @@ func (n *NullFloat32) Scan(value interface{}) error {
 	case NullFloat32:
 		n.Float32 = p.Float32
 		n.Valid = p.Valid
+	case string:
+		f, err := strconv.ParseFloat(p, 32)
+		if err != nil {
+			return err
+		}
+		n.Float32 = float32(f)
+		n.Valid = true
+	case *string:
+		f, err := strconv.ParseFloat(*p, 32)
+		if err != nil {
+			return err
+		}
+		n.Float32 = float32(f)
+		n.Valid = true
 	}
 	return nil
 }
@@ -593,6 +635,20 @@ func (n *NullBool) Scan(value interface{}) error {
 	case NullBool:
 		n.Bool = p.Bool
 		n.Valid = p.Valid
+	case string:
+		f, err := strconv.ParseBool(p)
+		if err != nil {
+			return err
+		}
+		n.Bool = f
+		n.Valid = true
+	case *string:
+		f, err := strconv.ParseBool(*p)
+		if err != nil {
+			return err
+		}
+		n.Bool = f
+		n.Valid = true
 	}
 	return nil
 }
@@ -678,6 +734,20 @@ func (n *NullTime) Scan(value interface{}) error {
 	case NullTime:
 		n.Time = p.Time
 		n.Valid = p.Valid
+	case string:
+		f, err := time.Parse(time.RFC3339Nano, p)
+		if err != nil {
+			return err
+		}
+		n.Time = f
+		n.Valid = true
+	case *string:
+		f, err := time.Parse(time.RFC3339Nano, *p)
+		if err != nil {
+			return err
+		}
+		n.Time = f
+		n.Valid = true
 	}
 	return nil
 }
@@ -752,7 +822,12 @@ func (n *NullDate) Scan(value interface{}) error {
 	n.Valid = true
 	switch p := value.(type) {
 	default:
-		return spannerErrorf(codes.InvalidArgument, "invalid type for NullDate: %v", p)
+		d := civil.Date{}
+		if err := d.Scan(value); err != nil {
+			return err
+		}
+		n.Date = d
+		n.Valid = true
 	case *civil.Date:
 		n.Date = *p
 	case civil.Date:
@@ -848,6 +923,20 @@ func (n *NullNumeric) Scan(value interface{}) error {
 	case NullNumeric:
 		n.Numeric = p.Numeric
 		n.Valid = p.Valid
+	case string:
+		y, ok := (&big.Rat{}).SetString(p)
+		if !ok {
+			return errUnexpectedNumericStr(p)
+		}
+		n.Numeric = *y
+		n.Valid = true
+	case *string:
+		y, ok := (&big.Rat{}).SetString(*p)
+		if !ok {
+			return errUnexpectedNumericStr(*p)
+		}
+		n.Numeric = *y
+		n.Valid = true
 	}
 	return nil
 }

spanner/value_test.go

@@ -3361,3 +3361,109 @@ func TestDecodeProtoArrayUsingBaseVariant(t *testing.T) {
 		t.Errorf("%s: got %+v, want %+v", "Test PROTO decode to [][]byte custom type", nb, b)
 	}
 }
+
+func TestScanNullInt64(t *testing.T) {
+	for _, val := range []any{"99", stringPointer("99")} {
+		n := NullInt64{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		want := NullInt64{Int64: 99, Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullString(t *testing.T) {
+	for _, val := range []any{"foo", stringPointer("foo")} {
+		n := NullString{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		want := NullString{StringVal: "foo", Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullFloat64(t *testing.T) {
+	for _, val := range []any{"3.14", stringPointer("3.14")} {
+		n := NullFloat64{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		want := NullFloat64{Float64: 3.14, Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullFloat32(t *testing.T) {
+	for _, val := range []any{"3.14", stringPointer("3.14")} {
+		n := NullFloat32{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		want := NullFloat32{Float32: float32(3.14), Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullBool(t *testing.T) {
+	for _, val := range []any{"true", stringPointer("true")} {
+		n := NullBool{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		want := NullBool{Bool: true, Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullTime(t *testing.T) {
+	for _, val := range []any{"2025-03-25T17:54:00+01:00", stringPointer("2025-03-25T17:54:00+01:00")} {
+		n := NullTime{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		tm, _ := time.Parse(time.RFC3339Nano, "2025-03-25T16:54:00Z")
+		want := NullTime{Time: tm, Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullDate(t *testing.T) {
+	for _, val := range []any{"2025-03-25", stringPointer("2025-03-25")} {
+		n := NullDate{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		want := NullDate{Date: civil.Date{Year: 2025, Month: 3, Day: 25}, Valid: true}
+		if g, w := n, want; !cmp.Equal(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}
+
+func TestScanNullNumeric(t *testing.T) {
+	for _, val := range []any{"3.14", stringPointer("3.14")} {
+		n := NullNumeric{}
+		if err := n.Scan(val); err != nil {
+			t.Fatal(err)
+		}
+		r, _ := (&big.Rat{}).SetString("3.14")
+		want := NullNumeric{Numeric: *r, Valid: true}
+		if g, w := n, want; !reflect.DeepEqual(g, w) {
+			t.Fatalf("value mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	}
+}