feat(spanner): support "readOnly" column tag parsing for Go struct operations (googleapis#12895)

Fixes: googleapis#8933

Author: rahul2393

spanner/doc.go

@@ -323,6 +323,14 @@ name in the struct definition is used. To specify a field with an empty field
 name in a Cloud Spanner STRUCT type, use the `spanner:""` tag annotation against
 the corresponding field in the Go struct's type definition.
 
+The spanner tag supports the following options:
+
+| Tag | Description |
+|-----|-------------|
+| `spanner:"column_name"` | Set column name to `column_name` |
+| `spanner:"->"` | Read-only field (excluded from writes, included in reads) |
+| `spanner:"column_name;->"` | Set column name and mark as read-only |
+
 A STRUCT value can contain STRUCT-typed and Array-of-STRUCT typed fields and
 these can be specified using named struct-typed and []struct-typed fields inside
 a Go struct. However, embedded struct fields are not allowed. Unexported struct

spanner/mutation.go

@@ -198,6 +198,11 @@ func structToMutationParams(in interface{}) ([]string, []interface{}, error) {
 	var cols []string
 	var vals []interface{}
 	for _, f := range fields {
+		if f.ParsedTag != nil {
+			if tag, ok := f.ParsedTag.(spannerTag); ok && tag.ReadOnly {
+				continue
+			}
+		}
 		cols = append(cols, f.Name)
 		vals = append(vals, v.FieldByIndex(f.Index).Interface())
 	}

spanner/mutation_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package spanner
 
 import (
+	"context"
 	"math/big"
 	"reflect"
 	"sort"
@@ -26,6 +27,7 @@ import (
 
 	"cloud.google.com/go/civil"
 	sppb "cloud.google.com/go/spanner/apiv1/spannerpb"
+	. "cloud.google.com/go/spanner/internal/testutil"
 	proto3 "google.golang.org/protobuf/types/known/structpb"
 )
 
@@ -430,6 +432,139 @@ func TestStructToMutationParams(t *testing.T) {
 	}
 }
 
+func TestStructToMutationParams_ReadOnly(t *testing.T) {
+	t.Parallel()
+	type ReadOnly struct {
+		ID   int64
+		Name string `spanner:"->"`
+	}
+	in := &ReadOnly{ID: 1, Name: "foo"}
+	wantCols := []string{"ID"}
+	wantVals := []interface{}{int64(1)}
+	gotCols, gotVals, err := structToMutationParams(in)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !testEqual(gotCols, wantCols) {
+		t.Errorf("got cols %v, want %v", gotCols, wantCols)
+	}
+	if !testEqual(gotVals, wantVals) {
+		t.Errorf("got vals %v, want %v", gotVals, wantVals)
+	}
+}
+
+func TestReadWrite_Generated(t *testing.T) {
+	t.Parallel()
+	server, client, teardown := setupMockedTestServer(t)
+	defer teardown()
+	// The full name is generated by the server.
+	server.TestSpanner.PutStatementResult(
+		"SELECT Id, FirstName, LastName, FullName FROM Users WHERE Id = 1",
+		&StatementResult{
+			Type: StatementResultResultSet,
+			ResultSet: &sppb.ResultSet{
+				Metadata: &sppb.ResultSetMetadata{
+					RowType: &sppb.StructType{
+						Fields: []*sppb.StructType_Field{
+							{Name: "Id", Type: &sppb.Type{Code: sppb.TypeCode_INT64}},
+							{Name: "FirstName", Type: &sppb.Type{Code: sppb.TypeCode_STRING}},
+							{Name: "LastName", Type: &sppb.Type{Code: sppb.TypeCode_STRING}},
+							{Name: "FullName", Type: &sppb.Type{Code: sppb.TypeCode_STRING}},
+						},
+					},
+				},
+				Rows: []*proto3.ListValue{
+					{
+						Values: []*proto3.Value{
+							intProto(1),
+							stringProto("First"),
+							stringProto("Last"),
+							stringProto("First Last"),
+						},
+					},
+				},
+			},
+		},
+	)
+
+	type User struct {
+		ID        int64 `spanner:"Id"`
+		FirstName string
+		LastName  string
+		FullName  string `spanner:"->"`
+	}
+	user := &User{
+		ID:        1,
+		FirstName: "First",
+		LastName:  "Last",
+	}
+	m, err := InsertStruct("Users", user)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = client.Apply(context.Background(), []*Mutation{m})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Verify that the generated column 'FullName' was excluded from the write mutation.
+	reqs := drainRequestsFromServer(server.TestSpanner)
+	var commitReq *sppb.CommitRequest
+	for _, r := range reqs {
+		if c, ok := r.(*sppb.CommitRequest); ok {
+			commitReq = c
+		}
+	}
+	if commitReq == nil {
+		t.Fatalf("no CommitRequest captured; got %v", reqs)
+	}
+	// Find the write mutation for Users.
+	var write *sppb.Mutation_Write
+	for _, mut := range commitReq.Mutations {
+		if ins := mut.GetInsert(); ins != nil && ins.Table == "Users" {
+			write = ins
+			break
+		}
+	}
+	if write == nil {
+		t.Fatalf("no write mutation for table Users in CommitRequest: %v", commitReq.Mutations)
+	}
+	// Ensure FullName is not present in columns.
+	for _, col := range write.Columns {
+		if col == "FullName" {
+			t.Fatalf("generated column FullName must be excluded from write.Columns: %v", write.Columns)
+		}
+	}
+	wantCols := []string{"Id", "FirstName", "LastName"}
+	if !reflect.DeepEqual(write.Columns, wantCols) {
+		t.Fatalf("write.Columns mismatch\ngot  %v\nwant %v", write.Columns, wantCols)
+	}
+	if g, w := len(write.Values), 1; g != w {
+		t.Fatalf("write.Values length mismatch: got %d, want 1", len(write.Values))
+	}
+	if g, w := len(write.Values[0].Values), len(wantCols); g != w {
+		t.Fatalf("write.Values[0] length mismatch\n Got: %v\nWant: %v", g, w)
+	}
+
+	iter := client.Single().Query(context.Background(), NewStatement("SELECT Id, FirstName, LastName, FullName FROM Users WHERE Id = 1"))
+	row, err := iter.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got User
+	if err := row.ToStruct(&got); err != nil {
+		t.Fatal(err)
+	}
+	want := &User{
+		ID:        1,
+		FirstName: "First",
+		LastName:  "Last",
+		FullName:  "First Last",
+	}
+	if !testEqual(got, *want) {
+		t.Errorf("got %v, want %v", got, *want)
+	}
+}
+
 // Test encoding Mutation into proto.
 func TestEncodeMutation(t *testing.T) {
 	for _, test := range []struct {

spanner/value.go

@@ -5592,12 +5592,30 @@ func encodeProtoEnumArray(len int, at func(int) reflect.Value) (*proto3.Value, e
 	return listProto(vs...), nil
 }
 
+// spannerTag contains metadata about a struct field's spanner tag.
+type spannerTag struct {
+	// ReadOnly is true if the field should be excluded from writes (read-only).
+	ReadOnly bool
+}
+
 func spannerTagParser(t reflect.StructTag) (name string, keep bool, other interface{}, err error) {
 	if s := t.Get("spanner"); s != "" {
 		if s == "-" {
 			return "", false, nil, nil
 		}
-		return s, true, nil, nil
+		if s == "->" {
+			tag := spannerTag{ReadOnly: true}
+			return "", true, tag, nil
+		}
+		parts := strings.Split(s, ";")
+		name = parts[0]
+		tag := spannerTag{}
+		for _, part := range parts[1:] {
+			if part == "->" || strings.ToLower(part) == "readonly" {
+				tag.ReadOnly = true
+			}
+		}
+		return name, true, tag, nil
 	}
 	return "", true, nil, nil
 }