fix(spanner/spannertest): add support for UUID column type (#20164)

Fixes #20163

---------

Co-authored-by: rahul2393 <irahul@google.com>
Co-authored-by: Sakthivel Subramanian <179120858+sakthivelmanii@users.noreply.github.com>

Author: 3 people

spanner/spannertest/db.go

@@ -38,6 +38,7 @@ import (
 
 	"cloud.google.com/go/civil"
 	"cloud.google.com/go/spanner/spansql"
+	"github.com/google/uuid"
 )
 
 type database struct {
@@ -1137,6 +1138,19 @@ func valForType(v *structpb.Value, t spansql.Type) (interface{}, error) {
 			}
 			return t, nil
 		}
+	case spansql.UUID:
+		sv, ok := v.Kind.(*structpb.Value_StringValue)
+		if ok {
+			s := sv.StringValue
+			if len(s) != 36 {
+				return nil, fmt.Errorf("invalid UUID %q", s)
+			}
+			id, err := uuid.Parse(s)
+			if err != nil {
+				return nil, fmt.Errorf("invalid UUID %q: %w", s, err)
+			}
+			return id.String(), nil
+		}
 	}
 	return nil, fmt.Errorf("unsupported inserting value kind %T into column of type %s", v.Kind, t.SQL())
 }

spanner/spannertest/db_eval.go

@@ -29,6 +29,7 @@ import (
 
 	"cloud.google.com/go/civil"
 	"cloud.google.com/go/spanner/spansql"
+	"github.com/google/uuid"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -665,6 +666,18 @@ func (ec evalContext) coerceString(target spansql.Expr, slit spansql.StringLiter
 			val:  t,
 			orig: slit,
 		}, nil
+	case spansql.UUID:
+		if len(slit) != 36 {
+			return nil, fmt.Errorf("coercing string literal %q to UUID: invalid UUID length", slit)
+		}
+		id, err := uuid.Parse(string(slit))
+		if err != nil {
+			return nil, fmt.Errorf("coercing string literal %q to UUID: %w", slit, err)
+		}
+		return coercedValue{
+			val:  id.String(),
+			orig: slit,
+		}, nil
 	}
 
 	// TODO: Any others?

spanner/spannertest/db_test.go

@@ -775,3 +775,107 @@ func TestCreateAndManageChangeStream(t *testing.T) {
 		t.Errorf("Generated SQL statement incorrect.\n got %v\nwant %v", got, want)
 	}
 }
+
+func TestUUIDColumn(t *testing.T) {
+	uuidTable := &spansql.CreateTable{
+		Name: "Tasks",
+		Columns: []spansql.ColumnDef{
+			{Name: "TaskId", Type: spansql.Type{Base: spansql.UUID}, NotNull: true},
+			{Name: "Data", Type: spansql.Type{Base: spansql.String}},
+		},
+		PrimaryKey: []spansql.KeyPart{{Column: "TaskId"}},
+	}
+
+	var db database
+	if st := db.ApplyDDL(uuidTable); st.Code() != codes.OK {
+		t.Fatalf("Creating table: %v", st.Err())
+	}
+
+	tx := db.NewTransaction()
+	tx.Start()
+	uuidVal := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"
+	upperUUIDVal := "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A22"
+	normalizedUpperUUIDVal := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a22"
+
+	err := db.Insert(tx, "Tasks", []spansql.ID{"TaskId", "Data"}, []*structpb.ListValue{
+		listV(stringV(uuidVal), stringV("some-data")),
+		listV(stringV(upperUUIDVal), stringV("upper-data")),
+	})
+	if err != nil {
+		t.Fatalf("Inserting data: %v", err)
+	}
+	if _, err := tx.Commit(); err != nil {
+		t.Fatalf("Committing changes: %v", err)
+	}
+
+	queryTests := []struct {
+		name string
+		sql  string
+		want [][]interface{}
+	}{
+		{
+			name: "all rows",
+			sql:  `SELECT * FROM Tasks`,
+			want: [][]interface{}{
+				{uuidVal, "some-data"},
+				{normalizedUpperUUIDVal, "upper-data"},
+			},
+		},
+		{
+			name: "uppercase literal filter for uppercase-inserted row",
+			sql:  `SELECT * FROM Tasks WHERE TaskId = 'A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A22'`,
+			want: [][]interface{}{
+				{normalizedUpperUUIDVal, "upper-data"},
+			},
+		},
+		{
+			name: "lowercase literal filter for uppercase-inserted row",
+			sql:  `SELECT * FROM Tasks WHERE TaskId = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a22'`,
+			want: [][]interface{}{
+				{normalizedUpperUUIDVal, "upper-data"},
+			},
+		},
+		{
+			name: "uppercase literal filter for lowercase-inserted row",
+			sql:  `SELECT * FROM Tasks WHERE TaskId = 'A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11'`,
+			want: [][]interface{}{
+				{uuidVal, "some-data"},
+			},
+		},
+	}
+
+	for _, tc := range queryTests {
+		q, err := spansql.ParseQuery(tc.sql)
+		if err != nil {
+			t.Fatalf("ParseQuery(%s) [%s]: %v", tc.sql, tc.name, err)
+		}
+		ri, err := db.Query(q, nil)
+		if err != nil {
+			t.Fatalf("Query(%s) [%s]: %v", tc.sql, tc.name, err)
+		}
+		got := slurp(t, ri)
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("[%s] Query(%s) got %v, want %v", tc.name, tc.sql, got, tc.want)
+		}
+	}
+
+	// Test invalid UUID insertions
+	invalidUUIDs := []string{
+		"not-a-uuid",
+		"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a1",   // too short (35 chars)
+		"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a111", // too long (37 chars)
+		"a0eebc999c0b4ef8bb6d6bb9bd380a11",      // missing hyphens
+		"g0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11",  // non-hex char
+	}
+	for _, badUUID := range invalidUUIDs {
+		txBad := db.NewTransaction()
+		txBad.Start()
+		errBad := db.Insert(txBad, "Tasks", []spansql.ID{"TaskId", "Data"}, []*structpb.ListValue{
+			listV(stringV(badUUID), stringV("bad")),
+		})
+		if errBad == nil {
+			t.Errorf("db.Insert succeeded for invalid UUID %q, want error", badUUID)
+		}
+		txBad.Rollback()
+	}
+}

spanner/spannertest/inmem.go

@@ -957,6 +957,8 @@ func spannerTypeFromType(typ spansql.Type) (*spannerpb.Type, error) {
 		code = spannerpb.TypeCode_DATE
 	case spansql.Timestamp:
 		code = spannerpb.TypeCode_TIMESTAMP
+	case spansql.UUID:
+		code = spannerpb.TypeCode_UUID
 	}
 	st := &spannerpb.Type{Code: code}
 	if typ.Array {

spanner/spannertest/integration_test.go

@@ -1614,6 +1614,69 @@ func TestIntegration_RowDeletionPolicy(t *testing.T) {
 	}
 }
 
+func TestIntegration_UUID(t *testing.T) {
+	client, adminClient, _, cleanup := makeClient(t)
+	defer cleanup()
+
+	ctx := context.Background()
+
+	err := updateDDL(t, adminClient,
+		`CREATE TABLE UUIDTable (
+			TaskId UUID NOT NULL,
+			Data STRING(MAX),
+		) PRIMARY KEY (TaskId)`)
+	if err != nil {
+		t.Fatalf("updateDDL failed: %v", err)
+	}
+
+	taskID := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"
+	upperTaskID := "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A22"
+	normalizedUpperTaskID := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a22"
+
+	_, err = client.Apply(ctx, []*spanner.Mutation{
+		spanner.Insert("UUIDTable", []string{"TaskId", "Data"}, []interface{}{taskID, "payload"}),
+		spanner.Insert("UUIDTable", []string{"TaskId", "Data"}, []interface{}{upperTaskID, "upper-payload"}),
+	})
+	if err != nil {
+		t.Fatalf("client.Apply failed: %v", err)
+	}
+
+	readTests := []struct {
+		name     string
+		key      spanner.Key
+		wantUUID string
+		wantData string
+	}{
+		{name: "exact match", key: spanner.Key{taskID}, wantUUID: taskID, wantData: "payload"},
+		{name: "lowercase key for uppercase insert", key: spanner.Key{normalizedUpperTaskID}, wantUUID: normalizedUpperTaskID, wantData: "upper-payload"},
+		{name: "uppercase key for uppercase insert", key: spanner.Key{upperTaskID}, wantUUID: normalizedUpperTaskID, wantData: "upper-payload"},
+	}
+
+	for _, tc := range readTests {
+		row, err := client.Single().ReadRow(ctx, "UUIDTable", tc.key, []string{"TaskId", "Data"})
+		if err != nil {
+			t.Fatalf("[%s] client.Single().ReadRow failed: %v", tc.name, err)
+		}
+		var gotTaskID spanner.NullUUID
+		var gotData string
+		if err := row.Columns(&gotTaskID, &gotData); err != nil {
+			t.Fatalf("[%s] row.Columns failed: %v", tc.name, err)
+		}
+		if !gotTaskID.Valid || gotTaskID.UUID.String() != tc.wantUUID || gotData != tc.wantData {
+			t.Errorf("[%s] Read row mismatch: got (%v, %q), want (%q, %q)", tc.name, gotTaskID, gotData, tc.wantUUID, tc.wantData)
+		}
+	}
+
+	// Verify invalid UUID is rejected on Apply
+	invalidTaskID := "invalid-uuid-string"
+	_, err = client.Apply(ctx, []*spanner.Mutation{
+		spanner.Insert("UUIDTable", []string{"TaskId", "Data"}, []interface{}{invalidTaskID, "invalid-payload"}),
+	})
+	if err == nil {
+		t.Errorf("client.Apply succeeded for invalid UUID %q, want error", invalidTaskID)
+	}
+}
+
 func dropTable(t *testing.T, adminClient *dbadmin.DatabaseAdminClient, table string) error {
 	t.Helper()
 	err := updateDDL(t, adminClient, "DROP TABLE "+table)
@@ -1700,6 +1763,8 @@ func genericValue(t *testing.T, gcv spanner.GenericColumnValue) interface{} {
 		dst = new(string)
 	case spannerpb.TypeCode_BYTES:
 		dst = new([]byte)
+	case spannerpb.TypeCode_UUID:
+		dst = new(string)
 	}
 	if dst == nil {
 		t.Fatalf("Can't decode Spanner generic column value: %v", gcv.Type)